pstlab / PLATINUm

package it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser;

import java.util.HashMap;

import org.antlr.runtime.BaseRecognizer;

import org.antlr.runtime.BitSet;

import org.antlr.runtime.DFA;

import org.antlr.runtime.EarlyExitException;

import org.antlr.runtime.IntStream;

import org.antlr.runtime.MismatchedSetException;

import org.antlr.runtime.NoViableAltException;

import org.antlr.runtime.Parser;

import org.antlr.runtime.ParserRuleReturnScope;

import org.antlr.runtime.RecognitionException;

import org.antlr.runtime.RecognizerSharedState;

import org.antlr.runtime.Token;

import org.antlr.runtime.TokenStream;

import org.antlr.runtime.tree.CommonTreeAdaptor;

import org.antlr.runtime.tree.RewriteEarlyExitException;

import org.antlr.runtime.tree.RewriteRuleSubtreeStream;

import org.antlr.runtime.tree.RewriteRuleTokenStream;

import org.antlr.runtime.tree.TreeAdaptor;

@SuppressWarnings("all")

public class ddl3Parser extends Parser {

	public static final String[] tokenNames = new String[] {

		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "COMMENT", "ID", "INT", "VarID", 

		"WS", "'!'", "'!='", "'('", "')'", "'*'", "'+'", "','", "'-'", "'.'", 

		"':'", "';'", "'<'", "'<='", "'='", "'>'", "'>='", "'?'", "'AFTER'", "'AFTER-END'", 

		"'AT'", "'AT-END'", "'AT-START'", "'BEFORE'", "'BEFORE-START'", "'BOUNDED'", 

		"'COMPONENT'", "'COMP_TYPE'", "'CONSUMPTION'", "'CONTAINS'", "'CONTAINS-END'", 

		"'CONTAINS-START'", "'ConsumableResource'", "'DOMAIN'", "'DURING'", "'END-END'", 

		"'END-START'", "'ENDS-AT'", "'ENDS-DURING'", "'EQUALS'", "'ESTA_LIGHT'", 

		"'ESTA_LIGHT_MAX_CONSUMPTION'", "'EnumerationParameterType'", "'FINISHED-BY'", 

		"'FINISHES'", "'FLEXIBLE'", "'INF'", "'MEETS'", "'MET-BY'", "'NumericParameterType'", 

		"'OVERLAPPED-BY'", "'OVERLAPS'", "'PAR_TYPE'", "'PROBLEM'", "'PRODUCTION'", 

		"'REQUIREMENT'", "'RenewableResource'", "'START-END'", "'START-START'", 

		"'STARTED-BY'", "'STARTS'", "'STARTS-AT'", "'STARTS-DURING'", "'SYNCHRONIZE'", 

		"'SimpleGroundStateVariable'", "'SingletonStateVariable'", "'TEMPORAL_MODULE'", 

		"'VALUE'", "'['", "']'", "'c'", "'u'", "'{'", "'}'"

	};

	public static final int EOF=-1;

	public static final int T__9=9;

	public static final int T__10=10;

	public static final int T__11=11;

	public static final int T__12=12;

	public static final int T__13=13;

	public static final int T__14=14;

	public static final int T__15=15;

	public static final int T__16=16;

	public static final int T__17=17;

	public static final int T__18=18;

	public static final int T__19=19;

	public static final int T__20=20;

	public static final int T__21=21;

	public static final int T__22=22;

	public static final int T__23=23;

	public static final int T__24=24;

	public static final int T__25=25;

	public static final int T__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__30=30;

	public static final int T__31=31;

	public static final int T__32=32;

	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 T__37=37;

	public static final int T__38=38;

	public static final int T__39=39;

	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__44=44;

	public static final int T__45=45;

	public static final int T__46=46;

	public static final int T__47=47;

	public static final int T__48=48;

	public static final int T__49=49;

	public static final int T__50=50;

	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__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__59=59;

	public static final int T__60=60;

	public static final int T__61=61;

	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 T__66=66;

	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__70=70;

	public static final int T__71=71;

	public static final int T__72=72;

	public static final int T__73=73;

	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__77=77;

	public static final int T__78=78;

	public static final int T__79=79;

	public static final int T__80=80;

	public static final int T__81=81;

	public static final int COMMENT=4;

	public static final int ID=5;

	public static final int INT=6;

	public static final int VarID=7;

	public static final int WS=8;

	// delegates

	public Parser[] getDelegates() {

		return new Parser[] {};

	}

	// delegators

	public ddl3Parser(TokenStream input) {

		this(input, new RecognizerSharedState());

	}

	public ddl3Parser(TokenStream input, RecognizerSharedState state) {

		super(input, state);

		this.state.ruleMemo = new HashMap[164+1];

	}

	protected TreeAdaptor adaptor = new CommonTreeAdaptor();

	public void setTreeAdaptor(TreeAdaptor adaptor) {

		this.adaptor = adaptor;

	}

	public TreeAdaptor getTreeAdaptor() {

		return adaptor;

	}

	@Override public String[] getTokenNames() { return ddl3Parser.tokenNames; }

	@Override public String getGrammarFileName() { return "/home/alessandro/opt/antlr/ddl3/ddl3.g"; }

	public static class ddl_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "ddl"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:1: ddl : ( domain ( problem )? -> ^( 'DOMAIN' domain ( problem )? ) | problem -> ^( 'PROBLEM' problem ) );

	public final ddl3Parser.ddl_return ddl() throws RecognitionException {

		ddl3Parser.ddl_return retval = new ddl3Parser.ddl_return();

		retval.start = input.LT(1);

		int ddl_StartIndex = input.index();

		Object root_0 = null;

		ParserRuleReturnScope domain1 =null;

		ParserRuleReturnScope problem2 =null;

		ParserRuleReturnScope problem3 =null;

		RewriteRuleSubtreeStream stream_problem=new RewriteRuleSubtreeStream(adaptor,"rule problem");

		RewriteRuleSubtreeStream stream_domain=new RewriteRuleSubtreeStream(adaptor,"rule domain");

		try {

			if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:5: ( domain ( problem )? -> ^( 'DOMAIN' domain ( problem )? ) | problem -> ^( 'PROBLEM' problem ) )

			int alt2=2;

			int LA2_0 = input.LA(1);

			if ( (LA2_0==41) ) {

				alt2=1;

			}

			else if ( (LA2_0==61) ) {

				alt2=2;

			}

			else {

				if (state.backtracking>0) {state.failed=true; return retval;}

				NoViableAltException nvae =

					new NoViableAltException("", 2, 0, input);

				throw nvae;

			}

			switch (alt2) {

				case 1 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:7: domain ( problem )?

					{

					pushFollow(FOLLOW_domain_in_ddl42);

					domain1=domain();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) stream_domain.add(domain1.getTree());

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:14: ( problem )?

					int alt1=2;

					int LA1_0 = input.LA(1);

					if ( (LA1_0==61) ) {

						alt1=1;

					}

					switch (alt1) {

						case 1 :

							// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:15: problem

							{

							pushFollow(FOLLOW_problem_in_ddl45);

							problem2=problem();

							state._fsp--;

							if (state.failed) return retval;

							if ( state.backtracking==0 ) stream_problem.add(problem2.getTree());

							}

							break;

					}

					// AST REWRITE

					// elements: problem, domain, 41

					// token labels: 

					// rule labels: retval

					// token list labels: 

					// rule list labels: 

					// wildcard labels: 

					if ( state.backtracking==0 ) {

					retval.tree = root_0;

					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();

					// 9:25: -> ^( 'DOMAIN' domain ( problem )? )

					{

						// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:27: ^( 'DOMAIN' domain ( problem )? )

						{

						Object root_1 = (Object)adaptor.nil();

						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(41, "41"), root_1);

						adaptor.addChild(root_1, stream_domain.nextTree());

						// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:45: ( problem )?

						if ( stream_problem.hasNext() ) {

							adaptor.addChild(root_1, stream_problem.nextTree());

						}

						stream_problem.reset();

						adaptor.addChild(root_0, root_1);

						}

					}

					retval.tree = root_0;

					}

					}

					break;

				case 2 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:59: problem

					{

					pushFollow(FOLLOW_problem_in_ddl63);

					problem3=problem();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) stream_problem.add(problem3.getTree());

					// AST REWRITE

					// elements: problem, 61

					// token labels: 

					// rule labels: retval

					// token list labels: 

					// rule list labels: 

					// wildcard labels: 

					if ( state.backtracking==0 ) {

					retval.tree = root_0;

					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();

					// 9:67: -> ^( 'PROBLEM' problem )

					{

						// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:69: ^( 'PROBLEM' problem )

						{

						Object root_1 = (Object)adaptor.nil();

						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(61, "61"), root_1);

						adaptor.addChild(root_1, stream_problem.nextTree());

						adaptor.addChild(root_0, root_1);

						}

					}

					retval.tree = root_0;

					}

					}

					break;

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 1, ddl_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "ddl"

	public static class domain_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "domain"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:11:1: domain : 'DOMAIN' ID '{' temporal_module ( domain_element )* '}' -> ^( ID temporal_module ( domain_element )* ) ;

	public final ddl3Parser.domain_return domain() throws RecognitionException {

		ddl3Parser.domain_return retval = new ddl3Parser.domain_return();

		retval.start = input.LT(1);

		int domain_StartIndex = input.index();

		Object root_0 = null;

		Token string_literal4=null;

		Token ID5=null;

		Token char_literal6=null;

		Token char_literal9=null;

		ParserRuleReturnScope temporal_module7 =null;

		ParserRuleReturnScope domain_element8 =null;

		Object string_literal4_tree=null;

		Object ID5_tree=null;

		Object char_literal6_tree=null;

		Object char_literal9_tree=null;

		RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");

		RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");

		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");

		RewriteRuleTokenStream stream_41=new RewriteRuleTokenStream(adaptor,"token 41");

		RewriteRuleSubtreeStream stream_domain_element=new RewriteRuleSubtreeStream(adaptor,"rule domain_element");

		RewriteRuleSubtreeStream stream_temporal_module=new RewriteRuleSubtreeStream(adaptor,"rule temporal_module");

		try {

			if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:2: ( 'DOMAIN' ID '{' temporal_module ( domain_element )* '}' -> ^( ID temporal_module ( domain_element )* ) )

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:4: 'DOMAIN' ID '{' temporal_module ( domain_element )* '}'

			{

			string_literal4=(Token)match(input,41,FOLLOW_41_in_domain80); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_41.add(string_literal4);

			ID5=(Token)match(input,ID,FOLLOW_ID_in_domain82); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_ID.add(ID5);

			char_literal6=(Token)match(input,80,FOLLOW_80_in_domain84); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_80.add(char_literal6);

			pushFollow(FOLLOW_temporal_module_in_domain86);

			temporal_module7=temporal_module();

			state._fsp--;

			if (state.failed) return retval;

			if ( state.backtracking==0 ) stream_temporal_module.add(temporal_module7.getTree());

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:36: ( domain_element )*

			loop3:

			while (true) {

				int alt3=2;

				int LA3_0 = input.LA(1);

				if ( ((LA3_0 >= 34 && LA3_0 <= 35)||LA3_0==60||LA3_0==71) ) {

					alt3=1;

				}

				switch (alt3) {

				case 1 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:36: domain_element

					{

					pushFollow(FOLLOW_domain_element_in_domain88);

					domain_element8=domain_element();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) stream_domain_element.add(domain_element8.getTree());

					}

					break;

				default :

					break loop3;

				}

			}

			char_literal9=(Token)match(input,81,FOLLOW_81_in_domain91); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_81.add(char_literal9);

			// AST REWRITE

			// elements: ID, temporal_module, domain_element

			// token labels: 

			// rule labels: retval

			// token list labels: 

			// rule list labels: 

			// wildcard labels: 

			if ( state.backtracking==0 ) {

			retval.tree = root_0;

			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();

			// 12:56: -> ^( ID temporal_module ( domain_element )* )

			{

				// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:58: ^( ID temporal_module ( domain_element )* )

				{

				Object root_1 = (Object)adaptor.nil();

				root_1 = (Object)adaptor.becomeRoot(new DDLDomain(stream_ID.nextToken()), root_1);

				adaptor.addChild(root_1, stream_temporal_module.nextTree());

				// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:90: ( domain_element )*

				while ( stream_domain_element.hasNext() ) {

					adaptor.addChild(root_1, stream_domain_element.nextTree());

				}

				stream_domain_element.reset();

				adaptor.addChild(root_0, root_1);

				}

			}

			retval.tree = root_0;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 2, domain_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "domain"

	public static class temporal_module_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "temporal_module"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:14:1: temporal_module : 'TEMPORAL_MODULE' ID '=' range ',' INT ';' -> ^( ID range INT ) ;

	public final ddl3Parser.temporal_module_return temporal_module() throws RecognitionException {

		ddl3Parser.temporal_module_return retval = new ddl3Parser.temporal_module_return();

		retval.start = input.LT(1);

		int temporal_module_StartIndex = input.index();

		Object root_0 = null;

		Token string_literal10=null;

		Token ID11=null;

		Token char_literal12=null;

		Token char_literal14=null;

		Token INT15=null;

		Token char_literal16=null;

		ParserRuleReturnScope range13 =null;

		Object string_literal10_tree=null;

		Object ID11_tree=null;

		Object char_literal12_tree=null;

		Object char_literal14_tree=null;

		Object INT15_tree=null;

		Object char_literal16_tree=null;

		RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");

		RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15");

		RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19");

		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");

		RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");

		RewriteRuleTokenStream stream_INT=new RewriteRuleTokenStream(adaptor,"token INT");

		RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range");

			if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:2: ( 'TEMPORAL_MODULE' ID '=' range ',' INT ';' -> ^( ID range INT ) )

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:4: 'TEMPORAL_MODULE' ID '=' range ',' INT ';'

			{

			string_literal10=(Token)match(input,74,FOLLOW_74_in_temporal_module113); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_74.add(string_literal10);

			ID11=(Token)match(input,ID,FOLLOW_ID_in_temporal_module115); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_ID.add(ID11);

			char_literal12=(Token)match(input,22,FOLLOW_22_in_temporal_module117); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_22.add(char_literal12);

			pushFollow(FOLLOW_range_in_temporal_module119);

			range13=range();

			state._fsp--;

			if (state.failed) return retval;

			if ( state.backtracking==0 ) stream_range.add(range13.getTree());

			char_literal14=(Token)match(input,15,FOLLOW_15_in_temporal_module121); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_15.add(char_literal14);

			INT15=(Token)match(input,INT,FOLLOW_INT_in_temporal_module123); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_INT.add(INT15);

			char_literal16=(Token)match(input,19,FOLLOW_19_in_temporal_module125); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_19.add(char_literal16);

			// AST REWRITE

			// elements: INT, range, ID

			// token labels: 

			// rule labels: retval

			// token list labels: 

			// rule list labels: 

			// wildcard labels: 

			if ( state.backtracking==0 ) {

			retval.tree = root_0;

			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();

			// 15:47: -> ^( ID range INT )

			{

				// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:49: ^( ID range INT )

				{

				Object root_1 = (Object)adaptor.nil();

				root_1 = (Object)adaptor.becomeRoot(new DDLTemporalModule(stream_ID.nextToken()), root_1);

				adaptor.addChild(root_1, stream_range.nextTree());

				adaptor.addChild(root_1, stream_INT.nextNode());

				adaptor.addChild(root_0, root_1);

				}

			}

			retval.tree = root_0;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 3, temporal_module_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "temporal_module"

	public static class domain_element_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "domain_element"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:17:1: domain_element : ( parameter_type | component_type | component | timeline_synchronization );

	public final ddl3Parser.domain_element_return domain_element() throws RecognitionException {

		ddl3Parser.domain_element_return retval = new ddl3Parser.domain_element_return();

		retval.start = input.LT(1);

		int domain_element_StartIndex = input.index();

		Object root_0 = null;

		ParserRuleReturnScope parameter_type17 =null;

		ParserRuleReturnScope component_type18 =null;

		ParserRuleReturnScope component19 =null;

		ParserRuleReturnScope timeline_synchronization20 =null;

		try {

			if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:2: ( parameter_type | component_type | component | timeline_synchronization )

			int alt4=4;

			case 60:

				{

				alt4=1;

				}

				break;

			case 35:

				{

				alt4=2;

				}

				break;

			case 34:

				{

				alt4=3;

				}

				break;

			case 71:

				{

				alt4=4;

				}

				break;

			default:

				if (state.backtracking>0) {state.failed=true; return retval;}

				NoViableAltException nvae =

					new NoViableAltException("", 4, 0, input);

				throw nvae;

			}

			switch (alt4) {

				case 1 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:4: parameter_type

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_parameter_type_in_domain_element146);

					parameter_type17=parameter_type();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_type17.getTree());

					}

					break;

				case 2 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:21: component_type

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_component_type_in_domain_element150);

					component_type18=component_type();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, component_type18.getTree());

					}

					break;

				case 3 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:38: component

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_component_in_domain_element154);

					component19=component();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, component19.getTree());

					}

					break;

				case 4 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:50: timeline_synchronization

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_timeline_synchronization_in_domain_element158);

					timeline_synchronization20=timeline_synchronization();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, timeline_synchronization20.getTree());

					}

					break;

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 4, domain_element_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "domain_element"

	public static class parameter_type_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "parameter_type"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:21:1: parameter_type : ( numeric_parameter_type | enumeration_parameter_type );

	public final ddl3Parser.parameter_type_return parameter_type() throws RecognitionException {

		ddl3Parser.parameter_type_return retval = new ddl3Parser.parameter_type_return();

		retval.start = input.LT(1);

		int parameter_type_StartIndex = input.index();

		Object root_0 = null;

		ParserRuleReturnScope numeric_parameter_type21 =null;

		ParserRuleReturnScope enumeration_parameter_type22 =null;

		try {

			if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:2: ( numeric_parameter_type | enumeration_parameter_type )

			int alt5=2;

			int LA5_0 = input.LA(1);

				int LA5_1 = input.LA(2);

				if ( (LA5_1==57) ) {

					alt5=1;

				}

				else if ( (LA5_1==50) ) {

					alt5=2;

				}

				else {

					if (state.backtracking>0) {state.failed=true; return retval;}

					int nvaeMark = input.mark();

					try {

						input.consume();

						NoViableAltException nvae =

							new NoViableAltException("", 5, 1, input);

						throw nvae;

					} finally {

						input.rewind(nvaeMark);

					}

				}

			}

			else {

				if (state.backtracking>0) {state.failed=true; return retval;}

				NoViableAltException nvae =

					new NoViableAltException("", 5, 0, input);

				throw nvae;

			}

			switch (alt5) {

				case 1 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:4: numeric_parameter_type

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_numeric_parameter_type_in_parameter_type168);

					numeric_parameter_type21=numeric_parameter_type();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, numeric_parameter_type21.getTree());

					}

					break;

				case 2 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:29: enumeration_parameter_type

					{

					root_0 = (Object)adaptor.nil();

					pushFollow(FOLLOW_enumeration_parameter_type_in_parameter_type172);

					enumeration_parameter_type22=enumeration_parameter_type();

					state._fsp--;

					if (state.failed) return retval;

					if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeration_parameter_type22.getTree());

					}

					break;

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 5, parameter_type_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "parameter_type"

	public static class numeric_parameter_type_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "numeric_parameter_type"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:24:1: numeric_parameter_type : 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';' -> ^( ID number number ) ;

	public final ddl3Parser.numeric_parameter_type_return numeric_parameter_type() throws RecognitionException {

		ddl3Parser.numeric_parameter_type_return retval = new ddl3Parser.numeric_parameter_type_return();

		retval.start = input.LT(1);

		int numeric_parameter_type_StartIndex = input.index();

		Object root_0 = null;

		Token string_literal23=null;

		Token string_literal24=null;

		Token ID25=null;

		Token char_literal26=null;

		Token char_literal27=null;

		Token char_literal29=null;

		Token char_literal31=null;

		Token char_literal32=null;

		ParserRuleReturnScope number28 =null;

		ParserRuleReturnScope number30 =null;

		Object string_literal23_tree=null;

		Object string_literal24_tree=null;

		Object ID25_tree=null;

		Object char_literal26_tree=null;

		Object char_literal27_tree=null;

		Object char_literal29_tree=null;

		Object char_literal31_tree=null;

		Object char_literal32_tree=null;

		RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");

		RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77");

		RewriteRuleTokenStream stream_57=new RewriteRuleTokenStream(adaptor,"token 57");

		RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15");

		RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19");

		RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60");

		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");

		RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76");

		RewriteRuleSubtreeStream stream_number=new RewriteRuleSubtreeStream(adaptor,"rule number");

			if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:2: ( 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';' -> ^( ID number number ) )

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:4: 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';'

			{

			string_literal23=(Token)match(input,60,FOLLOW_60_in_numeric_parameter_type182); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_60.add(string_literal23);

			string_literal24=(Token)match(input,57,FOLLOW_57_in_numeric_parameter_type184); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_57.add(string_literal24);

			ID25=(Token)match(input,ID,FOLLOW_ID_in_numeric_parameter_type186); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_ID.add(ID25);

			char_literal26=(Token)match(input,22,FOLLOW_22_in_numeric_parameter_type188); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_22.add(char_literal26);

			char_literal27=(Token)match(input,76,FOLLOW_76_in_numeric_parameter_type190); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_76.add(char_literal27);

			pushFollow(FOLLOW_number_in_numeric_parameter_type192);

			number28=number();

			state._fsp--;

			if (state.failed) return retval;

			if ( state.backtracking==0 ) stream_number.add(number28.getTree());

			char_literal29=(Token)match(input,15,FOLLOW_15_in_numeric_parameter_type194); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_15.add(char_literal29);

			pushFollow(FOLLOW_number_in_numeric_parameter_type196);

			number30=number();

			state._fsp--;

			if (state.failed) return retval;

			if ( state.backtracking==0 ) stream_number.add(number30.getTree());

			char_literal31=(Token)match(input,77,FOLLOW_77_in_numeric_parameter_type198); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_77.add(char_literal31);

			char_literal32=(Token)match(input,19,FOLLOW_19_in_numeric_parameter_type200); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_19.add(char_literal32);

			// AST REWRITE

			// elements: number, ID, number

			// token labels: 

			// rule labels: retval

			// token list labels: 

			// rule list labels: 

			// wildcard labels: 

			if ( state.backtracking==0 ) {

			retval.tree = root_0;

			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();

			// 25:75: -> ^( ID number number )

			{

				// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:77: ^( ID number number )

				{

				Object root_1 = (Object)adaptor.nil();

				root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterType(stream_ID.nextToken()), root_1);

				adaptor.addChild(root_1, stream_number.nextTree());

				adaptor.addChild(root_1, stream_number.nextTree());

				adaptor.addChild(root_0, root_1);

				}

			}

			retval.tree = root_0;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {

			retval.tree = (Object)adaptor.rulePostProcessing(root_0);

			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

			}

		}

		catch (RecognitionException re) {

			reportError(re);

			recover(input,re);

			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

		}

		finally {

			// do for sure before leaving

			if ( state.backtracking>0 ) { memoize(input, 6, numeric_parameter_type_StartIndex); }

		}

		return retval;

	}

	// $ANTLR end "numeric_parameter_type"

	public static class enumeration_parameter_type_return extends ParserRuleReturnScope {

		Object tree;

		@Override

		public Object getTree() { return tree; }

	};

	// $ANTLR start "enumeration_parameter_type"

	// /home/alessandro/opt/antlr/ddl3/ddl3.g:27:1: enumeration_parameter_type : 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';' -> ^( ID ( ID )* ) ;

	public final ddl3Parser.enumeration_parameter_type_return enumeration_parameter_type() throws RecognitionException {

		ddl3Parser.enumeration_parameter_type_return retval = new ddl3Parser.enumeration_parameter_type_return();

		retval.start = input.LT(1);

		int enumeration_parameter_type_StartIndex = input.index();

		Object root_0 = null;

		Token string_literal33=null;

		Token string_literal34=null;

		Token ID35=null;

		Token char_literal36=null;

		Token char_literal37=null;

		Token ID38=null;

		Token char_literal39=null;

		Token ID40=null;

		Token char_literal41=null;

		Token char_literal42=null;

		Object string_literal33_tree=null;

		Object string_literal34_tree=null;

		Object ID35_tree=null;

		Object char_literal36_tree=null;

		Object char_literal37_tree=null;

		Object ID38_tree=null;

		Object char_literal39_tree=null;

		Object ID40_tree=null;

		Object char_literal41_tree=null;

		Object char_literal42_tree=null;

		RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");

		RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15");

		RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80");

		RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19");

		RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81");

		RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60");

		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");

		RewriteRuleTokenStream stream_50=new RewriteRuleTokenStream(adaptor,"token 50");

		try {

			if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:2: ( 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';' -> ^( ID ( ID )* ) )

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:4: 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';'

			{

			string_literal33=(Token)match(input,60,FOLLOW_60_in_enumeration_parameter_type222); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_60.add(string_literal33);

			string_literal34=(Token)match(input,50,FOLLOW_50_in_enumeration_parameter_type224); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_50.add(string_literal34);

			ID35=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type226); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_ID.add(ID35);

			char_literal36=(Token)match(input,22,FOLLOW_22_in_enumeration_parameter_type228); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_22.add(char_literal36);

			char_literal37=(Token)match(input,80,FOLLOW_80_in_enumeration_parameter_type230); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_80.add(char_literal37);

			ID38=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type232); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_ID.add(ID38);

			// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:56: ( ',' ID )*

			loop6:

				int alt6=2;

				int LA6_0 = input.LA(1);

				if ( (LA6_0==15) ) {

					alt6=1;

				}

				switch (alt6) {

				case 1 :

					// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:57: ',' ID

					{

					char_literal39=(Token)match(input,15,FOLLOW_15_in_enumeration_parameter_type235); if (state.failed) return retval; 

					if ( state.backtracking==0 ) stream_15.add(char_literal39);

					ID40=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type237); if (state.failed) return retval; 

					if ( state.backtracking==0 ) stream_ID.add(ID40);

					}

					break;

				default :

					break loop6;

				}

			}

			char_literal41=(Token)match(input,81,FOLLOW_81_in_enumeration_parameter_type241); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_81.add(char_literal41);

			char_literal42=(Token)match(input,19,FOLLOW_19_in_enumeration_parameter_type243); if (state.failed) return retval; 

			if ( state.backtracking==0 ) stream_19.add(char_literal42);

			// AST REWRITE

			// elements: ID, ID

			// token labels: 

			// rule labels: retval

			// token list labels: 

			// rule list labels: 

			// wildcard labels: 

			if ( state.backtracking==0 ) {

			retval.tree = root_0;

			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();