|
1
|
|
|
// $ANTLR null /home/alessandro/opt/antlr/ddl3/ddl3.g 2021-03-11 11:26:35 |
|
2
|
|
|
package it.cnr.istc.pst.platinum.ai.lang.ddl.v3.parser; |
|
3
|
|
|
|
|
4
|
|
|
|
|
5
|
|
|
import java.util.HashMap; |
|
6
|
|
|
|
|
7
|
|
|
import org.antlr.runtime.BaseRecognizer; |
|
8
|
|
|
import org.antlr.runtime.BitSet; |
|
9
|
|
|
import org.antlr.runtime.DFA; |
|
10
|
|
|
import org.antlr.runtime.EarlyExitException; |
|
11
|
|
|
import org.antlr.runtime.IntStream; |
|
12
|
|
|
import org.antlr.runtime.MismatchedSetException; |
|
13
|
|
|
import org.antlr.runtime.NoViableAltException; |
|
14
|
|
|
import org.antlr.runtime.Parser; |
|
15
|
|
|
import org.antlr.runtime.ParserRuleReturnScope; |
|
16
|
|
|
import org.antlr.runtime.RecognitionException; |
|
17
|
|
|
import org.antlr.runtime.RecognizerSharedState; |
|
18
|
|
|
import org.antlr.runtime.Token; |
|
19
|
|
|
import org.antlr.runtime.TokenStream; |
|
20
|
|
|
import org.antlr.runtime.tree.CommonTreeAdaptor; |
|
21
|
|
|
import org.antlr.runtime.tree.RewriteEarlyExitException; |
|
22
|
|
|
import org.antlr.runtime.tree.RewriteRuleSubtreeStream; |
|
23
|
|
|
import org.antlr.runtime.tree.RewriteRuleTokenStream; |
|
24
|
|
|
import org.antlr.runtime.tree.TreeAdaptor; |
|
25
|
|
|
|
|
26
|
|
|
|
|
27
|
|
|
@SuppressWarnings("all") |
|
28
|
|
|
public class ddl3Parser extends Parser { |
|
29
|
|
|
public static final String[] tokenNames = new String[] { |
|
30
|
|
|
"<invalid>", "<EOR>", "<DOWN>", "<UP>", "COMMENT", "ID", "INT", "VarID", |
|
31
|
|
|
"WS", "'!'", "'!='", "'('", "')'", "'*'", "'+'", "','", "'-'", "'.'", |
|
32
|
|
|
"':'", "';'", "'<'", "'<='", "'='", "'>'", "'>='", "'?'", "'AFTER'", "'AFTER-END'", |
|
33
|
|
|
"'AT'", "'AT-END'", "'AT-START'", "'BEFORE'", "'BEFORE-START'", "'BOUNDED'", |
|
34
|
|
|
"'COMPONENT'", "'COMP_TYPE'", "'CONSUMPTION'", "'CONTAINS'", "'CONTAINS-END'", |
|
35
|
|
|
"'CONTAINS-START'", "'ConsumableResource'", "'DOMAIN'", "'DURING'", "'END-END'", |
|
36
|
|
|
"'END-START'", "'ENDS-AT'", "'ENDS-DURING'", "'EQUALS'", "'ESTA_LIGHT'", |
|
37
|
|
|
"'ESTA_LIGHT_MAX_CONSUMPTION'", "'EnumerationParameterType'", "'FINISHED-BY'", |
|
38
|
|
|
"'FINISHES'", "'FLEXIBLE'", "'INF'", "'MEETS'", "'MET-BY'", "'NumericParameterType'", |
|
39
|
|
|
"'OVERLAPPED-BY'", "'OVERLAPS'", "'PAR_TYPE'", "'PROBLEM'", "'PRODUCTION'", |
|
40
|
|
|
"'REQUIREMENT'", "'RenewableResource'", "'START-END'", "'START-START'", |
|
41
|
|
|
"'STARTED-BY'", "'STARTS'", "'STARTS-AT'", "'STARTS-DURING'", "'SYNCHRONIZE'", |
|
42
|
|
|
"'SimpleGroundStateVariable'", "'SingletonStateVariable'", "'TEMPORAL_MODULE'", |
|
43
|
|
|
"'VALUE'", "'['", "']'", "'c'", "'u'", "'{'", "'}'" |
|
44
|
|
|
}; |
|
45
|
|
|
public static final int EOF=-1; |
|
46
|
|
|
public static final int T__9=9; |
|
47
|
|
|
public static final int T__10=10; |
|
48
|
|
|
public static final int T__11=11; |
|
49
|
|
|
public static final int T__12=12; |
|
50
|
|
|
public static final int T__13=13; |
|
51
|
|
|
public static final int T__14=14; |
|
52
|
|
|
public static final int T__15=15; |
|
53
|
|
|
public static final int T__16=16; |
|
54
|
|
|
public static final int T__17=17; |
|
55
|
|
|
public static final int T__18=18; |
|
56
|
|
|
public static final int T__19=19; |
|
57
|
|
|
public static final int T__20=20; |
|
58
|
|
|
public static final int T__21=21; |
|
59
|
|
|
public static final int T__22=22; |
|
60
|
|
|
public static final int T__23=23; |
|
61
|
|
|
public static final int T__24=24; |
|
62
|
|
|
public static final int T__25=25; |
|
63
|
|
|
public static final int T__26=26; |
|
64
|
|
|
public static final int T__27=27; |
|
65
|
|
|
public static final int T__28=28; |
|
66
|
|
|
public static final int T__29=29; |
|
67
|
|
|
public static final int T__30=30; |
|
68
|
|
|
public static final int T__31=31; |
|
69
|
|
|
public static final int T__32=32; |
|
70
|
|
|
public static final int T__33=33; |
|
71
|
|
|
public static final int T__34=34; |
|
72
|
|
|
public static final int T__35=35; |
|
73
|
|
|
public static final int T__36=36; |
|
74
|
|
|
public static final int T__37=37; |
|
75
|
|
|
public static final int T__38=38; |
|
76
|
|
|
public static final int T__39=39; |
|
77
|
|
|
public static final int T__40=40; |
|
78
|
|
|
public static final int T__41=41; |
|
79
|
|
|
public static final int T__42=42; |
|
80
|
|
|
public static final int T__43=43; |
|
81
|
|
|
public static final int T__44=44; |
|
82
|
|
|
public static final int T__45=45; |
|
83
|
|
|
public static final int T__46=46; |
|
84
|
|
|
public static final int T__47=47; |
|
85
|
|
|
public static final int T__48=48; |
|
86
|
|
|
public static final int T__49=49; |
|
87
|
|
|
public static final int T__50=50; |
|
88
|
|
|
public static final int T__51=51; |
|
89
|
|
|
public static final int T__52=52; |
|
90
|
|
|
public static final int T__53=53; |
|
91
|
|
|
public static final int T__54=54; |
|
92
|
|
|
public static final int T__55=55; |
|
93
|
|
|
public static final int T__56=56; |
|
94
|
|
|
public static final int T__57=57; |
|
95
|
|
|
public static final int T__58=58; |
|
96
|
|
|
public static final int T__59=59; |
|
97
|
|
|
public static final int T__60=60; |
|
98
|
|
|
public static final int T__61=61; |
|
99
|
|
|
public static final int T__62=62; |
|
100
|
|
|
public static final int T__63=63; |
|
101
|
|
|
public static final int T__64=64; |
|
102
|
|
|
public static final int T__65=65; |
|
103
|
|
|
public static final int T__66=66; |
|
104
|
|
|
public static final int T__67=67; |
|
105
|
|
|
public static final int T__68=68; |
|
106
|
|
|
public static final int T__69=69; |
|
107
|
|
|
public static final int T__70=70; |
|
108
|
|
|
public static final int T__71=71; |
|
109
|
|
|
public static final int T__72=72; |
|
110
|
|
|
public static final int T__73=73; |
|
111
|
|
|
public static final int T__74=74; |
|
112
|
|
|
public static final int T__75=75; |
|
113
|
|
|
public static final int T__76=76; |
|
114
|
|
|
public static final int T__77=77; |
|
115
|
|
|
public static final int T__78=78; |
|
116
|
|
|
public static final int T__79=79; |
|
117
|
|
|
public static final int T__80=80; |
|
118
|
|
|
public static final int T__81=81; |
|
119
|
|
|
public static final int COMMENT=4; |
|
120
|
|
|
public static final int ID=5; |
|
121
|
|
|
public static final int INT=6; |
|
122
|
|
|
public static final int VarID=7; |
|
123
|
|
|
public static final int WS=8; |
|
124
|
|
|
|
|
125
|
|
|
// delegates |
|
126
|
|
|
public Parser[] getDelegates() { |
|
127
|
|
|
return new Parser[] {}; |
|
128
|
|
|
} |
|
129
|
|
|
|
|
130
|
|
|
// delegators |
|
131
|
|
|
|
|
132
|
|
|
|
|
133
|
|
|
public ddl3Parser(TokenStream input) { |
|
134
|
|
|
this(input, new RecognizerSharedState()); |
|
135
|
|
|
} |
|
136
|
|
|
public ddl3Parser(TokenStream input, RecognizerSharedState state) { |
|
137
|
|
|
super(input, state); |
|
138
|
|
|
this.state.ruleMemo = new HashMap[164+1]; |
|
139
|
|
|
|
|
140
|
|
|
|
|
141
|
|
|
} |
|
142
|
|
|
|
|
143
|
|
|
protected TreeAdaptor adaptor = new CommonTreeAdaptor(); |
|
144
|
|
|
|
|
145
|
|
|
public void setTreeAdaptor(TreeAdaptor adaptor) { |
|
146
|
|
|
this.adaptor = adaptor; |
|
147
|
|
|
} |
|
148
|
|
|
public TreeAdaptor getTreeAdaptor() { |
|
149
|
|
|
return adaptor; |
|
150
|
|
|
} |
|
151
|
|
|
@Override public String[] getTokenNames() { return ddl3Parser.tokenNames; } |
|
152
|
|
|
@Override public String getGrammarFileName() { return "/home/alessandro/opt/antlr/ddl3/ddl3.g"; } |
|
153
|
|
|
|
|
154
|
|
|
|
|
155
|
|
|
public static class ddl_return extends ParserRuleReturnScope { |
|
156
|
|
|
Object tree; |
|
157
|
|
|
@Override |
|
158
|
|
|
public Object getTree() { return tree; } |
|
159
|
|
|
}; |
|
160
|
|
|
|
|
161
|
|
|
|
|
162
|
|
|
// $ANTLR start "ddl" |
|
163
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:1: ddl : ( domain ( problem )? -> ^( 'DOMAIN' domain ( problem )? ) | problem -> ^( 'PROBLEM' problem ) ); |
|
164
|
|
|
public final ddl3Parser.ddl_return ddl() throws RecognitionException { |
|
165
|
|
|
ddl3Parser.ddl_return retval = new ddl3Parser.ddl_return(); |
|
166
|
|
|
retval.start = input.LT(1); |
|
167
|
|
|
int ddl_StartIndex = input.index(); |
|
168
|
|
|
|
|
169
|
|
|
Object root_0 = null; |
|
170
|
|
|
|
|
171
|
|
|
ParserRuleReturnScope domain1 =null; |
|
172
|
|
|
ParserRuleReturnScope problem2 =null; |
|
173
|
|
|
ParserRuleReturnScope problem3 =null; |
|
174
|
|
|
|
|
175
|
|
|
RewriteRuleSubtreeStream stream_problem=new RewriteRuleSubtreeStream(adaptor,"rule problem"); |
|
176
|
|
|
RewriteRuleSubtreeStream stream_domain=new RewriteRuleSubtreeStream(adaptor,"rule domain"); |
|
177
|
|
|
|
|
178
|
|
|
try { |
|
179
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; } |
|
180
|
|
|
|
|
181
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:5: ( domain ( problem )? -> ^( 'DOMAIN' domain ( problem )? ) | problem -> ^( 'PROBLEM' problem ) ) |
|
182
|
|
|
int alt2=2; |
|
183
|
|
|
int LA2_0 = input.LA(1); |
|
184
|
|
|
if ( (LA2_0==41) ) { |
|
185
|
|
|
alt2=1; |
|
186
|
|
|
} |
|
187
|
|
|
else if ( (LA2_0==61) ) { |
|
188
|
|
|
alt2=2; |
|
189
|
|
|
} |
|
190
|
|
|
|
|
191
|
|
|
else { |
|
192
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
193
|
|
|
NoViableAltException nvae = |
|
194
|
|
|
new NoViableAltException("", 2, 0, input); |
|
195
|
|
|
throw nvae; |
|
196
|
|
|
} |
|
197
|
|
|
|
|
198
|
|
|
switch (alt2) { |
|
199
|
|
|
case 1 : |
|
200
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:7: domain ( problem )? |
|
201
|
|
|
{ |
|
202
|
|
|
pushFollow(FOLLOW_domain_in_ddl42); |
|
203
|
|
|
domain1=domain(); |
|
204
|
|
|
state._fsp--; |
|
205
|
|
|
if (state.failed) return retval; |
|
206
|
|
|
if ( state.backtracking==0 ) stream_domain.add(domain1.getTree()); |
|
207
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:14: ( problem )? |
|
208
|
|
|
int alt1=2; |
|
209
|
|
|
int LA1_0 = input.LA(1); |
|
210
|
|
|
if ( (LA1_0==61) ) { |
|
211
|
|
|
alt1=1; |
|
212
|
|
|
} |
|
213
|
|
|
switch (alt1) { |
|
214
|
|
|
case 1 : |
|
215
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:15: problem |
|
216
|
|
|
{ |
|
217
|
|
|
pushFollow(FOLLOW_problem_in_ddl45); |
|
218
|
|
|
problem2=problem(); |
|
219
|
|
|
state._fsp--; |
|
220
|
|
|
if (state.failed) return retval; |
|
221
|
|
|
if ( state.backtracking==0 ) stream_problem.add(problem2.getTree()); |
|
222
|
|
|
} |
|
223
|
|
|
break; |
|
224
|
|
|
|
|
225
|
|
|
} |
|
226
|
|
|
|
|
227
|
|
|
// AST REWRITE |
|
228
|
|
|
// elements: problem, domain, 41 |
|
229
|
|
|
// token labels: |
|
230
|
|
|
// rule labels: retval |
|
231
|
|
|
// token list labels: |
|
232
|
|
|
// rule list labels: |
|
233
|
|
|
// wildcard labels: |
|
234
|
|
|
if ( state.backtracking==0 ) { |
|
235
|
|
|
retval.tree = root_0; |
|
236
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
237
|
|
|
|
|
238
|
|
|
root_0 = (Object)adaptor.nil(); |
|
239
|
|
|
// 9:25: -> ^( 'DOMAIN' domain ( problem )? ) |
|
240
|
|
|
{ |
|
241
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:27: ^( 'DOMAIN' domain ( problem )? ) |
|
242
|
|
|
{ |
|
243
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
244
|
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(41, "41"), root_1); |
|
245
|
|
|
adaptor.addChild(root_1, stream_domain.nextTree()); |
|
246
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:45: ( problem )? |
|
247
|
|
|
if ( stream_problem.hasNext() ) { |
|
248
|
|
|
adaptor.addChild(root_1, stream_problem.nextTree()); |
|
249
|
|
|
} |
|
250
|
|
|
stream_problem.reset(); |
|
251
|
|
|
|
|
252
|
|
|
adaptor.addChild(root_0, root_1); |
|
253
|
|
|
} |
|
254
|
|
|
|
|
255
|
|
|
} |
|
256
|
|
|
|
|
257
|
|
|
|
|
258
|
|
|
retval.tree = root_0; |
|
259
|
|
|
} |
|
260
|
|
|
|
|
261
|
|
|
} |
|
262
|
|
|
break; |
|
263
|
|
|
case 2 : |
|
264
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:59: problem |
|
265
|
|
|
{ |
|
266
|
|
|
pushFollow(FOLLOW_problem_in_ddl63); |
|
267
|
|
|
problem3=problem(); |
|
268
|
|
|
state._fsp--; |
|
269
|
|
|
if (state.failed) return retval; |
|
270
|
|
|
if ( state.backtracking==0 ) stream_problem.add(problem3.getTree()); |
|
271
|
|
|
// AST REWRITE |
|
272
|
|
|
// elements: problem, 61 |
|
273
|
|
|
// token labels: |
|
274
|
|
|
// rule labels: retval |
|
275
|
|
|
// token list labels: |
|
276
|
|
|
// rule list labels: |
|
277
|
|
|
// wildcard labels: |
|
278
|
|
|
if ( state.backtracking==0 ) { |
|
279
|
|
|
retval.tree = root_0; |
|
280
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
281
|
|
|
|
|
282
|
|
|
root_0 = (Object)adaptor.nil(); |
|
283
|
|
|
// 9:67: -> ^( 'PROBLEM' problem ) |
|
284
|
|
|
{ |
|
285
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:9:69: ^( 'PROBLEM' problem ) |
|
286
|
|
|
{ |
|
287
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
288
|
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(61, "61"), root_1); |
|
289
|
|
|
adaptor.addChild(root_1, stream_problem.nextTree()); |
|
290
|
|
|
adaptor.addChild(root_0, root_1); |
|
291
|
|
|
} |
|
292
|
|
|
|
|
293
|
|
|
} |
|
294
|
|
|
|
|
295
|
|
|
|
|
296
|
|
|
retval.tree = root_0; |
|
297
|
|
|
} |
|
298
|
|
|
|
|
299
|
|
|
} |
|
300
|
|
|
break; |
|
301
|
|
|
|
|
302
|
|
|
} |
|
303
|
|
|
retval.stop = input.LT(-1); |
|
304
|
|
|
|
|
305
|
|
|
if ( state.backtracking==0 ) { |
|
306
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
307
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
308
|
|
|
} |
|
309
|
|
|
} |
|
310
|
|
|
catch (RecognitionException re) { |
|
311
|
|
|
reportError(re); |
|
312
|
|
|
recover(input,re); |
|
313
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
314
|
|
|
} |
|
315
|
|
|
finally { |
|
316
|
|
|
// do for sure before leaving |
|
317
|
|
|
if ( state.backtracking>0 ) { memoize(input, 1, ddl_StartIndex); } |
|
318
|
|
|
|
|
319
|
|
|
} |
|
320
|
|
|
return retval; |
|
321
|
|
|
} |
|
322
|
|
|
// $ANTLR end "ddl" |
|
323
|
|
|
|
|
324
|
|
|
|
|
325
|
|
|
public static class domain_return extends ParserRuleReturnScope { |
|
326
|
|
|
Object tree; |
|
327
|
|
|
@Override |
|
328
|
|
|
public Object getTree() { return tree; } |
|
329
|
|
|
}; |
|
330
|
|
|
|
|
331
|
|
|
|
|
332
|
|
|
// $ANTLR start "domain" |
|
333
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:11:1: domain : 'DOMAIN' ID '{' temporal_module ( domain_element )* '}' -> ^( ID temporal_module ( domain_element )* ) ; |
|
334
|
|
|
public final ddl3Parser.domain_return domain() throws RecognitionException { |
|
335
|
|
|
ddl3Parser.domain_return retval = new ddl3Parser.domain_return(); |
|
336
|
|
|
retval.start = input.LT(1); |
|
337
|
|
|
int domain_StartIndex = input.index(); |
|
338
|
|
|
|
|
339
|
|
|
Object root_0 = null; |
|
340
|
|
|
|
|
341
|
|
|
Token string_literal4=null; |
|
342
|
|
|
Token ID5=null; |
|
343
|
|
|
Token char_literal6=null; |
|
344
|
|
|
Token char_literal9=null; |
|
345
|
|
|
ParserRuleReturnScope temporal_module7 =null; |
|
346
|
|
|
ParserRuleReturnScope domain_element8 =null; |
|
347
|
|
|
|
|
348
|
|
|
Object string_literal4_tree=null; |
|
349
|
|
|
Object ID5_tree=null; |
|
350
|
|
|
Object char_literal6_tree=null; |
|
351
|
|
|
Object char_literal9_tree=null; |
|
352
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
353
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
354
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
355
|
|
|
RewriteRuleTokenStream stream_41=new RewriteRuleTokenStream(adaptor,"token 41"); |
|
356
|
|
|
RewriteRuleSubtreeStream stream_domain_element=new RewriteRuleSubtreeStream(adaptor,"rule domain_element"); |
|
357
|
|
|
RewriteRuleSubtreeStream stream_temporal_module=new RewriteRuleSubtreeStream(adaptor,"rule temporal_module"); |
|
358
|
|
|
|
|
359
|
|
|
try { |
|
360
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; } |
|
361
|
|
|
|
|
362
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:2: ( 'DOMAIN' ID '{' temporal_module ( domain_element )* '}' -> ^( ID temporal_module ( domain_element )* ) ) |
|
363
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:4: 'DOMAIN' ID '{' temporal_module ( domain_element )* '}' |
|
364
|
|
|
{ |
|
365
|
|
|
string_literal4=(Token)match(input,41,FOLLOW_41_in_domain80); if (state.failed) return retval; |
|
366
|
|
|
if ( state.backtracking==0 ) stream_41.add(string_literal4); |
|
367
|
|
|
|
|
368
|
|
|
ID5=(Token)match(input,ID,FOLLOW_ID_in_domain82); if (state.failed) return retval; |
|
369
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID5); |
|
370
|
|
|
|
|
371
|
|
|
char_literal6=(Token)match(input,80,FOLLOW_80_in_domain84); if (state.failed) return retval; |
|
372
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal6); |
|
373
|
|
|
|
|
374
|
|
|
pushFollow(FOLLOW_temporal_module_in_domain86); |
|
375
|
|
|
temporal_module7=temporal_module(); |
|
376
|
|
|
state._fsp--; |
|
377
|
|
|
if (state.failed) return retval; |
|
378
|
|
|
if ( state.backtracking==0 ) stream_temporal_module.add(temporal_module7.getTree()); |
|
379
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:36: ( domain_element )* |
|
380
|
|
|
loop3: |
|
381
|
|
|
while (true) { |
|
382
|
|
|
int alt3=2; |
|
383
|
|
|
int LA3_0 = input.LA(1); |
|
384
|
|
|
if ( ((LA3_0 >= 34 && LA3_0 <= 35)||LA3_0==60||LA3_0==71) ) { |
|
385
|
|
|
alt3=1; |
|
386
|
|
|
} |
|
387
|
|
|
|
|
388
|
|
|
switch (alt3) { |
|
389
|
|
|
case 1 : |
|
390
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:36: domain_element |
|
391
|
|
|
{ |
|
392
|
|
|
pushFollow(FOLLOW_domain_element_in_domain88); |
|
393
|
|
|
domain_element8=domain_element(); |
|
394
|
|
|
state._fsp--; |
|
395
|
|
|
if (state.failed) return retval; |
|
396
|
|
|
if ( state.backtracking==0 ) stream_domain_element.add(domain_element8.getTree()); |
|
397
|
|
|
} |
|
398
|
|
|
break; |
|
399
|
|
|
|
|
400
|
|
|
default : |
|
401
|
|
|
break loop3; |
|
402
|
|
|
} |
|
403
|
|
|
} |
|
404
|
|
|
|
|
405
|
|
|
char_literal9=(Token)match(input,81,FOLLOW_81_in_domain91); if (state.failed) return retval; |
|
406
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal9); |
|
407
|
|
|
|
|
408
|
|
|
// AST REWRITE |
|
409
|
|
|
// elements: ID, temporal_module, domain_element |
|
410
|
|
|
// token labels: |
|
411
|
|
|
// rule labels: retval |
|
412
|
|
|
// token list labels: |
|
413
|
|
|
// rule list labels: |
|
414
|
|
|
// wildcard labels: |
|
415
|
|
|
if ( state.backtracking==0 ) { |
|
416
|
|
|
retval.tree = root_0; |
|
417
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
418
|
|
|
|
|
419
|
|
|
root_0 = (Object)adaptor.nil(); |
|
420
|
|
|
// 12:56: -> ^( ID temporal_module ( domain_element )* ) |
|
421
|
|
|
{ |
|
422
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:58: ^( ID temporal_module ( domain_element )* ) |
|
423
|
|
|
{ |
|
424
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
425
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLDomain(stream_ID.nextToken()), root_1); |
|
426
|
|
|
adaptor.addChild(root_1, stream_temporal_module.nextTree()); |
|
427
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:12:90: ( domain_element )* |
|
428
|
|
|
while ( stream_domain_element.hasNext() ) { |
|
429
|
|
|
adaptor.addChild(root_1, stream_domain_element.nextTree()); |
|
430
|
|
|
} |
|
431
|
|
|
stream_domain_element.reset(); |
|
432
|
|
|
|
|
433
|
|
|
adaptor.addChild(root_0, root_1); |
|
434
|
|
|
} |
|
435
|
|
|
|
|
436
|
|
|
} |
|
437
|
|
|
|
|
438
|
|
|
|
|
439
|
|
|
retval.tree = root_0; |
|
440
|
|
|
} |
|
441
|
|
|
|
|
442
|
|
|
} |
|
443
|
|
|
|
|
444
|
|
|
retval.stop = input.LT(-1); |
|
445
|
|
|
|
|
446
|
|
|
if ( state.backtracking==0 ) { |
|
447
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
448
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
449
|
|
|
} |
|
450
|
|
|
} |
|
451
|
|
|
catch (RecognitionException re) { |
|
452
|
|
|
reportError(re); |
|
453
|
|
|
recover(input,re); |
|
454
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
455
|
|
|
} |
|
456
|
|
|
finally { |
|
457
|
|
|
// do for sure before leaving |
|
458
|
|
|
if ( state.backtracking>0 ) { memoize(input, 2, domain_StartIndex); } |
|
459
|
|
|
|
|
460
|
|
|
} |
|
461
|
|
|
return retval; |
|
462
|
|
|
} |
|
463
|
|
|
// $ANTLR end "domain" |
|
464
|
|
|
|
|
465
|
|
|
|
|
466
|
|
|
public static class temporal_module_return extends ParserRuleReturnScope { |
|
467
|
|
|
Object tree; |
|
468
|
|
|
@Override |
|
469
|
|
|
public Object getTree() { return tree; } |
|
470
|
|
|
}; |
|
471
|
|
|
|
|
472
|
|
|
|
|
473
|
|
|
// $ANTLR start "temporal_module" |
|
474
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:14:1: temporal_module : 'TEMPORAL_MODULE' ID '=' range ',' INT ';' -> ^( ID range INT ) ; |
|
475
|
|
|
public final ddl3Parser.temporal_module_return temporal_module() throws RecognitionException { |
|
476
|
|
|
ddl3Parser.temporal_module_return retval = new ddl3Parser.temporal_module_return(); |
|
477
|
|
|
retval.start = input.LT(1); |
|
478
|
|
|
int temporal_module_StartIndex = input.index(); |
|
479
|
|
|
|
|
480
|
|
|
Object root_0 = null; |
|
481
|
|
|
|
|
482
|
|
|
Token string_literal10=null; |
|
483
|
|
|
Token ID11=null; |
|
484
|
|
|
Token char_literal12=null; |
|
485
|
|
|
Token char_literal14=null; |
|
486
|
|
|
Token INT15=null; |
|
487
|
|
|
Token char_literal16=null; |
|
488
|
|
|
ParserRuleReturnScope range13 =null; |
|
489
|
|
|
|
|
490
|
|
|
Object string_literal10_tree=null; |
|
491
|
|
|
Object ID11_tree=null; |
|
492
|
|
|
Object char_literal12_tree=null; |
|
493
|
|
|
Object char_literal14_tree=null; |
|
494
|
|
|
Object INT15_tree=null; |
|
495
|
|
|
Object char_literal16_tree=null; |
|
496
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
497
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
498
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
499
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
500
|
|
|
RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74"); |
|
501
|
|
|
RewriteRuleTokenStream stream_INT=new RewriteRuleTokenStream(adaptor,"token INT"); |
|
502
|
|
|
RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range"); |
|
503
|
|
|
|
|
504
|
|
View Code Duplication |
try { |
|
|
|
|
|
|
505
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; } |
|
506
|
|
|
|
|
507
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:2: ( 'TEMPORAL_MODULE' ID '=' range ',' INT ';' -> ^( ID range INT ) ) |
|
508
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:4: 'TEMPORAL_MODULE' ID '=' range ',' INT ';' |
|
509
|
|
|
{ |
|
510
|
|
|
string_literal10=(Token)match(input,74,FOLLOW_74_in_temporal_module113); if (state.failed) return retval; |
|
511
|
|
|
if ( state.backtracking==0 ) stream_74.add(string_literal10); |
|
512
|
|
|
|
|
513
|
|
|
ID11=(Token)match(input,ID,FOLLOW_ID_in_temporal_module115); if (state.failed) return retval; |
|
514
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID11); |
|
515
|
|
|
|
|
516
|
|
|
char_literal12=(Token)match(input,22,FOLLOW_22_in_temporal_module117); if (state.failed) return retval; |
|
517
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal12); |
|
518
|
|
|
|
|
519
|
|
|
pushFollow(FOLLOW_range_in_temporal_module119); |
|
520
|
|
|
range13=range(); |
|
521
|
|
|
state._fsp--; |
|
522
|
|
|
if (state.failed) return retval; |
|
523
|
|
|
if ( state.backtracking==0 ) stream_range.add(range13.getTree()); |
|
524
|
|
|
char_literal14=(Token)match(input,15,FOLLOW_15_in_temporal_module121); if (state.failed) return retval; |
|
525
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal14); |
|
526
|
|
|
|
|
527
|
|
|
INT15=(Token)match(input,INT,FOLLOW_INT_in_temporal_module123); if (state.failed) return retval; |
|
528
|
|
|
if ( state.backtracking==0 ) stream_INT.add(INT15); |
|
529
|
|
|
|
|
530
|
|
|
char_literal16=(Token)match(input,19,FOLLOW_19_in_temporal_module125); if (state.failed) return retval; |
|
531
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal16); |
|
532
|
|
|
|
|
533
|
|
|
// AST REWRITE |
|
534
|
|
|
// elements: INT, range, ID |
|
535
|
|
|
// token labels: |
|
536
|
|
|
// rule labels: retval |
|
537
|
|
|
// token list labels: |
|
538
|
|
|
// rule list labels: |
|
539
|
|
|
// wildcard labels: |
|
540
|
|
|
if ( state.backtracking==0 ) { |
|
541
|
|
|
retval.tree = root_0; |
|
542
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
543
|
|
|
|
|
544
|
|
|
root_0 = (Object)adaptor.nil(); |
|
545
|
|
|
// 15:47: -> ^( ID range INT ) |
|
546
|
|
|
{ |
|
547
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:15:49: ^( ID range INT ) |
|
548
|
|
|
{ |
|
549
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
550
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalModule(stream_ID.nextToken()), root_1); |
|
551
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
552
|
|
|
adaptor.addChild(root_1, stream_INT.nextNode()); |
|
553
|
|
|
adaptor.addChild(root_0, root_1); |
|
554
|
|
|
} |
|
555
|
|
|
|
|
556
|
|
|
} |
|
557
|
|
|
|
|
558
|
|
|
|
|
559
|
|
|
retval.tree = root_0; |
|
560
|
|
|
} |
|
561
|
|
|
|
|
562
|
|
|
} |
|
563
|
|
|
|
|
564
|
|
|
retval.stop = input.LT(-1); |
|
565
|
|
|
|
|
566
|
|
|
if ( state.backtracking==0 ) { |
|
567
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
568
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
569
|
|
|
} |
|
570
|
|
|
} |
|
571
|
|
|
catch (RecognitionException re) { |
|
572
|
|
|
reportError(re); |
|
573
|
|
|
recover(input,re); |
|
574
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
575
|
|
|
} |
|
576
|
|
|
finally { |
|
577
|
|
|
// do for sure before leaving |
|
578
|
|
|
if ( state.backtracking>0 ) { memoize(input, 3, temporal_module_StartIndex); } |
|
579
|
|
|
|
|
580
|
|
|
} |
|
581
|
|
|
return retval; |
|
582
|
|
|
} |
|
583
|
|
|
// $ANTLR end "temporal_module" |
|
584
|
|
|
|
|
585
|
|
|
|
|
586
|
|
|
public static class domain_element_return extends ParserRuleReturnScope { |
|
587
|
|
|
Object tree; |
|
588
|
|
|
@Override |
|
589
|
|
|
public Object getTree() { return tree; } |
|
590
|
|
|
}; |
|
591
|
|
|
|
|
592
|
|
|
|
|
593
|
|
|
// $ANTLR start "domain_element" |
|
594
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:17:1: domain_element : ( parameter_type | component_type | component | timeline_synchronization ); |
|
595
|
|
|
public final ddl3Parser.domain_element_return domain_element() throws RecognitionException { |
|
596
|
|
|
ddl3Parser.domain_element_return retval = new ddl3Parser.domain_element_return(); |
|
597
|
|
|
retval.start = input.LT(1); |
|
598
|
|
|
int domain_element_StartIndex = input.index(); |
|
599
|
|
|
|
|
600
|
|
|
Object root_0 = null; |
|
601
|
|
|
|
|
602
|
|
|
ParserRuleReturnScope parameter_type17 =null; |
|
603
|
|
|
ParserRuleReturnScope component_type18 =null; |
|
604
|
|
|
ParserRuleReturnScope component19 =null; |
|
605
|
|
|
ParserRuleReturnScope timeline_synchronization20 =null; |
|
606
|
|
|
|
|
607
|
|
|
|
|
608
|
|
|
try { |
|
609
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; } |
|
610
|
|
|
|
|
611
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:2: ( parameter_type | component_type | component | timeline_synchronization ) |
|
612
|
|
|
int alt4=4; |
|
613
|
|
View Code Duplication |
switch ( input.LA(1) ) { |
|
|
|
|
|
|
614
|
|
|
case 60: |
|
615
|
|
|
{ |
|
616
|
|
|
alt4=1; |
|
617
|
|
|
} |
|
618
|
|
|
break; |
|
619
|
|
|
case 35: |
|
620
|
|
|
{ |
|
621
|
|
|
alt4=2; |
|
622
|
|
|
} |
|
623
|
|
|
break; |
|
624
|
|
|
case 34: |
|
625
|
|
|
{ |
|
626
|
|
|
alt4=3; |
|
627
|
|
|
} |
|
628
|
|
|
break; |
|
629
|
|
|
case 71: |
|
630
|
|
|
{ |
|
631
|
|
|
alt4=4; |
|
632
|
|
|
} |
|
633
|
|
|
break; |
|
634
|
|
|
default: |
|
635
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
636
|
|
|
NoViableAltException nvae = |
|
637
|
|
|
new NoViableAltException("", 4, 0, input); |
|
638
|
|
|
throw nvae; |
|
639
|
|
|
} |
|
640
|
|
|
switch (alt4) { |
|
641
|
|
|
case 1 : |
|
642
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:4: parameter_type |
|
643
|
|
|
{ |
|
644
|
|
|
root_0 = (Object)adaptor.nil(); |
|
645
|
|
|
|
|
646
|
|
|
|
|
647
|
|
|
pushFollow(FOLLOW_parameter_type_in_domain_element146); |
|
648
|
|
|
parameter_type17=parameter_type(); |
|
649
|
|
|
state._fsp--; |
|
650
|
|
|
if (state.failed) return retval; |
|
651
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_type17.getTree()); |
|
652
|
|
|
|
|
653
|
|
|
} |
|
654
|
|
|
break; |
|
655
|
|
|
case 2 : |
|
656
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:21: component_type |
|
657
|
|
|
{ |
|
658
|
|
|
root_0 = (Object)adaptor.nil(); |
|
659
|
|
|
|
|
660
|
|
|
|
|
661
|
|
|
pushFollow(FOLLOW_component_type_in_domain_element150); |
|
662
|
|
|
component_type18=component_type(); |
|
663
|
|
|
state._fsp--; |
|
664
|
|
|
if (state.failed) return retval; |
|
665
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, component_type18.getTree()); |
|
666
|
|
|
|
|
667
|
|
|
} |
|
668
|
|
|
break; |
|
669
|
|
|
case 3 : |
|
670
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:38: component |
|
671
|
|
|
{ |
|
672
|
|
|
root_0 = (Object)adaptor.nil(); |
|
673
|
|
|
|
|
674
|
|
|
|
|
675
|
|
|
pushFollow(FOLLOW_component_in_domain_element154); |
|
676
|
|
|
component19=component(); |
|
677
|
|
|
state._fsp--; |
|
678
|
|
|
if (state.failed) return retval; |
|
679
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, component19.getTree()); |
|
680
|
|
|
|
|
681
|
|
|
} |
|
682
|
|
|
break; |
|
683
|
|
|
case 4 : |
|
684
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:18:50: timeline_synchronization |
|
685
|
|
|
{ |
|
686
|
|
|
root_0 = (Object)adaptor.nil(); |
|
687
|
|
|
|
|
688
|
|
|
|
|
689
|
|
|
pushFollow(FOLLOW_timeline_synchronization_in_domain_element158); |
|
690
|
|
|
timeline_synchronization20=timeline_synchronization(); |
|
691
|
|
|
state._fsp--; |
|
692
|
|
|
if (state.failed) return retval; |
|
693
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, timeline_synchronization20.getTree()); |
|
694
|
|
|
|
|
695
|
|
|
} |
|
696
|
|
|
break; |
|
697
|
|
|
|
|
698
|
|
|
} |
|
699
|
|
|
retval.stop = input.LT(-1); |
|
700
|
|
|
|
|
701
|
|
|
if ( state.backtracking==0 ) { |
|
702
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
703
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
704
|
|
|
} |
|
705
|
|
|
} |
|
706
|
|
|
catch (RecognitionException re) { |
|
707
|
|
|
reportError(re); |
|
708
|
|
|
recover(input,re); |
|
709
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
710
|
|
|
} |
|
711
|
|
|
finally { |
|
712
|
|
|
// do for sure before leaving |
|
713
|
|
|
if ( state.backtracking>0 ) { memoize(input, 4, domain_element_StartIndex); } |
|
714
|
|
|
|
|
715
|
|
|
} |
|
716
|
|
|
return retval; |
|
717
|
|
|
} |
|
718
|
|
|
// $ANTLR end "domain_element" |
|
719
|
|
|
|
|
720
|
|
|
|
|
721
|
|
|
public static class parameter_type_return extends ParserRuleReturnScope { |
|
722
|
|
|
Object tree; |
|
723
|
|
|
@Override |
|
724
|
|
|
public Object getTree() { return tree; } |
|
725
|
|
|
}; |
|
726
|
|
|
|
|
727
|
|
|
|
|
728
|
|
|
// $ANTLR start "parameter_type" |
|
729
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:21:1: parameter_type : ( numeric_parameter_type | enumeration_parameter_type ); |
|
730
|
|
|
public final ddl3Parser.parameter_type_return parameter_type() throws RecognitionException { |
|
731
|
|
|
ddl3Parser.parameter_type_return retval = new ddl3Parser.parameter_type_return(); |
|
732
|
|
|
retval.start = input.LT(1); |
|
733
|
|
|
int parameter_type_StartIndex = input.index(); |
|
734
|
|
|
|
|
735
|
|
|
Object root_0 = null; |
|
736
|
|
|
|
|
737
|
|
|
ParserRuleReturnScope numeric_parameter_type21 =null; |
|
738
|
|
|
ParserRuleReturnScope enumeration_parameter_type22 =null; |
|
739
|
|
|
|
|
740
|
|
|
|
|
741
|
|
|
try { |
|
742
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; } |
|
743
|
|
|
|
|
744
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:2: ( numeric_parameter_type | enumeration_parameter_type ) |
|
745
|
|
|
int alt5=2; |
|
746
|
|
|
int LA5_0 = input.LA(1); |
|
747
|
|
View Code Duplication |
if ( (LA5_0==60) ) { |
|
|
|
|
|
|
748
|
|
|
int LA5_1 = input.LA(2); |
|
749
|
|
|
if ( (LA5_1==57) ) { |
|
750
|
|
|
alt5=1; |
|
751
|
|
|
} |
|
752
|
|
|
else if ( (LA5_1==50) ) { |
|
753
|
|
|
alt5=2; |
|
754
|
|
|
} |
|
755
|
|
|
|
|
756
|
|
|
else { |
|
757
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
758
|
|
|
int nvaeMark = input.mark(); |
|
759
|
|
|
try { |
|
760
|
|
|
input.consume(); |
|
761
|
|
|
NoViableAltException nvae = |
|
762
|
|
|
new NoViableAltException("", 5, 1, input); |
|
763
|
|
|
throw nvae; |
|
764
|
|
|
} finally { |
|
765
|
|
|
input.rewind(nvaeMark); |
|
766
|
|
|
} |
|
767
|
|
|
} |
|
768
|
|
|
|
|
769
|
|
|
} |
|
770
|
|
|
|
|
771
|
|
|
else { |
|
772
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
773
|
|
|
NoViableAltException nvae = |
|
774
|
|
|
new NoViableAltException("", 5, 0, input); |
|
775
|
|
|
throw nvae; |
|
776
|
|
|
} |
|
777
|
|
|
|
|
778
|
|
|
switch (alt5) { |
|
779
|
|
|
case 1 : |
|
780
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:4: numeric_parameter_type |
|
781
|
|
|
{ |
|
782
|
|
|
root_0 = (Object)adaptor.nil(); |
|
783
|
|
|
|
|
784
|
|
|
|
|
785
|
|
|
pushFollow(FOLLOW_numeric_parameter_type_in_parameter_type168); |
|
786
|
|
|
numeric_parameter_type21=numeric_parameter_type(); |
|
787
|
|
|
state._fsp--; |
|
788
|
|
|
if (state.failed) return retval; |
|
789
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, numeric_parameter_type21.getTree()); |
|
790
|
|
|
|
|
791
|
|
|
} |
|
792
|
|
|
break; |
|
793
|
|
|
case 2 : |
|
794
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:22:29: enumeration_parameter_type |
|
795
|
|
|
{ |
|
796
|
|
|
root_0 = (Object)adaptor.nil(); |
|
797
|
|
|
|
|
798
|
|
|
|
|
799
|
|
|
pushFollow(FOLLOW_enumeration_parameter_type_in_parameter_type172); |
|
800
|
|
|
enumeration_parameter_type22=enumeration_parameter_type(); |
|
801
|
|
|
state._fsp--; |
|
802
|
|
|
if (state.failed) return retval; |
|
803
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeration_parameter_type22.getTree()); |
|
804
|
|
|
|
|
805
|
|
|
} |
|
806
|
|
|
break; |
|
807
|
|
|
|
|
808
|
|
|
} |
|
809
|
|
|
retval.stop = input.LT(-1); |
|
810
|
|
|
|
|
811
|
|
|
if ( state.backtracking==0 ) { |
|
812
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
813
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
814
|
|
|
} |
|
815
|
|
|
} |
|
816
|
|
|
catch (RecognitionException re) { |
|
817
|
|
|
reportError(re); |
|
818
|
|
|
recover(input,re); |
|
819
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
820
|
|
|
} |
|
821
|
|
|
finally { |
|
822
|
|
|
// do for sure before leaving |
|
823
|
|
|
if ( state.backtracking>0 ) { memoize(input, 5, parameter_type_StartIndex); } |
|
824
|
|
|
|
|
825
|
|
|
} |
|
826
|
|
|
return retval; |
|
827
|
|
|
} |
|
828
|
|
|
// $ANTLR end "parameter_type" |
|
829
|
|
|
|
|
830
|
|
|
|
|
831
|
|
|
public static class numeric_parameter_type_return extends ParserRuleReturnScope { |
|
832
|
|
|
Object tree; |
|
833
|
|
|
@Override |
|
834
|
|
|
public Object getTree() { return tree; } |
|
835
|
|
|
}; |
|
836
|
|
|
|
|
837
|
|
|
|
|
838
|
|
|
// $ANTLR start "numeric_parameter_type" |
|
839
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:24:1: numeric_parameter_type : 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';' -> ^( ID number number ) ; |
|
840
|
|
|
public final ddl3Parser.numeric_parameter_type_return numeric_parameter_type() throws RecognitionException { |
|
841
|
|
|
ddl3Parser.numeric_parameter_type_return retval = new ddl3Parser.numeric_parameter_type_return(); |
|
842
|
|
|
retval.start = input.LT(1); |
|
843
|
|
|
int numeric_parameter_type_StartIndex = input.index(); |
|
844
|
|
|
|
|
845
|
|
|
Object root_0 = null; |
|
846
|
|
|
|
|
847
|
|
|
Token string_literal23=null; |
|
848
|
|
|
Token string_literal24=null; |
|
849
|
|
|
Token ID25=null; |
|
850
|
|
|
Token char_literal26=null; |
|
851
|
|
|
Token char_literal27=null; |
|
852
|
|
|
Token char_literal29=null; |
|
853
|
|
|
Token char_literal31=null; |
|
854
|
|
|
Token char_literal32=null; |
|
855
|
|
|
ParserRuleReturnScope number28 =null; |
|
856
|
|
|
ParserRuleReturnScope number30 =null; |
|
857
|
|
|
|
|
858
|
|
|
Object string_literal23_tree=null; |
|
859
|
|
|
Object string_literal24_tree=null; |
|
860
|
|
|
Object ID25_tree=null; |
|
861
|
|
|
Object char_literal26_tree=null; |
|
862
|
|
|
Object char_literal27_tree=null; |
|
863
|
|
|
Object char_literal29_tree=null; |
|
864
|
|
|
Object char_literal31_tree=null; |
|
865
|
|
|
Object char_literal32_tree=null; |
|
866
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
867
|
|
|
RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77"); |
|
868
|
|
|
RewriteRuleTokenStream stream_57=new RewriteRuleTokenStream(adaptor,"token 57"); |
|
869
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
870
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
871
|
|
|
RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60"); |
|
872
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
873
|
|
|
RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76"); |
|
874
|
|
|
RewriteRuleSubtreeStream stream_number=new RewriteRuleSubtreeStream(adaptor,"rule number"); |
|
875
|
|
|
|
|
876
|
|
View Code Duplication |
try { |
|
|
|
|
|
|
877
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; } |
|
878
|
|
|
|
|
879
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:2: ( 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';' -> ^( ID number number ) ) |
|
880
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:4: 'PAR_TYPE' 'NumericParameterType' ID '=' '[' number ',' number ']' ';' |
|
881
|
|
|
{ |
|
882
|
|
|
string_literal23=(Token)match(input,60,FOLLOW_60_in_numeric_parameter_type182); if (state.failed) return retval; |
|
883
|
|
|
if ( state.backtracking==0 ) stream_60.add(string_literal23); |
|
884
|
|
|
|
|
885
|
|
|
string_literal24=(Token)match(input,57,FOLLOW_57_in_numeric_parameter_type184); if (state.failed) return retval; |
|
886
|
|
|
if ( state.backtracking==0 ) stream_57.add(string_literal24); |
|
887
|
|
|
|
|
888
|
|
|
ID25=(Token)match(input,ID,FOLLOW_ID_in_numeric_parameter_type186); if (state.failed) return retval; |
|
889
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID25); |
|
890
|
|
|
|
|
891
|
|
|
char_literal26=(Token)match(input,22,FOLLOW_22_in_numeric_parameter_type188); if (state.failed) return retval; |
|
892
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal26); |
|
893
|
|
|
|
|
894
|
|
|
char_literal27=(Token)match(input,76,FOLLOW_76_in_numeric_parameter_type190); if (state.failed) return retval; |
|
895
|
|
|
if ( state.backtracking==0 ) stream_76.add(char_literal27); |
|
896
|
|
|
|
|
897
|
|
|
pushFollow(FOLLOW_number_in_numeric_parameter_type192); |
|
898
|
|
|
number28=number(); |
|
899
|
|
|
state._fsp--; |
|
900
|
|
|
if (state.failed) return retval; |
|
901
|
|
|
if ( state.backtracking==0 ) stream_number.add(number28.getTree()); |
|
902
|
|
|
char_literal29=(Token)match(input,15,FOLLOW_15_in_numeric_parameter_type194); if (state.failed) return retval; |
|
903
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal29); |
|
904
|
|
|
|
|
905
|
|
|
pushFollow(FOLLOW_number_in_numeric_parameter_type196); |
|
906
|
|
|
number30=number(); |
|
907
|
|
|
state._fsp--; |
|
908
|
|
|
if (state.failed) return retval; |
|
909
|
|
|
if ( state.backtracking==0 ) stream_number.add(number30.getTree()); |
|
910
|
|
|
char_literal31=(Token)match(input,77,FOLLOW_77_in_numeric_parameter_type198); if (state.failed) return retval; |
|
911
|
|
|
if ( state.backtracking==0 ) stream_77.add(char_literal31); |
|
912
|
|
|
|
|
913
|
|
|
char_literal32=(Token)match(input,19,FOLLOW_19_in_numeric_parameter_type200); if (state.failed) return retval; |
|
914
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal32); |
|
915
|
|
|
|
|
916
|
|
|
// AST REWRITE |
|
917
|
|
|
// elements: number, ID, number |
|
918
|
|
|
// token labels: |
|
919
|
|
|
// rule labels: retval |
|
920
|
|
|
// token list labels: |
|
921
|
|
|
// rule list labels: |
|
922
|
|
|
// wildcard labels: |
|
923
|
|
|
if ( state.backtracking==0 ) { |
|
924
|
|
|
retval.tree = root_0; |
|
925
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
926
|
|
|
|
|
927
|
|
|
root_0 = (Object)adaptor.nil(); |
|
928
|
|
|
// 25:75: -> ^( ID number number ) |
|
929
|
|
|
{ |
|
930
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:25:77: ^( ID number number ) |
|
931
|
|
|
{ |
|
932
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
933
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterType(stream_ID.nextToken()), root_1); |
|
934
|
|
|
adaptor.addChild(root_1, stream_number.nextTree()); |
|
935
|
|
|
adaptor.addChild(root_1, stream_number.nextTree()); |
|
936
|
|
|
adaptor.addChild(root_0, root_1); |
|
937
|
|
|
} |
|
938
|
|
|
|
|
939
|
|
|
} |
|
940
|
|
|
|
|
941
|
|
|
|
|
942
|
|
|
retval.tree = root_0; |
|
943
|
|
|
} |
|
944
|
|
|
|
|
945
|
|
|
} |
|
946
|
|
|
|
|
947
|
|
|
retval.stop = input.LT(-1); |
|
948
|
|
|
|
|
949
|
|
|
if ( state.backtracking==0 ) { |
|
950
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
951
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
952
|
|
|
} |
|
953
|
|
|
} |
|
954
|
|
|
catch (RecognitionException re) { |
|
955
|
|
|
reportError(re); |
|
956
|
|
|
recover(input,re); |
|
957
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
958
|
|
|
} |
|
959
|
|
|
finally { |
|
960
|
|
|
// do for sure before leaving |
|
961
|
|
|
if ( state.backtracking>0 ) { memoize(input, 6, numeric_parameter_type_StartIndex); } |
|
962
|
|
|
|
|
963
|
|
|
} |
|
964
|
|
|
return retval; |
|
965
|
|
|
} |
|
966
|
|
|
// $ANTLR end "numeric_parameter_type" |
|
967
|
|
|
|
|
968
|
|
|
|
|
969
|
|
|
public static class enumeration_parameter_type_return extends ParserRuleReturnScope { |
|
970
|
|
|
Object tree; |
|
971
|
|
|
@Override |
|
972
|
|
|
public Object getTree() { return tree; } |
|
973
|
|
|
}; |
|
974
|
|
|
|
|
975
|
|
|
|
|
976
|
|
|
// $ANTLR start "enumeration_parameter_type" |
|
977
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:27:1: enumeration_parameter_type : 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';' -> ^( ID ( ID )* ) ; |
|
978
|
|
|
public final ddl3Parser.enumeration_parameter_type_return enumeration_parameter_type() throws RecognitionException { |
|
979
|
|
|
ddl3Parser.enumeration_parameter_type_return retval = new ddl3Parser.enumeration_parameter_type_return(); |
|
980
|
|
|
retval.start = input.LT(1); |
|
981
|
|
|
int enumeration_parameter_type_StartIndex = input.index(); |
|
982
|
|
|
|
|
983
|
|
|
Object root_0 = null; |
|
984
|
|
|
|
|
985
|
|
|
Token string_literal33=null; |
|
986
|
|
|
Token string_literal34=null; |
|
987
|
|
|
Token ID35=null; |
|
988
|
|
|
Token char_literal36=null; |
|
989
|
|
|
Token char_literal37=null; |
|
990
|
|
|
Token ID38=null; |
|
991
|
|
|
Token char_literal39=null; |
|
992
|
|
|
Token ID40=null; |
|
993
|
|
|
Token char_literal41=null; |
|
994
|
|
|
Token char_literal42=null; |
|
995
|
|
|
|
|
996
|
|
|
Object string_literal33_tree=null; |
|
997
|
|
|
Object string_literal34_tree=null; |
|
998
|
|
|
Object ID35_tree=null; |
|
999
|
|
|
Object char_literal36_tree=null; |
|
1000
|
|
|
Object char_literal37_tree=null; |
|
1001
|
|
|
Object ID38_tree=null; |
|
1002
|
|
|
Object char_literal39_tree=null; |
|
1003
|
|
|
Object ID40_tree=null; |
|
1004
|
|
|
Object char_literal41_tree=null; |
|
1005
|
|
|
Object char_literal42_tree=null; |
|
1006
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
1007
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
1008
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
1009
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
1010
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
1011
|
|
|
RewriteRuleTokenStream stream_60=new RewriteRuleTokenStream(adaptor,"token 60"); |
|
1012
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
1013
|
|
|
RewriteRuleTokenStream stream_50=new RewriteRuleTokenStream(adaptor,"token 50"); |
|
1014
|
|
|
|
|
1015
|
|
|
try { |
|
1016
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; } |
|
1017
|
|
|
|
|
1018
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:2: ( 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';' -> ^( ID ( ID )* ) ) |
|
1019
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:4: 'PAR_TYPE' 'EnumerationParameterType' ID '=' '{' ID ( ',' ID )* '}' ';' |
|
1020
|
|
|
{ |
|
1021
|
|
|
string_literal33=(Token)match(input,60,FOLLOW_60_in_enumeration_parameter_type222); if (state.failed) return retval; |
|
1022
|
|
|
if ( state.backtracking==0 ) stream_60.add(string_literal33); |
|
1023
|
|
|
|
|
1024
|
|
|
string_literal34=(Token)match(input,50,FOLLOW_50_in_enumeration_parameter_type224); if (state.failed) return retval; |
|
1025
|
|
|
if ( state.backtracking==0 ) stream_50.add(string_literal34); |
|
1026
|
|
|
|
|
1027
|
|
|
ID35=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type226); if (state.failed) return retval; |
|
1028
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID35); |
|
1029
|
|
|
|
|
1030
|
|
|
char_literal36=(Token)match(input,22,FOLLOW_22_in_enumeration_parameter_type228); if (state.failed) return retval; |
|
1031
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal36); |
|
1032
|
|
|
|
|
1033
|
|
|
char_literal37=(Token)match(input,80,FOLLOW_80_in_enumeration_parameter_type230); if (state.failed) return retval; |
|
1034
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal37); |
|
1035
|
|
|
|
|
1036
|
|
|
ID38=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type232); if (state.failed) return retval; |
|
1037
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID38); |
|
1038
|
|
|
|
|
1039
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:56: ( ',' ID )* |
|
1040
|
|
|
loop6: |
|
1041
|
|
View Code Duplication |
while (true) { |
|
|
|
|
|
|
1042
|
|
|
int alt6=2; |
|
1043
|
|
|
int LA6_0 = input.LA(1); |
|
1044
|
|
|
if ( (LA6_0==15) ) { |
|
1045
|
|
|
alt6=1; |
|
1046
|
|
|
} |
|
1047
|
|
|
|
|
1048
|
|
|
switch (alt6) { |
|
1049
|
|
|
case 1 : |
|
1050
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:57: ',' ID |
|
1051
|
|
|
{ |
|
1052
|
|
|
char_literal39=(Token)match(input,15,FOLLOW_15_in_enumeration_parameter_type235); if (state.failed) return retval; |
|
1053
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal39); |
|
1054
|
|
|
|
|
1055
|
|
|
ID40=(Token)match(input,ID,FOLLOW_ID_in_enumeration_parameter_type237); if (state.failed) return retval; |
|
1056
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID40); |
|
1057
|
|
|
|
|
1058
|
|
|
} |
|
1059
|
|
|
break; |
|
1060
|
|
|
|
|
1061
|
|
|
default : |
|
1062
|
|
|
break loop6; |
|
1063
|
|
|
} |
|
1064
|
|
|
} |
|
1065
|
|
|
|
|
1066
|
|
|
char_literal41=(Token)match(input,81,FOLLOW_81_in_enumeration_parameter_type241); if (state.failed) return retval; |
|
1067
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal41); |
|
1068
|
|
|
|
|
1069
|
|
|
char_literal42=(Token)match(input,19,FOLLOW_19_in_enumeration_parameter_type243); if (state.failed) return retval; |
|
1070
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal42); |
|
1071
|
|
|
|
|
1072
|
|
|
// AST REWRITE |
|
1073
|
|
|
// elements: ID, ID |
|
1074
|
|
|
// token labels: |
|
1075
|
|
|
// rule labels: retval |
|
1076
|
|
|
// token list labels: |
|
1077
|
|
|
// rule list labels: |
|
1078
|
|
|
// wildcard labels: |
|
1079
|
|
|
if ( state.backtracking==0 ) { |
|
1080
|
|
|
retval.tree = root_0; |
|
1081
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1082
|
|
|
|
|
1083
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1084
|
|
|
// 28:74: -> ^( ID ( ID )* ) |
|
1085
|
|
|
{ |
|
1086
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:76: ^( ID ( ID )* ) |
|
1087
|
|
|
{ |
|
1088
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1089
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLEnumerationParameterType(stream_ID.nextToken()), root_1); |
|
1090
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:28:110: ( ID )* |
|
1091
|
|
|
while ( stream_ID.hasNext() ) { |
|
1092
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
1093
|
|
|
} |
|
1094
|
|
|
stream_ID.reset(); |
|
1095
|
|
|
|
|
1096
|
|
|
adaptor.addChild(root_0, root_1); |
|
1097
|
|
|
} |
|
1098
|
|
|
|
|
1099
|
|
|
} |
|
1100
|
|
|
|
|
1101
|
|
|
|
|
1102
|
|
|
retval.tree = root_0; |
|
1103
|
|
|
} |
|
1104
|
|
|
|
|
1105
|
|
|
} |
|
1106
|
|
|
|
|
1107
|
|
|
retval.stop = input.LT(-1); |
|
1108
|
|
|
|
|
1109
|
|
|
if ( state.backtracking==0 ) { |
|
1110
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
1111
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
1112
|
|
|
} |
|
1113
|
|
|
} |
|
1114
|
|
|
catch (RecognitionException re) { |
|
1115
|
|
|
reportError(re); |
|
1116
|
|
|
recover(input,re); |
|
1117
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
1118
|
|
|
} |
|
1119
|
|
|
finally { |
|
1120
|
|
|
// do for sure before leaving |
|
1121
|
|
|
if ( state.backtracking>0 ) { memoize(input, 7, enumeration_parameter_type_StartIndex); } |
|
1122
|
|
|
|
|
1123
|
|
|
} |
|
1124
|
|
|
return retval; |
|
1125
|
|
|
} |
|
1126
|
|
|
// $ANTLR end "enumeration_parameter_type" |
|
1127
|
|
|
|
|
1128
|
|
|
|
|
1129
|
|
|
public static class temporal_relation_type_return extends ParserRuleReturnScope { |
|
1130
|
|
|
Object tree; |
|
1131
|
|
|
@Override |
|
1132
|
|
|
public Object getTree() { return tree; } |
|
1133
|
|
|
}; |
|
1134
|
|
|
|
|
1135
|
|
|
|
|
1136
|
|
|
// $ANTLR start "temporal_relation_type" |
|
1137
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:31:1: temporal_relation_type : ( 'MEETS' -> ^( 'MEETS' ) | 'MET-BY' -> ^( 'MET-BY' ) | 'BEFORE' range -> ^( 'BEFORE' range ) | 'AFTER' range -> ^( 'AFTER' range ) | 'EQUALS' -> ^( 'EQUALS' ) | 'STARTS' -> ^( 'STARTS' ) | 'STARTED-BY' -> ^( 'STARTED-BY' ) | 'FINISHES' -> ^( 'FINISHES' ) | 'FINISHED-BY' -> ^( 'FINISHED-BY' ) | 'DURING' range range -> ^( 'DURING' range range ) | 'CONTAINS' range range -> ^( 'CONTAINS' range range ) | 'OVERLAPS' range -> ^( 'OVERLAPS' range ) | 'OVERLAPPED-BY' range -> ^( 'OVERLAPPED-BY' range ) | 'STARTS-AT' -> ^( 'STARTS-AT' ) | 'ENDS-AT' -> ^( 'ENDS-AT' ) | 'AT-START' -> ^( 'AT-START' ) | 'AT-END' -> ^( 'AT-END' ) | 'BEFORE-START' range -> ^( 'BEFORE-START' range ) | 'AFTER-END' range -> ^( 'AFTER-END' range ) | 'START-START' range -> ^( 'START-START' range ) | 'START-END' range -> ^( 'START-END' range ) | 'END-START' range -> ^( 'END-START' range ) | 'END-END' range -> ^( 'END-END' range ) | 'CONTAINS-START' range range -> ^( 'CONTAINS-START' range range ) | 'CONTAINS-END' range range -> ^( 'CONTAINS-END' range range ) | 'STARTS-DURING' range range -> ^( 'STARTS-DURING' range range ) | 'ENDS-DURING' range range -> ^( 'ENDS-DURING' range range ) ); |
|
1138
|
|
|
public final ddl3Parser.temporal_relation_type_return temporal_relation_type() throws RecognitionException { |
|
1139
|
|
|
ddl3Parser.temporal_relation_type_return retval = new ddl3Parser.temporal_relation_type_return(); |
|
1140
|
|
|
retval.start = input.LT(1); |
|
1141
|
|
|
int temporal_relation_type_StartIndex = input.index(); |
|
1142
|
|
|
|
|
1143
|
|
|
Object root_0 = null; |
|
1144
|
|
|
|
|
1145
|
|
|
Token string_literal43=null; |
|
1146
|
|
|
Token string_literal44=null; |
|
1147
|
|
|
Token string_literal45=null; |
|
1148
|
|
|
Token string_literal47=null; |
|
1149
|
|
|
Token string_literal49=null; |
|
1150
|
|
|
Token string_literal50=null; |
|
1151
|
|
|
Token string_literal51=null; |
|
1152
|
|
|
Token string_literal52=null; |
|
1153
|
|
|
Token string_literal53=null; |
|
1154
|
|
|
Token string_literal54=null; |
|
1155
|
|
|
Token string_literal57=null; |
|
1156
|
|
|
Token string_literal60=null; |
|
1157
|
|
|
Token string_literal62=null; |
|
1158
|
|
|
Token string_literal64=null; |
|
1159
|
|
|
Token string_literal65=null; |
|
1160
|
|
|
Token string_literal66=null; |
|
1161
|
|
|
Token string_literal67=null; |
|
1162
|
|
|
Token string_literal68=null; |
|
1163
|
|
|
Token string_literal70=null; |
|
1164
|
|
|
Token string_literal72=null; |
|
1165
|
|
|
Token string_literal74=null; |
|
1166
|
|
|
Token string_literal76=null; |
|
1167
|
|
|
Token string_literal78=null; |
|
1168
|
|
|
Token string_literal80=null; |
|
1169
|
|
|
Token string_literal83=null; |
|
1170
|
|
|
Token string_literal86=null; |
|
1171
|
|
|
Token string_literal89=null; |
|
1172
|
|
|
ParserRuleReturnScope range46 =null; |
|
1173
|
|
|
ParserRuleReturnScope range48 =null; |
|
1174
|
|
|
ParserRuleReturnScope range55 =null; |
|
1175
|
|
|
ParserRuleReturnScope range56 =null; |
|
1176
|
|
|
ParserRuleReturnScope range58 =null; |
|
1177
|
|
|
ParserRuleReturnScope range59 =null; |
|
1178
|
|
|
ParserRuleReturnScope range61 =null; |
|
1179
|
|
|
ParserRuleReturnScope range63 =null; |
|
1180
|
|
|
ParserRuleReturnScope range69 =null; |
|
1181
|
|
|
ParserRuleReturnScope range71 =null; |
|
1182
|
|
|
ParserRuleReturnScope range73 =null; |
|
1183
|
|
|
ParserRuleReturnScope range75 =null; |
|
1184
|
|
|
ParserRuleReturnScope range77 =null; |
|
1185
|
|
|
ParserRuleReturnScope range79 =null; |
|
1186
|
|
|
ParserRuleReturnScope range81 =null; |
|
1187
|
|
|
ParserRuleReturnScope range82 =null; |
|
1188
|
|
|
ParserRuleReturnScope range84 =null; |
|
1189
|
|
|
ParserRuleReturnScope range85 =null; |
|
1190
|
|
|
ParserRuleReturnScope range87 =null; |
|
1191
|
|
|
ParserRuleReturnScope range88 =null; |
|
1192
|
|
|
ParserRuleReturnScope range90 =null; |
|
1193
|
|
|
ParserRuleReturnScope range91 =null; |
|
1194
|
|
|
|
|
1195
|
|
|
Object string_literal43_tree=null; |
|
1196
|
|
|
Object string_literal44_tree=null; |
|
1197
|
|
|
Object string_literal45_tree=null; |
|
1198
|
|
|
Object string_literal47_tree=null; |
|
1199
|
|
|
Object string_literal49_tree=null; |
|
1200
|
|
|
Object string_literal50_tree=null; |
|
1201
|
|
|
Object string_literal51_tree=null; |
|
1202
|
|
|
Object string_literal52_tree=null; |
|
1203
|
|
|
Object string_literal53_tree=null; |
|
1204
|
|
|
Object string_literal54_tree=null; |
|
1205
|
|
|
Object string_literal57_tree=null; |
|
1206
|
|
|
Object string_literal60_tree=null; |
|
1207
|
|
|
Object string_literal62_tree=null; |
|
1208
|
|
|
Object string_literal64_tree=null; |
|
1209
|
|
|
Object string_literal65_tree=null; |
|
1210
|
|
|
Object string_literal66_tree=null; |
|
1211
|
|
|
Object string_literal67_tree=null; |
|
1212
|
|
|
Object string_literal68_tree=null; |
|
1213
|
|
|
Object string_literal70_tree=null; |
|
1214
|
|
|
Object string_literal72_tree=null; |
|
1215
|
|
|
Object string_literal74_tree=null; |
|
1216
|
|
|
Object string_literal76_tree=null; |
|
1217
|
|
|
Object string_literal78_tree=null; |
|
1218
|
|
|
Object string_literal80_tree=null; |
|
1219
|
|
|
Object string_literal83_tree=null; |
|
1220
|
|
|
Object string_literal86_tree=null; |
|
1221
|
|
|
Object string_literal89_tree=null; |
|
1222
|
|
|
RewriteRuleTokenStream stream_66=new RewriteRuleTokenStream(adaptor,"token 66"); |
|
1223
|
|
|
RewriteRuleTokenStream stream_44=new RewriteRuleTokenStream(adaptor,"token 44"); |
|
1224
|
|
|
RewriteRuleTokenStream stream_67=new RewriteRuleTokenStream(adaptor,"token 67"); |
|
1225
|
|
|
RewriteRuleTokenStream stream_45=new RewriteRuleTokenStream(adaptor,"token 45"); |
|
1226
|
|
|
RewriteRuleTokenStream stream_68=new RewriteRuleTokenStream(adaptor,"token 68"); |
|
1227
|
|
|
RewriteRuleTokenStream stream_46=new RewriteRuleTokenStream(adaptor,"token 46"); |
|
1228
|
|
|
RewriteRuleTokenStream stream_47=new RewriteRuleTokenStream(adaptor,"token 47"); |
|
1229
|
|
|
RewriteRuleTokenStream stream_69=new RewriteRuleTokenStream(adaptor,"token 69"); |
|
1230
|
|
|
RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26"); |
|
1231
|
|
|
RewriteRuleTokenStream stream_27=new RewriteRuleTokenStream(adaptor,"token 27"); |
|
1232
|
|
|
RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29"); |
|
1233
|
|
|
RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70"); |
|
1234
|
|
|
RewriteRuleTokenStream stream_51=new RewriteRuleTokenStream(adaptor,"token 51"); |
|
1235
|
|
|
RewriteRuleTokenStream stream_52=new RewriteRuleTokenStream(adaptor,"token 52"); |
|
1236
|
|
|
RewriteRuleTokenStream stream_30=new RewriteRuleTokenStream(adaptor,"token 30"); |
|
1237
|
|
|
RewriteRuleTokenStream stream_31=new RewriteRuleTokenStream(adaptor,"token 31"); |
|
1238
|
|
|
RewriteRuleTokenStream stream_32=new RewriteRuleTokenStream(adaptor,"token 32"); |
|
1239
|
|
|
RewriteRuleTokenStream stream_55=new RewriteRuleTokenStream(adaptor,"token 55"); |
|
1240
|
|
|
RewriteRuleTokenStream stream_56=new RewriteRuleTokenStream(adaptor,"token 56"); |
|
1241
|
|
|
RewriteRuleTokenStream stream_58=new RewriteRuleTokenStream(adaptor,"token 58"); |
|
1242
|
|
|
RewriteRuleTokenStream stream_37=new RewriteRuleTokenStream(adaptor,"token 37"); |
|
1243
|
|
|
RewriteRuleTokenStream stream_59=new RewriteRuleTokenStream(adaptor,"token 59"); |
|
1244
|
|
|
RewriteRuleTokenStream stream_38=new RewriteRuleTokenStream(adaptor,"token 38"); |
|
1245
|
|
|
RewriteRuleTokenStream stream_39=new RewriteRuleTokenStream(adaptor,"token 39"); |
|
1246
|
|
|
RewriteRuleTokenStream stream_42=new RewriteRuleTokenStream(adaptor,"token 42"); |
|
1247
|
|
|
RewriteRuleTokenStream stream_65=new RewriteRuleTokenStream(adaptor,"token 65"); |
|
1248
|
|
|
RewriteRuleTokenStream stream_43=new RewriteRuleTokenStream(adaptor,"token 43"); |
|
1249
|
|
|
RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range"); |
|
1250
|
|
|
|
|
1251
|
|
|
try { |
|
1252
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; } |
|
1253
|
|
|
|
|
1254
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:32:2: ( 'MEETS' -> ^( 'MEETS' ) | 'MET-BY' -> ^( 'MET-BY' ) | 'BEFORE' range -> ^( 'BEFORE' range ) | 'AFTER' range -> ^( 'AFTER' range ) | 'EQUALS' -> ^( 'EQUALS' ) | 'STARTS' -> ^( 'STARTS' ) | 'STARTED-BY' -> ^( 'STARTED-BY' ) | 'FINISHES' -> ^( 'FINISHES' ) | 'FINISHED-BY' -> ^( 'FINISHED-BY' ) | 'DURING' range range -> ^( 'DURING' range range ) | 'CONTAINS' range range -> ^( 'CONTAINS' range range ) | 'OVERLAPS' range -> ^( 'OVERLAPS' range ) | 'OVERLAPPED-BY' range -> ^( 'OVERLAPPED-BY' range ) | 'STARTS-AT' -> ^( 'STARTS-AT' ) | 'ENDS-AT' -> ^( 'ENDS-AT' ) | 'AT-START' -> ^( 'AT-START' ) | 'AT-END' -> ^( 'AT-END' ) | 'BEFORE-START' range -> ^( 'BEFORE-START' range ) | 'AFTER-END' range -> ^( 'AFTER-END' range ) | 'START-START' range -> ^( 'START-START' range ) | 'START-END' range -> ^( 'START-END' range ) | 'END-START' range -> ^( 'END-START' range ) | 'END-END' range -> ^( 'END-END' range ) | 'CONTAINS-START' range range -> ^( 'CONTAINS-START' range range ) | 'CONTAINS-END' range range -> ^( 'CONTAINS-END' range range ) | 'STARTS-DURING' range range -> ^( 'STARTS-DURING' range range ) | 'ENDS-DURING' range range -> ^( 'ENDS-DURING' range range ) ) |
|
1255
|
|
|
int alt7=27; |
|
1256
|
|
|
switch ( input.LA(1) ) { |
|
1257
|
|
|
case 55: |
|
1258
|
|
|
{ |
|
1259
|
|
|
alt7=1; |
|
1260
|
|
|
} |
|
1261
|
|
|
break; |
|
1262
|
|
|
case 56: |
|
1263
|
|
|
{ |
|
1264
|
|
|
alt7=2; |
|
1265
|
|
|
} |
|
1266
|
|
|
break; |
|
1267
|
|
|
case 31: |
|
1268
|
|
|
{ |
|
1269
|
|
|
alt7=3; |
|
1270
|
|
|
} |
|
1271
|
|
|
break; |
|
1272
|
|
|
case 26: |
|
1273
|
|
|
{ |
|
1274
|
|
|
alt7=4; |
|
1275
|
|
|
} |
|
1276
|
|
|
break; |
|
1277
|
|
|
case 47: |
|
1278
|
|
|
{ |
|
1279
|
|
|
alt7=5; |
|
1280
|
|
|
} |
|
1281
|
|
|
break; |
|
1282
|
|
|
case 68: |
|
1283
|
|
|
{ |
|
1284
|
|
|
alt7=6; |
|
1285
|
|
|
} |
|
1286
|
|
|
break; |
|
1287
|
|
|
case 67: |
|
1288
|
|
|
{ |
|
1289
|
|
|
alt7=7; |
|
1290
|
|
|
} |
|
1291
|
|
|
break; |
|
1292
|
|
|
case 52: |
|
1293
|
|
|
{ |
|
1294
|
|
|
alt7=8; |
|
1295
|
|
|
} |
|
1296
|
|
|
break; |
|
1297
|
|
|
case 51: |
|
1298
|
|
|
{ |
|
1299
|
|
|
alt7=9; |
|
1300
|
|
|
} |
|
1301
|
|
|
break; |
|
1302
|
|
|
case 42: |
|
1303
|
|
|
{ |
|
1304
|
|
|
alt7=10; |
|
1305
|
|
|
} |
|
1306
|
|
|
break; |
|
1307
|
|
|
case 37: |
|
1308
|
|
|
{ |
|
1309
|
|
|
alt7=11; |
|
1310
|
|
|
} |
|
1311
|
|
|
break; |
|
1312
|
|
|
case 59: |
|
1313
|
|
|
{ |
|
1314
|
|
|
alt7=12; |
|
1315
|
|
|
} |
|
1316
|
|
|
break; |
|
1317
|
|
|
case 58: |
|
1318
|
|
|
{ |
|
1319
|
|
|
alt7=13; |
|
1320
|
|
|
} |
|
1321
|
|
|
break; |
|
1322
|
|
|
case 69: |
|
1323
|
|
|
{ |
|
1324
|
|
|
alt7=14; |
|
1325
|
|
|
} |
|
1326
|
|
|
break; |
|
1327
|
|
|
case 45: |
|
1328
|
|
|
{ |
|
1329
|
|
|
alt7=15; |
|
1330
|
|
|
} |
|
1331
|
|
|
break; |
|
1332
|
|
|
case 30: |
|
1333
|
|
|
{ |
|
1334
|
|
|
alt7=16; |
|
1335
|
|
|
} |
|
1336
|
|
|
break; |
|
1337
|
|
|
case 29: |
|
1338
|
|
|
{ |
|
1339
|
|
|
alt7=17; |
|
1340
|
|
|
} |
|
1341
|
|
|
break; |
|
1342
|
|
|
case 32: |
|
1343
|
|
|
{ |
|
1344
|
|
|
alt7=18; |
|
1345
|
|
|
} |
|
1346
|
|
|
break; |
|
1347
|
|
|
case 27: |
|
1348
|
|
|
{ |
|
1349
|
|
|
alt7=19; |
|
1350
|
|
|
} |
|
1351
|
|
|
break; |
|
1352
|
|
|
case 66: |
|
1353
|
|
|
{ |
|
1354
|
|
|
alt7=20; |
|
1355
|
|
|
} |
|
1356
|
|
|
break; |
|
1357
|
|
|
case 65: |
|
1358
|
|
|
{ |
|
1359
|
|
|
alt7=21; |
|
1360
|
|
|
} |
|
1361
|
|
|
break; |
|
1362
|
|
|
case 44: |
|
1363
|
|
|
{ |
|
1364
|
|
|
alt7=22; |
|
1365
|
|
|
} |
|
1366
|
|
|
break; |
|
1367
|
|
|
case 43: |
|
1368
|
|
|
{ |
|
1369
|
|
|
alt7=23; |
|
1370
|
|
|
} |
|
1371
|
|
|
break; |
|
1372
|
|
|
case 39: |
|
1373
|
|
|
{ |
|
1374
|
|
|
alt7=24; |
|
1375
|
|
|
} |
|
1376
|
|
|
break; |
|
1377
|
|
|
case 38: |
|
1378
|
|
|
{ |
|
1379
|
|
|
alt7=25; |
|
1380
|
|
|
} |
|
1381
|
|
|
break; |
|
1382
|
|
|
case 70: |
|
1383
|
|
|
{ |
|
1384
|
|
|
alt7=26; |
|
1385
|
|
|
} |
|
1386
|
|
|
break; |
|
1387
|
|
|
case 46: |
|
1388
|
|
|
{ |
|
1389
|
|
|
alt7=27; |
|
1390
|
|
|
} |
|
1391
|
|
|
break; |
|
1392
|
|
|
default: |
|
1393
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
1394
|
|
|
NoViableAltException nvae = |
|
1395
|
|
|
new NoViableAltException("", 7, 0, input); |
|
1396
|
|
|
throw nvae; |
|
1397
|
|
|
} |
|
1398
|
|
|
switch (alt7) { |
|
1399
|
|
|
case 1 : |
|
1400
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:32:4: 'MEETS' |
|
1401
|
|
|
{ |
|
1402
|
|
|
string_literal43=(Token)match(input,55,FOLLOW_55_in_temporal_relation_type264); if (state.failed) return retval; |
|
1403
|
|
|
if ( state.backtracking==0 ) stream_55.add(string_literal43); |
|
1404
|
|
|
|
|
1405
|
|
|
// AST REWRITE |
|
1406
|
|
|
// elements: 55 |
|
1407
|
|
|
// token labels: |
|
1408
|
|
|
// rule labels: retval |
|
1409
|
|
|
// token list labels: |
|
1410
|
|
|
// rule list labels: |
|
1411
|
|
|
// wildcard labels: |
|
1412
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1413
|
|
|
retval.tree = root_0; |
|
1414
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1415
|
|
|
|
|
1416
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1417
|
|
|
// 32:12: -> ^( 'MEETS' ) |
|
1418
|
|
|
{ |
|
1419
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:32:14: ^( 'MEETS' ) |
|
1420
|
|
|
{ |
|
1421
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1422
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_55.nextToken()), root_1); |
|
1423
|
|
|
adaptor.addChild(root_0, root_1); |
|
1424
|
|
|
} |
|
1425
|
|
|
|
|
1426
|
|
|
} |
|
1427
|
|
|
|
|
1428
|
|
|
|
|
1429
|
|
|
retval.tree = root_0; |
|
1430
|
|
|
} |
|
1431
|
|
|
|
|
1432
|
|
|
} |
|
1433
|
|
|
break; |
|
1434
|
|
|
case 2 : |
|
1435
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:33:4: 'MET-BY' |
|
1436
|
|
|
{ |
|
1437
|
|
|
string_literal44=(Token)match(input,56,FOLLOW_56_in_temporal_relation_type277); if (state.failed) return retval; |
|
1438
|
|
|
if ( state.backtracking==0 ) stream_56.add(string_literal44); |
|
1439
|
|
|
|
|
1440
|
|
|
// AST REWRITE |
|
1441
|
|
|
// elements: 56 |
|
1442
|
|
|
// token labels: |
|
1443
|
|
|
// rule labels: retval |
|
1444
|
|
|
// token list labels: |
|
1445
|
|
|
// rule list labels: |
|
1446
|
|
|
// wildcard labels: |
|
1447
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1448
|
|
|
retval.tree = root_0; |
|
1449
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1450
|
|
|
|
|
1451
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1452
|
|
|
// 33:13: -> ^( 'MET-BY' ) |
|
1453
|
|
|
{ |
|
1454
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:33:15: ^( 'MET-BY' ) |
|
1455
|
|
|
{ |
|
1456
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1457
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_56.nextToken()), root_1); |
|
1458
|
|
|
adaptor.addChild(root_0, root_1); |
|
1459
|
|
|
} |
|
1460
|
|
|
|
|
1461
|
|
|
} |
|
1462
|
|
|
|
|
1463
|
|
|
|
|
1464
|
|
|
retval.tree = root_0; |
|
1465
|
|
|
} |
|
1466
|
|
|
|
|
1467
|
|
|
} |
|
1468
|
|
|
break; |
|
1469
|
|
|
case 3 : |
|
1470
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:34:4: 'BEFORE' range |
|
1471
|
|
|
{ |
|
1472
|
|
|
string_literal45=(Token)match(input,31,FOLLOW_31_in_temporal_relation_type290); if (state.failed) return retval; |
|
1473
|
|
|
if ( state.backtracking==0 ) stream_31.add(string_literal45); |
|
1474
|
|
|
|
|
1475
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type292); |
|
1476
|
|
|
range46=range(); |
|
1477
|
|
|
state._fsp--; |
|
1478
|
|
|
if (state.failed) return retval; |
|
1479
|
|
|
if ( state.backtracking==0 ) stream_range.add(range46.getTree()); |
|
1480
|
|
|
// AST REWRITE |
|
1481
|
|
|
// elements: range, 31 |
|
1482
|
|
|
// token labels: |
|
1483
|
|
|
// rule labels: retval |
|
1484
|
|
|
// token list labels: |
|
1485
|
|
|
// rule list labels: |
|
1486
|
|
|
// wildcard labels: |
|
1487
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1488
|
|
|
retval.tree = root_0; |
|
1489
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1490
|
|
|
|
|
1491
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1492
|
|
|
// 34:19: -> ^( 'BEFORE' range ) |
|
1493
|
|
|
{ |
|
1494
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:34:21: ^( 'BEFORE' range ) |
|
1495
|
|
|
{ |
|
1496
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1497
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_31.nextToken()), root_1); |
|
1498
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1499
|
|
|
adaptor.addChild(root_0, root_1); |
|
1500
|
|
|
} |
|
1501
|
|
|
|
|
1502
|
|
|
} |
|
1503
|
|
|
|
|
1504
|
|
|
|
|
1505
|
|
|
retval.tree = root_0; |
|
1506
|
|
|
} |
|
1507
|
|
|
|
|
1508
|
|
|
} |
|
1509
|
|
|
break; |
|
1510
|
|
|
case 4 : |
|
1511
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:35:4: 'AFTER' range |
|
1512
|
|
|
{ |
|
1513
|
|
|
string_literal47=(Token)match(input,26,FOLLOW_26_in_temporal_relation_type307); if (state.failed) return retval; |
|
1514
|
|
|
if ( state.backtracking==0 ) stream_26.add(string_literal47); |
|
1515
|
|
|
|
|
1516
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type309); |
|
1517
|
|
|
range48=range(); |
|
1518
|
|
|
state._fsp--; |
|
1519
|
|
|
if (state.failed) return retval; |
|
1520
|
|
|
if ( state.backtracking==0 ) stream_range.add(range48.getTree()); |
|
1521
|
|
|
// AST REWRITE |
|
1522
|
|
|
// elements: 26, range |
|
1523
|
|
|
// token labels: |
|
1524
|
|
|
// rule labels: retval |
|
1525
|
|
|
// token list labels: |
|
1526
|
|
|
// rule list labels: |
|
1527
|
|
|
// wildcard labels: |
|
1528
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1529
|
|
|
retval.tree = root_0; |
|
1530
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1531
|
|
|
|
|
1532
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1533
|
|
|
// 35:18: -> ^( 'AFTER' range ) |
|
1534
|
|
|
{ |
|
1535
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:35:20: ^( 'AFTER' range ) |
|
1536
|
|
|
{ |
|
1537
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1538
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_26.nextToken()), root_1); |
|
1539
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1540
|
|
|
adaptor.addChild(root_0, root_1); |
|
1541
|
|
|
} |
|
1542
|
|
|
|
|
1543
|
|
|
} |
|
1544
|
|
|
|
|
1545
|
|
|
|
|
1546
|
|
|
retval.tree = root_0; |
|
1547
|
|
|
} |
|
1548
|
|
|
|
|
1549
|
|
|
} |
|
1550
|
|
|
break; |
|
1551
|
|
|
case 5 : |
|
1552
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:36:4: 'EQUALS' |
|
1553
|
|
|
{ |
|
1554
|
|
|
string_literal49=(Token)match(input,47,FOLLOW_47_in_temporal_relation_type324); if (state.failed) return retval; |
|
1555
|
|
|
if ( state.backtracking==0 ) stream_47.add(string_literal49); |
|
1556
|
|
|
|
|
1557
|
|
|
// AST REWRITE |
|
1558
|
|
|
// elements: 47 |
|
1559
|
|
|
// token labels: |
|
1560
|
|
|
// rule labels: retval |
|
1561
|
|
|
// token list labels: |
|
1562
|
|
|
// rule list labels: |
|
1563
|
|
|
// wildcard labels: |
|
1564
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1565
|
|
|
retval.tree = root_0; |
|
1566
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1567
|
|
|
|
|
1568
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1569
|
|
|
// 36:13: -> ^( 'EQUALS' ) |
|
1570
|
|
|
{ |
|
1571
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:36:15: ^( 'EQUALS' ) |
|
1572
|
|
|
{ |
|
1573
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1574
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_47.nextToken()), root_1); |
|
1575
|
|
|
adaptor.addChild(root_0, root_1); |
|
1576
|
|
|
} |
|
1577
|
|
|
|
|
1578
|
|
|
} |
|
1579
|
|
|
|
|
1580
|
|
|
|
|
1581
|
|
|
retval.tree = root_0; |
|
1582
|
|
|
} |
|
1583
|
|
|
|
|
1584
|
|
|
} |
|
1585
|
|
|
break; |
|
1586
|
|
|
case 6 : |
|
1587
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:37:4: 'STARTS' |
|
1588
|
|
|
{ |
|
1589
|
|
|
string_literal50=(Token)match(input,68,FOLLOW_68_in_temporal_relation_type337); if (state.failed) return retval; |
|
1590
|
|
|
if ( state.backtracking==0 ) stream_68.add(string_literal50); |
|
1591
|
|
|
|
|
1592
|
|
|
// AST REWRITE |
|
1593
|
|
|
// elements: 68 |
|
1594
|
|
|
// token labels: |
|
1595
|
|
|
// rule labels: retval |
|
1596
|
|
|
// token list labels: |
|
1597
|
|
|
// rule list labels: |
|
1598
|
|
|
// wildcard labels: |
|
1599
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1600
|
|
|
retval.tree = root_0; |
|
1601
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1602
|
|
|
|
|
1603
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1604
|
|
|
// 37:13: -> ^( 'STARTS' ) |
|
1605
|
|
|
{ |
|
1606
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:37:15: ^( 'STARTS' ) |
|
1607
|
|
|
{ |
|
1608
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1609
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_68.nextToken()), root_1); |
|
1610
|
|
|
adaptor.addChild(root_0, root_1); |
|
1611
|
|
|
} |
|
1612
|
|
|
|
|
1613
|
|
|
} |
|
1614
|
|
|
|
|
1615
|
|
|
|
|
1616
|
|
|
retval.tree = root_0; |
|
1617
|
|
|
} |
|
1618
|
|
|
|
|
1619
|
|
|
} |
|
1620
|
|
|
break; |
|
1621
|
|
|
case 7 : |
|
1622
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:38:4: 'STARTED-BY' |
|
1623
|
|
|
{ |
|
1624
|
|
|
string_literal51=(Token)match(input,67,FOLLOW_67_in_temporal_relation_type350); if (state.failed) return retval; |
|
1625
|
|
|
if ( state.backtracking==0 ) stream_67.add(string_literal51); |
|
1626
|
|
|
|
|
1627
|
|
|
// AST REWRITE |
|
1628
|
|
|
// elements: 67 |
|
1629
|
|
|
// token labels: |
|
1630
|
|
|
// rule labels: retval |
|
1631
|
|
|
// token list labels: |
|
1632
|
|
|
// rule list labels: |
|
1633
|
|
|
// wildcard labels: |
|
1634
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1635
|
|
|
retval.tree = root_0; |
|
1636
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1637
|
|
|
|
|
1638
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1639
|
|
|
// 38:17: -> ^( 'STARTED-BY' ) |
|
1640
|
|
|
{ |
|
1641
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:38:19: ^( 'STARTED-BY' ) |
|
1642
|
|
|
{ |
|
1643
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1644
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_67.nextToken()), root_1); |
|
1645
|
|
|
adaptor.addChild(root_0, root_1); |
|
1646
|
|
|
} |
|
1647
|
|
|
|
|
1648
|
|
|
} |
|
1649
|
|
|
|
|
1650
|
|
|
|
|
1651
|
|
|
retval.tree = root_0; |
|
1652
|
|
|
} |
|
1653
|
|
|
|
|
1654
|
|
|
} |
|
1655
|
|
|
break; |
|
1656
|
|
|
case 8 : |
|
1657
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:39:4: 'FINISHES' |
|
1658
|
|
|
{ |
|
1659
|
|
|
string_literal52=(Token)match(input,52,FOLLOW_52_in_temporal_relation_type363); if (state.failed) return retval; |
|
1660
|
|
|
if ( state.backtracking==0 ) stream_52.add(string_literal52); |
|
1661
|
|
|
|
|
1662
|
|
|
// AST REWRITE |
|
1663
|
|
|
// elements: 52 |
|
1664
|
|
|
// token labels: |
|
1665
|
|
|
// rule labels: retval |
|
1666
|
|
|
// token list labels: |
|
1667
|
|
|
// rule list labels: |
|
1668
|
|
|
// wildcard labels: |
|
1669
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1670
|
|
|
retval.tree = root_0; |
|
1671
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1672
|
|
|
|
|
1673
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1674
|
|
|
// 39:15: -> ^( 'FINISHES' ) |
|
1675
|
|
|
{ |
|
1676
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:39:17: ^( 'FINISHES' ) |
|
1677
|
|
|
{ |
|
1678
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1679
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_52.nextToken()), root_1); |
|
1680
|
|
|
adaptor.addChild(root_0, root_1); |
|
1681
|
|
|
} |
|
1682
|
|
|
|
|
1683
|
|
|
} |
|
1684
|
|
|
|
|
1685
|
|
|
|
|
1686
|
|
|
retval.tree = root_0; |
|
1687
|
|
|
} |
|
1688
|
|
|
|
|
1689
|
|
|
} |
|
1690
|
|
|
break; |
|
1691
|
|
|
case 9 : |
|
1692
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:40:4: 'FINISHED-BY' |
|
1693
|
|
|
{ |
|
1694
|
|
|
string_literal53=(Token)match(input,51,FOLLOW_51_in_temporal_relation_type376); if (state.failed) return retval; |
|
1695
|
|
|
if ( state.backtracking==0 ) stream_51.add(string_literal53); |
|
1696
|
|
|
|
|
1697
|
|
|
// AST REWRITE |
|
1698
|
|
|
// elements: 51 |
|
1699
|
|
|
// token labels: |
|
1700
|
|
|
// rule labels: retval |
|
1701
|
|
|
// token list labels: |
|
1702
|
|
|
// rule list labels: |
|
1703
|
|
|
// wildcard labels: |
|
1704
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1705
|
|
|
retval.tree = root_0; |
|
1706
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1707
|
|
|
|
|
1708
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1709
|
|
|
// 40:18: -> ^( 'FINISHED-BY' ) |
|
1710
|
|
|
{ |
|
1711
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:40:20: ^( 'FINISHED-BY' ) |
|
1712
|
|
|
{ |
|
1713
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1714
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_51.nextToken()), root_1); |
|
1715
|
|
|
adaptor.addChild(root_0, root_1); |
|
1716
|
|
|
} |
|
1717
|
|
|
|
|
1718
|
|
|
} |
|
1719
|
|
|
|
|
1720
|
|
|
|
|
1721
|
|
|
retval.tree = root_0; |
|
1722
|
|
|
} |
|
1723
|
|
|
|
|
1724
|
|
|
} |
|
1725
|
|
|
break; |
|
1726
|
|
|
case 10 : |
|
1727
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:41:4: 'DURING' range range |
|
1728
|
|
|
{ |
|
1729
|
|
|
string_literal54=(Token)match(input,42,FOLLOW_42_in_temporal_relation_type389); if (state.failed) return retval; |
|
1730
|
|
|
if ( state.backtracking==0 ) stream_42.add(string_literal54); |
|
1731
|
|
|
|
|
1732
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type391); |
|
1733
|
|
|
range55=range(); |
|
1734
|
|
|
state._fsp--; |
|
1735
|
|
|
if (state.failed) return retval; |
|
1736
|
|
|
if ( state.backtracking==0 ) stream_range.add(range55.getTree()); |
|
1737
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type393); |
|
1738
|
|
|
range56=range(); |
|
1739
|
|
|
state._fsp--; |
|
1740
|
|
|
if (state.failed) return retval; |
|
1741
|
|
|
if ( state.backtracking==0 ) stream_range.add(range56.getTree()); |
|
1742
|
|
|
// AST REWRITE |
|
1743
|
|
|
// elements: range, range, 42 |
|
1744
|
|
|
// token labels: |
|
1745
|
|
|
// rule labels: retval |
|
1746
|
|
|
// token list labels: |
|
1747
|
|
|
// rule list labels: |
|
1748
|
|
|
// wildcard labels: |
|
1749
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1750
|
|
|
retval.tree = root_0; |
|
1751
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1752
|
|
|
|
|
1753
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1754
|
|
|
// 41:25: -> ^( 'DURING' range range ) |
|
1755
|
|
|
{ |
|
1756
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:41:27: ^( 'DURING' range range ) |
|
1757
|
|
|
{ |
|
1758
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1759
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_42.nextToken()), root_1); |
|
1760
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1761
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1762
|
|
|
adaptor.addChild(root_0, root_1); |
|
1763
|
|
|
} |
|
1764
|
|
|
|
|
1765
|
|
|
} |
|
1766
|
|
|
|
|
1767
|
|
|
|
|
1768
|
|
|
retval.tree = root_0; |
|
1769
|
|
|
} |
|
1770
|
|
|
|
|
1771
|
|
|
} |
|
1772
|
|
|
break; |
|
1773
|
|
|
case 11 : |
|
1774
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:42:4: 'CONTAINS' range range |
|
1775
|
|
|
{ |
|
1776
|
|
|
string_literal57=(Token)match(input,37,FOLLOW_37_in_temporal_relation_type410); if (state.failed) return retval; |
|
1777
|
|
|
if ( state.backtracking==0 ) stream_37.add(string_literal57); |
|
1778
|
|
|
|
|
1779
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type412); |
|
1780
|
|
|
range58=range(); |
|
1781
|
|
|
state._fsp--; |
|
1782
|
|
|
if (state.failed) return retval; |
|
1783
|
|
|
if ( state.backtracking==0 ) stream_range.add(range58.getTree()); |
|
1784
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type414); |
|
1785
|
|
|
range59=range(); |
|
1786
|
|
|
state._fsp--; |
|
1787
|
|
|
if (state.failed) return retval; |
|
1788
|
|
|
if ( state.backtracking==0 ) stream_range.add(range59.getTree()); |
|
1789
|
|
|
// AST REWRITE |
|
1790
|
|
|
// elements: 37, range, range |
|
1791
|
|
|
// token labels: |
|
1792
|
|
|
// rule labels: retval |
|
1793
|
|
|
// token list labels: |
|
1794
|
|
|
// rule list labels: |
|
1795
|
|
|
// wildcard labels: |
|
1796
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1797
|
|
|
retval.tree = root_0; |
|
1798
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1799
|
|
|
|
|
1800
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1801
|
|
|
// 42:27: -> ^( 'CONTAINS' range range ) |
|
1802
|
|
|
{ |
|
1803
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:42:29: ^( 'CONTAINS' range range ) |
|
1804
|
|
|
{ |
|
1805
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1806
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_37.nextToken()), root_1); |
|
1807
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1808
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1809
|
|
|
adaptor.addChild(root_0, root_1); |
|
1810
|
|
|
} |
|
1811
|
|
|
|
|
1812
|
|
|
} |
|
1813
|
|
|
|
|
1814
|
|
|
|
|
1815
|
|
|
retval.tree = root_0; |
|
1816
|
|
|
} |
|
1817
|
|
|
|
|
1818
|
|
|
} |
|
1819
|
|
|
break; |
|
1820
|
|
|
case 12 : |
|
1821
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:43:4: 'OVERLAPS' range |
|
1822
|
|
|
{ |
|
1823
|
|
|
string_literal60=(Token)match(input,59,FOLLOW_59_in_temporal_relation_type431); if (state.failed) return retval; |
|
1824
|
|
|
if ( state.backtracking==0 ) stream_59.add(string_literal60); |
|
1825
|
|
|
|
|
1826
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type433); |
|
1827
|
|
|
range61=range(); |
|
1828
|
|
|
state._fsp--; |
|
1829
|
|
|
if (state.failed) return retval; |
|
1830
|
|
|
if ( state.backtracking==0 ) stream_range.add(range61.getTree()); |
|
1831
|
|
|
// AST REWRITE |
|
1832
|
|
|
// elements: range, 59 |
|
1833
|
|
|
// token labels: |
|
1834
|
|
|
// rule labels: retval |
|
1835
|
|
|
// token list labels: |
|
1836
|
|
|
// rule list labels: |
|
1837
|
|
|
// wildcard labels: |
|
1838
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1839
|
|
|
retval.tree = root_0; |
|
1840
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1841
|
|
|
|
|
1842
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1843
|
|
|
// 43:21: -> ^( 'OVERLAPS' range ) |
|
1844
|
|
|
{ |
|
1845
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:43:23: ^( 'OVERLAPS' range ) |
|
1846
|
|
|
{ |
|
1847
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1848
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_59.nextToken()), root_1); |
|
1849
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1850
|
|
|
adaptor.addChild(root_0, root_1); |
|
1851
|
|
|
} |
|
1852
|
|
|
|
|
1853
|
|
|
} |
|
1854
|
|
|
|
|
1855
|
|
|
|
|
1856
|
|
|
retval.tree = root_0; |
|
1857
|
|
|
} |
|
1858
|
|
|
|
|
1859
|
|
|
} |
|
1860
|
|
|
break; |
|
1861
|
|
|
case 13 : |
|
1862
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:44:4: 'OVERLAPPED-BY' range |
|
1863
|
|
|
{ |
|
1864
|
|
|
string_literal62=(Token)match(input,58,FOLLOW_58_in_temporal_relation_type448); if (state.failed) return retval; |
|
1865
|
|
|
if ( state.backtracking==0 ) stream_58.add(string_literal62); |
|
1866
|
|
|
|
|
1867
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type450); |
|
1868
|
|
|
range63=range(); |
|
1869
|
|
|
state._fsp--; |
|
1870
|
|
|
if (state.failed) return retval; |
|
1871
|
|
|
if ( state.backtracking==0 ) stream_range.add(range63.getTree()); |
|
1872
|
|
|
// AST REWRITE |
|
1873
|
|
|
// elements: 58, range |
|
1874
|
|
|
// token labels: |
|
1875
|
|
|
// rule labels: retval |
|
1876
|
|
|
// token list labels: |
|
1877
|
|
|
// rule list labels: |
|
1878
|
|
|
// wildcard labels: |
|
1879
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1880
|
|
|
retval.tree = root_0; |
|
1881
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1882
|
|
|
|
|
1883
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1884
|
|
|
// 44:26: -> ^( 'OVERLAPPED-BY' range ) |
|
1885
|
|
|
{ |
|
1886
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:44:28: ^( 'OVERLAPPED-BY' range ) |
|
1887
|
|
|
{ |
|
1888
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1889
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_58.nextToken()), root_1); |
|
1890
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
1891
|
|
|
adaptor.addChild(root_0, root_1); |
|
1892
|
|
|
} |
|
1893
|
|
|
|
|
1894
|
|
|
} |
|
1895
|
|
|
|
|
1896
|
|
|
|
|
1897
|
|
|
retval.tree = root_0; |
|
1898
|
|
|
} |
|
1899
|
|
|
|
|
1900
|
|
|
} |
|
1901
|
|
|
break; |
|
1902
|
|
|
case 14 : |
|
1903
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:45:4: 'STARTS-AT' |
|
1904
|
|
|
{ |
|
1905
|
|
|
string_literal64=(Token)match(input,69,FOLLOW_69_in_temporal_relation_type465); if (state.failed) return retval; |
|
1906
|
|
|
if ( state.backtracking==0 ) stream_69.add(string_literal64); |
|
1907
|
|
|
|
|
1908
|
|
|
// AST REWRITE |
|
1909
|
|
|
// elements: 69 |
|
1910
|
|
|
// token labels: |
|
1911
|
|
|
// rule labels: retval |
|
1912
|
|
|
// token list labels: |
|
1913
|
|
|
// rule list labels: |
|
1914
|
|
|
// wildcard labels: |
|
1915
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1916
|
|
|
retval.tree = root_0; |
|
1917
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1918
|
|
|
|
|
1919
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1920
|
|
|
// 45:16: -> ^( 'STARTS-AT' ) |
|
1921
|
|
|
{ |
|
1922
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:45:18: ^( 'STARTS-AT' ) |
|
1923
|
|
|
{ |
|
1924
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1925
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_69.nextToken()), root_1); |
|
1926
|
|
|
adaptor.addChild(root_0, root_1); |
|
1927
|
|
|
} |
|
1928
|
|
|
|
|
1929
|
|
|
} |
|
1930
|
|
|
|
|
1931
|
|
|
|
|
1932
|
|
|
retval.tree = root_0; |
|
1933
|
|
|
} |
|
1934
|
|
|
|
|
1935
|
|
|
} |
|
1936
|
|
|
break; |
|
1937
|
|
|
case 15 : |
|
1938
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:46:4: 'ENDS-AT' |
|
1939
|
|
|
{ |
|
1940
|
|
|
string_literal65=(Token)match(input,45,FOLLOW_45_in_temporal_relation_type478); if (state.failed) return retval; |
|
1941
|
|
|
if ( state.backtracking==0 ) stream_45.add(string_literal65); |
|
1942
|
|
|
|
|
1943
|
|
|
// AST REWRITE |
|
1944
|
|
|
// elements: 45 |
|
1945
|
|
|
// token labels: |
|
1946
|
|
|
// rule labels: retval |
|
1947
|
|
|
// token list labels: |
|
1948
|
|
|
// rule list labels: |
|
1949
|
|
|
// wildcard labels: |
|
1950
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1951
|
|
|
retval.tree = root_0; |
|
1952
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1953
|
|
|
|
|
1954
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1955
|
|
|
// 46:14: -> ^( 'ENDS-AT' ) |
|
1956
|
|
|
{ |
|
1957
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:46:16: ^( 'ENDS-AT' ) |
|
1958
|
|
|
{ |
|
1959
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1960
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_45.nextToken()), root_1); |
|
1961
|
|
|
adaptor.addChild(root_0, root_1); |
|
1962
|
|
|
} |
|
1963
|
|
|
|
|
1964
|
|
|
} |
|
1965
|
|
|
|
|
1966
|
|
|
|
|
1967
|
|
|
retval.tree = root_0; |
|
1968
|
|
|
} |
|
1969
|
|
|
|
|
1970
|
|
|
} |
|
1971
|
|
|
break; |
|
1972
|
|
|
case 16 : |
|
1973
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:47:4: 'AT-START' |
|
1974
|
|
|
{ |
|
1975
|
|
|
string_literal66=(Token)match(input,30,FOLLOW_30_in_temporal_relation_type491); if (state.failed) return retval; |
|
1976
|
|
|
if ( state.backtracking==0 ) stream_30.add(string_literal66); |
|
1977
|
|
|
|
|
1978
|
|
|
// AST REWRITE |
|
1979
|
|
|
// elements: 30 |
|
1980
|
|
|
// token labels: |
|
1981
|
|
|
// rule labels: retval |
|
1982
|
|
|
// token list labels: |
|
1983
|
|
|
// rule list labels: |
|
1984
|
|
|
// wildcard labels: |
|
1985
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
1986
|
|
|
retval.tree = root_0; |
|
1987
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
1988
|
|
|
|
|
1989
|
|
|
root_0 = (Object)adaptor.nil(); |
|
1990
|
|
|
// 47:15: -> ^( 'AT-START' ) |
|
1991
|
|
|
{ |
|
1992
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:47:17: ^( 'AT-START' ) |
|
1993
|
|
|
{ |
|
1994
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
1995
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_30.nextToken()), root_1); |
|
1996
|
|
|
adaptor.addChild(root_0, root_1); |
|
1997
|
|
|
} |
|
1998
|
|
|
|
|
1999
|
|
|
} |
|
2000
|
|
|
|
|
2001
|
|
|
|
|
2002
|
|
|
retval.tree = root_0; |
|
2003
|
|
|
} |
|
2004
|
|
|
|
|
2005
|
|
|
} |
|
2006
|
|
|
break; |
|
2007
|
|
|
case 17 : |
|
2008
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:48:4: 'AT-END' |
|
2009
|
|
|
{ |
|
2010
|
|
|
string_literal67=(Token)match(input,29,FOLLOW_29_in_temporal_relation_type504); if (state.failed) return retval; |
|
2011
|
|
|
if ( state.backtracking==0 ) stream_29.add(string_literal67); |
|
2012
|
|
|
|
|
2013
|
|
|
// AST REWRITE |
|
2014
|
|
|
// elements: 29 |
|
2015
|
|
|
// token labels: |
|
2016
|
|
|
// rule labels: retval |
|
2017
|
|
|
// token list labels: |
|
2018
|
|
|
// rule list labels: |
|
2019
|
|
|
// wildcard labels: |
|
2020
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2021
|
|
|
retval.tree = root_0; |
|
2022
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2023
|
|
|
|
|
2024
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2025
|
|
|
// 48:13: -> ^( 'AT-END' ) |
|
2026
|
|
|
{ |
|
2027
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:48:15: ^( 'AT-END' ) |
|
2028
|
|
|
{ |
|
2029
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2030
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_29.nextToken()), root_1); |
|
2031
|
|
|
adaptor.addChild(root_0, root_1); |
|
2032
|
|
|
} |
|
2033
|
|
|
|
|
2034
|
|
|
} |
|
2035
|
|
|
|
|
2036
|
|
|
|
|
2037
|
|
|
retval.tree = root_0; |
|
2038
|
|
|
} |
|
2039
|
|
|
|
|
2040
|
|
|
} |
|
2041
|
|
|
break; |
|
2042
|
|
|
case 18 : |
|
2043
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:49:4: 'BEFORE-START' range |
|
2044
|
|
|
{ |
|
2045
|
|
|
string_literal68=(Token)match(input,32,FOLLOW_32_in_temporal_relation_type517); if (state.failed) return retval; |
|
2046
|
|
|
if ( state.backtracking==0 ) stream_32.add(string_literal68); |
|
2047
|
|
|
|
|
2048
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type519); |
|
2049
|
|
|
range69=range(); |
|
2050
|
|
|
state._fsp--; |
|
2051
|
|
|
if (state.failed) return retval; |
|
2052
|
|
|
if ( state.backtracking==0 ) stream_range.add(range69.getTree()); |
|
2053
|
|
|
// AST REWRITE |
|
2054
|
|
|
// elements: range, 32 |
|
2055
|
|
|
// token labels: |
|
2056
|
|
|
// rule labels: retval |
|
2057
|
|
|
// token list labels: |
|
2058
|
|
|
// rule list labels: |
|
2059
|
|
|
// wildcard labels: |
|
2060
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2061
|
|
|
retval.tree = root_0; |
|
2062
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2063
|
|
|
|
|
2064
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2065
|
|
|
// 49:25: -> ^( 'BEFORE-START' range ) |
|
2066
|
|
|
{ |
|
2067
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:49:27: ^( 'BEFORE-START' range ) |
|
2068
|
|
|
{ |
|
2069
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2070
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_32.nextToken()), root_1); |
|
2071
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2072
|
|
|
adaptor.addChild(root_0, root_1); |
|
2073
|
|
|
} |
|
2074
|
|
|
|
|
2075
|
|
|
} |
|
2076
|
|
|
|
|
2077
|
|
|
|
|
2078
|
|
|
retval.tree = root_0; |
|
2079
|
|
|
} |
|
2080
|
|
|
|
|
2081
|
|
|
} |
|
2082
|
|
|
break; |
|
2083
|
|
|
case 19 : |
|
2084
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:50:4: 'AFTER-END' range |
|
2085
|
|
|
{ |
|
2086
|
|
|
string_literal70=(Token)match(input,27,FOLLOW_27_in_temporal_relation_type534); if (state.failed) return retval; |
|
2087
|
|
|
if ( state.backtracking==0 ) stream_27.add(string_literal70); |
|
2088
|
|
|
|
|
2089
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type536); |
|
2090
|
|
|
range71=range(); |
|
2091
|
|
|
state._fsp--; |
|
2092
|
|
|
if (state.failed) return retval; |
|
2093
|
|
|
if ( state.backtracking==0 ) stream_range.add(range71.getTree()); |
|
2094
|
|
|
// AST REWRITE |
|
2095
|
|
|
// elements: range, 27 |
|
2096
|
|
|
// token labels: |
|
2097
|
|
|
// rule labels: retval |
|
2098
|
|
|
// token list labels: |
|
2099
|
|
|
// rule list labels: |
|
2100
|
|
|
// wildcard labels: |
|
2101
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2102
|
|
|
retval.tree = root_0; |
|
2103
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2104
|
|
|
|
|
2105
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2106
|
|
|
// 50:22: -> ^( 'AFTER-END' range ) |
|
2107
|
|
|
{ |
|
2108
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:50:24: ^( 'AFTER-END' range ) |
|
2109
|
|
|
{ |
|
2110
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2111
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_27.nextToken()), root_1); |
|
2112
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2113
|
|
|
adaptor.addChild(root_0, root_1); |
|
2114
|
|
|
} |
|
2115
|
|
|
|
|
2116
|
|
|
} |
|
2117
|
|
|
|
|
2118
|
|
|
|
|
2119
|
|
|
retval.tree = root_0; |
|
2120
|
|
|
} |
|
2121
|
|
|
|
|
2122
|
|
|
} |
|
2123
|
|
|
break; |
|
2124
|
|
|
case 20 : |
|
2125
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:51:4: 'START-START' range |
|
2126
|
|
|
{ |
|
2127
|
|
|
string_literal72=(Token)match(input,66,FOLLOW_66_in_temporal_relation_type551); if (state.failed) return retval; |
|
2128
|
|
|
if ( state.backtracking==0 ) stream_66.add(string_literal72); |
|
2129
|
|
|
|
|
2130
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type553); |
|
2131
|
|
|
range73=range(); |
|
2132
|
|
|
state._fsp--; |
|
2133
|
|
|
if (state.failed) return retval; |
|
2134
|
|
|
if ( state.backtracking==0 ) stream_range.add(range73.getTree()); |
|
2135
|
|
|
// AST REWRITE |
|
2136
|
|
|
// elements: 66, range |
|
2137
|
|
|
// token labels: |
|
2138
|
|
|
// rule labels: retval |
|
2139
|
|
|
// token list labels: |
|
2140
|
|
|
// rule list labels: |
|
2141
|
|
|
// wildcard labels: |
|
2142
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2143
|
|
|
retval.tree = root_0; |
|
2144
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2145
|
|
|
|
|
2146
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2147
|
|
|
// 51:24: -> ^( 'START-START' range ) |
|
2148
|
|
|
{ |
|
2149
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:51:26: ^( 'START-START' range ) |
|
2150
|
|
|
{ |
|
2151
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2152
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_66.nextToken()), root_1); |
|
2153
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2154
|
|
|
adaptor.addChild(root_0, root_1); |
|
2155
|
|
|
} |
|
2156
|
|
|
|
|
2157
|
|
|
} |
|
2158
|
|
|
|
|
2159
|
|
|
|
|
2160
|
|
|
retval.tree = root_0; |
|
2161
|
|
|
} |
|
2162
|
|
|
|
|
2163
|
|
|
} |
|
2164
|
|
|
break; |
|
2165
|
|
|
case 21 : |
|
2166
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:52:4: 'START-END' range |
|
2167
|
|
|
{ |
|
2168
|
|
|
string_literal74=(Token)match(input,65,FOLLOW_65_in_temporal_relation_type568); if (state.failed) return retval; |
|
2169
|
|
|
if ( state.backtracking==0 ) stream_65.add(string_literal74); |
|
2170
|
|
|
|
|
2171
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type570); |
|
2172
|
|
|
range75=range(); |
|
2173
|
|
|
state._fsp--; |
|
2174
|
|
|
if (state.failed) return retval; |
|
2175
|
|
|
if ( state.backtracking==0 ) stream_range.add(range75.getTree()); |
|
2176
|
|
|
// AST REWRITE |
|
2177
|
|
|
// elements: 65, range |
|
2178
|
|
|
// token labels: |
|
2179
|
|
|
// rule labels: retval |
|
2180
|
|
|
// token list labels: |
|
2181
|
|
|
// rule list labels: |
|
2182
|
|
|
// wildcard labels: |
|
2183
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2184
|
|
|
retval.tree = root_0; |
|
2185
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2186
|
|
|
|
|
2187
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2188
|
|
|
// 52:22: -> ^( 'START-END' range ) |
|
2189
|
|
|
{ |
|
2190
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:52:24: ^( 'START-END' range ) |
|
2191
|
|
|
{ |
|
2192
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2193
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_65.nextToken()), root_1); |
|
2194
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2195
|
|
|
adaptor.addChild(root_0, root_1); |
|
2196
|
|
|
} |
|
2197
|
|
|
|
|
2198
|
|
|
} |
|
2199
|
|
|
|
|
2200
|
|
|
|
|
2201
|
|
|
retval.tree = root_0; |
|
2202
|
|
|
} |
|
2203
|
|
|
|
|
2204
|
|
|
} |
|
2205
|
|
|
break; |
|
2206
|
|
|
case 22 : |
|
2207
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:53:4: 'END-START' range |
|
2208
|
|
|
{ |
|
2209
|
|
|
string_literal76=(Token)match(input,44,FOLLOW_44_in_temporal_relation_type585); if (state.failed) return retval; |
|
2210
|
|
|
if ( state.backtracking==0 ) stream_44.add(string_literal76); |
|
2211
|
|
|
|
|
2212
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type587); |
|
2213
|
|
|
range77=range(); |
|
2214
|
|
|
state._fsp--; |
|
2215
|
|
|
if (state.failed) return retval; |
|
2216
|
|
|
if ( state.backtracking==0 ) stream_range.add(range77.getTree()); |
|
2217
|
|
|
// AST REWRITE |
|
2218
|
|
|
// elements: range, 44 |
|
2219
|
|
|
// token labels: |
|
2220
|
|
|
// rule labels: retval |
|
2221
|
|
|
// token list labels: |
|
2222
|
|
|
// rule list labels: |
|
2223
|
|
|
// wildcard labels: |
|
2224
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2225
|
|
|
retval.tree = root_0; |
|
2226
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2227
|
|
|
|
|
2228
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2229
|
|
|
// 53:22: -> ^( 'END-START' range ) |
|
2230
|
|
|
{ |
|
2231
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:53:24: ^( 'END-START' range ) |
|
2232
|
|
|
{ |
|
2233
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2234
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_44.nextToken()), root_1); |
|
2235
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2236
|
|
|
adaptor.addChild(root_0, root_1); |
|
2237
|
|
|
} |
|
2238
|
|
|
|
|
2239
|
|
|
} |
|
2240
|
|
|
|
|
2241
|
|
|
|
|
2242
|
|
|
retval.tree = root_0; |
|
2243
|
|
|
} |
|
2244
|
|
|
|
|
2245
|
|
|
} |
|
2246
|
|
|
break; |
|
2247
|
|
|
case 23 : |
|
2248
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:54:4: 'END-END' range |
|
2249
|
|
|
{ |
|
2250
|
|
|
string_literal78=(Token)match(input,43,FOLLOW_43_in_temporal_relation_type602); if (state.failed) return retval; |
|
2251
|
|
|
if ( state.backtracking==0 ) stream_43.add(string_literal78); |
|
2252
|
|
|
|
|
2253
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type604); |
|
2254
|
|
|
range79=range(); |
|
2255
|
|
|
state._fsp--; |
|
2256
|
|
|
if (state.failed) return retval; |
|
2257
|
|
|
if ( state.backtracking==0 ) stream_range.add(range79.getTree()); |
|
2258
|
|
|
// AST REWRITE |
|
2259
|
|
|
// elements: range, 43 |
|
2260
|
|
|
// token labels: |
|
2261
|
|
|
// rule labels: retval |
|
2262
|
|
|
// token list labels: |
|
2263
|
|
|
// rule list labels: |
|
2264
|
|
|
// wildcard labels: |
|
2265
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2266
|
|
|
retval.tree = root_0; |
|
2267
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2268
|
|
|
|
|
2269
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2270
|
|
|
// 54:20: -> ^( 'END-END' range ) |
|
2271
|
|
|
{ |
|
2272
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:54:22: ^( 'END-END' range ) |
|
2273
|
|
|
{ |
|
2274
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2275
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_43.nextToken()), root_1); |
|
2276
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2277
|
|
|
adaptor.addChild(root_0, root_1); |
|
2278
|
|
|
} |
|
2279
|
|
|
|
|
2280
|
|
|
} |
|
2281
|
|
|
|
|
2282
|
|
|
|
|
2283
|
|
|
retval.tree = root_0; |
|
2284
|
|
|
} |
|
2285
|
|
|
|
|
2286
|
|
|
} |
|
2287
|
|
|
break; |
|
2288
|
|
|
case 24 : |
|
2289
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:55:4: 'CONTAINS-START' range range |
|
2290
|
|
|
{ |
|
2291
|
|
|
string_literal80=(Token)match(input,39,FOLLOW_39_in_temporal_relation_type619); if (state.failed) return retval; |
|
2292
|
|
|
if ( state.backtracking==0 ) stream_39.add(string_literal80); |
|
2293
|
|
|
|
|
2294
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type621); |
|
2295
|
|
|
range81=range(); |
|
2296
|
|
|
state._fsp--; |
|
2297
|
|
|
if (state.failed) return retval; |
|
2298
|
|
|
if ( state.backtracking==0 ) stream_range.add(range81.getTree()); |
|
2299
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type623); |
|
2300
|
|
|
range82=range(); |
|
2301
|
|
|
state._fsp--; |
|
2302
|
|
|
if (state.failed) return retval; |
|
2303
|
|
|
if ( state.backtracking==0 ) stream_range.add(range82.getTree()); |
|
2304
|
|
|
// AST REWRITE |
|
2305
|
|
|
// elements: range, 39, range |
|
2306
|
|
|
// token labels: |
|
2307
|
|
|
// rule labels: retval |
|
2308
|
|
|
// token list labels: |
|
2309
|
|
|
// rule list labels: |
|
2310
|
|
|
// wildcard labels: |
|
2311
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2312
|
|
|
retval.tree = root_0; |
|
2313
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2314
|
|
|
|
|
2315
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2316
|
|
|
// 55:33: -> ^( 'CONTAINS-START' range range ) |
|
2317
|
|
|
{ |
|
2318
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:55:35: ^( 'CONTAINS-START' range range ) |
|
2319
|
|
|
{ |
|
2320
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2321
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_39.nextToken()), root_1); |
|
2322
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2323
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2324
|
|
|
adaptor.addChild(root_0, root_1); |
|
2325
|
|
|
} |
|
2326
|
|
|
|
|
2327
|
|
|
} |
|
2328
|
|
|
|
|
2329
|
|
|
|
|
2330
|
|
|
retval.tree = root_0; |
|
2331
|
|
|
} |
|
2332
|
|
|
|
|
2333
|
|
|
} |
|
2334
|
|
|
break; |
|
2335
|
|
|
case 25 : |
|
2336
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:56:4: 'CONTAINS-END' range range |
|
2337
|
|
|
{ |
|
2338
|
|
|
string_literal83=(Token)match(input,38,FOLLOW_38_in_temporal_relation_type640); if (state.failed) return retval; |
|
2339
|
|
|
if ( state.backtracking==0 ) stream_38.add(string_literal83); |
|
2340
|
|
|
|
|
2341
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type642); |
|
2342
|
|
|
range84=range(); |
|
2343
|
|
|
state._fsp--; |
|
2344
|
|
|
if (state.failed) return retval; |
|
2345
|
|
|
if ( state.backtracking==0 ) stream_range.add(range84.getTree()); |
|
2346
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type644); |
|
2347
|
|
|
range85=range(); |
|
2348
|
|
|
state._fsp--; |
|
2349
|
|
|
if (state.failed) return retval; |
|
2350
|
|
|
if ( state.backtracking==0 ) stream_range.add(range85.getTree()); |
|
2351
|
|
|
// AST REWRITE |
|
2352
|
|
|
// elements: range, range, 38 |
|
2353
|
|
|
// token labels: |
|
2354
|
|
|
// rule labels: retval |
|
2355
|
|
|
// token list labels: |
|
2356
|
|
|
// rule list labels: |
|
2357
|
|
|
// wildcard labels: |
|
2358
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2359
|
|
|
retval.tree = root_0; |
|
2360
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2361
|
|
|
|
|
2362
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2363
|
|
|
// 56:31: -> ^( 'CONTAINS-END' range range ) |
|
2364
|
|
|
{ |
|
2365
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:56:33: ^( 'CONTAINS-END' range range ) |
|
2366
|
|
|
{ |
|
2367
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2368
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_38.nextToken()), root_1); |
|
2369
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2370
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2371
|
|
|
adaptor.addChild(root_0, root_1); |
|
2372
|
|
|
} |
|
2373
|
|
|
|
|
2374
|
|
|
} |
|
2375
|
|
|
|
|
2376
|
|
|
|
|
2377
|
|
|
retval.tree = root_0; |
|
2378
|
|
|
} |
|
2379
|
|
|
|
|
2380
|
|
|
} |
|
2381
|
|
|
break; |
|
2382
|
|
|
case 26 : |
|
2383
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:57:4: 'STARTS-DURING' range range |
|
2384
|
|
|
{ |
|
2385
|
|
|
string_literal86=(Token)match(input,70,FOLLOW_70_in_temporal_relation_type661); if (state.failed) return retval; |
|
2386
|
|
|
if ( state.backtracking==0 ) stream_70.add(string_literal86); |
|
2387
|
|
|
|
|
2388
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type663); |
|
2389
|
|
|
range87=range(); |
|
2390
|
|
|
state._fsp--; |
|
2391
|
|
|
if (state.failed) return retval; |
|
2392
|
|
|
if ( state.backtracking==0 ) stream_range.add(range87.getTree()); |
|
2393
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type665); |
|
2394
|
|
|
range88=range(); |
|
2395
|
|
|
state._fsp--; |
|
2396
|
|
|
if (state.failed) return retval; |
|
2397
|
|
|
if ( state.backtracking==0 ) stream_range.add(range88.getTree()); |
|
2398
|
|
|
// AST REWRITE |
|
2399
|
|
|
// elements: 70, range, range |
|
2400
|
|
|
// token labels: |
|
2401
|
|
|
// rule labels: retval |
|
2402
|
|
|
// token list labels: |
|
2403
|
|
|
// rule list labels: |
|
2404
|
|
|
// wildcard labels: |
|
2405
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2406
|
|
|
retval.tree = root_0; |
|
2407
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2408
|
|
|
|
|
2409
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2410
|
|
|
// 57:32: -> ^( 'STARTS-DURING' range range ) |
|
2411
|
|
|
{ |
|
2412
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:57:34: ^( 'STARTS-DURING' range range ) |
|
2413
|
|
|
{ |
|
2414
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2415
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_70.nextToken()), root_1); |
|
2416
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2417
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2418
|
|
|
adaptor.addChild(root_0, root_1); |
|
2419
|
|
|
} |
|
2420
|
|
|
|
|
2421
|
|
|
} |
|
2422
|
|
|
|
|
2423
|
|
|
|
|
2424
|
|
|
retval.tree = root_0; |
|
2425
|
|
|
} |
|
2426
|
|
|
|
|
2427
|
|
|
} |
|
2428
|
|
|
break; |
|
2429
|
|
|
case 27 : |
|
2430
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:58:4: 'ENDS-DURING' range range |
|
2431
|
|
|
{ |
|
2432
|
|
|
string_literal89=(Token)match(input,46,FOLLOW_46_in_temporal_relation_type682); if (state.failed) return retval; |
|
2433
|
|
|
if ( state.backtracking==0 ) stream_46.add(string_literal89); |
|
2434
|
|
|
|
|
2435
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type684); |
|
2436
|
|
|
range90=range(); |
|
2437
|
|
|
state._fsp--; |
|
2438
|
|
|
if (state.failed) return retval; |
|
2439
|
|
|
if ( state.backtracking==0 ) stream_range.add(range90.getTree()); |
|
2440
|
|
|
pushFollow(FOLLOW_range_in_temporal_relation_type686); |
|
2441
|
|
|
range91=range(); |
|
2442
|
|
|
state._fsp--; |
|
2443
|
|
|
if (state.failed) return retval; |
|
2444
|
|
|
if ( state.backtracking==0 ) stream_range.add(range91.getTree()); |
|
2445
|
|
|
// AST REWRITE |
|
2446
|
|
|
// elements: range, range, 46 |
|
2447
|
|
|
// token labels: |
|
2448
|
|
|
// rule labels: retval |
|
2449
|
|
|
// token list labels: |
|
2450
|
|
|
// rule list labels: |
|
2451
|
|
|
// wildcard labels: |
|
2452
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
2453
|
|
|
retval.tree = root_0; |
|
2454
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
2455
|
|
|
|
|
2456
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2457
|
|
|
// 58:30: -> ^( 'ENDS-DURING' range range ) |
|
2458
|
|
|
{ |
|
2459
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:58:32: ^( 'ENDS-DURING' range range ) |
|
2460
|
|
|
{ |
|
2461
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
2462
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelationType(stream_46.nextToken()), root_1); |
|
2463
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2464
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
2465
|
|
|
adaptor.addChild(root_0, root_1); |
|
2466
|
|
|
} |
|
2467
|
|
|
|
|
2468
|
|
|
} |
|
2469
|
|
|
|
|
2470
|
|
|
|
|
2471
|
|
|
retval.tree = root_0; |
|
2472
|
|
|
} |
|
2473
|
|
|
|
|
2474
|
|
|
} |
|
2475
|
|
|
break; |
|
2476
|
|
|
|
|
2477
|
|
|
} |
|
2478
|
|
|
retval.stop = input.LT(-1); |
|
2479
|
|
|
|
|
2480
|
|
|
if ( state.backtracking==0 ) { |
|
2481
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
2482
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
2483
|
|
|
} |
|
2484
|
|
|
} |
|
2485
|
|
|
catch (RecognitionException re) { |
|
2486
|
|
|
reportError(re); |
|
2487
|
|
|
recover(input,re); |
|
2488
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
2489
|
|
|
} |
|
2490
|
|
|
finally { |
|
2491
|
|
|
// do for sure before leaving |
|
2492
|
|
|
if ( state.backtracking>0 ) { memoize(input, 8, temporal_relation_type_StartIndex); } |
|
2493
|
|
|
|
|
2494
|
|
|
} |
|
2495
|
|
|
return retval; |
|
2496
|
|
|
} |
|
2497
|
|
|
// $ANTLR end "temporal_relation_type" |
|
2498
|
|
|
|
|
2499
|
|
|
|
|
2500
|
|
|
public static class parameter_constraint_return extends ParserRuleReturnScope { |
|
2501
|
|
|
Object tree; |
|
2502
|
|
|
@Override |
|
2503
|
|
|
public Object getTree() { return tree; } |
|
2504
|
|
|
}; |
|
2505
|
|
|
|
|
2506
|
|
|
|
|
2507
|
|
|
// $ANTLR start "parameter_constraint" |
|
2508
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:61:1: parameter_constraint : ( numeric_parameter_constraint | enumeration_parameter_constraint ); |
|
2509
|
|
|
public final ddl3Parser.parameter_constraint_return parameter_constraint() throws RecognitionException { |
|
2510
|
|
|
ddl3Parser.parameter_constraint_return retval = new ddl3Parser.parameter_constraint_return(); |
|
2511
|
|
|
retval.start = input.LT(1); |
|
2512
|
|
|
int parameter_constraint_StartIndex = input.index(); |
|
2513
|
|
|
|
|
2514
|
|
|
Object root_0 = null; |
|
2515
|
|
|
|
|
2516
|
|
|
ParserRuleReturnScope numeric_parameter_constraint92 =null; |
|
2517
|
|
|
ParserRuleReturnScope enumeration_parameter_constraint93 =null; |
|
2518
|
|
|
|
|
2519
|
|
|
|
|
2520
|
|
|
try { |
|
2521
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; } |
|
2522
|
|
|
|
|
2523
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:62:2: ( numeric_parameter_constraint | enumeration_parameter_constraint ) |
|
2524
|
|
|
int alt8=2; |
|
2525
|
|
|
int LA8_0 = input.LA(1); |
|
2526
|
|
|
if ( (LA8_0==VarID) ) { |
|
2527
|
|
|
switch ( input.LA(2) ) { |
|
2528
|
|
|
case 22: |
|
2529
|
|
|
{ |
|
2530
|
|
View Code Duplication |
switch ( input.LA(3) ) { |
|
|
|
|
|
|
2531
|
|
|
case VarID: |
|
2532
|
|
|
{ |
|
2533
|
|
|
int LA8_5 = input.LA(4); |
|
2534
|
|
|
if ( (synpred35_ddl3()) ) { |
|
2535
|
|
|
alt8=1; |
|
2536
|
|
|
} |
|
2537
|
|
|
else if ( (true) ) { |
|
2538
|
|
|
alt8=2; |
|
2539
|
|
|
} |
|
2540
|
|
|
|
|
2541
|
|
|
} |
|
2542
|
|
|
break; |
|
2543
|
|
|
case ID: |
|
2544
|
|
|
{ |
|
2545
|
|
|
alt8=2; |
|
2546
|
|
|
} |
|
2547
|
|
|
break; |
|
2548
|
|
|
case INT: |
|
2549
|
|
|
case 14: |
|
2550
|
|
|
case 16: |
|
2551
|
|
|
case 54: |
|
2552
|
|
|
{ |
|
2553
|
|
|
alt8=1; |
|
2554
|
|
|
} |
|
2555
|
|
|
break; |
|
2556
|
|
|
default: |
|
2557
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2558
|
|
|
int nvaeMark = input.mark(); |
|
2559
|
|
|
try { |
|
2560
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
2561
|
|
|
input.consume(); |
|
2562
|
|
|
} |
|
2563
|
|
|
NoViableAltException nvae = |
|
2564
|
|
|
new NoViableAltException("", 8, 3, input); |
|
2565
|
|
|
throw nvae; |
|
2566
|
|
|
} finally { |
|
2567
|
|
|
input.rewind(nvaeMark); |
|
2568
|
|
|
} |
|
2569
|
|
|
} |
|
2570
|
|
|
} |
|
2571
|
|
|
break; |
|
2572
|
|
|
case 10: |
|
2573
|
|
|
{ |
|
2574
|
|
View Code Duplication |
switch ( input.LA(3) ) { |
|
|
|
|
|
|
2575
|
|
|
case VarID: |
|
2576
|
|
|
{ |
|
2577
|
|
|
int LA8_7 = input.LA(4); |
|
2578
|
|
|
if ( (synpred35_ddl3()) ) { |
|
2579
|
|
|
alt8=1; |
|
2580
|
|
|
} |
|
2581
|
|
|
else if ( (true) ) { |
|
2582
|
|
|
alt8=2; |
|
2583
|
|
|
} |
|
2584
|
|
|
|
|
2585
|
|
|
} |
|
2586
|
|
|
break; |
|
2587
|
|
|
case ID: |
|
2588
|
|
|
{ |
|
2589
|
|
|
alt8=2; |
|
2590
|
|
|
} |
|
2591
|
|
|
break; |
|
2592
|
|
|
case INT: |
|
2593
|
|
|
case 14: |
|
2594
|
|
|
case 16: |
|
2595
|
|
|
case 54: |
|
2596
|
|
|
{ |
|
2597
|
|
|
alt8=1; |
|
2598
|
|
|
} |
|
2599
|
|
|
break; |
|
2600
|
|
|
default: |
|
2601
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2602
|
|
|
int nvaeMark = input.mark(); |
|
2603
|
|
|
try { |
|
2604
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
2605
|
|
|
input.consume(); |
|
2606
|
|
|
} |
|
2607
|
|
|
NoViableAltException nvae = |
|
2608
|
|
|
new NoViableAltException("", 8, 4, input); |
|
2609
|
|
|
throw nvae; |
|
2610
|
|
|
} finally { |
|
2611
|
|
|
input.rewind(nvaeMark); |
|
2612
|
|
|
} |
|
2613
|
|
|
} |
|
2614
|
|
|
} |
|
2615
|
|
|
break; |
|
2616
|
|
|
case 20: |
|
2617
|
|
|
case 21: |
|
2618
|
|
|
case 23: |
|
2619
|
|
|
case 24: |
|
2620
|
|
|
{ |
|
2621
|
|
|
alt8=1; |
|
2622
|
|
|
} |
|
2623
|
|
|
break; |
|
2624
|
|
|
default: |
|
2625
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2626
|
|
|
int nvaeMark = input.mark(); |
|
2627
|
|
|
try { |
|
2628
|
|
|
input.consume(); |
|
2629
|
|
|
NoViableAltException nvae = |
|
2630
|
|
|
new NoViableAltException("", 8, 1, input); |
|
2631
|
|
|
throw nvae; |
|
2632
|
|
|
} finally { |
|
2633
|
|
|
input.rewind(nvaeMark); |
|
2634
|
|
|
} |
|
2635
|
|
|
} |
|
2636
|
|
|
} |
|
2637
|
|
|
else if ( (LA8_0==INT||LA8_0==14||LA8_0==16||LA8_0==54) ) { |
|
2638
|
|
|
alt8=1; |
|
2639
|
|
|
} |
|
2640
|
|
|
|
|
2641
|
|
|
else { |
|
2642
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2643
|
|
|
NoViableAltException nvae = |
|
2644
|
|
|
new NoViableAltException("", 8, 0, input); |
|
2645
|
|
|
throw nvae; |
|
2646
|
|
|
} |
|
2647
|
|
|
|
|
2648
|
|
|
switch (alt8) { |
|
2649
|
|
|
case 1 : |
|
2650
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:62:4: numeric_parameter_constraint |
|
2651
|
|
|
{ |
|
2652
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2653
|
|
|
|
|
2654
|
|
|
|
|
2655
|
|
|
pushFollow(FOLLOW_numeric_parameter_constraint_in_parameter_constraint708); |
|
2656
|
|
|
numeric_parameter_constraint92=numeric_parameter_constraint(); |
|
2657
|
|
|
state._fsp--; |
|
2658
|
|
|
if (state.failed) return retval; |
|
2659
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, numeric_parameter_constraint92.getTree()); |
|
2660
|
|
|
|
|
2661
|
|
|
} |
|
2662
|
|
|
break; |
|
2663
|
|
|
case 2 : |
|
2664
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:62:35: enumeration_parameter_constraint |
|
2665
|
|
|
{ |
|
2666
|
|
|
root_0 = (Object)adaptor.nil(); |
|
2667
|
|
|
|
|
2668
|
|
|
|
|
2669
|
|
|
pushFollow(FOLLOW_enumeration_parameter_constraint_in_parameter_constraint712); |
|
2670
|
|
|
enumeration_parameter_constraint93=enumeration_parameter_constraint(); |
|
2671
|
|
|
state._fsp--; |
|
2672
|
|
|
if (state.failed) return retval; |
|
2673
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeration_parameter_constraint93.getTree()); |
|
2674
|
|
|
|
|
2675
|
|
|
} |
|
2676
|
|
|
break; |
|
2677
|
|
|
|
|
2678
|
|
|
} |
|
2679
|
|
|
retval.stop = input.LT(-1); |
|
2680
|
|
|
|
|
2681
|
|
|
if ( state.backtracking==0 ) { |
|
2682
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
2683
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
2684
|
|
|
} |
|
2685
|
|
|
} |
|
2686
|
|
|
catch (RecognitionException re) { |
|
2687
|
|
|
reportError(re); |
|
2688
|
|
|
recover(input,re); |
|
2689
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
2690
|
|
|
} |
|
2691
|
|
|
finally { |
|
2692
|
|
|
// do for sure before leaving |
|
2693
|
|
|
if ( state.backtracking>0 ) { memoize(input, 9, parameter_constraint_StartIndex); } |
|
2694
|
|
|
|
|
2695
|
|
|
} |
|
2696
|
|
|
return retval; |
|
2697
|
|
|
} |
|
2698
|
|
|
// $ANTLR end "parameter_constraint" |
|
2699
|
|
|
|
|
2700
|
|
|
|
|
2701
|
|
|
public static class numeric_parameter_constraint_return extends ParserRuleReturnScope { |
|
2702
|
|
|
Object tree; |
|
2703
|
|
|
@Override |
|
2704
|
|
|
public Object getTree() { return tree; } |
|
2705
|
|
|
}; |
|
2706
|
|
|
|
|
2707
|
|
|
|
|
2708
|
|
|
// $ANTLR start "numeric_parameter_constraint" |
|
2709
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:64:1: numeric_parameter_constraint : ( numeric_comparison_lvalue '=' numeric_comparison_rvalue -> ^( '=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '<' numeric_comparison_rvalue -> ^( '<' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '>' numeric_comparison_rvalue -> ^( '>' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '<=' numeric_comparison_rvalue -> ^( '<=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '>=' numeric_comparison_rvalue -> ^( '>=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '!=' numeric_comparison_rvalue -> ^( '!=' numeric_comparison_lvalue numeric_comparison_rvalue ) ); |
|
2710
|
|
|
public final ddl3Parser.numeric_parameter_constraint_return numeric_parameter_constraint() throws RecognitionException { |
|
2711
|
|
|
ddl3Parser.numeric_parameter_constraint_return retval = new ddl3Parser.numeric_parameter_constraint_return(); |
|
2712
|
|
|
retval.start = input.LT(1); |
|
2713
|
|
|
int numeric_parameter_constraint_StartIndex = input.index(); |
|
2714
|
|
|
|
|
2715
|
|
|
Object root_0 = null; |
|
2716
|
|
|
|
|
2717
|
|
|
Token char_literal95=null; |
|
2718
|
|
|
Token char_literal98=null; |
|
2719
|
|
|
Token char_literal101=null; |
|
2720
|
|
|
Token string_literal104=null; |
|
2721
|
|
|
Token string_literal107=null; |
|
2722
|
|
|
Token string_literal110=null; |
|
2723
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue94 =null; |
|
2724
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue96 =null; |
|
2725
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue97 =null; |
|
2726
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue99 =null; |
|
2727
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue100 =null; |
|
2728
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue102 =null; |
|
2729
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue103 =null; |
|
2730
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue105 =null; |
|
2731
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue106 =null; |
|
2732
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue108 =null; |
|
2733
|
|
|
ParserRuleReturnScope numeric_comparison_lvalue109 =null; |
|
2734
|
|
|
ParserRuleReturnScope numeric_comparison_rvalue111 =null; |
|
2735
|
|
|
|
|
2736
|
|
|
Object char_literal95_tree=null; |
|
2737
|
|
|
Object char_literal98_tree=null; |
|
2738
|
|
|
Object char_literal101_tree=null; |
|
2739
|
|
|
Object string_literal104_tree=null; |
|
2740
|
|
|
Object string_literal107_tree=null; |
|
2741
|
|
|
Object string_literal110_tree=null; |
|
2742
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
2743
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
2744
|
|
|
RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24"); |
|
2745
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
2746
|
|
|
RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21"); |
|
2747
|
|
|
RewriteRuleTokenStream stream_10=new RewriteRuleTokenStream(adaptor,"token 10"); |
|
2748
|
|
|
RewriteRuleSubtreeStream stream_numeric_comparison_rvalue=new RewriteRuleSubtreeStream(adaptor,"rule numeric_comparison_rvalue"); |
|
2749
|
|
|
RewriteRuleSubtreeStream stream_numeric_comparison_lvalue=new RewriteRuleSubtreeStream(adaptor,"rule numeric_comparison_lvalue"); |
|
2750
|
|
|
|
|
2751
|
|
|
try { |
|
2752
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; } |
|
2753
|
|
|
|
|
2754
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:65:2: ( numeric_comparison_lvalue '=' numeric_comparison_rvalue -> ^( '=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '<' numeric_comparison_rvalue -> ^( '<' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '>' numeric_comparison_rvalue -> ^( '>' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '<=' numeric_comparison_rvalue -> ^( '<=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '>=' numeric_comparison_rvalue -> ^( '>=' numeric_comparison_lvalue numeric_comparison_rvalue ) | numeric_comparison_lvalue '!=' numeric_comparison_rvalue -> ^( '!=' numeric_comparison_lvalue numeric_comparison_rvalue ) ) |
|
2755
|
|
|
int alt9=6; |
|
2756
|
|
|
switch ( input.LA(1) ) { |
|
2757
|
|
|
case VarID: |
|
2758
|
|
|
{ |
|
2759
|
|
|
switch ( input.LA(2) ) { |
|
2760
|
|
|
case 22: |
|
2761
|
|
|
{ |
|
2762
|
|
|
alt9=1; |
|
2763
|
|
|
} |
|
2764
|
|
|
break; |
|
2765
|
|
|
case 20: |
|
2766
|
|
|
{ |
|
2767
|
|
|
alt9=2; |
|
2768
|
|
|
} |
|
2769
|
|
|
break; |
|
2770
|
|
|
case 23: |
|
2771
|
|
|
{ |
|
2772
|
|
|
alt9=3; |
|
2773
|
|
|
} |
|
2774
|
|
|
break; |
|
2775
|
|
|
case 21: |
|
2776
|
|
|
{ |
|
2777
|
|
|
alt9=4; |
|
2778
|
|
|
} |
|
2779
|
|
|
break; |
|
2780
|
|
|
case 24: |
|
2781
|
|
|
{ |
|
2782
|
|
|
alt9=5; |
|
2783
|
|
|
} |
|
2784
|
|
|
break; |
|
2785
|
|
|
case 10: |
|
2786
|
|
|
{ |
|
2787
|
|
|
alt9=6; |
|
2788
|
|
|
} |
|
2789
|
|
|
break; |
|
2790
|
|
|
default: |
|
2791
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2792
|
|
|
int nvaeMark = input.mark(); |
|
2793
|
|
|
try { |
|
2794
|
|
|
input.consume(); |
|
2795
|
|
|
NoViableAltException nvae = |
|
2796
|
|
|
new NoViableAltException("", 9, 1, input); |
|
2797
|
|
|
throw nvae; |
|
2798
|
|
|
} finally { |
|
2799
|
|
|
input.rewind(nvaeMark); |
|
2800
|
|
|
} |
|
2801
|
|
|
} |
|
2802
|
|
|
} |
|
2803
|
|
|
break; |
|
2804
|
|
|
case 14: |
|
2805
|
|
|
case 16: |
|
2806
|
|
|
{ |
|
2807
|
|
|
int LA9_2 = input.LA(2); |
|
2808
|
|
|
if ( (LA9_2==INT) ) { |
|
2809
|
|
|
int LA9_3 = input.LA(3); |
|
2810
|
|
View Code Duplication |
if ( (LA9_3==13) ) { |
|
|
|
|
|
|
2811
|
|
|
int LA9_11 = input.LA(4); |
|
2812
|
|
|
if ( (LA9_11==VarID) ) { |
|
2813
|
|
|
switch ( input.LA(5) ) { |
|
2814
|
|
|
case 22: |
|
2815
|
|
|
{ |
|
2816
|
|
|
alt9=1; |
|
2817
|
|
|
} |
|
2818
|
|
|
break; |
|
2819
|
|
|
case 20: |
|
2820
|
|
|
{ |
|
2821
|
|
|
alt9=2; |
|
2822
|
|
|
} |
|
2823
|
|
|
break; |
|
2824
|
|
|
case 23: |
|
2825
|
|
|
{ |
|
2826
|
|
|
alt9=3; |
|
2827
|
|
|
} |
|
2828
|
|
|
break; |
|
2829
|
|
|
case 21: |
|
2830
|
|
|
{ |
|
2831
|
|
|
alt9=4; |
|
2832
|
|
|
} |
|
2833
|
|
|
break; |
|
2834
|
|
|
case 24: |
|
2835
|
|
|
{ |
|
2836
|
|
|
alt9=5; |
|
2837
|
|
|
} |
|
2838
|
|
|
break; |
|
2839
|
|
|
case 10: |
|
2840
|
|
|
{ |
|
2841
|
|
|
alt9=6; |
|
2842
|
|
|
} |
|
2843
|
|
|
break; |
|
2844
|
|
|
default: |
|
2845
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2846
|
|
|
int nvaeMark = input.mark(); |
|
2847
|
|
|
try { |
|
2848
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 5 - 1; nvaeConsume++) { |
|
2849
|
|
|
input.consume(); |
|
2850
|
|
|
} |
|
2851
|
|
|
NoViableAltException nvae = |
|
2852
|
|
|
new NoViableAltException("", 9, 12, input); |
|
2853
|
|
|
throw nvae; |
|
2854
|
|
|
} finally { |
|
2855
|
|
|
input.rewind(nvaeMark); |
|
2856
|
|
|
} |
|
2857
|
|
|
} |
|
2858
|
|
|
} |
|
2859
|
|
|
|
|
2860
|
|
|
else { |
|
2861
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2862
|
|
|
int nvaeMark = input.mark(); |
|
2863
|
|
|
try { |
|
2864
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { |
|
2865
|
|
|
input.consume(); |
|
2866
|
|
|
} |
|
2867
|
|
|
NoViableAltException nvae = |
|
2868
|
|
|
new NoViableAltException("", 9, 11, input); |
|
2869
|
|
|
throw nvae; |
|
2870
|
|
|
} finally { |
|
2871
|
|
|
input.rewind(nvaeMark); |
|
2872
|
|
|
} |
|
2873
|
|
|
} |
|
2874
|
|
|
|
|
2875
|
|
|
} |
|
2876
|
|
|
|
|
2877
|
|
|
else { |
|
2878
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2879
|
|
|
int nvaeMark = input.mark(); |
|
2880
|
|
|
try { |
|
2881
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
2882
|
|
|
input.consume(); |
|
2883
|
|
|
} |
|
2884
|
|
|
NoViableAltException nvae = |
|
2885
|
|
|
new NoViableAltException("", 9, 3, input); |
|
2886
|
|
|
throw nvae; |
|
2887
|
|
|
} finally { |
|
2888
|
|
|
input.rewind(nvaeMark); |
|
2889
|
|
|
} |
|
2890
|
|
|
} |
|
2891
|
|
|
|
|
2892
|
|
|
} |
|
2893
|
|
|
else if ( (LA9_2==54) ) { |
|
2894
|
|
|
int LA9_4 = input.LA(3); |
|
2895
|
|
View Code Duplication |
if ( (LA9_4==13) ) { |
|
|
|
|
|
|
2896
|
|
|
int LA9_11 = input.LA(4); |
|
2897
|
|
|
if ( (LA9_11==VarID) ) { |
|
2898
|
|
|
switch ( input.LA(5) ) { |
|
2899
|
|
|
case 22: |
|
2900
|
|
|
{ |
|
2901
|
|
|
alt9=1; |
|
2902
|
|
|
} |
|
2903
|
|
|
break; |
|
2904
|
|
|
case 20: |
|
2905
|
|
|
{ |
|
2906
|
|
|
alt9=2; |
|
2907
|
|
|
} |
|
2908
|
|
|
break; |
|
2909
|
|
|
case 23: |
|
2910
|
|
|
{ |
|
2911
|
|
|
alt9=3; |
|
2912
|
|
|
} |
|
2913
|
|
|
break; |
|
2914
|
|
|
case 21: |
|
2915
|
|
|
{ |
|
2916
|
|
|
alt9=4; |
|
2917
|
|
|
} |
|
2918
|
|
|
break; |
|
2919
|
|
|
case 24: |
|
2920
|
|
|
{ |
|
2921
|
|
|
alt9=5; |
|
2922
|
|
|
} |
|
2923
|
|
|
break; |
|
2924
|
|
|
case 10: |
|
2925
|
|
|
{ |
|
2926
|
|
|
alt9=6; |
|
2927
|
|
|
} |
|
2928
|
|
|
break; |
|
2929
|
|
|
default: |
|
2930
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2931
|
|
|
int nvaeMark = input.mark(); |
|
2932
|
|
|
try { |
|
2933
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 5 - 1; nvaeConsume++) { |
|
2934
|
|
|
input.consume(); |
|
2935
|
|
|
} |
|
2936
|
|
|
NoViableAltException nvae = |
|
2937
|
|
|
new NoViableAltException("", 9, 12, input); |
|
2938
|
|
|
throw nvae; |
|
2939
|
|
|
} finally { |
|
2940
|
|
|
input.rewind(nvaeMark); |
|
2941
|
|
|
} |
|
2942
|
|
|
} |
|
2943
|
|
|
} |
|
2944
|
|
|
|
|
2945
|
|
|
else { |
|
2946
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2947
|
|
|
int nvaeMark = input.mark(); |
|
2948
|
|
|
try { |
|
2949
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { |
|
2950
|
|
|
input.consume(); |
|
2951
|
|
|
} |
|
2952
|
|
|
NoViableAltException nvae = |
|
2953
|
|
|
new NoViableAltException("", 9, 11, input); |
|
2954
|
|
|
throw nvae; |
|
2955
|
|
|
} finally { |
|
2956
|
|
|
input.rewind(nvaeMark); |
|
2957
|
|
|
} |
|
2958
|
|
|
} |
|
2959
|
|
|
|
|
2960
|
|
|
} |
|
2961
|
|
|
|
|
2962
|
|
|
else { |
|
2963
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2964
|
|
|
int nvaeMark = input.mark(); |
|
2965
|
|
|
try { |
|
2966
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
2967
|
|
|
input.consume(); |
|
2968
|
|
|
} |
|
2969
|
|
|
NoViableAltException nvae = |
|
2970
|
|
|
new NoViableAltException("", 9, 4, input); |
|
2971
|
|
|
throw nvae; |
|
2972
|
|
|
} finally { |
|
2973
|
|
|
input.rewind(nvaeMark); |
|
2974
|
|
|
} |
|
2975
|
|
|
} |
|
2976
|
|
|
|
|
2977
|
|
|
} |
|
2978
|
|
|
|
|
2979
|
|
|
else { |
|
2980
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
2981
|
|
|
int nvaeMark = input.mark(); |
|
2982
|
|
|
try { |
|
2983
|
|
|
input.consume(); |
|
2984
|
|
|
NoViableAltException nvae = |
|
2985
|
|
|
new NoViableAltException("", 9, 2, input); |
|
2986
|
|
|
throw nvae; |
|
2987
|
|
|
} finally { |
|
2988
|
|
|
input.rewind(nvaeMark); |
|
2989
|
|
|
} |
|
2990
|
|
|
} |
|
2991
|
|
|
|
|
2992
|
|
|
} |
|
2993
|
|
|
break; |
|
2994
|
|
|
case INT: |
|
2995
|
|
|
{ |
|
2996
|
|
|
int LA9_3 = input.LA(2); |
|
2997
|
|
View Code Duplication |
if ( (LA9_3==13) ) { |
|
|
|
|
|
|
2998
|
|
|
int LA9_11 = input.LA(3); |
|
2999
|
|
|
if ( (LA9_11==VarID) ) { |
|
3000
|
|
|
switch ( input.LA(4) ) { |
|
3001
|
|
|
case 22: |
|
3002
|
|
|
{ |
|
3003
|
|
|
alt9=1; |
|
3004
|
|
|
} |
|
3005
|
|
|
break; |
|
3006
|
|
|
case 20: |
|
3007
|
|
|
{ |
|
3008
|
|
|
alt9=2; |
|
3009
|
|
|
} |
|
3010
|
|
|
break; |
|
3011
|
|
|
case 23: |
|
3012
|
|
|
{ |
|
3013
|
|
|
alt9=3; |
|
3014
|
|
|
} |
|
3015
|
|
|
break; |
|
3016
|
|
|
case 21: |
|
3017
|
|
|
{ |
|
3018
|
|
|
alt9=4; |
|
3019
|
|
|
} |
|
3020
|
|
|
break; |
|
3021
|
|
|
case 24: |
|
3022
|
|
|
{ |
|
3023
|
|
|
alt9=5; |
|
3024
|
|
|
} |
|
3025
|
|
|
break; |
|
3026
|
|
|
case 10: |
|
3027
|
|
|
{ |
|
3028
|
|
|
alt9=6; |
|
3029
|
|
|
} |
|
3030
|
|
|
break; |
|
3031
|
|
|
default: |
|
3032
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3033
|
|
|
int nvaeMark = input.mark(); |
|
3034
|
|
|
try { |
|
3035
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { |
|
3036
|
|
|
input.consume(); |
|
3037
|
|
|
} |
|
3038
|
|
|
NoViableAltException nvae = |
|
3039
|
|
|
new NoViableAltException("", 9, 12, input); |
|
3040
|
|
|
throw nvae; |
|
3041
|
|
|
} finally { |
|
3042
|
|
|
input.rewind(nvaeMark); |
|
3043
|
|
|
} |
|
3044
|
|
|
} |
|
3045
|
|
|
} |
|
3046
|
|
|
|
|
3047
|
|
|
else { |
|
3048
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3049
|
|
|
int nvaeMark = input.mark(); |
|
3050
|
|
|
try { |
|
3051
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
3052
|
|
|
input.consume(); |
|
3053
|
|
|
} |
|
3054
|
|
|
NoViableAltException nvae = |
|
3055
|
|
|
new NoViableAltException("", 9, 11, input); |
|
3056
|
|
|
throw nvae; |
|
3057
|
|
|
} finally { |
|
3058
|
|
|
input.rewind(nvaeMark); |
|
3059
|
|
|
} |
|
3060
|
|
|
} |
|
3061
|
|
|
|
|
3062
|
|
|
} |
|
3063
|
|
|
|
|
3064
|
|
|
else { |
|
3065
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3066
|
|
|
int nvaeMark = input.mark(); |
|
3067
|
|
|
try { |
|
3068
|
|
|
input.consume(); |
|
3069
|
|
|
NoViableAltException nvae = |
|
3070
|
|
|
new NoViableAltException("", 9, 3, input); |
|
3071
|
|
|
throw nvae; |
|
3072
|
|
|
} finally { |
|
3073
|
|
|
input.rewind(nvaeMark); |
|
3074
|
|
|
} |
|
3075
|
|
|
} |
|
3076
|
|
|
|
|
3077
|
|
|
} |
|
3078
|
|
|
break; |
|
3079
|
|
|
case 54: |
|
3080
|
|
|
{ |
|
3081
|
|
|
int LA9_4 = input.LA(2); |
|
3082
|
|
View Code Duplication |
if ( (LA9_4==13) ) { |
|
|
|
|
|
|
3083
|
|
|
int LA9_11 = input.LA(3); |
|
3084
|
|
|
if ( (LA9_11==VarID) ) { |
|
3085
|
|
|
switch ( input.LA(4) ) { |
|
3086
|
|
|
case 22: |
|
3087
|
|
|
{ |
|
3088
|
|
|
alt9=1; |
|
3089
|
|
|
} |
|
3090
|
|
|
break; |
|
3091
|
|
|
case 20: |
|
3092
|
|
|
{ |
|
3093
|
|
|
alt9=2; |
|
3094
|
|
|
} |
|
3095
|
|
|
break; |
|
3096
|
|
|
case 23: |
|
3097
|
|
|
{ |
|
3098
|
|
|
alt9=3; |
|
3099
|
|
|
} |
|
3100
|
|
|
break; |
|
3101
|
|
|
case 21: |
|
3102
|
|
|
{ |
|
3103
|
|
|
alt9=4; |
|
3104
|
|
|
} |
|
3105
|
|
|
break; |
|
3106
|
|
|
case 24: |
|
3107
|
|
|
{ |
|
3108
|
|
|
alt9=5; |
|
3109
|
|
|
} |
|
3110
|
|
|
break; |
|
3111
|
|
|
case 10: |
|
3112
|
|
|
{ |
|
3113
|
|
|
alt9=6; |
|
3114
|
|
|
} |
|
3115
|
|
|
break; |
|
3116
|
|
|
default: |
|
3117
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3118
|
|
|
int nvaeMark = input.mark(); |
|
3119
|
|
|
try { |
|
3120
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { |
|
3121
|
|
|
input.consume(); |
|
3122
|
|
|
} |
|
3123
|
|
|
NoViableAltException nvae = |
|
3124
|
|
|
new NoViableAltException("", 9, 12, input); |
|
3125
|
|
|
throw nvae; |
|
3126
|
|
|
} finally { |
|
3127
|
|
|
input.rewind(nvaeMark); |
|
3128
|
|
|
} |
|
3129
|
|
|
} |
|
3130
|
|
|
} |
|
3131
|
|
|
|
|
3132
|
|
|
else { |
|
3133
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3134
|
|
|
int nvaeMark = input.mark(); |
|
3135
|
|
|
try { |
|
3136
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
3137
|
|
|
input.consume(); |
|
3138
|
|
|
} |
|
3139
|
|
|
NoViableAltException nvae = |
|
3140
|
|
|
new NoViableAltException("", 9, 11, input); |
|
3141
|
|
|
throw nvae; |
|
3142
|
|
|
} finally { |
|
3143
|
|
|
input.rewind(nvaeMark); |
|
3144
|
|
|
} |
|
3145
|
|
|
} |
|
3146
|
|
|
|
|
3147
|
|
|
} |
|
3148
|
|
|
|
|
3149
|
|
|
else { |
|
3150
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3151
|
|
|
int nvaeMark = input.mark(); |
|
3152
|
|
|
try { |
|
3153
|
|
|
input.consume(); |
|
3154
|
|
|
NoViableAltException nvae = |
|
3155
|
|
|
new NoViableAltException("", 9, 4, input); |
|
3156
|
|
|
throw nvae; |
|
3157
|
|
|
} finally { |
|
3158
|
|
|
input.rewind(nvaeMark); |
|
3159
|
|
|
} |
|
3160
|
|
|
} |
|
3161
|
|
|
|
|
3162
|
|
|
} |
|
3163
|
|
|
break; |
|
3164
|
|
|
default: |
|
3165
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3166
|
|
|
NoViableAltException nvae = |
|
3167
|
|
|
new NoViableAltException("", 9, 0, input); |
|
3168
|
|
|
throw nvae; |
|
3169
|
|
|
} |
|
3170
|
|
|
switch (alt9) { |
|
3171
|
|
|
case 1 : |
|
3172
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:65:4: numeric_comparison_lvalue '=' numeric_comparison_rvalue |
|
3173
|
|
|
{ |
|
3174
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint722); |
|
3175
|
|
|
numeric_comparison_lvalue94=numeric_comparison_lvalue(); |
|
3176
|
|
|
state._fsp--; |
|
3177
|
|
|
if (state.failed) return retval; |
|
3178
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue94.getTree()); |
|
3179
|
|
|
char_literal95=(Token)match(input,22,FOLLOW_22_in_numeric_parameter_constraint724); if (state.failed) return retval; |
|
3180
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal95); |
|
3181
|
|
|
|
|
3182
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint726); |
|
3183
|
|
|
numeric_comparison_rvalue96=numeric_comparison_rvalue(); |
|
3184
|
|
|
state._fsp--; |
|
3185
|
|
|
if (state.failed) return retval; |
|
3186
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue96.getTree()); |
|
3187
|
|
|
// AST REWRITE |
|
3188
|
|
|
// elements: 22, numeric_comparison_lvalue, numeric_comparison_rvalue |
|
3189
|
|
|
// token labels: |
|
3190
|
|
|
// rule labels: retval |
|
3191
|
|
|
// token list labels: |
|
3192
|
|
|
// rule list labels: |
|
3193
|
|
|
// wildcard labels: |
|
3194
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3195
|
|
|
retval.tree = root_0; |
|
3196
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3197
|
|
|
|
|
3198
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3199
|
|
|
// 65:60: -> ^( '=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3200
|
|
|
{ |
|
3201
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:65:62: ^( '=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3202
|
|
|
{ |
|
3203
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3204
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_22.nextToken()), root_1); |
|
3205
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3206
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3207
|
|
|
adaptor.addChild(root_0, root_1); |
|
3208
|
|
|
} |
|
3209
|
|
|
|
|
3210
|
|
|
} |
|
3211
|
|
|
|
|
3212
|
|
|
|
|
3213
|
|
|
retval.tree = root_0; |
|
3214
|
|
|
} |
|
3215
|
|
|
|
|
3216
|
|
|
} |
|
3217
|
|
|
break; |
|
3218
|
|
|
case 2 : |
|
3219
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:66:4: numeric_comparison_lvalue '<' numeric_comparison_rvalue |
|
3220
|
|
|
{ |
|
3221
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint743); |
|
3222
|
|
|
numeric_comparison_lvalue97=numeric_comparison_lvalue(); |
|
3223
|
|
|
state._fsp--; |
|
3224
|
|
|
if (state.failed) return retval; |
|
3225
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue97.getTree()); |
|
3226
|
|
|
char_literal98=(Token)match(input,20,FOLLOW_20_in_numeric_parameter_constraint745); if (state.failed) return retval; |
|
3227
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal98); |
|
3228
|
|
|
|
|
3229
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint747); |
|
3230
|
|
|
numeric_comparison_rvalue99=numeric_comparison_rvalue(); |
|
3231
|
|
|
state._fsp--; |
|
3232
|
|
|
if (state.failed) return retval; |
|
3233
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue99.getTree()); |
|
3234
|
|
|
// AST REWRITE |
|
3235
|
|
|
// elements: 20, numeric_comparison_rvalue, numeric_comparison_lvalue |
|
3236
|
|
|
// token labels: |
|
3237
|
|
|
// rule labels: retval |
|
3238
|
|
|
// token list labels: |
|
3239
|
|
|
// rule list labels: |
|
3240
|
|
|
// wildcard labels: |
|
3241
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3242
|
|
|
retval.tree = root_0; |
|
3243
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3244
|
|
|
|
|
3245
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3246
|
|
|
// 66:60: -> ^( '<' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3247
|
|
|
{ |
|
3248
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:66:62: ^( '<' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3249
|
|
|
{ |
|
3250
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3251
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_20.nextToken()), root_1); |
|
3252
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3253
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3254
|
|
|
adaptor.addChild(root_0, root_1); |
|
3255
|
|
|
} |
|
3256
|
|
|
|
|
3257
|
|
|
} |
|
3258
|
|
|
|
|
3259
|
|
|
|
|
3260
|
|
|
retval.tree = root_0; |
|
3261
|
|
|
} |
|
3262
|
|
|
|
|
3263
|
|
|
} |
|
3264
|
|
|
break; |
|
3265
|
|
|
case 3 : |
|
3266
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:67:4: numeric_comparison_lvalue '>' numeric_comparison_rvalue |
|
3267
|
|
|
{ |
|
3268
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint764); |
|
3269
|
|
|
numeric_comparison_lvalue100=numeric_comparison_lvalue(); |
|
3270
|
|
|
state._fsp--; |
|
3271
|
|
|
if (state.failed) return retval; |
|
3272
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue100.getTree()); |
|
3273
|
|
|
char_literal101=(Token)match(input,23,FOLLOW_23_in_numeric_parameter_constraint766); if (state.failed) return retval; |
|
3274
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal101); |
|
3275
|
|
|
|
|
3276
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint768); |
|
3277
|
|
|
numeric_comparison_rvalue102=numeric_comparison_rvalue(); |
|
3278
|
|
|
state._fsp--; |
|
3279
|
|
|
if (state.failed) return retval; |
|
3280
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue102.getTree()); |
|
3281
|
|
|
// AST REWRITE |
|
3282
|
|
|
// elements: 23, numeric_comparison_rvalue, numeric_comparison_lvalue |
|
3283
|
|
|
// token labels: |
|
3284
|
|
|
// rule labels: retval |
|
3285
|
|
|
// token list labels: |
|
3286
|
|
|
// rule list labels: |
|
3287
|
|
|
// wildcard labels: |
|
3288
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3289
|
|
|
retval.tree = root_0; |
|
3290
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3291
|
|
|
|
|
3292
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3293
|
|
|
// 67:60: -> ^( '>' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3294
|
|
|
{ |
|
3295
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:67:62: ^( '>' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3296
|
|
|
{ |
|
3297
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3298
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_23.nextToken()), root_1); |
|
3299
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3300
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3301
|
|
|
adaptor.addChild(root_0, root_1); |
|
3302
|
|
|
} |
|
3303
|
|
|
|
|
3304
|
|
|
} |
|
3305
|
|
|
|
|
3306
|
|
|
|
|
3307
|
|
|
retval.tree = root_0; |
|
3308
|
|
|
} |
|
3309
|
|
|
|
|
3310
|
|
|
} |
|
3311
|
|
|
break; |
|
3312
|
|
|
case 4 : |
|
3313
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:68:4: numeric_comparison_lvalue '<=' numeric_comparison_rvalue |
|
3314
|
|
|
{ |
|
3315
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint785); |
|
3316
|
|
|
numeric_comparison_lvalue103=numeric_comparison_lvalue(); |
|
3317
|
|
|
state._fsp--; |
|
3318
|
|
|
if (state.failed) return retval; |
|
3319
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue103.getTree()); |
|
3320
|
|
|
string_literal104=(Token)match(input,21,FOLLOW_21_in_numeric_parameter_constraint787); if (state.failed) return retval; |
|
3321
|
|
|
if ( state.backtracking==0 ) stream_21.add(string_literal104); |
|
3322
|
|
|
|
|
3323
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint789); |
|
3324
|
|
|
numeric_comparison_rvalue105=numeric_comparison_rvalue(); |
|
3325
|
|
|
state._fsp--; |
|
3326
|
|
|
if (state.failed) return retval; |
|
3327
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue105.getTree()); |
|
3328
|
|
|
// AST REWRITE |
|
3329
|
|
|
// elements: 21, numeric_comparison_lvalue, numeric_comparison_rvalue |
|
3330
|
|
|
// token labels: |
|
3331
|
|
|
// rule labels: retval |
|
3332
|
|
|
// token list labels: |
|
3333
|
|
|
// rule list labels: |
|
3334
|
|
|
// wildcard labels: |
|
3335
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3336
|
|
|
retval.tree = root_0; |
|
3337
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3338
|
|
|
|
|
3339
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3340
|
|
|
// 68:61: -> ^( '<=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3341
|
|
|
{ |
|
3342
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:68:63: ^( '<=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3343
|
|
|
{ |
|
3344
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3345
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_21.nextToken()), root_1); |
|
3346
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3347
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3348
|
|
|
adaptor.addChild(root_0, root_1); |
|
3349
|
|
|
} |
|
3350
|
|
|
|
|
3351
|
|
|
} |
|
3352
|
|
|
|
|
3353
|
|
|
|
|
3354
|
|
|
retval.tree = root_0; |
|
3355
|
|
|
} |
|
3356
|
|
|
|
|
3357
|
|
|
} |
|
3358
|
|
|
break; |
|
3359
|
|
|
case 5 : |
|
3360
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:69:4: numeric_comparison_lvalue '>=' numeric_comparison_rvalue |
|
3361
|
|
|
{ |
|
3362
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint806); |
|
3363
|
|
|
numeric_comparison_lvalue106=numeric_comparison_lvalue(); |
|
3364
|
|
|
state._fsp--; |
|
3365
|
|
|
if (state.failed) return retval; |
|
3366
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue106.getTree()); |
|
3367
|
|
|
string_literal107=(Token)match(input,24,FOLLOW_24_in_numeric_parameter_constraint808); if (state.failed) return retval; |
|
3368
|
|
|
if ( state.backtracking==0 ) stream_24.add(string_literal107); |
|
3369
|
|
|
|
|
3370
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint810); |
|
3371
|
|
|
numeric_comparison_rvalue108=numeric_comparison_rvalue(); |
|
3372
|
|
|
state._fsp--; |
|
3373
|
|
|
if (state.failed) return retval; |
|
3374
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue108.getTree()); |
|
3375
|
|
|
// AST REWRITE |
|
3376
|
|
|
// elements: numeric_comparison_lvalue, 24, numeric_comparison_rvalue |
|
3377
|
|
|
// token labels: |
|
3378
|
|
|
// rule labels: retval |
|
3379
|
|
|
// token list labels: |
|
3380
|
|
|
// rule list labels: |
|
3381
|
|
|
// wildcard labels: |
|
3382
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3383
|
|
|
retval.tree = root_0; |
|
3384
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3385
|
|
|
|
|
3386
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3387
|
|
|
// 69:61: -> ^( '>=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3388
|
|
|
{ |
|
3389
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:69:63: ^( '>=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3390
|
|
|
{ |
|
3391
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3392
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_24.nextToken()), root_1); |
|
3393
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3394
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3395
|
|
|
adaptor.addChild(root_0, root_1); |
|
3396
|
|
|
} |
|
3397
|
|
|
|
|
3398
|
|
|
} |
|
3399
|
|
|
|
|
3400
|
|
|
|
|
3401
|
|
|
retval.tree = root_0; |
|
3402
|
|
|
} |
|
3403
|
|
|
|
|
3404
|
|
|
} |
|
3405
|
|
|
break; |
|
3406
|
|
|
case 6 : |
|
3407
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:70:4: numeric_comparison_lvalue '!=' numeric_comparison_rvalue |
|
3408
|
|
|
{ |
|
3409
|
|
|
pushFollow(FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint827); |
|
3410
|
|
|
numeric_comparison_lvalue109=numeric_comparison_lvalue(); |
|
3411
|
|
|
state._fsp--; |
|
3412
|
|
|
if (state.failed) return retval; |
|
3413
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_lvalue.add(numeric_comparison_lvalue109.getTree()); |
|
3414
|
|
|
string_literal110=(Token)match(input,10,FOLLOW_10_in_numeric_parameter_constraint829); if (state.failed) return retval; |
|
3415
|
|
|
if ( state.backtracking==0 ) stream_10.add(string_literal110); |
|
3416
|
|
|
|
|
3417
|
|
|
pushFollow(FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint831); |
|
3418
|
|
|
numeric_comparison_rvalue111=numeric_comparison_rvalue(); |
|
3419
|
|
|
state._fsp--; |
|
3420
|
|
|
if (state.failed) return retval; |
|
3421
|
|
|
if ( state.backtracking==0 ) stream_numeric_comparison_rvalue.add(numeric_comparison_rvalue111.getTree()); |
|
3422
|
|
|
// AST REWRITE |
|
3423
|
|
|
// elements: numeric_comparison_rvalue, 10, numeric_comparison_lvalue |
|
3424
|
|
|
// token labels: |
|
3425
|
|
|
// rule labels: retval |
|
3426
|
|
|
// token list labels: |
|
3427
|
|
|
// rule list labels: |
|
3428
|
|
|
// wildcard labels: |
|
3429
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
3430
|
|
|
retval.tree = root_0; |
|
3431
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
3432
|
|
|
|
|
3433
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3434
|
|
|
// 70:61: -> ^( '!=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3435
|
|
|
{ |
|
3436
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:70:63: ^( '!=' numeric_comparison_lvalue numeric_comparison_rvalue ) |
|
3437
|
|
|
{ |
|
3438
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
3439
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLNumericParameterConstraint(stream_10.nextToken()), root_1); |
|
3440
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_lvalue.nextTree()); |
|
3441
|
|
|
adaptor.addChild(root_1, stream_numeric_comparison_rvalue.nextTree()); |
|
3442
|
|
|
adaptor.addChild(root_0, root_1); |
|
3443
|
|
|
} |
|
3444
|
|
|
|
|
3445
|
|
|
} |
|
3446
|
|
|
|
|
3447
|
|
|
|
|
3448
|
|
|
retval.tree = root_0; |
|
3449
|
|
|
} |
|
3450
|
|
|
|
|
3451
|
|
|
} |
|
3452
|
|
|
break; |
|
3453
|
|
|
|
|
3454
|
|
|
} |
|
3455
|
|
|
retval.stop = input.LT(-1); |
|
3456
|
|
|
|
|
3457
|
|
|
if ( state.backtracking==0 ) { |
|
3458
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
3459
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
3460
|
|
|
} |
|
3461
|
|
|
} |
|
3462
|
|
|
catch (RecognitionException re) { |
|
3463
|
|
|
reportError(re); |
|
3464
|
|
|
recover(input,re); |
|
3465
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
3466
|
|
|
} |
|
3467
|
|
|
finally { |
|
3468
|
|
|
// do for sure before leaving |
|
3469
|
|
|
if ( state.backtracking>0 ) { memoize(input, 10, numeric_parameter_constraint_StartIndex); } |
|
3470
|
|
|
|
|
3471
|
|
|
} |
|
3472
|
|
|
return retval; |
|
3473
|
|
|
} |
|
3474
|
|
|
// $ANTLR end "numeric_parameter_constraint" |
|
3475
|
|
|
|
|
3476
|
|
|
|
|
3477
|
|
|
public static class numeric_comparison_lvalue_return extends ParserRuleReturnScope { |
|
3478
|
|
|
Object tree; |
|
3479
|
|
|
@Override |
|
3480
|
|
|
public Object getTree() { return tree; } |
|
3481
|
|
|
}; |
|
3482
|
|
|
|
|
3483
|
|
|
|
|
3484
|
|
|
// $ANTLR start "numeric_comparison_lvalue" |
|
3485
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:72:1: numeric_comparison_lvalue : ( VarID | number '*' ^ VarID ); |
|
3486
|
|
|
public final ddl3Parser.numeric_comparison_lvalue_return numeric_comparison_lvalue() throws RecognitionException { |
|
3487
|
|
|
ddl3Parser.numeric_comparison_lvalue_return retval = new ddl3Parser.numeric_comparison_lvalue_return(); |
|
3488
|
|
|
retval.start = input.LT(1); |
|
3489
|
|
|
int numeric_comparison_lvalue_StartIndex = input.index(); |
|
3490
|
|
|
|
|
3491
|
|
|
Object root_0 = null; |
|
3492
|
|
|
|
|
3493
|
|
|
Token VarID112=null; |
|
3494
|
|
|
Token char_literal114=null; |
|
3495
|
|
|
Token VarID115=null; |
|
3496
|
|
|
ParserRuleReturnScope number113 =null; |
|
3497
|
|
|
|
|
3498
|
|
|
Object VarID112_tree=null; |
|
3499
|
|
|
Object char_literal114_tree=null; |
|
3500
|
|
|
Object VarID115_tree=null; |
|
3501
|
|
|
|
|
3502
|
|
|
try { |
|
3503
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; } |
|
3504
|
|
|
|
|
3505
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:73:2: ( VarID | number '*' ^ VarID ) |
|
3506
|
|
|
int alt10=2; |
|
3507
|
|
|
int LA10_0 = input.LA(1); |
|
3508
|
|
View Code Duplication |
if ( (LA10_0==VarID) ) { |
|
|
|
|
|
|
3509
|
|
|
alt10=1; |
|
3510
|
|
|
} |
|
3511
|
|
|
else if ( (LA10_0==INT||LA10_0==14||LA10_0==16||LA10_0==54) ) { |
|
3512
|
|
|
alt10=2; |
|
3513
|
|
|
} |
|
3514
|
|
|
|
|
3515
|
|
|
else { |
|
3516
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3517
|
|
|
NoViableAltException nvae = |
|
3518
|
|
|
new NoViableAltException("", 10, 0, input); |
|
3519
|
|
|
throw nvae; |
|
3520
|
|
|
} |
|
3521
|
|
|
|
|
3522
|
|
|
switch (alt10) { |
|
3523
|
|
|
case 1 : |
|
3524
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:73:4: VarID |
|
3525
|
|
|
{ |
|
3526
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3527
|
|
|
|
|
3528
|
|
|
|
|
3529
|
|
|
VarID112=(Token)match(input,VarID,FOLLOW_VarID_in_numeric_comparison_lvalue852); if (state.failed) return retval; |
|
3530
|
|
|
if ( state.backtracking==0 ) { |
|
3531
|
|
|
VarID112_tree = (Object)adaptor.create(VarID112); |
|
3532
|
|
|
adaptor.addChild(root_0, VarID112_tree); |
|
3533
|
|
|
} |
|
3534
|
|
|
|
|
3535
|
|
|
} |
|
3536
|
|
|
break; |
|
3537
|
|
|
case 2 : |
|
3538
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:73:12: number '*' ^ VarID |
|
3539
|
|
|
{ |
|
3540
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3541
|
|
|
|
|
3542
|
|
|
|
|
3543
|
|
|
pushFollow(FOLLOW_number_in_numeric_comparison_lvalue856); |
|
3544
|
|
|
number113=number(); |
|
3545
|
|
|
state._fsp--; |
|
3546
|
|
|
if (state.failed) return retval; |
|
3547
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, number113.getTree()); |
|
3548
|
|
|
|
|
3549
|
|
|
char_literal114=(Token)match(input,13,FOLLOW_13_in_numeric_comparison_lvalue858); if (state.failed) return retval; |
|
3550
|
|
|
if ( state.backtracking==0 ) { |
|
3551
|
|
|
char_literal114_tree = (Object)adaptor.create(char_literal114); |
|
3552
|
|
|
root_0 = (Object)adaptor.becomeRoot(char_literal114_tree, root_0); |
|
3553
|
|
|
} |
|
3554
|
|
|
|
|
3555
|
|
|
VarID115=(Token)match(input,VarID,FOLLOW_VarID_in_numeric_comparison_lvalue861); if (state.failed) return retval; |
|
3556
|
|
|
if ( state.backtracking==0 ) { |
|
3557
|
|
|
VarID115_tree = (Object)adaptor.create(VarID115); |
|
3558
|
|
|
adaptor.addChild(root_0, VarID115_tree); |
|
3559
|
|
|
} |
|
3560
|
|
|
|
|
3561
|
|
|
} |
|
3562
|
|
|
break; |
|
3563
|
|
|
|
|
3564
|
|
|
} |
|
3565
|
|
|
retval.stop = input.LT(-1); |
|
3566
|
|
|
|
|
3567
|
|
|
if ( state.backtracking==0 ) { |
|
3568
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
3569
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
3570
|
|
|
} |
|
3571
|
|
|
} |
|
3572
|
|
|
catch (RecognitionException re) { |
|
3573
|
|
|
reportError(re); |
|
3574
|
|
|
recover(input,re); |
|
3575
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
3576
|
|
|
} |
|
3577
|
|
|
finally { |
|
3578
|
|
|
// do for sure before leaving |
|
3579
|
|
|
if ( state.backtracking>0 ) { memoize(input, 11, numeric_comparison_lvalue_StartIndex); } |
|
3580
|
|
|
|
|
3581
|
|
|
} |
|
3582
|
|
|
return retval; |
|
3583
|
|
|
} |
|
3584
|
|
|
// $ANTLR end "numeric_comparison_lvalue" |
|
3585
|
|
|
|
|
3586
|
|
|
|
|
3587
|
|
|
public static class numeric_comparison_rvalue_return extends ParserRuleReturnScope { |
|
3588
|
|
|
Object tree; |
|
3589
|
|
|
@Override |
|
3590
|
|
|
public Object getTree() { return tree; } |
|
3591
|
|
|
}; |
|
3592
|
|
|
|
|
3593
|
|
|
|
|
3594
|
|
|
// $ANTLR start "numeric_comparison_rvalue" |
|
3595
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:75:1: numeric_comparison_rvalue : first_numeric_comparison_rvalue ( other_numeric_comparison_rvalues )* ; |
|
3596
|
|
|
public final ddl3Parser.numeric_comparison_rvalue_return numeric_comparison_rvalue() throws RecognitionException { |
|
3597
|
|
|
ddl3Parser.numeric_comparison_rvalue_return retval = new ddl3Parser.numeric_comparison_rvalue_return(); |
|
3598
|
|
|
retval.start = input.LT(1); |
|
3599
|
|
|
int numeric_comparison_rvalue_StartIndex = input.index(); |
|
3600
|
|
|
|
|
3601
|
|
|
Object root_0 = null; |
|
3602
|
|
|
|
|
3603
|
|
|
ParserRuleReturnScope first_numeric_comparison_rvalue116 =null; |
|
3604
|
|
|
ParserRuleReturnScope other_numeric_comparison_rvalues117 =null; |
|
3605
|
|
|
|
|
3606
|
|
|
|
|
3607
|
|
|
try { |
|
3608
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return retval; } |
|
3609
|
|
|
|
|
3610
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:76:2: ( first_numeric_comparison_rvalue ( other_numeric_comparison_rvalues )* ) |
|
3611
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:76:4: first_numeric_comparison_rvalue ( other_numeric_comparison_rvalues )* |
|
3612
|
|
|
{ |
|
3613
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3614
|
|
|
|
|
3615
|
|
|
|
|
3616
|
|
|
pushFollow(FOLLOW_first_numeric_comparison_rvalue_in_numeric_comparison_rvalue870); |
|
3617
|
|
|
first_numeric_comparison_rvalue116=first_numeric_comparison_rvalue(); |
|
3618
|
|
|
state._fsp--; |
|
3619
|
|
|
if (state.failed) return retval; |
|
3620
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, first_numeric_comparison_rvalue116.getTree()); |
|
3621
|
|
|
|
|
3622
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:76:36: ( other_numeric_comparison_rvalues )* |
|
3623
|
|
|
loop11: |
|
3624
|
|
|
while (true) { |
|
3625
|
|
|
int alt11=2; |
|
3626
|
|
|
int LA11_0 = input.LA(1); |
|
3627
|
|
|
if ( (LA11_0==14||LA11_0==16) ) { |
|
3628
|
|
|
alt11=1; |
|
3629
|
|
|
} |
|
3630
|
|
|
|
|
3631
|
|
|
switch (alt11) { |
|
3632
|
|
|
case 1 : |
|
3633
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:76:37: other_numeric_comparison_rvalues |
|
3634
|
|
|
{ |
|
3635
|
|
|
pushFollow(FOLLOW_other_numeric_comparison_rvalues_in_numeric_comparison_rvalue873); |
|
3636
|
|
|
other_numeric_comparison_rvalues117=other_numeric_comparison_rvalues(); |
|
3637
|
|
|
state._fsp--; |
|
3638
|
|
|
if (state.failed) return retval; |
|
3639
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, other_numeric_comparison_rvalues117.getTree()); |
|
3640
|
|
|
|
|
3641
|
|
|
} |
|
3642
|
|
|
break; |
|
3643
|
|
|
|
|
3644
|
|
|
default : |
|
3645
|
|
|
break loop11; |
|
3646
|
|
|
} |
|
3647
|
|
|
} |
|
3648
|
|
|
|
|
3649
|
|
|
} |
|
3650
|
|
|
|
|
3651
|
|
|
retval.stop = input.LT(-1); |
|
3652
|
|
|
|
|
3653
|
|
|
if ( state.backtracking==0 ) { |
|
3654
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
3655
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
3656
|
|
|
} |
|
3657
|
|
|
} |
|
3658
|
|
|
catch (RecognitionException re) { |
|
3659
|
|
|
reportError(re); |
|
3660
|
|
|
recover(input,re); |
|
3661
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
3662
|
|
|
} |
|
3663
|
|
|
finally { |
|
3664
|
|
|
// do for sure before leaving |
|
3665
|
|
|
if ( state.backtracking>0 ) { memoize(input, 12, numeric_comparison_rvalue_StartIndex); } |
|
3666
|
|
|
|
|
3667
|
|
|
} |
|
3668
|
|
|
return retval; |
|
3669
|
|
|
} |
|
3670
|
|
|
// $ANTLR end "numeric_comparison_rvalue" |
|
3671
|
|
|
|
|
3672
|
|
|
|
|
3673
|
|
|
public static class first_numeric_comparison_rvalue_return extends ParserRuleReturnScope { |
|
3674
|
|
|
Object tree; |
|
3675
|
|
|
@Override |
|
3676
|
|
|
public Object getTree() { return tree; } |
|
3677
|
|
|
}; |
|
3678
|
|
|
|
|
3679
|
|
|
|
|
3680
|
|
|
// $ANTLR start "first_numeric_comparison_rvalue" |
|
3681
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:78:1: first_numeric_comparison_rvalue : ( VarID | number '*' ^ VarID | number ); |
|
3682
|
|
|
public final ddl3Parser.first_numeric_comparison_rvalue_return first_numeric_comparison_rvalue() throws RecognitionException { |
|
3683
|
|
|
ddl3Parser.first_numeric_comparison_rvalue_return retval = new ddl3Parser.first_numeric_comparison_rvalue_return(); |
|
3684
|
|
|
retval.start = input.LT(1); |
|
3685
|
|
|
int first_numeric_comparison_rvalue_StartIndex = input.index(); |
|
3686
|
|
|
|
|
3687
|
|
|
Object root_0 = null; |
|
3688
|
|
|
|
|
3689
|
|
|
Token VarID118=null; |
|
3690
|
|
|
Token char_literal120=null; |
|
3691
|
|
|
Token VarID121=null; |
|
3692
|
|
|
ParserRuleReturnScope number119 =null; |
|
3693
|
|
|
ParserRuleReturnScope number122 =null; |
|
3694
|
|
|
|
|
3695
|
|
|
Object VarID118_tree=null; |
|
3696
|
|
|
Object char_literal120_tree=null; |
|
3697
|
|
|
Object VarID121_tree=null; |
|
3698
|
|
|
|
|
3699
|
|
|
try { |
|
3700
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return retval; } |
|
3701
|
|
|
|
|
3702
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:79:2: ( VarID | number '*' ^ VarID | number ) |
|
3703
|
|
|
int alt12=3; |
|
3704
|
|
|
switch ( input.LA(1) ) { |
|
3705
|
|
|
case VarID: |
|
3706
|
|
|
{ |
|
3707
|
|
|
alt12=1; |
|
3708
|
|
|
} |
|
3709
|
|
|
break; |
|
3710
|
|
|
case 14: |
|
3711
|
|
|
case 16: |
|
3712
|
|
|
{ |
|
3713
|
|
|
int LA12_2 = input.LA(2); |
|
3714
|
|
|
if ( (LA12_2==INT) ) { |
|
3715
|
|
|
int LA12_3 = input.LA(3); |
|
3716
|
|
View Code Duplication |
if ( (LA12_3==13) ) { |
|
|
|
|
|
|
3717
|
|
|
alt12=2; |
|
3718
|
|
|
} |
|
3719
|
|
|
else if ( (LA12_3==EOF||LA12_3==14||LA12_3==16||LA12_3==19) ) { |
|
3720
|
|
|
alt12=3; |
|
3721
|
|
|
} |
|
3722
|
|
|
|
|
3723
|
|
|
else { |
|
3724
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3725
|
|
|
int nvaeMark = input.mark(); |
|
3726
|
|
|
try { |
|
3727
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
3728
|
|
|
input.consume(); |
|
3729
|
|
|
} |
|
3730
|
|
|
NoViableAltException nvae = |
|
3731
|
|
|
new NoViableAltException("", 12, 3, input); |
|
3732
|
|
|
throw nvae; |
|
3733
|
|
|
} finally { |
|
3734
|
|
|
input.rewind(nvaeMark); |
|
3735
|
|
|
} |
|
3736
|
|
|
} |
|
3737
|
|
|
|
|
3738
|
|
|
} |
|
3739
|
|
|
else if ( (LA12_2==54) ) { |
|
3740
|
|
|
int LA12_4 = input.LA(3); |
|
3741
|
|
View Code Duplication |
if ( (LA12_4==13) ) { |
|
|
|
|
|
|
3742
|
|
|
alt12=2; |
|
3743
|
|
|
} |
|
3744
|
|
|
else if ( (LA12_4==EOF||LA12_4==14||LA12_4==16||LA12_4==19) ) { |
|
3745
|
|
|
alt12=3; |
|
3746
|
|
|
} |
|
3747
|
|
|
|
|
3748
|
|
|
else { |
|
3749
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3750
|
|
|
int nvaeMark = input.mark(); |
|
3751
|
|
|
try { |
|
3752
|
|
|
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { |
|
3753
|
|
|
input.consume(); |
|
3754
|
|
|
} |
|
3755
|
|
|
NoViableAltException nvae = |
|
3756
|
|
|
new NoViableAltException("", 12, 4, input); |
|
3757
|
|
|
throw nvae; |
|
3758
|
|
|
} finally { |
|
3759
|
|
|
input.rewind(nvaeMark); |
|
3760
|
|
|
} |
|
3761
|
|
|
} |
|
3762
|
|
|
|
|
3763
|
|
|
} |
|
3764
|
|
|
|
|
3765
|
|
|
else { |
|
3766
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3767
|
|
|
int nvaeMark = input.mark(); |
|
3768
|
|
|
try { |
|
3769
|
|
|
input.consume(); |
|
3770
|
|
|
NoViableAltException nvae = |
|
3771
|
|
|
new NoViableAltException("", 12, 2, input); |
|
3772
|
|
|
throw nvae; |
|
3773
|
|
|
} finally { |
|
3774
|
|
|
input.rewind(nvaeMark); |
|
3775
|
|
|
} |
|
3776
|
|
|
} |
|
3777
|
|
|
|
|
3778
|
|
|
} |
|
3779
|
|
|
break; |
|
3780
|
|
|
case INT: |
|
3781
|
|
|
{ |
|
3782
|
|
|
int LA12_3 = input.LA(2); |
|
3783
|
|
View Code Duplication |
if ( (LA12_3==13) ) { |
|
|
|
|
|
|
3784
|
|
|
alt12=2; |
|
3785
|
|
|
} |
|
3786
|
|
|
else if ( (LA12_3==EOF||LA12_3==14||LA12_3==16||LA12_3==19) ) { |
|
3787
|
|
|
alt12=3; |
|
3788
|
|
|
} |
|
3789
|
|
|
|
|
3790
|
|
|
else { |
|
3791
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3792
|
|
|
int nvaeMark = input.mark(); |
|
3793
|
|
|
try { |
|
3794
|
|
|
input.consume(); |
|
3795
|
|
|
NoViableAltException nvae = |
|
3796
|
|
|
new NoViableAltException("", 12, 3, input); |
|
3797
|
|
|
throw nvae; |
|
3798
|
|
|
} finally { |
|
3799
|
|
|
input.rewind(nvaeMark); |
|
3800
|
|
|
} |
|
3801
|
|
|
} |
|
3802
|
|
|
|
|
3803
|
|
|
} |
|
3804
|
|
|
break; |
|
3805
|
|
|
case 54: |
|
3806
|
|
|
{ |
|
3807
|
|
|
int LA12_4 = input.LA(2); |
|
3808
|
|
View Code Duplication |
if ( (LA12_4==13) ) { |
|
|
|
|
|
|
3809
|
|
|
alt12=2; |
|
3810
|
|
|
} |
|
3811
|
|
|
else if ( (LA12_4==EOF||LA12_4==14||LA12_4==16||LA12_4==19) ) { |
|
3812
|
|
|
alt12=3; |
|
3813
|
|
|
} |
|
3814
|
|
|
|
|
3815
|
|
|
else { |
|
3816
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3817
|
|
|
int nvaeMark = input.mark(); |
|
3818
|
|
|
try { |
|
3819
|
|
|
input.consume(); |
|
3820
|
|
|
NoViableAltException nvae = |
|
3821
|
|
|
new NoViableAltException("", 12, 4, input); |
|
3822
|
|
|
throw nvae; |
|
3823
|
|
|
} finally { |
|
3824
|
|
|
input.rewind(nvaeMark); |
|
3825
|
|
|
} |
|
3826
|
|
|
} |
|
3827
|
|
|
|
|
3828
|
|
|
} |
|
3829
|
|
|
break; |
|
3830
|
|
|
default: |
|
3831
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3832
|
|
|
NoViableAltException nvae = |
|
3833
|
|
|
new NoViableAltException("", 12, 0, input); |
|
3834
|
|
|
throw nvae; |
|
3835
|
|
|
} |
|
3836
|
|
|
switch (alt12) { |
|
3837
|
|
|
case 1 : |
|
3838
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:79:4: VarID |
|
3839
|
|
|
{ |
|
3840
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3841
|
|
|
|
|
3842
|
|
|
|
|
3843
|
|
|
VarID118=(Token)match(input,VarID,FOLLOW_VarID_in_first_numeric_comparison_rvalue884); if (state.failed) return retval; |
|
3844
|
|
|
if ( state.backtracking==0 ) { |
|
3845
|
|
|
VarID118_tree = (Object)adaptor.create(VarID118); |
|
3846
|
|
|
adaptor.addChild(root_0, VarID118_tree); |
|
3847
|
|
|
} |
|
3848
|
|
|
|
|
3849
|
|
|
} |
|
3850
|
|
|
break; |
|
3851
|
|
|
case 2 : |
|
3852
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:79:12: number '*' ^ VarID |
|
3853
|
|
|
{ |
|
3854
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3855
|
|
|
|
|
3856
|
|
|
|
|
3857
|
|
|
pushFollow(FOLLOW_number_in_first_numeric_comparison_rvalue888); |
|
3858
|
|
|
number119=number(); |
|
3859
|
|
|
state._fsp--; |
|
3860
|
|
|
if (state.failed) return retval; |
|
3861
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, number119.getTree()); |
|
3862
|
|
|
|
|
3863
|
|
|
char_literal120=(Token)match(input,13,FOLLOW_13_in_first_numeric_comparison_rvalue890); if (state.failed) return retval; |
|
3864
|
|
|
if ( state.backtracking==0 ) { |
|
3865
|
|
|
char_literal120_tree = (Object)adaptor.create(char_literal120); |
|
3866
|
|
|
root_0 = (Object)adaptor.becomeRoot(char_literal120_tree, root_0); |
|
3867
|
|
|
} |
|
3868
|
|
|
|
|
3869
|
|
|
VarID121=(Token)match(input,VarID,FOLLOW_VarID_in_first_numeric_comparison_rvalue893); if (state.failed) return retval; |
|
3870
|
|
|
if ( state.backtracking==0 ) { |
|
3871
|
|
|
VarID121_tree = (Object)adaptor.create(VarID121); |
|
3872
|
|
|
adaptor.addChild(root_0, VarID121_tree); |
|
3873
|
|
|
} |
|
3874
|
|
|
|
|
3875
|
|
|
} |
|
3876
|
|
|
break; |
|
3877
|
|
|
case 3 : |
|
3878
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:79:32: number |
|
3879
|
|
|
{ |
|
3880
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3881
|
|
|
|
|
3882
|
|
|
|
|
3883
|
|
|
pushFollow(FOLLOW_number_in_first_numeric_comparison_rvalue897); |
|
3884
|
|
|
number122=number(); |
|
3885
|
|
|
state._fsp--; |
|
3886
|
|
|
if (state.failed) return retval; |
|
3887
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, number122.getTree()); |
|
3888
|
|
|
|
|
3889
|
|
|
} |
|
3890
|
|
|
break; |
|
3891
|
|
|
|
|
3892
|
|
|
} |
|
3893
|
|
|
retval.stop = input.LT(-1); |
|
3894
|
|
|
|
|
3895
|
|
|
if ( state.backtracking==0 ) { |
|
3896
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
3897
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
3898
|
|
|
} |
|
3899
|
|
|
} |
|
3900
|
|
|
catch (RecognitionException re) { |
|
3901
|
|
|
reportError(re); |
|
3902
|
|
|
recover(input,re); |
|
3903
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
3904
|
|
|
} |
|
3905
|
|
|
finally { |
|
3906
|
|
|
// do for sure before leaving |
|
3907
|
|
|
if ( state.backtracking>0 ) { memoize(input, 13, first_numeric_comparison_rvalue_StartIndex); } |
|
3908
|
|
|
|
|
3909
|
|
|
} |
|
3910
|
|
|
return retval; |
|
3911
|
|
|
} |
|
3912
|
|
|
// $ANTLR end "first_numeric_comparison_rvalue" |
|
3913
|
|
|
|
|
3914
|
|
|
|
|
3915
|
|
|
public static class other_numeric_comparison_rvalues_return extends ParserRuleReturnScope { |
|
3916
|
|
|
Object tree; |
|
3917
|
|
|
@Override |
|
3918
|
|
|
public Object getTree() { return tree; } |
|
3919
|
|
|
}; |
|
3920
|
|
|
|
|
3921
|
|
|
|
|
3922
|
|
|
// $ANTLR start "other_numeric_comparison_rvalues" |
|
3923
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:81:1: other_numeric_comparison_rvalues : ( '+' | '-' ) ^ numeric_comparison_value ; |
|
3924
|
|
|
public final ddl3Parser.other_numeric_comparison_rvalues_return other_numeric_comparison_rvalues() throws RecognitionException { |
|
3925
|
|
|
ddl3Parser.other_numeric_comparison_rvalues_return retval = new ddl3Parser.other_numeric_comparison_rvalues_return(); |
|
3926
|
|
|
retval.start = input.LT(1); |
|
3927
|
|
|
int other_numeric_comparison_rvalues_StartIndex = input.index(); |
|
3928
|
|
|
|
|
3929
|
|
|
Object root_0 = null; |
|
3930
|
|
|
|
|
3931
|
|
|
Token set123=null; |
|
3932
|
|
|
ParserRuleReturnScope numeric_comparison_value124 =null; |
|
3933
|
|
|
|
|
3934
|
|
|
Object set123_tree=null; |
|
3935
|
|
|
|
|
3936
|
|
|
try { |
|
3937
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return retval; } |
|
3938
|
|
|
|
|
3939
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:82:2: ( ( '+' | '-' ) ^ numeric_comparison_value ) |
|
3940
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:82:4: ( '+' | '-' ) ^ numeric_comparison_value |
|
3941
|
|
|
{ |
|
3942
|
|
|
root_0 = (Object)adaptor.nil(); |
|
3943
|
|
|
|
|
3944
|
|
|
|
|
3945
|
|
|
set123=input.LT(1); |
|
3946
|
|
|
set123=input.LT(1); |
|
3947
|
|
|
if ( input.LA(1)==14||input.LA(1)==16 ) { |
|
3948
|
|
|
input.consume(); |
|
3949
|
|
|
if ( state.backtracking==0 ) root_0 = (Object)adaptor.becomeRoot((Object)adaptor.create(set123), root_0); |
|
3950
|
|
|
state.errorRecovery=false; |
|
3951
|
|
|
state.failed=false; |
|
3952
|
|
|
} |
|
3953
|
|
|
else { |
|
3954
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
3955
|
|
|
MismatchedSetException mse = new MismatchedSetException(null,input); |
|
3956
|
|
|
throw mse; |
|
3957
|
|
|
} |
|
3958
|
|
|
pushFollow(FOLLOW_numeric_comparison_value_in_other_numeric_comparison_rvalues915); |
|
3959
|
|
|
numeric_comparison_value124=numeric_comparison_value(); |
|
3960
|
|
|
state._fsp--; |
|
3961
|
|
|
if (state.failed) return retval; |
|
3962
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, numeric_comparison_value124.getTree()); |
|
3963
|
|
|
|
|
3964
|
|
|
} |
|
3965
|
|
|
|
|
3966
|
|
|
retval.stop = input.LT(-1); |
|
3967
|
|
|
|
|
3968
|
|
|
if ( state.backtracking==0 ) { |
|
3969
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
3970
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
3971
|
|
|
} |
|
3972
|
|
|
} |
|
3973
|
|
|
catch (RecognitionException re) { |
|
3974
|
|
|
reportError(re); |
|
3975
|
|
|
recover(input,re); |
|
3976
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
3977
|
|
|
} |
|
3978
|
|
|
finally { |
|
3979
|
|
|
// do for sure before leaving |
|
3980
|
|
|
if ( state.backtracking>0 ) { memoize(input, 14, other_numeric_comparison_rvalues_StartIndex); } |
|
3981
|
|
|
|
|
3982
|
|
|
} |
|
3983
|
|
|
return retval; |
|
3984
|
|
|
} |
|
3985
|
|
|
// $ANTLR end "other_numeric_comparison_rvalues" |
|
3986
|
|
|
|
|
3987
|
|
|
|
|
3988
|
|
|
public static class numeric_comparison_value_return extends ParserRuleReturnScope { |
|
3989
|
|
|
Object tree; |
|
3990
|
|
|
@Override |
|
3991
|
|
|
public Object getTree() { return tree; } |
|
3992
|
|
|
}; |
|
3993
|
|
|
|
|
3994
|
|
|
|
|
3995
|
|
|
// $ANTLR start "numeric_comparison_value" |
|
3996
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:84:1: numeric_comparison_value : ( VarID | INT '*' ^ VarID | INT ); |
|
3997
|
|
|
public final ddl3Parser.numeric_comparison_value_return numeric_comparison_value() throws RecognitionException { |
|
3998
|
|
|
ddl3Parser.numeric_comparison_value_return retval = new ddl3Parser.numeric_comparison_value_return(); |
|
3999
|
|
|
retval.start = input.LT(1); |
|
4000
|
|
|
int numeric_comparison_value_StartIndex = input.index(); |
|
4001
|
|
|
|
|
4002
|
|
|
Object root_0 = null; |
|
4003
|
|
|
|
|
4004
|
|
|
Token VarID125=null; |
|
4005
|
|
|
Token INT126=null; |
|
4006
|
|
|
Token char_literal127=null; |
|
4007
|
|
|
Token VarID128=null; |
|
4008
|
|
|
Token INT129=null; |
|
4009
|
|
|
|
|
4010
|
|
|
Object VarID125_tree=null; |
|
4011
|
|
|
Object INT126_tree=null; |
|
4012
|
|
|
Object char_literal127_tree=null; |
|
4013
|
|
|
Object VarID128_tree=null; |
|
4014
|
|
|
Object INT129_tree=null; |
|
4015
|
|
|
|
|
4016
|
|
|
try { |
|
4017
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return retval; } |
|
4018
|
|
|
|
|
4019
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:85:2: ( VarID | INT '*' ^ VarID | INT ) |
|
4020
|
|
|
int alt13=3; |
|
4021
|
|
|
int LA13_0 = input.LA(1); |
|
4022
|
|
|
if ( (LA13_0==VarID) ) { |
|
4023
|
|
|
alt13=1; |
|
4024
|
|
|
} |
|
4025
|
|
|
else if ( (LA13_0==INT) ) { |
|
4026
|
|
|
int LA13_2 = input.LA(2); |
|
4027
|
|
View Code Duplication |
if ( (LA13_2==13) ) { |
|
|
|
|
|
|
4028
|
|
|
alt13=2; |
|
4029
|
|
|
} |
|
4030
|
|
|
else if ( (LA13_2==EOF||LA13_2==14||LA13_2==16||LA13_2==19) ) { |
|
4031
|
|
|
alt13=3; |
|
4032
|
|
|
} |
|
4033
|
|
|
|
|
4034
|
|
|
else { |
|
4035
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4036
|
|
|
int nvaeMark = input.mark(); |
|
4037
|
|
|
try { |
|
4038
|
|
|
input.consume(); |
|
4039
|
|
|
NoViableAltException nvae = |
|
4040
|
|
|
new NoViableAltException("", 13, 2, input); |
|
4041
|
|
|
throw nvae; |
|
4042
|
|
|
} finally { |
|
4043
|
|
|
input.rewind(nvaeMark); |
|
4044
|
|
|
} |
|
4045
|
|
|
} |
|
4046
|
|
|
|
|
4047
|
|
|
} |
|
4048
|
|
|
|
|
4049
|
|
|
else { |
|
4050
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4051
|
|
|
NoViableAltException nvae = |
|
4052
|
|
|
new NoViableAltException("", 13, 0, input); |
|
4053
|
|
|
throw nvae; |
|
4054
|
|
|
} |
|
4055
|
|
|
|
|
4056
|
|
|
switch (alt13) { |
|
4057
|
|
|
case 1 : |
|
4058
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:85:4: VarID |
|
4059
|
|
|
{ |
|
4060
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4061
|
|
|
|
|
4062
|
|
|
|
|
4063
|
|
|
VarID125=(Token)match(input,VarID,FOLLOW_VarID_in_numeric_comparison_value924); if (state.failed) return retval; |
|
4064
|
|
|
if ( state.backtracking==0 ) { |
|
4065
|
|
|
VarID125_tree = (Object)adaptor.create(VarID125); |
|
4066
|
|
|
adaptor.addChild(root_0, VarID125_tree); |
|
4067
|
|
|
} |
|
4068
|
|
|
|
|
4069
|
|
|
} |
|
4070
|
|
|
break; |
|
4071
|
|
|
case 2 : |
|
4072
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:85:12: INT '*' ^ VarID |
|
4073
|
|
|
{ |
|
4074
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4075
|
|
|
|
|
4076
|
|
|
|
|
4077
|
|
|
INT126=(Token)match(input,INT,FOLLOW_INT_in_numeric_comparison_value928); if (state.failed) return retval; |
|
4078
|
|
|
if ( state.backtracking==0 ) { |
|
4079
|
|
|
INT126_tree = (Object)adaptor.create(INT126); |
|
4080
|
|
|
adaptor.addChild(root_0, INT126_tree); |
|
4081
|
|
|
} |
|
4082
|
|
|
|
|
4083
|
|
|
char_literal127=(Token)match(input,13,FOLLOW_13_in_numeric_comparison_value930); if (state.failed) return retval; |
|
4084
|
|
|
if ( state.backtracking==0 ) { |
|
4085
|
|
|
char_literal127_tree = (Object)adaptor.create(char_literal127); |
|
4086
|
|
|
root_0 = (Object)adaptor.becomeRoot(char_literal127_tree, root_0); |
|
4087
|
|
|
} |
|
4088
|
|
|
|
|
4089
|
|
|
VarID128=(Token)match(input,VarID,FOLLOW_VarID_in_numeric_comparison_value933); if (state.failed) return retval; |
|
4090
|
|
|
if ( state.backtracking==0 ) { |
|
4091
|
|
|
VarID128_tree = (Object)adaptor.create(VarID128); |
|
4092
|
|
|
adaptor.addChild(root_0, VarID128_tree); |
|
4093
|
|
|
} |
|
4094
|
|
|
|
|
4095
|
|
|
} |
|
4096
|
|
|
break; |
|
4097
|
|
|
case 3 : |
|
4098
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:85:29: INT |
|
4099
|
|
|
{ |
|
4100
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4101
|
|
|
|
|
4102
|
|
|
|
|
4103
|
|
|
INT129=(Token)match(input,INT,FOLLOW_INT_in_numeric_comparison_value937); if (state.failed) return retval; |
|
4104
|
|
|
if ( state.backtracking==0 ) { |
|
4105
|
|
|
INT129_tree = (Object)adaptor.create(INT129); |
|
4106
|
|
|
adaptor.addChild(root_0, INT129_tree); |
|
4107
|
|
|
} |
|
4108
|
|
|
|
|
4109
|
|
|
} |
|
4110
|
|
|
break; |
|
4111
|
|
|
|
|
4112
|
|
|
} |
|
4113
|
|
|
retval.stop = input.LT(-1); |
|
4114
|
|
|
|
|
4115
|
|
|
if ( state.backtracking==0 ) { |
|
4116
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4117
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4118
|
|
|
} |
|
4119
|
|
|
} |
|
4120
|
|
|
catch (RecognitionException re) { |
|
4121
|
|
|
reportError(re); |
|
4122
|
|
|
recover(input,re); |
|
4123
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4124
|
|
|
} |
|
4125
|
|
|
finally { |
|
4126
|
|
|
// do for sure before leaving |
|
4127
|
|
|
if ( state.backtracking>0 ) { memoize(input, 15, numeric_comparison_value_StartIndex); } |
|
4128
|
|
|
|
|
4129
|
|
|
} |
|
4130
|
|
|
return retval; |
|
4131
|
|
|
} |
|
4132
|
|
|
// $ANTLR end "numeric_comparison_value" |
|
4133
|
|
|
|
|
4134
|
|
|
|
|
4135
|
|
|
public static class enumeration_parameter_constraint_return extends ParserRuleReturnScope { |
|
4136
|
|
|
Object tree; |
|
4137
|
|
|
@Override |
|
4138
|
|
|
public Object getTree() { return tree; } |
|
4139
|
|
|
}; |
|
4140
|
|
|
|
|
4141
|
|
|
|
|
4142
|
|
|
// $ANTLR start "enumeration_parameter_constraint" |
|
4143
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:87:1: enumeration_parameter_constraint : ( VarID '=' enumeration_comparison_rvalue -> ^( '=' VarID enumeration_comparison_rvalue ) | VarID '!=' enumeration_comparison_rvalue -> ^( '!=' VarID enumeration_comparison_rvalue ) ); |
|
4144
|
|
|
public final ddl3Parser.enumeration_parameter_constraint_return enumeration_parameter_constraint() throws RecognitionException { |
|
4145
|
|
|
ddl3Parser.enumeration_parameter_constraint_return retval = new ddl3Parser.enumeration_parameter_constraint_return(); |
|
4146
|
|
|
retval.start = input.LT(1); |
|
4147
|
|
|
int enumeration_parameter_constraint_StartIndex = input.index(); |
|
4148
|
|
|
|
|
4149
|
|
|
Object root_0 = null; |
|
4150
|
|
|
|
|
4151
|
|
|
Token VarID130=null; |
|
4152
|
|
|
Token char_literal131=null; |
|
4153
|
|
|
Token VarID133=null; |
|
4154
|
|
|
Token string_literal134=null; |
|
4155
|
|
|
ParserRuleReturnScope enumeration_comparison_rvalue132 =null; |
|
4156
|
|
|
ParserRuleReturnScope enumeration_comparison_rvalue135 =null; |
|
4157
|
|
|
|
|
4158
|
|
|
Object VarID130_tree=null; |
|
4159
|
|
|
Object char_literal131_tree=null; |
|
4160
|
|
|
Object VarID133_tree=null; |
|
4161
|
|
|
Object string_literal134_tree=null; |
|
4162
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
4163
|
|
|
RewriteRuleTokenStream stream_VarID=new RewriteRuleTokenStream(adaptor,"token VarID"); |
|
4164
|
|
|
RewriteRuleTokenStream stream_10=new RewriteRuleTokenStream(adaptor,"token 10"); |
|
4165
|
|
|
RewriteRuleSubtreeStream stream_enumeration_comparison_rvalue=new RewriteRuleSubtreeStream(adaptor,"rule enumeration_comparison_rvalue"); |
|
4166
|
|
|
|
|
4167
|
|
|
try { |
|
4168
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return retval; } |
|
4169
|
|
|
|
|
4170
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:88:2: ( VarID '=' enumeration_comparison_rvalue -> ^( '=' VarID enumeration_comparison_rvalue ) | VarID '!=' enumeration_comparison_rvalue -> ^( '!=' VarID enumeration_comparison_rvalue ) ) |
|
4171
|
|
|
int alt14=2; |
|
4172
|
|
|
int LA14_0 = input.LA(1); |
|
4173
|
|
View Code Duplication |
if ( (LA14_0==VarID) ) { |
|
|
|
|
|
|
4174
|
|
|
int LA14_1 = input.LA(2); |
|
4175
|
|
|
if ( (LA14_1==22) ) { |
|
4176
|
|
|
alt14=1; |
|
4177
|
|
|
} |
|
4178
|
|
|
else if ( (LA14_1==10) ) { |
|
4179
|
|
|
alt14=2; |
|
4180
|
|
|
} |
|
4181
|
|
|
|
|
4182
|
|
|
else { |
|
4183
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4184
|
|
|
int nvaeMark = input.mark(); |
|
4185
|
|
|
try { |
|
4186
|
|
|
input.consume(); |
|
4187
|
|
|
NoViableAltException nvae = |
|
4188
|
|
|
new NoViableAltException("", 14, 1, input); |
|
4189
|
|
|
throw nvae; |
|
4190
|
|
|
} finally { |
|
4191
|
|
|
input.rewind(nvaeMark); |
|
4192
|
|
|
} |
|
4193
|
|
|
} |
|
4194
|
|
|
|
|
4195
|
|
|
} |
|
4196
|
|
|
|
|
4197
|
|
|
else { |
|
4198
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4199
|
|
|
NoViableAltException nvae = |
|
4200
|
|
|
new NoViableAltException("", 14, 0, input); |
|
4201
|
|
|
throw nvae; |
|
4202
|
|
|
} |
|
4203
|
|
|
|
|
4204
|
|
|
switch (alt14) { |
|
4205
|
|
|
case 1 : |
|
4206
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:88:4: VarID '=' enumeration_comparison_rvalue |
|
4207
|
|
|
{ |
|
4208
|
|
|
VarID130=(Token)match(input,VarID,FOLLOW_VarID_in_enumeration_parameter_constraint946); if (state.failed) return retval; |
|
4209
|
|
|
if ( state.backtracking==0 ) stream_VarID.add(VarID130); |
|
4210
|
|
|
|
|
4211
|
|
|
char_literal131=(Token)match(input,22,FOLLOW_22_in_enumeration_parameter_constraint948); if (state.failed) return retval; |
|
4212
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal131); |
|
4213
|
|
|
|
|
4214
|
|
|
pushFollow(FOLLOW_enumeration_comparison_rvalue_in_enumeration_parameter_constraint950); |
|
4215
|
|
|
enumeration_comparison_rvalue132=enumeration_comparison_rvalue(); |
|
4216
|
|
|
state._fsp--; |
|
4217
|
|
|
if (state.failed) return retval; |
|
4218
|
|
|
if ( state.backtracking==0 ) stream_enumeration_comparison_rvalue.add(enumeration_comparison_rvalue132.getTree()); |
|
4219
|
|
|
// AST REWRITE |
|
4220
|
|
|
// elements: 22, VarID, enumeration_comparison_rvalue |
|
4221
|
|
|
// token labels: |
|
4222
|
|
|
// rule labels: retval |
|
4223
|
|
|
// token list labels: |
|
4224
|
|
|
// rule list labels: |
|
4225
|
|
|
// wildcard labels: |
|
4226
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
4227
|
|
|
retval.tree = root_0; |
|
4228
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
4229
|
|
|
|
|
4230
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4231
|
|
|
// 88:44: -> ^( '=' VarID enumeration_comparison_rvalue ) |
|
4232
|
|
|
{ |
|
4233
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:88:46: ^( '=' VarID enumeration_comparison_rvalue ) |
|
4234
|
|
|
{ |
|
4235
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
4236
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLEnumerationParameterConstraint(stream_22.nextToken()), root_1); |
|
4237
|
|
|
adaptor.addChild(root_1, stream_VarID.nextNode()); |
|
4238
|
|
|
adaptor.addChild(root_1, stream_enumeration_comparison_rvalue.nextTree()); |
|
4239
|
|
|
adaptor.addChild(root_0, root_1); |
|
4240
|
|
|
} |
|
4241
|
|
|
|
|
4242
|
|
|
} |
|
4243
|
|
|
|
|
4244
|
|
|
|
|
4245
|
|
|
retval.tree = root_0; |
|
4246
|
|
|
} |
|
4247
|
|
|
|
|
4248
|
|
|
} |
|
4249
|
|
|
break; |
|
4250
|
|
|
case 2 : |
|
4251
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:88:126: VarID '!=' enumeration_comparison_rvalue |
|
4252
|
|
|
{ |
|
4253
|
|
|
VarID133=(Token)match(input,VarID,FOLLOW_VarID_in_enumeration_parameter_constraint966); if (state.failed) return retval; |
|
4254
|
|
|
if ( state.backtracking==0 ) stream_VarID.add(VarID133); |
|
4255
|
|
|
|
|
4256
|
|
|
string_literal134=(Token)match(input,10,FOLLOW_10_in_enumeration_parameter_constraint968); if (state.failed) return retval; |
|
4257
|
|
|
if ( state.backtracking==0 ) stream_10.add(string_literal134); |
|
4258
|
|
|
|
|
4259
|
|
|
pushFollow(FOLLOW_enumeration_comparison_rvalue_in_enumeration_parameter_constraint970); |
|
4260
|
|
|
enumeration_comparison_rvalue135=enumeration_comparison_rvalue(); |
|
4261
|
|
|
state._fsp--; |
|
4262
|
|
|
if (state.failed) return retval; |
|
4263
|
|
|
if ( state.backtracking==0 ) stream_enumeration_comparison_rvalue.add(enumeration_comparison_rvalue135.getTree()); |
|
4264
|
|
|
// AST REWRITE |
|
4265
|
|
|
// elements: 10, VarID, enumeration_comparison_rvalue |
|
4266
|
|
|
// token labels: |
|
4267
|
|
|
// rule labels: retval |
|
4268
|
|
|
// token list labels: |
|
4269
|
|
|
// rule list labels: |
|
4270
|
|
|
// wildcard labels: |
|
4271
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
4272
|
|
|
retval.tree = root_0; |
|
4273
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
4274
|
|
|
|
|
4275
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4276
|
|
|
// 88:167: -> ^( '!=' VarID enumeration_comparison_rvalue ) |
|
4277
|
|
|
{ |
|
4278
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:88:169: ^( '!=' VarID enumeration_comparison_rvalue ) |
|
4279
|
|
|
{ |
|
4280
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
4281
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLEnumerationParameterConstraint(stream_10.nextToken()), root_1); |
|
4282
|
|
|
adaptor.addChild(root_1, stream_VarID.nextNode()); |
|
4283
|
|
|
adaptor.addChild(root_1, stream_enumeration_comparison_rvalue.nextTree()); |
|
4284
|
|
|
adaptor.addChild(root_0, root_1); |
|
4285
|
|
|
} |
|
4286
|
|
|
|
|
4287
|
|
|
} |
|
4288
|
|
|
|
|
4289
|
|
|
|
|
4290
|
|
|
retval.tree = root_0; |
|
4291
|
|
|
} |
|
4292
|
|
|
|
|
4293
|
|
|
} |
|
4294
|
|
|
break; |
|
4295
|
|
|
|
|
4296
|
|
|
} |
|
4297
|
|
|
retval.stop = input.LT(-1); |
|
4298
|
|
|
|
|
4299
|
|
|
if ( state.backtracking==0 ) { |
|
4300
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4301
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4302
|
|
|
} |
|
4303
|
|
|
} |
|
4304
|
|
|
catch (RecognitionException re) { |
|
4305
|
|
|
reportError(re); |
|
4306
|
|
|
recover(input,re); |
|
4307
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4308
|
|
|
} |
|
4309
|
|
|
finally { |
|
4310
|
|
|
// do for sure before leaving |
|
4311
|
|
|
if ( state.backtracking>0 ) { memoize(input, 16, enumeration_parameter_constraint_StartIndex); } |
|
4312
|
|
|
|
|
4313
|
|
|
} |
|
4314
|
|
|
return retval; |
|
4315
|
|
|
} |
|
4316
|
|
|
// $ANTLR end "enumeration_parameter_constraint" |
|
4317
|
|
|
|
|
4318
|
|
|
|
|
4319
|
|
|
public static class enumeration_comparison_rvalue_return extends ParserRuleReturnScope { |
|
4320
|
|
|
Object tree; |
|
4321
|
|
|
@Override |
|
4322
|
|
|
public Object getTree() { return tree; } |
|
4323
|
|
|
}; |
|
4324
|
|
|
|
|
4325
|
|
|
|
|
4326
|
|
|
// $ANTLR start "enumeration_comparison_rvalue" |
|
4327
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:90:1: enumeration_comparison_rvalue : ( VarID | ID ); |
|
4328
|
|
View Code Duplication |
public final ddl3Parser.enumeration_comparison_rvalue_return enumeration_comparison_rvalue() throws RecognitionException { |
|
|
|
|
|
|
4329
|
|
|
ddl3Parser.enumeration_comparison_rvalue_return retval = new ddl3Parser.enumeration_comparison_rvalue_return(); |
|
4330
|
|
|
retval.start = input.LT(1); |
|
4331
|
|
|
int enumeration_comparison_rvalue_StartIndex = input.index(); |
|
4332
|
|
|
|
|
4333
|
|
|
Object root_0 = null; |
|
4334
|
|
|
|
|
4335
|
|
|
Token set136=null; |
|
4336
|
|
|
|
|
4337
|
|
|
Object set136_tree=null; |
|
4338
|
|
|
|
|
4339
|
|
|
try { |
|
4340
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return retval; } |
|
4341
|
|
|
|
|
4342
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:91:2: ( VarID | ID ) |
|
4343
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g: |
|
4344
|
|
|
{ |
|
4345
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4346
|
|
|
|
|
4347
|
|
|
|
|
4348
|
|
|
set136=input.LT(1); |
|
4349
|
|
|
if ( input.LA(1)==ID||input.LA(1)==VarID ) { |
|
4350
|
|
|
input.consume(); |
|
4351
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set136)); |
|
4352
|
|
|
state.errorRecovery=false; |
|
4353
|
|
|
state.failed=false; |
|
4354
|
|
|
} |
|
4355
|
|
|
else { |
|
4356
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4357
|
|
|
MismatchedSetException mse = new MismatchedSetException(null,input); |
|
4358
|
|
|
throw mse; |
|
4359
|
|
|
} |
|
4360
|
|
|
} |
|
4361
|
|
|
|
|
4362
|
|
|
retval.stop = input.LT(-1); |
|
4363
|
|
|
|
|
4364
|
|
|
if ( state.backtracking==0 ) { |
|
4365
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4366
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4367
|
|
|
} |
|
4368
|
|
|
} |
|
4369
|
|
|
catch (RecognitionException re) { |
|
4370
|
|
|
reportError(re); |
|
4371
|
|
|
recover(input,re); |
|
4372
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4373
|
|
|
} |
|
4374
|
|
|
finally { |
|
4375
|
|
|
// do for sure before leaving |
|
4376
|
|
|
if ( state.backtracking>0 ) { memoize(input, 17, enumeration_comparison_rvalue_StartIndex); } |
|
4377
|
|
|
|
|
4378
|
|
|
} |
|
4379
|
|
|
return retval; |
|
4380
|
|
|
} |
|
4381
|
|
|
// $ANTLR end "enumeration_comparison_rvalue" |
|
4382
|
|
|
|
|
4383
|
|
|
|
|
4384
|
|
|
public static class component_type_return extends ParserRuleReturnScope { |
|
4385
|
|
|
Object tree; |
|
4386
|
|
|
@Override |
|
4387
|
|
|
public Object getTree() { return tree; } |
|
4388
|
|
|
}; |
|
4389
|
|
|
|
|
4390
|
|
|
|
|
4391
|
|
|
// $ANTLR start "component_type" |
|
4392
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:94:1: component_type : ( simple_ground_state_variable_component_type | singleton_state_variable_component_type | renewable_resource_component_type | consumable_resource_component_type ); |
|
4393
|
|
|
public final ddl3Parser.component_type_return component_type() throws RecognitionException { |
|
4394
|
|
|
ddl3Parser.component_type_return retval = new ddl3Parser.component_type_return(); |
|
4395
|
|
|
retval.start = input.LT(1); |
|
4396
|
|
|
int component_type_StartIndex = input.index(); |
|
4397
|
|
|
|
|
4398
|
|
|
Object root_0 = null; |
|
4399
|
|
|
|
|
4400
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_type137 =null; |
|
4401
|
|
|
ParserRuleReturnScope singleton_state_variable_component_type138 =null; |
|
4402
|
|
|
ParserRuleReturnScope renewable_resource_component_type139 =null; |
|
4403
|
|
|
ParserRuleReturnScope consumable_resource_component_type140 =null; |
|
4404
|
|
|
|
|
4405
|
|
|
|
|
4406
|
|
|
try { |
|
4407
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return retval; } |
|
4408
|
|
|
|
|
4409
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:95:2: ( simple_ground_state_variable_component_type | singleton_state_variable_component_type | renewable_resource_component_type | consumable_resource_component_type ) |
|
4410
|
|
|
int alt15=4; |
|
4411
|
|
|
int LA15_0 = input.LA(1); |
|
4412
|
|
|
if ( (LA15_0==35) ) { |
|
4413
|
|
|
switch ( input.LA(2) ) { |
|
4414
|
|
|
case 72: |
|
4415
|
|
|
{ |
|
4416
|
|
|
alt15=1; |
|
4417
|
|
|
} |
|
4418
|
|
|
break; |
|
4419
|
|
|
case 73: |
|
4420
|
|
|
{ |
|
4421
|
|
|
alt15=2; |
|
4422
|
|
|
} |
|
4423
|
|
|
break; |
|
4424
|
|
|
case 64: |
|
4425
|
|
|
{ |
|
4426
|
|
|
alt15=3; |
|
4427
|
|
|
} |
|
4428
|
|
|
break; |
|
4429
|
|
|
case 40: |
|
4430
|
|
|
{ |
|
4431
|
|
|
alt15=4; |
|
4432
|
|
|
} |
|
4433
|
|
|
break; |
|
4434
|
|
|
default: |
|
4435
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4436
|
|
|
int nvaeMark = input.mark(); |
|
4437
|
|
|
try { |
|
4438
|
|
|
input.consume(); |
|
4439
|
|
|
NoViableAltException nvae = |
|
4440
|
|
|
new NoViableAltException("", 15, 1, input); |
|
4441
|
|
|
throw nvae; |
|
4442
|
|
|
} finally { |
|
4443
|
|
|
input.rewind(nvaeMark); |
|
4444
|
|
|
} |
|
4445
|
|
|
} |
|
4446
|
|
|
} |
|
4447
|
|
|
|
|
4448
|
|
|
else { |
|
4449
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
4450
|
|
|
NoViableAltException nvae = |
|
4451
|
|
|
new NoViableAltException("", 15, 0, input); |
|
4452
|
|
|
throw nvae; |
|
4453
|
|
|
} |
|
4454
|
|
|
|
|
4455
|
|
|
switch (alt15) { |
|
4456
|
|
|
case 1 : |
|
4457
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:95:4: simple_ground_state_variable_component_type |
|
4458
|
|
|
{ |
|
4459
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4460
|
|
|
|
|
4461
|
|
|
|
|
4462
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_type_in_component_type1006); |
|
4463
|
|
|
simple_ground_state_variable_component_type137=simple_ground_state_variable_component_type(); |
|
4464
|
|
|
state._fsp--; |
|
4465
|
|
|
if (state.failed) return retval; |
|
4466
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_ground_state_variable_component_type137.getTree()); |
|
4467
|
|
|
|
|
4468
|
|
|
} |
|
4469
|
|
|
break; |
|
4470
|
|
|
case 2 : |
|
4471
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:95:50: singleton_state_variable_component_type |
|
4472
|
|
|
{ |
|
4473
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4474
|
|
|
|
|
4475
|
|
|
|
|
4476
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_type_in_component_type1010); |
|
4477
|
|
|
singleton_state_variable_component_type138=singleton_state_variable_component_type(); |
|
4478
|
|
|
state._fsp--; |
|
4479
|
|
|
if (state.failed) return retval; |
|
4480
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, singleton_state_variable_component_type138.getTree()); |
|
4481
|
|
|
|
|
4482
|
|
|
} |
|
4483
|
|
|
break; |
|
4484
|
|
|
case 3 : |
|
4485
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:95:92: renewable_resource_component_type |
|
4486
|
|
|
{ |
|
4487
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4488
|
|
|
|
|
4489
|
|
|
|
|
4490
|
|
|
pushFollow(FOLLOW_renewable_resource_component_type_in_component_type1014); |
|
4491
|
|
|
renewable_resource_component_type139=renewable_resource_component_type(); |
|
4492
|
|
|
state._fsp--; |
|
4493
|
|
|
if (state.failed) return retval; |
|
4494
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, renewable_resource_component_type139.getTree()); |
|
4495
|
|
|
|
|
4496
|
|
|
} |
|
4497
|
|
|
break; |
|
4498
|
|
|
case 4 : |
|
4499
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:95:128: consumable_resource_component_type |
|
4500
|
|
|
{ |
|
4501
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4502
|
|
|
|
|
4503
|
|
|
|
|
4504
|
|
|
pushFollow(FOLLOW_consumable_resource_component_type_in_component_type1018); |
|
4505
|
|
|
consumable_resource_component_type140=consumable_resource_component_type(); |
|
4506
|
|
|
state._fsp--; |
|
4507
|
|
|
if (state.failed) return retval; |
|
4508
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, consumable_resource_component_type140.getTree()); |
|
4509
|
|
|
|
|
4510
|
|
|
} |
|
4511
|
|
|
break; |
|
4512
|
|
|
|
|
4513
|
|
|
} |
|
4514
|
|
|
retval.stop = input.LT(-1); |
|
4515
|
|
|
|
|
4516
|
|
|
if ( state.backtracking==0 ) { |
|
4517
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4518
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4519
|
|
|
} |
|
4520
|
|
|
} |
|
4521
|
|
|
catch (RecognitionException re) { |
|
4522
|
|
|
reportError(re); |
|
4523
|
|
|
recover(input,re); |
|
4524
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4525
|
|
|
} |
|
4526
|
|
|
finally { |
|
4527
|
|
|
// do for sure before leaving |
|
4528
|
|
|
if ( state.backtracking>0 ) { memoize(input, 18, component_type_StartIndex); } |
|
4529
|
|
|
|
|
4530
|
|
|
} |
|
4531
|
|
|
return retval; |
|
4532
|
|
|
} |
|
4533
|
|
|
// $ANTLR end "component_type" |
|
4534
|
|
|
|
|
4535
|
|
|
|
|
4536
|
|
|
public static class simple_ground_state_variable_component_type_return extends ParserRuleReturnScope { |
|
4537
|
|
|
Object tree; |
|
4538
|
|
|
@Override |
|
4539
|
|
|
public Object getTree() { return tree; } |
|
4540
|
|
|
}; |
|
4541
|
|
|
|
|
4542
|
|
|
|
|
4543
|
|
|
// $ANTLR start "simple_ground_state_variable_component_type" |
|
4544
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:98:1: simple_ground_state_variable_component_type : 'COMP_TYPE' 'SimpleGroundStateVariable' ID '(' simple_ground_state_variable_component_decision_type ( ',' simple_ground_state_variable_component_decision_type )* ')' '{' ( simple_ground_state_variable_transition_constraint )* '}' -> ^( ID ( simple_ground_state_variable_component_decision_type )+ ( simple_ground_state_variable_transition_constraint )* ) ; |
|
4545
|
|
View Code Duplication |
public final ddl3Parser.simple_ground_state_variable_component_type_return simple_ground_state_variable_component_type() throws RecognitionException { |
|
|
|
|
|
|
4546
|
|
|
ddl3Parser.simple_ground_state_variable_component_type_return retval = new ddl3Parser.simple_ground_state_variable_component_type_return(); |
|
4547
|
|
|
retval.start = input.LT(1); |
|
4548
|
|
|
int simple_ground_state_variable_component_type_StartIndex = input.index(); |
|
4549
|
|
|
|
|
4550
|
|
|
Object root_0 = null; |
|
4551
|
|
|
|
|
4552
|
|
|
Token string_literal141=null; |
|
4553
|
|
|
Token string_literal142=null; |
|
4554
|
|
|
Token ID143=null; |
|
4555
|
|
|
Token char_literal144=null; |
|
4556
|
|
|
Token char_literal146=null; |
|
4557
|
|
|
Token char_literal148=null; |
|
4558
|
|
|
Token char_literal149=null; |
|
4559
|
|
|
Token char_literal151=null; |
|
4560
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_decision_type145 =null; |
|
4561
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_decision_type147 =null; |
|
4562
|
|
|
ParserRuleReturnScope simple_ground_state_variable_transition_constraint150 =null; |
|
4563
|
|
|
|
|
4564
|
|
|
Object string_literal141_tree=null; |
|
4565
|
|
|
Object string_literal142_tree=null; |
|
4566
|
|
|
Object ID143_tree=null; |
|
4567
|
|
|
Object char_literal144_tree=null; |
|
4568
|
|
|
Object char_literal146_tree=null; |
|
4569
|
|
|
Object char_literal148_tree=null; |
|
4570
|
|
|
Object char_literal149_tree=null; |
|
4571
|
|
|
Object char_literal151_tree=null; |
|
4572
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
4573
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
4574
|
|
|
RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35"); |
|
4575
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
4576
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
4577
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
4578
|
|
|
RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72"); |
|
4579
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
4580
|
|
|
RewriteRuleSubtreeStream stream_simple_ground_state_variable_component_decision_type=new RewriteRuleSubtreeStream(adaptor,"rule simple_ground_state_variable_component_decision_type"); |
|
4581
|
|
|
RewriteRuleSubtreeStream stream_simple_ground_state_variable_transition_constraint=new RewriteRuleSubtreeStream(adaptor,"rule simple_ground_state_variable_transition_constraint"); |
|
4582
|
|
|
|
|
4583
|
|
|
try { |
|
4584
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return retval; } |
|
4585
|
|
|
|
|
4586
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:2: ( 'COMP_TYPE' 'SimpleGroundStateVariable' ID '(' simple_ground_state_variable_component_decision_type ( ',' simple_ground_state_variable_component_decision_type )* ')' '{' ( simple_ground_state_variable_transition_constraint )* '}' -> ^( ID ( simple_ground_state_variable_component_decision_type )+ ( simple_ground_state_variable_transition_constraint )* ) ) |
|
4587
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:4: 'COMP_TYPE' 'SimpleGroundStateVariable' ID '(' simple_ground_state_variable_component_decision_type ( ',' simple_ground_state_variable_component_decision_type )* ')' '{' ( simple_ground_state_variable_transition_constraint )* '}' |
|
4588
|
|
|
{ |
|
4589
|
|
|
string_literal141=(Token)match(input,35,FOLLOW_35_in_simple_ground_state_variable_component_type1028); if (state.failed) return retval; |
|
4590
|
|
|
if ( state.backtracking==0 ) stream_35.add(string_literal141); |
|
4591
|
|
|
|
|
4592
|
|
|
string_literal142=(Token)match(input,72,FOLLOW_72_in_simple_ground_state_variable_component_type1030); if (state.failed) return retval; |
|
4593
|
|
|
if ( state.backtracking==0 ) stream_72.add(string_literal142); |
|
4594
|
|
|
|
|
4595
|
|
|
ID143=(Token)match(input,ID,FOLLOW_ID_in_simple_ground_state_variable_component_type1032); if (state.failed) return retval; |
|
4596
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID143); |
|
4597
|
|
|
|
|
4598
|
|
|
char_literal144=(Token)match(input,11,FOLLOW_11_in_simple_ground_state_variable_component_type1034); if (state.failed) return retval; |
|
4599
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal144); |
|
4600
|
|
|
|
|
4601
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_type_in_simple_ground_state_variable_component_type1036); |
|
4602
|
|
|
simple_ground_state_variable_component_decision_type145=simple_ground_state_variable_component_decision_type(); |
|
4603
|
|
|
state._fsp--; |
|
4604
|
|
|
if (state.failed) return retval; |
|
4605
|
|
|
if ( state.backtracking==0 ) stream_simple_ground_state_variable_component_decision_type.add(simple_ground_state_variable_component_decision_type145.getTree()); |
|
4606
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:104: ( ',' simple_ground_state_variable_component_decision_type )* |
|
4607
|
|
|
loop16: |
|
4608
|
|
|
while (true) { |
|
4609
|
|
|
int alt16=2; |
|
4610
|
|
|
int LA16_0 = input.LA(1); |
|
4611
|
|
|
if ( (LA16_0==15) ) { |
|
4612
|
|
|
alt16=1; |
|
4613
|
|
|
} |
|
4614
|
|
|
|
|
4615
|
|
|
switch (alt16) { |
|
4616
|
|
|
case 1 : |
|
4617
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:105: ',' simple_ground_state_variable_component_decision_type |
|
4618
|
|
|
{ |
|
4619
|
|
|
char_literal146=(Token)match(input,15,FOLLOW_15_in_simple_ground_state_variable_component_type1039); if (state.failed) return retval; |
|
4620
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal146); |
|
4621
|
|
|
|
|
4622
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_type_in_simple_ground_state_variable_component_type1041); |
|
4623
|
|
|
simple_ground_state_variable_component_decision_type147=simple_ground_state_variable_component_decision_type(); |
|
4624
|
|
|
state._fsp--; |
|
4625
|
|
|
if (state.failed) return retval; |
|
4626
|
|
|
if ( state.backtracking==0 ) stream_simple_ground_state_variable_component_decision_type.add(simple_ground_state_variable_component_decision_type147.getTree()); |
|
4627
|
|
|
} |
|
4628
|
|
|
break; |
|
4629
|
|
|
|
|
4630
|
|
|
default : |
|
4631
|
|
|
break loop16; |
|
4632
|
|
|
} |
|
4633
|
|
|
} |
|
4634
|
|
|
|
|
4635
|
|
|
char_literal148=(Token)match(input,12,FOLLOW_12_in_simple_ground_state_variable_component_type1045); if (state.failed) return retval; |
|
4636
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal148); |
|
4637
|
|
|
|
|
4638
|
|
|
char_literal149=(Token)match(input,80,FOLLOW_80_in_simple_ground_state_variable_component_type1047); if (state.failed) return retval; |
|
4639
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal149); |
|
4640
|
|
|
|
|
4641
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:172: ( simple_ground_state_variable_transition_constraint )* |
|
4642
|
|
|
loop17: |
|
4643
|
|
|
while (true) { |
|
4644
|
|
|
int alt17=2; |
|
4645
|
|
|
int LA17_0 = input.LA(1); |
|
4646
|
|
|
if ( (LA17_0==75) ) { |
|
4647
|
|
|
alt17=1; |
|
4648
|
|
|
} |
|
4649
|
|
|
|
|
4650
|
|
|
switch (alt17) { |
|
4651
|
|
|
case 1 : |
|
4652
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:173: simple_ground_state_variable_transition_constraint |
|
4653
|
|
|
{ |
|
4654
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_transition_constraint_in_simple_ground_state_variable_component_type1050); |
|
4655
|
|
|
simple_ground_state_variable_transition_constraint150=simple_ground_state_variable_transition_constraint(); |
|
4656
|
|
|
state._fsp--; |
|
4657
|
|
|
if (state.failed) return retval; |
|
4658
|
|
|
if ( state.backtracking==0 ) stream_simple_ground_state_variable_transition_constraint.add(simple_ground_state_variable_transition_constraint150.getTree()); |
|
4659
|
|
|
} |
|
4660
|
|
|
break; |
|
4661
|
|
|
|
|
4662
|
|
|
default : |
|
4663
|
|
|
break loop17; |
|
4664
|
|
|
} |
|
4665
|
|
|
} |
|
4666
|
|
|
|
|
4667
|
|
|
char_literal151=(Token)match(input,81,FOLLOW_81_in_simple_ground_state_variable_component_type1054); if (state.failed) return retval; |
|
4668
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal151); |
|
4669
|
|
|
|
|
4670
|
|
|
// AST REWRITE |
|
4671
|
|
|
// elements: simple_ground_state_variable_component_decision_type, ID, simple_ground_state_variable_transition_constraint |
|
4672
|
|
|
// token labels: |
|
4673
|
|
|
// rule labels: retval |
|
4674
|
|
|
// token list labels: |
|
4675
|
|
|
// rule list labels: |
|
4676
|
|
|
// wildcard labels: |
|
4677
|
|
|
if ( state.backtracking==0 ) { |
|
4678
|
|
|
retval.tree = root_0; |
|
4679
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
4680
|
|
|
|
|
4681
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4682
|
|
|
// 99:230: -> ^( ID ( simple_ground_state_variable_component_decision_type )+ ( simple_ground_state_variable_transition_constraint )* ) |
|
4683
|
|
|
{ |
|
4684
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:232: ^( ID ( simple_ground_state_variable_component_decision_type )+ ( simple_ground_state_variable_transition_constraint )* ) |
|
4685
|
|
|
{ |
|
4686
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
4687
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSimpleGroundStateVariableComponentType(stream_ID.nextToken()), root_1); |
|
4688
|
|
|
if ( !(stream_simple_ground_state_variable_component_decision_type.hasNext()) ) { |
|
4689
|
|
|
throw new RewriteEarlyExitException(); |
|
4690
|
|
|
} |
|
4691
|
|
|
while ( stream_simple_ground_state_variable_component_decision_type.hasNext() ) { |
|
4692
|
|
|
adaptor.addChild(root_1, stream_simple_ground_state_variable_component_decision_type.nextTree()); |
|
4693
|
|
|
} |
|
4694
|
|
|
stream_simple_ground_state_variable_component_decision_type.reset(); |
|
4695
|
|
|
|
|
4696
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:99:336: ( simple_ground_state_variable_transition_constraint )* |
|
4697
|
|
|
while ( stream_simple_ground_state_variable_transition_constraint.hasNext() ) { |
|
4698
|
|
|
adaptor.addChild(root_1, stream_simple_ground_state_variable_transition_constraint.nextTree()); |
|
4699
|
|
|
} |
|
4700
|
|
|
stream_simple_ground_state_variable_transition_constraint.reset(); |
|
4701
|
|
|
|
|
4702
|
|
|
adaptor.addChild(root_0, root_1); |
|
4703
|
|
|
} |
|
4704
|
|
|
|
|
4705
|
|
|
} |
|
4706
|
|
|
|
|
4707
|
|
|
|
|
4708
|
|
|
retval.tree = root_0; |
|
4709
|
|
|
} |
|
4710
|
|
|
|
|
4711
|
|
|
} |
|
4712
|
|
|
|
|
4713
|
|
|
retval.stop = input.LT(-1); |
|
4714
|
|
|
|
|
4715
|
|
|
if ( state.backtracking==0 ) { |
|
4716
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4717
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4718
|
|
|
} |
|
4719
|
|
|
} |
|
4720
|
|
|
catch (RecognitionException re) { |
|
4721
|
|
|
reportError(re); |
|
4722
|
|
|
recover(input,re); |
|
4723
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4724
|
|
|
} |
|
4725
|
|
|
finally { |
|
4726
|
|
|
// do for sure before leaving |
|
4727
|
|
|
if ( state.backtracking>0 ) { memoize(input, 19, simple_ground_state_variable_component_type_StartIndex); } |
|
4728
|
|
|
|
|
4729
|
|
|
} |
|
4730
|
|
|
return retval; |
|
4731
|
|
|
} |
|
4732
|
|
|
// $ANTLR end "simple_ground_state_variable_component_type" |
|
4733
|
|
|
|
|
4734
|
|
|
|
|
4735
|
|
|
public static class simple_ground_state_variable_component_decision_type_return extends ParserRuleReturnScope { |
|
4736
|
|
|
Object tree; |
|
4737
|
|
|
@Override |
|
4738
|
|
|
public Object getTree() { return tree; } |
|
4739
|
|
|
}; |
|
4740
|
|
|
|
|
4741
|
|
|
|
|
4742
|
|
|
// $ANTLR start "simple_ground_state_variable_component_decision_type" |
|
4743
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:101:1: simple_ground_state_variable_component_decision_type : ID '(' ')' -> ^( ID ) ; |
|
4744
|
|
|
public final ddl3Parser.simple_ground_state_variable_component_decision_type_return simple_ground_state_variable_component_decision_type() throws RecognitionException { |
|
4745
|
|
|
ddl3Parser.simple_ground_state_variable_component_decision_type_return retval = new ddl3Parser.simple_ground_state_variable_component_decision_type_return(); |
|
4746
|
|
|
retval.start = input.LT(1); |
|
4747
|
|
|
int simple_ground_state_variable_component_decision_type_StartIndex = input.index(); |
|
4748
|
|
|
|
|
4749
|
|
|
Object root_0 = null; |
|
4750
|
|
|
|
|
4751
|
|
|
Token ID152=null; |
|
4752
|
|
|
Token char_literal153=null; |
|
4753
|
|
|
Token char_literal154=null; |
|
4754
|
|
|
|
|
4755
|
|
|
Object ID152_tree=null; |
|
4756
|
|
|
Object char_literal153_tree=null; |
|
4757
|
|
|
Object char_literal154_tree=null; |
|
4758
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
4759
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
4760
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
4761
|
|
|
|
|
4762
|
|
|
try { |
|
4763
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; } |
|
4764
|
|
|
|
|
4765
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:102:2: ( ID '(' ')' -> ^( ID ) ) |
|
4766
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:102:4: ID '(' ')' |
|
4767
|
|
|
{ |
|
4768
|
|
|
ID152=(Token)match(input,ID,FOLLOW_ID_in_simple_ground_state_variable_component_decision_type1081); if (state.failed) return retval; |
|
4769
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID152); |
|
4770
|
|
|
|
|
4771
|
|
|
char_literal153=(Token)match(input,11,FOLLOW_11_in_simple_ground_state_variable_component_decision_type1083); if (state.failed) return retval; |
|
4772
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal153); |
|
4773
|
|
|
|
|
4774
|
|
|
char_literal154=(Token)match(input,12,FOLLOW_12_in_simple_ground_state_variable_component_decision_type1085); if (state.failed) return retval; |
|
4775
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal154); |
|
4776
|
|
|
|
|
4777
|
|
|
// AST REWRITE |
|
4778
|
|
|
// elements: ID |
|
4779
|
|
|
// token labels: |
|
4780
|
|
|
// rule labels: retval |
|
4781
|
|
|
// token list labels: |
|
4782
|
|
|
// rule list labels: |
|
4783
|
|
|
// wildcard labels: |
|
4784
|
|
|
if ( state.backtracking==0 ) { |
|
4785
|
|
|
retval.tree = root_0; |
|
4786
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
4787
|
|
|
|
|
4788
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4789
|
|
|
// 102:15: -> ^( ID ) |
|
4790
|
|
|
{ |
|
4791
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:102:17: ^( ID ) |
|
4792
|
|
|
{ |
|
4793
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
4794
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSimpleGroundStateVariableComponentDecisionType(stream_ID.nextToken()), root_1); |
|
4795
|
|
|
adaptor.addChild(root_0, root_1); |
|
4796
|
|
|
} |
|
4797
|
|
|
|
|
4798
|
|
|
} |
|
4799
|
|
|
|
|
4800
|
|
|
|
|
4801
|
|
|
retval.tree = root_0; |
|
4802
|
|
|
} |
|
4803
|
|
|
|
|
4804
|
|
|
} |
|
4805
|
|
|
|
|
4806
|
|
|
retval.stop = input.LT(-1); |
|
4807
|
|
|
|
|
4808
|
|
|
if ( state.backtracking==0 ) { |
|
4809
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4810
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4811
|
|
|
} |
|
4812
|
|
|
} |
|
4813
|
|
|
catch (RecognitionException re) { |
|
4814
|
|
|
reportError(re); |
|
4815
|
|
|
recover(input,re); |
|
4816
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4817
|
|
|
} |
|
4818
|
|
|
finally { |
|
4819
|
|
|
// do for sure before leaving |
|
4820
|
|
|
if ( state.backtracking>0 ) { memoize(input, 20, simple_ground_state_variable_component_decision_type_StartIndex); } |
|
4821
|
|
|
|
|
4822
|
|
|
} |
|
4823
|
|
|
return retval; |
|
4824
|
|
|
} |
|
4825
|
|
|
// $ANTLR end "simple_ground_state_variable_component_decision_type" |
|
4826
|
|
|
|
|
4827
|
|
|
|
|
4828
|
|
|
public static class simple_ground_state_variable_transition_constraint_return extends ParserRuleReturnScope { |
|
4829
|
|
|
Object tree; |
|
4830
|
|
|
@Override |
|
4831
|
|
|
public Object getTree() { return tree; } |
|
4832
|
|
|
}; |
|
4833
|
|
|
|
|
4834
|
|
|
|
|
4835
|
|
|
// $ANTLR start "simple_ground_state_variable_transition_constraint" |
|
4836
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:104:1: simple_ground_state_variable_transition_constraint : 'VALUE' simple_ground_state_variable_component_decision range ( 'MEETS' '{' ( simple_ground_state_variable_transition_element ';' )* '}' )? -> ^( 'VALUE' simple_ground_state_variable_component_decision range ( simple_ground_state_variable_transition_element )* ) ; |
|
4837
|
|
View Code Duplication |
public final ddl3Parser.simple_ground_state_variable_transition_constraint_return simple_ground_state_variable_transition_constraint() throws RecognitionException { |
|
|
|
|
|
|
4838
|
|
|
ddl3Parser.simple_ground_state_variable_transition_constraint_return retval = new ddl3Parser.simple_ground_state_variable_transition_constraint_return(); |
|
4839
|
|
|
retval.start = input.LT(1); |
|
4840
|
|
|
int simple_ground_state_variable_transition_constraint_StartIndex = input.index(); |
|
4841
|
|
|
|
|
4842
|
|
|
Object root_0 = null; |
|
4843
|
|
|
|
|
4844
|
|
|
Token string_literal155=null; |
|
4845
|
|
|
Token string_literal158=null; |
|
4846
|
|
|
Token char_literal159=null; |
|
4847
|
|
|
Token char_literal161=null; |
|
4848
|
|
|
Token char_literal162=null; |
|
4849
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_decision156 =null; |
|
4850
|
|
|
ParserRuleReturnScope range157 =null; |
|
4851
|
|
|
ParserRuleReturnScope simple_ground_state_variable_transition_element160 =null; |
|
4852
|
|
|
|
|
4853
|
|
|
Object string_literal155_tree=null; |
|
4854
|
|
|
Object string_literal158_tree=null; |
|
4855
|
|
|
Object char_literal159_tree=null; |
|
4856
|
|
|
Object char_literal161_tree=null; |
|
4857
|
|
|
Object char_literal162_tree=null; |
|
4858
|
|
|
RewriteRuleTokenStream stream_55=new RewriteRuleTokenStream(adaptor,"token 55"); |
|
4859
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
4860
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
4861
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
4862
|
|
|
RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75"); |
|
4863
|
|
|
RewriteRuleSubtreeStream stream_simple_ground_state_variable_transition_element=new RewriteRuleSubtreeStream(adaptor,"rule simple_ground_state_variable_transition_element"); |
|
4864
|
|
|
RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range"); |
|
4865
|
|
|
RewriteRuleSubtreeStream stream_simple_ground_state_variable_component_decision=new RewriteRuleSubtreeStream(adaptor,"rule simple_ground_state_variable_component_decision"); |
|
4866
|
|
|
|
|
4867
|
|
|
try { |
|
4868
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; } |
|
4869
|
|
|
|
|
4870
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:2: ( 'VALUE' simple_ground_state_variable_component_decision range ( 'MEETS' '{' ( simple_ground_state_variable_transition_element ';' )* '}' )? -> ^( 'VALUE' simple_ground_state_variable_component_decision range ( simple_ground_state_variable_transition_element )* ) ) |
|
4871
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:4: 'VALUE' simple_ground_state_variable_component_decision range ( 'MEETS' '{' ( simple_ground_state_variable_transition_element ';' )* '}' )? |
|
4872
|
|
|
{ |
|
4873
|
|
|
string_literal155=(Token)match(input,75,FOLLOW_75_in_simple_ground_state_variable_transition_constraint1102); if (state.failed) return retval; |
|
4874
|
|
|
if ( state.backtracking==0 ) stream_75.add(string_literal155); |
|
4875
|
|
|
|
|
4876
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_in_simple_ground_state_variable_transition_constraint1104); |
|
4877
|
|
|
simple_ground_state_variable_component_decision156=simple_ground_state_variable_component_decision(); |
|
4878
|
|
|
state._fsp--; |
|
4879
|
|
|
if (state.failed) return retval; |
|
4880
|
|
|
if ( state.backtracking==0 ) stream_simple_ground_state_variable_component_decision.add(simple_ground_state_variable_component_decision156.getTree()); |
|
4881
|
|
|
pushFollow(FOLLOW_range_in_simple_ground_state_variable_transition_constraint1106); |
|
4882
|
|
|
range157=range(); |
|
4883
|
|
|
state._fsp--; |
|
4884
|
|
|
if (state.failed) return retval; |
|
4885
|
|
|
if ( state.backtracking==0 ) stream_range.add(range157.getTree()); |
|
4886
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:66: ( 'MEETS' '{' ( simple_ground_state_variable_transition_element ';' )* '}' )? |
|
4887
|
|
|
int alt19=2; |
|
4888
|
|
|
int LA19_0 = input.LA(1); |
|
4889
|
|
|
if ( (LA19_0==55) ) { |
|
4890
|
|
|
alt19=1; |
|
4891
|
|
|
} |
|
4892
|
|
|
switch (alt19) { |
|
4893
|
|
|
case 1 : |
|
4894
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:67: 'MEETS' '{' ( simple_ground_state_variable_transition_element ';' )* '}' |
|
4895
|
|
|
{ |
|
4896
|
|
|
string_literal158=(Token)match(input,55,FOLLOW_55_in_simple_ground_state_variable_transition_constraint1109); if (state.failed) return retval; |
|
4897
|
|
|
if ( state.backtracking==0 ) stream_55.add(string_literal158); |
|
4898
|
|
|
|
|
4899
|
|
|
char_literal159=(Token)match(input,80,FOLLOW_80_in_simple_ground_state_variable_transition_constraint1111); if (state.failed) return retval; |
|
4900
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal159); |
|
4901
|
|
|
|
|
4902
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:79: ( simple_ground_state_variable_transition_element ';' )* |
|
4903
|
|
|
loop18: |
|
4904
|
|
|
while (true) { |
|
4905
|
|
|
int alt18=2; |
|
4906
|
|
|
int LA18_0 = input.LA(1); |
|
4907
|
|
|
if ( (LA18_0==ID||LA18_0==20) ) { |
|
4908
|
|
|
alt18=1; |
|
4909
|
|
|
} |
|
4910
|
|
|
|
|
4911
|
|
|
switch (alt18) { |
|
4912
|
|
|
case 1 : |
|
4913
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:80: simple_ground_state_variable_transition_element ';' |
|
4914
|
|
|
{ |
|
4915
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_transition_element_in_simple_ground_state_variable_transition_constraint1114); |
|
4916
|
|
|
simple_ground_state_variable_transition_element160=simple_ground_state_variable_transition_element(); |
|
4917
|
|
|
state._fsp--; |
|
4918
|
|
|
if (state.failed) return retval; |
|
4919
|
|
|
if ( state.backtracking==0 ) stream_simple_ground_state_variable_transition_element.add(simple_ground_state_variable_transition_element160.getTree()); |
|
4920
|
|
|
char_literal161=(Token)match(input,19,FOLLOW_19_in_simple_ground_state_variable_transition_constraint1116); if (state.failed) return retval; |
|
4921
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal161); |
|
4922
|
|
|
|
|
4923
|
|
|
} |
|
4924
|
|
|
break; |
|
4925
|
|
|
|
|
4926
|
|
|
default : |
|
4927
|
|
|
break loop18; |
|
4928
|
|
|
} |
|
4929
|
|
|
} |
|
4930
|
|
|
|
|
4931
|
|
|
char_literal162=(Token)match(input,81,FOLLOW_81_in_simple_ground_state_variable_transition_constraint1120); if (state.failed) return retval; |
|
4932
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal162); |
|
4933
|
|
|
|
|
4934
|
|
|
} |
|
4935
|
|
|
break; |
|
4936
|
|
|
|
|
4937
|
|
|
} |
|
4938
|
|
|
|
|
4939
|
|
|
// AST REWRITE |
|
4940
|
|
|
// elements: simple_ground_state_variable_transition_element, 75, simple_ground_state_variable_component_decision, range |
|
4941
|
|
|
// token labels: |
|
4942
|
|
|
// rule labels: retval |
|
4943
|
|
|
// token list labels: |
|
4944
|
|
|
// rule list labels: |
|
4945
|
|
|
// wildcard labels: |
|
4946
|
|
|
if ( state.backtracking==0 ) { |
|
4947
|
|
|
retval.tree = root_0; |
|
4948
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
4949
|
|
|
|
|
4950
|
|
|
root_0 = (Object)adaptor.nil(); |
|
4951
|
|
|
// 105:140: -> ^( 'VALUE' simple_ground_state_variable_component_decision range ( simple_ground_state_variable_transition_element )* ) |
|
4952
|
|
|
{ |
|
4953
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:142: ^( 'VALUE' simple_ground_state_variable_component_decision range ( simple_ground_state_variable_transition_element )* ) |
|
4954
|
|
|
{ |
|
4955
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
4956
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSimpleGroundStateVariableTransitionConstraint(stream_75.nextToken()), root_1); |
|
4957
|
|
|
adaptor.addChild(root_1, stream_simple_ground_state_variable_component_decision.nextTree()); |
|
4958
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
4959
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:105:256: ( simple_ground_state_variable_transition_element )* |
|
4960
|
|
|
while ( stream_simple_ground_state_variable_transition_element.hasNext() ) { |
|
4961
|
|
|
adaptor.addChild(root_1, stream_simple_ground_state_variable_transition_element.nextTree()); |
|
4962
|
|
|
} |
|
4963
|
|
|
stream_simple_ground_state_variable_transition_element.reset(); |
|
4964
|
|
|
|
|
4965
|
|
|
adaptor.addChild(root_0, root_1); |
|
4966
|
|
|
} |
|
4967
|
|
|
|
|
4968
|
|
|
} |
|
4969
|
|
|
|
|
4970
|
|
|
|
|
4971
|
|
|
retval.tree = root_0; |
|
4972
|
|
|
} |
|
4973
|
|
|
|
|
4974
|
|
|
} |
|
4975
|
|
|
|
|
4976
|
|
|
retval.stop = input.LT(-1); |
|
4977
|
|
|
|
|
4978
|
|
|
if ( state.backtracking==0 ) { |
|
4979
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
4980
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
4981
|
|
|
} |
|
4982
|
|
|
} |
|
4983
|
|
|
catch (RecognitionException re) { |
|
4984
|
|
|
reportError(re); |
|
4985
|
|
|
recover(input,re); |
|
4986
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
4987
|
|
|
} |
|
4988
|
|
|
finally { |
|
4989
|
|
|
// do for sure before leaving |
|
4990
|
|
|
if ( state.backtracking>0 ) { memoize(input, 21, simple_ground_state_variable_transition_constraint_StartIndex); } |
|
4991
|
|
|
|
|
4992
|
|
|
} |
|
4993
|
|
|
return retval; |
|
4994
|
|
|
} |
|
4995
|
|
|
// $ANTLR end "simple_ground_state_variable_transition_constraint" |
|
4996
|
|
|
|
|
4997
|
|
|
|
|
4998
|
|
|
public static class simple_ground_state_variable_transition_element_return extends ParserRuleReturnScope { |
|
4999
|
|
|
Object tree; |
|
5000
|
|
|
@Override |
|
5001
|
|
|
public Object getTree() { return tree; } |
|
5002
|
|
|
}; |
|
5003
|
|
|
|
|
5004
|
|
|
|
|
5005
|
|
|
// $ANTLR start "simple_ground_state_variable_transition_element" |
|
5006
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:107:1: simple_ground_state_variable_transition_element : simple_ground_state_variable_component_decision ; |
|
5007
|
|
|
public final ddl3Parser.simple_ground_state_variable_transition_element_return simple_ground_state_variable_transition_element() throws RecognitionException { |
|
5008
|
|
|
ddl3Parser.simple_ground_state_variable_transition_element_return retval = new ddl3Parser.simple_ground_state_variable_transition_element_return(); |
|
5009
|
|
|
retval.start = input.LT(1); |
|
5010
|
|
|
int simple_ground_state_variable_transition_element_StartIndex = input.index(); |
|
5011
|
|
|
|
|
5012
|
|
|
Object root_0 = null; |
|
5013
|
|
|
|
|
5014
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_decision163 =null; |
|
5015
|
|
|
|
|
5016
|
|
|
|
|
5017
|
|
|
try { |
|
5018
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return retval; } |
|
5019
|
|
|
|
|
5020
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:108:2: ( simple_ground_state_variable_component_decision ) |
|
5021
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:108:4: simple_ground_state_variable_component_decision |
|
5022
|
|
|
{ |
|
5023
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5024
|
|
|
|
|
5025
|
|
|
|
|
5026
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_in_simple_ground_state_variable_transition_element1148); |
|
5027
|
|
|
simple_ground_state_variable_component_decision163=simple_ground_state_variable_component_decision(); |
|
5028
|
|
|
state._fsp--; |
|
5029
|
|
|
if (state.failed) return retval; |
|
5030
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_ground_state_variable_component_decision163.getTree()); |
|
5031
|
|
|
|
|
5032
|
|
|
} |
|
5033
|
|
|
|
|
5034
|
|
|
retval.stop = input.LT(-1); |
|
5035
|
|
|
|
|
5036
|
|
|
if ( state.backtracking==0 ) { |
|
5037
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5038
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5039
|
|
|
} |
|
5040
|
|
|
} |
|
5041
|
|
|
catch (RecognitionException re) { |
|
5042
|
|
|
reportError(re); |
|
5043
|
|
|
recover(input,re); |
|
5044
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5045
|
|
|
} |
|
5046
|
|
|
finally { |
|
5047
|
|
|
// do for sure before leaving |
|
5048
|
|
|
if ( state.backtracking>0 ) { memoize(input, 22, simple_ground_state_variable_transition_element_StartIndex); } |
|
5049
|
|
|
|
|
5050
|
|
|
} |
|
5051
|
|
|
return retval; |
|
5052
|
|
|
} |
|
5053
|
|
|
// $ANTLR end "simple_ground_state_variable_transition_element" |
|
5054
|
|
|
|
|
5055
|
|
|
|
|
5056
|
|
|
public static class singleton_state_variable_component_type_return extends ParserRuleReturnScope { |
|
5057
|
|
|
Object tree; |
|
5058
|
|
|
@Override |
|
5059
|
|
|
public Object getTree() { return tree; } |
|
5060
|
|
|
}; |
|
5061
|
|
|
|
|
5062
|
|
|
|
|
5063
|
|
|
// $ANTLR start "singleton_state_variable_component_type" |
|
5064
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:111:1: singleton_state_variable_component_type : 'COMP_TYPE' 'SingletonStateVariable' ID '(' singleton_state_variable_component_decision_type ( ',' singleton_state_variable_component_decision_type )* ')' '{' ( singleton_state_variable_transition_constraint )* '}' -> ^( ID ( singleton_state_variable_component_decision_type )+ ( singleton_state_variable_transition_constraint )* ) ; |
|
5065
|
|
View Code Duplication |
public final ddl3Parser.singleton_state_variable_component_type_return singleton_state_variable_component_type() throws RecognitionException { |
|
|
|
|
|
|
5066
|
|
|
ddl3Parser.singleton_state_variable_component_type_return retval = new ddl3Parser.singleton_state_variable_component_type_return(); |
|
5067
|
|
|
retval.start = input.LT(1); |
|
5068
|
|
|
int singleton_state_variable_component_type_StartIndex = input.index(); |
|
5069
|
|
|
|
|
5070
|
|
|
Object root_0 = null; |
|
5071
|
|
|
|
|
5072
|
|
|
Token string_literal164=null; |
|
5073
|
|
|
Token string_literal165=null; |
|
5074
|
|
|
Token ID166=null; |
|
5075
|
|
|
Token char_literal167=null; |
|
5076
|
|
|
Token char_literal169=null; |
|
5077
|
|
|
Token char_literal171=null; |
|
5078
|
|
|
Token char_literal172=null; |
|
5079
|
|
|
Token char_literal174=null; |
|
5080
|
|
|
ParserRuleReturnScope singleton_state_variable_component_decision_type168 =null; |
|
5081
|
|
|
ParserRuleReturnScope singleton_state_variable_component_decision_type170 =null; |
|
5082
|
|
|
ParserRuleReturnScope singleton_state_variable_transition_constraint173 =null; |
|
5083
|
|
|
|
|
5084
|
|
|
Object string_literal164_tree=null; |
|
5085
|
|
|
Object string_literal165_tree=null; |
|
5086
|
|
|
Object ID166_tree=null; |
|
5087
|
|
|
Object char_literal167_tree=null; |
|
5088
|
|
|
Object char_literal169_tree=null; |
|
5089
|
|
|
Object char_literal171_tree=null; |
|
5090
|
|
|
Object char_literal172_tree=null; |
|
5091
|
|
|
Object char_literal174_tree=null; |
|
5092
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
5093
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
5094
|
|
|
RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35"); |
|
5095
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
5096
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
5097
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
5098
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
5099
|
|
|
RewriteRuleTokenStream stream_73=new RewriteRuleTokenStream(adaptor,"token 73"); |
|
5100
|
|
|
RewriteRuleSubtreeStream stream_singleton_state_variable_component_decision_type=new RewriteRuleSubtreeStream(adaptor,"rule singleton_state_variable_component_decision_type"); |
|
5101
|
|
|
RewriteRuleSubtreeStream stream_singleton_state_variable_transition_constraint=new RewriteRuleSubtreeStream(adaptor,"rule singleton_state_variable_transition_constraint"); |
|
5102
|
|
|
|
|
5103
|
|
|
try { |
|
5104
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; } |
|
5105
|
|
|
|
|
5106
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:2: ( 'COMP_TYPE' 'SingletonStateVariable' ID '(' singleton_state_variable_component_decision_type ( ',' singleton_state_variable_component_decision_type )* ')' '{' ( singleton_state_variable_transition_constraint )* '}' -> ^( ID ( singleton_state_variable_component_decision_type )+ ( singleton_state_variable_transition_constraint )* ) ) |
|
5107
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:4: 'COMP_TYPE' 'SingletonStateVariable' ID '(' singleton_state_variable_component_decision_type ( ',' singleton_state_variable_component_decision_type )* ')' '{' ( singleton_state_variable_transition_constraint )* '}' |
|
5108
|
|
|
{ |
|
5109
|
|
|
string_literal164=(Token)match(input,35,FOLLOW_35_in_singleton_state_variable_component_type1158); if (state.failed) return retval; |
|
5110
|
|
|
if ( state.backtracking==0 ) stream_35.add(string_literal164); |
|
5111
|
|
|
|
|
5112
|
|
|
string_literal165=(Token)match(input,73,FOLLOW_73_in_singleton_state_variable_component_type1160); if (state.failed) return retval; |
|
5113
|
|
|
if ( state.backtracking==0 ) stream_73.add(string_literal165); |
|
5114
|
|
|
|
|
5115
|
|
|
ID166=(Token)match(input,ID,FOLLOW_ID_in_singleton_state_variable_component_type1162); if (state.failed) return retval; |
|
5116
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID166); |
|
5117
|
|
|
|
|
5118
|
|
|
char_literal167=(Token)match(input,11,FOLLOW_11_in_singleton_state_variable_component_type1164); if (state.failed) return retval; |
|
5119
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal167); |
|
5120
|
|
|
|
|
5121
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_type_in_singleton_state_variable_component_type1166); |
|
5122
|
|
|
singleton_state_variable_component_decision_type168=singleton_state_variable_component_decision_type(); |
|
5123
|
|
|
state._fsp--; |
|
5124
|
|
|
if (state.failed) return retval; |
|
5125
|
|
|
if ( state.backtracking==0 ) stream_singleton_state_variable_component_decision_type.add(singleton_state_variable_component_decision_type168.getTree()); |
|
5126
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:97: ( ',' singleton_state_variable_component_decision_type )* |
|
5127
|
|
|
loop20: |
|
5128
|
|
|
while (true) { |
|
5129
|
|
|
int alt20=2; |
|
5130
|
|
|
int LA20_0 = input.LA(1); |
|
5131
|
|
|
if ( (LA20_0==15) ) { |
|
5132
|
|
|
alt20=1; |
|
5133
|
|
|
} |
|
5134
|
|
|
|
|
5135
|
|
|
switch (alt20) { |
|
5136
|
|
|
case 1 : |
|
5137
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:98: ',' singleton_state_variable_component_decision_type |
|
5138
|
|
|
{ |
|
5139
|
|
|
char_literal169=(Token)match(input,15,FOLLOW_15_in_singleton_state_variable_component_type1169); if (state.failed) return retval; |
|
5140
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal169); |
|
5141
|
|
|
|
|
5142
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_type_in_singleton_state_variable_component_type1171); |
|
5143
|
|
|
singleton_state_variable_component_decision_type170=singleton_state_variable_component_decision_type(); |
|
5144
|
|
|
state._fsp--; |
|
5145
|
|
|
if (state.failed) return retval; |
|
5146
|
|
|
if ( state.backtracking==0 ) stream_singleton_state_variable_component_decision_type.add(singleton_state_variable_component_decision_type170.getTree()); |
|
5147
|
|
|
} |
|
5148
|
|
|
break; |
|
5149
|
|
|
|
|
5150
|
|
|
default : |
|
5151
|
|
|
break loop20; |
|
5152
|
|
|
} |
|
5153
|
|
|
} |
|
5154
|
|
|
|
|
5155
|
|
|
char_literal171=(Token)match(input,12,FOLLOW_12_in_singleton_state_variable_component_type1175); if (state.failed) return retval; |
|
5156
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal171); |
|
5157
|
|
|
|
|
5158
|
|
|
char_literal172=(Token)match(input,80,FOLLOW_80_in_singleton_state_variable_component_type1177); if (state.failed) return retval; |
|
5159
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal172); |
|
5160
|
|
|
|
|
5161
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:161: ( singleton_state_variable_transition_constraint )* |
|
5162
|
|
|
loop21: |
|
5163
|
|
|
while (true) { |
|
5164
|
|
|
int alt21=2; |
|
5165
|
|
|
int LA21_0 = input.LA(1); |
|
5166
|
|
|
if ( (LA21_0==75) ) { |
|
5167
|
|
|
alt21=1; |
|
5168
|
|
|
} |
|
5169
|
|
|
|
|
5170
|
|
|
switch (alt21) { |
|
5171
|
|
|
case 1 : |
|
5172
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:162: singleton_state_variable_transition_constraint |
|
5173
|
|
|
{ |
|
5174
|
|
|
pushFollow(FOLLOW_singleton_state_variable_transition_constraint_in_singleton_state_variable_component_type1180); |
|
5175
|
|
|
singleton_state_variable_transition_constraint173=singleton_state_variable_transition_constraint(); |
|
5176
|
|
|
state._fsp--; |
|
5177
|
|
|
if (state.failed) return retval; |
|
5178
|
|
|
if ( state.backtracking==0 ) stream_singleton_state_variable_transition_constraint.add(singleton_state_variable_transition_constraint173.getTree()); |
|
5179
|
|
|
} |
|
5180
|
|
|
break; |
|
5181
|
|
|
|
|
5182
|
|
|
default : |
|
5183
|
|
|
break loop21; |
|
5184
|
|
|
} |
|
5185
|
|
|
} |
|
5186
|
|
|
|
|
5187
|
|
|
char_literal174=(Token)match(input,81,FOLLOW_81_in_singleton_state_variable_component_type1184); if (state.failed) return retval; |
|
5188
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal174); |
|
5189
|
|
|
|
|
5190
|
|
|
// AST REWRITE |
|
5191
|
|
|
// elements: ID, singleton_state_variable_component_decision_type, singleton_state_variable_transition_constraint |
|
5192
|
|
|
// token labels: |
|
5193
|
|
|
// rule labels: retval |
|
5194
|
|
|
// token list labels: |
|
5195
|
|
|
// rule list labels: |
|
5196
|
|
|
// wildcard labels: |
|
5197
|
|
|
if ( state.backtracking==0 ) { |
|
5198
|
|
|
retval.tree = root_0; |
|
5199
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
5200
|
|
|
|
|
5201
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5202
|
|
|
// 112:215: -> ^( ID ( singleton_state_variable_component_decision_type )+ ( singleton_state_variable_transition_constraint )* ) |
|
5203
|
|
|
{ |
|
5204
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:217: ^( ID ( singleton_state_variable_component_decision_type )+ ( singleton_state_variable_transition_constraint )* ) |
|
5205
|
|
|
{ |
|
5206
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
5207
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSingletonStateVariableComponentType(stream_ID.nextToken()), root_1); |
|
5208
|
|
|
if ( !(stream_singleton_state_variable_component_decision_type.hasNext()) ) { |
|
5209
|
|
|
throw new RewriteEarlyExitException(); |
|
5210
|
|
|
} |
|
5211
|
|
|
while ( stream_singleton_state_variable_component_decision_type.hasNext() ) { |
|
5212
|
|
|
adaptor.addChild(root_1, stream_singleton_state_variable_component_decision_type.nextTree()); |
|
5213
|
|
|
} |
|
5214
|
|
|
stream_singleton_state_variable_component_decision_type.reset(); |
|
5215
|
|
|
|
|
5216
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:112:314: ( singleton_state_variable_transition_constraint )* |
|
5217
|
|
|
while ( stream_singleton_state_variable_transition_constraint.hasNext() ) { |
|
5218
|
|
|
adaptor.addChild(root_1, stream_singleton_state_variable_transition_constraint.nextTree()); |
|
5219
|
|
|
} |
|
5220
|
|
|
stream_singleton_state_variable_transition_constraint.reset(); |
|
5221
|
|
|
|
|
5222
|
|
|
adaptor.addChild(root_0, root_1); |
|
5223
|
|
|
} |
|
5224
|
|
|
|
|
5225
|
|
|
} |
|
5226
|
|
|
|
|
5227
|
|
|
|
|
5228
|
|
|
retval.tree = root_0; |
|
5229
|
|
|
} |
|
5230
|
|
|
|
|
5231
|
|
|
} |
|
5232
|
|
|
|
|
5233
|
|
|
retval.stop = input.LT(-1); |
|
5234
|
|
|
|
|
5235
|
|
|
if ( state.backtracking==0 ) { |
|
5236
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5237
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5238
|
|
|
} |
|
5239
|
|
|
} |
|
5240
|
|
|
catch (RecognitionException re) { |
|
5241
|
|
|
reportError(re); |
|
5242
|
|
|
recover(input,re); |
|
5243
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5244
|
|
|
} |
|
5245
|
|
|
finally { |
|
5246
|
|
|
// do for sure before leaving |
|
5247
|
|
|
if ( state.backtracking>0 ) { memoize(input, 23, singleton_state_variable_component_type_StartIndex); } |
|
5248
|
|
|
|
|
5249
|
|
|
} |
|
5250
|
|
|
return retval; |
|
5251
|
|
|
} |
|
5252
|
|
|
// $ANTLR end "singleton_state_variable_component_type" |
|
5253
|
|
|
|
|
5254
|
|
|
|
|
5255
|
|
|
public static class singleton_state_variable_component_decision_type_return extends ParserRuleReturnScope { |
|
5256
|
|
|
Object tree; |
|
5257
|
|
|
@Override |
|
5258
|
|
|
public Object getTree() { return tree; } |
|
5259
|
|
|
}; |
|
5260
|
|
|
|
|
5261
|
|
|
|
|
5262
|
|
|
// $ANTLR start "singleton_state_variable_component_decision_type" |
|
5263
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:114:1: singleton_state_variable_component_decision_type : ID '(' ( ID ( ',' ID )* )? ')' -> ^( ID ( ID )* ) ; |
|
5264
|
|
|
public final ddl3Parser.singleton_state_variable_component_decision_type_return singleton_state_variable_component_decision_type() throws RecognitionException { |
|
5265
|
|
|
ddl3Parser.singleton_state_variable_component_decision_type_return retval = new ddl3Parser.singleton_state_variable_component_decision_type_return(); |
|
5266
|
|
|
retval.start = input.LT(1); |
|
5267
|
|
|
int singleton_state_variable_component_decision_type_StartIndex = input.index(); |
|
5268
|
|
|
|
|
5269
|
|
|
Object root_0 = null; |
|
5270
|
|
|
|
|
5271
|
|
|
Token ID175=null; |
|
5272
|
|
|
Token char_literal176=null; |
|
5273
|
|
|
Token ID177=null; |
|
5274
|
|
|
Token char_literal178=null; |
|
5275
|
|
|
Token ID179=null; |
|
5276
|
|
|
Token char_literal180=null; |
|
5277
|
|
|
|
|
5278
|
|
|
Object ID175_tree=null; |
|
5279
|
|
|
Object char_literal176_tree=null; |
|
5280
|
|
|
Object ID177_tree=null; |
|
5281
|
|
|
Object char_literal178_tree=null; |
|
5282
|
|
|
Object ID179_tree=null; |
|
5283
|
|
|
Object char_literal180_tree=null; |
|
5284
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
5285
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
5286
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
5287
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
5288
|
|
|
|
|
5289
|
|
|
try { |
|
5290
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return retval; } |
|
5291
|
|
|
|
|
5292
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:2: ( ID '(' ( ID ( ',' ID )* )? ')' -> ^( ID ( ID )* ) ) |
|
5293
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:4: ID '(' ( ID ( ',' ID )* )? ')' |
|
5294
|
|
|
{ |
|
5295
|
|
|
ID175=(Token)match(input,ID,FOLLOW_ID_in_singleton_state_variable_component_decision_type1211); if (state.failed) return retval; |
|
5296
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID175); |
|
5297
|
|
|
|
|
5298
|
|
|
char_literal176=(Token)match(input,11,FOLLOW_11_in_singleton_state_variable_component_decision_type1213); if (state.failed) return retval; |
|
5299
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal176); |
|
5300
|
|
|
|
|
5301
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:11: ( ID ( ',' ID )* )? |
|
5302
|
|
|
int alt23=2; |
|
5303
|
|
|
int LA23_0 = input.LA(1); |
|
5304
|
|
|
if ( (LA23_0==ID) ) { |
|
5305
|
|
|
alt23=1; |
|
5306
|
|
|
} |
|
5307
|
|
|
switch (alt23) { |
|
5308
|
|
|
case 1 : |
|
5309
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:12: ID ( ',' ID )* |
|
5310
|
|
|
{ |
|
5311
|
|
|
ID177=(Token)match(input,ID,FOLLOW_ID_in_singleton_state_variable_component_decision_type1216); if (state.failed) return retval; |
|
5312
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID177); |
|
5313
|
|
|
|
|
5314
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:15: ( ',' ID )* |
|
5315
|
|
|
loop22: |
|
5316
|
|
View Code Duplication |
while (true) { |
|
|
|
|
|
|
5317
|
|
|
int alt22=2; |
|
5318
|
|
|
int LA22_0 = input.LA(1); |
|
5319
|
|
|
if ( (LA22_0==15) ) { |
|
5320
|
|
|
alt22=1; |
|
5321
|
|
|
} |
|
5322
|
|
|
|
|
5323
|
|
|
switch (alt22) { |
|
5324
|
|
|
case 1 : |
|
5325
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:16: ',' ID |
|
5326
|
|
|
{ |
|
5327
|
|
|
char_literal178=(Token)match(input,15,FOLLOW_15_in_singleton_state_variable_component_decision_type1219); if (state.failed) return retval; |
|
5328
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal178); |
|
5329
|
|
|
|
|
5330
|
|
|
ID179=(Token)match(input,ID,FOLLOW_ID_in_singleton_state_variable_component_decision_type1221); if (state.failed) return retval; |
|
5331
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID179); |
|
5332
|
|
|
|
|
5333
|
|
|
} |
|
5334
|
|
|
break; |
|
5335
|
|
|
|
|
5336
|
|
|
default : |
|
5337
|
|
|
break loop22; |
|
5338
|
|
|
} |
|
5339
|
|
|
} |
|
5340
|
|
|
|
|
5341
|
|
|
} |
|
5342
|
|
|
break; |
|
5343
|
|
|
|
|
5344
|
|
|
} |
|
5345
|
|
|
|
|
5346
|
|
|
char_literal180=(Token)match(input,12,FOLLOW_12_in_singleton_state_variable_component_decision_type1227); if (state.failed) return retval; |
|
5347
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal180); |
|
5348
|
|
|
|
|
5349
|
|
|
// AST REWRITE |
|
5350
|
|
|
// elements: ID, ID |
|
5351
|
|
|
// token labels: |
|
5352
|
|
|
// rule labels: retval |
|
5353
|
|
|
// token list labels: |
|
5354
|
|
|
// rule list labels: |
|
5355
|
|
|
// wildcard labels: |
|
5356
|
|
|
if ( state.backtracking==0 ) { |
|
5357
|
|
|
retval.tree = root_0; |
|
5358
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
5359
|
|
|
|
|
5360
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5361
|
|
|
// 115:31: -> ^( ID ( ID )* ) |
|
5362
|
|
|
{ |
|
5363
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:33: ^( ID ( ID )* ) |
|
5364
|
|
|
{ |
|
5365
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
5366
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSingletonStateVariableComponentDecisionType(stream_ID.nextToken()), root_1); |
|
5367
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:115:86: ( ID )* |
|
5368
|
|
|
while ( stream_ID.hasNext() ) { |
|
5369
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
5370
|
|
|
} |
|
5371
|
|
|
stream_ID.reset(); |
|
5372
|
|
|
|
|
5373
|
|
|
adaptor.addChild(root_0, root_1); |
|
5374
|
|
|
} |
|
5375
|
|
|
|
|
5376
|
|
|
} |
|
5377
|
|
|
|
|
5378
|
|
|
|
|
5379
|
|
|
retval.tree = root_0; |
|
5380
|
|
|
} |
|
5381
|
|
|
|
|
5382
|
|
|
} |
|
5383
|
|
|
|
|
5384
|
|
|
retval.stop = input.LT(-1); |
|
5385
|
|
|
|
|
5386
|
|
|
if ( state.backtracking==0 ) { |
|
5387
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5388
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5389
|
|
|
} |
|
5390
|
|
|
} |
|
5391
|
|
|
catch (RecognitionException re) { |
|
5392
|
|
|
reportError(re); |
|
5393
|
|
|
recover(input,re); |
|
5394
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5395
|
|
|
} |
|
5396
|
|
|
finally { |
|
5397
|
|
|
// do for sure before leaving |
|
5398
|
|
|
if ( state.backtracking>0 ) { memoize(input, 24, singleton_state_variable_component_decision_type_StartIndex); } |
|
5399
|
|
|
|
|
5400
|
|
|
} |
|
5401
|
|
|
return retval; |
|
5402
|
|
|
} |
|
5403
|
|
|
// $ANTLR end "singleton_state_variable_component_decision_type" |
|
5404
|
|
|
|
|
5405
|
|
|
|
|
5406
|
|
|
public static class singleton_state_variable_transition_constraint_return extends ParserRuleReturnScope { |
|
5407
|
|
|
Object tree; |
|
5408
|
|
|
@Override |
|
5409
|
|
|
public Object getTree() { return tree; } |
|
5410
|
|
|
}; |
|
5411
|
|
|
|
|
5412
|
|
|
|
|
5413
|
|
|
// $ANTLR start "singleton_state_variable_transition_constraint" |
|
5414
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:117:1: singleton_state_variable_transition_constraint : 'VALUE' singleton_state_variable_component_decision range 'MEETS' '{' ( singleton_state_variable_transition_element ';' )* '}' -> ^( 'VALUE' singleton_state_variable_component_decision range ( singleton_state_variable_transition_element )* ) ; |
|
5415
|
|
|
public final ddl3Parser.singleton_state_variable_transition_constraint_return singleton_state_variable_transition_constraint() throws RecognitionException { |
|
5416
|
|
|
ddl3Parser.singleton_state_variable_transition_constraint_return retval = new ddl3Parser.singleton_state_variable_transition_constraint_return(); |
|
5417
|
|
|
retval.start = input.LT(1); |
|
5418
|
|
|
int singleton_state_variable_transition_constraint_StartIndex = input.index(); |
|
5419
|
|
|
|
|
5420
|
|
|
Object root_0 = null; |
|
5421
|
|
|
|
|
5422
|
|
|
Token string_literal181=null; |
|
5423
|
|
|
Token string_literal184=null; |
|
5424
|
|
|
Token char_literal185=null; |
|
5425
|
|
|
Token char_literal187=null; |
|
5426
|
|
|
Token char_literal188=null; |
|
5427
|
|
|
ParserRuleReturnScope singleton_state_variable_component_decision182 =null; |
|
5428
|
|
|
ParserRuleReturnScope range183 =null; |
|
5429
|
|
|
ParserRuleReturnScope singleton_state_variable_transition_element186 =null; |
|
5430
|
|
|
|
|
5431
|
|
|
Object string_literal181_tree=null; |
|
5432
|
|
|
Object string_literal184_tree=null; |
|
5433
|
|
|
Object char_literal185_tree=null; |
|
5434
|
|
|
Object char_literal187_tree=null; |
|
5435
|
|
|
Object char_literal188_tree=null; |
|
5436
|
|
|
RewriteRuleTokenStream stream_55=new RewriteRuleTokenStream(adaptor,"token 55"); |
|
5437
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
5438
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
5439
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
5440
|
|
|
RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75"); |
|
5441
|
|
|
RewriteRuleSubtreeStream stream_singleton_state_variable_component_decision=new RewriteRuleSubtreeStream(adaptor,"rule singleton_state_variable_component_decision"); |
|
5442
|
|
|
RewriteRuleSubtreeStream stream_singleton_state_variable_transition_element=new RewriteRuleSubtreeStream(adaptor,"rule singleton_state_variable_transition_element"); |
|
5443
|
|
|
RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range"); |
|
5444
|
|
|
|
|
5445
|
|
|
try { |
|
5446
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return retval; } |
|
5447
|
|
|
|
|
5448
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:2: ( 'VALUE' singleton_state_variable_component_decision range 'MEETS' '{' ( singleton_state_variable_transition_element ';' )* '}' -> ^( 'VALUE' singleton_state_variable_component_decision range ( singleton_state_variable_transition_element )* ) ) |
|
5449
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:4: 'VALUE' singleton_state_variable_component_decision range 'MEETS' '{' ( singleton_state_variable_transition_element ';' )* '}' |
|
5450
|
|
|
{ |
|
5451
|
|
|
string_literal181=(Token)match(input,75,FOLLOW_75_in_singleton_state_variable_transition_constraint1247); if (state.failed) return retval; |
|
5452
|
|
|
if ( state.backtracking==0 ) stream_75.add(string_literal181); |
|
5453
|
|
|
|
|
5454
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_in_singleton_state_variable_transition_constraint1249); |
|
5455
|
|
|
singleton_state_variable_component_decision182=singleton_state_variable_component_decision(); |
|
5456
|
|
|
state._fsp--; |
|
5457
|
|
|
if (state.failed) return retval; |
|
5458
|
|
|
if ( state.backtracking==0 ) stream_singleton_state_variable_component_decision.add(singleton_state_variable_component_decision182.getTree()); |
|
5459
|
|
|
pushFollow(FOLLOW_range_in_singleton_state_variable_transition_constraint1251); |
|
5460
|
|
|
range183=range(); |
|
5461
|
|
|
state._fsp--; |
|
5462
|
|
|
if (state.failed) return retval; |
|
5463
|
|
|
if ( state.backtracking==0 ) stream_range.add(range183.getTree()); |
|
5464
|
|
|
string_literal184=(Token)match(input,55,FOLLOW_55_in_singleton_state_variable_transition_constraint1253); if (state.failed) return retval; |
|
5465
|
|
|
if ( state.backtracking==0 ) stream_55.add(string_literal184); |
|
5466
|
|
|
|
|
5467
|
|
|
char_literal185=(Token)match(input,80,FOLLOW_80_in_singleton_state_variable_transition_constraint1255); if (state.failed) return retval; |
|
5468
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal185); |
|
5469
|
|
|
|
|
5470
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:74: ( singleton_state_variable_transition_element ';' )* |
|
5471
|
|
|
loop24: |
|
5472
|
|
|
while (true) { |
|
5473
|
|
|
int alt24=2; |
|
5474
|
|
|
int LA24_0 = input.LA(1); |
|
5475
|
|
|
if ( ((LA24_0 >= ID && LA24_0 <= VarID)||LA24_0==14||LA24_0==16||LA24_0==20||LA24_0==54) ) { |
|
5476
|
|
|
alt24=1; |
|
5477
|
|
|
} |
|
5478
|
|
|
|
|
5479
|
|
|
switch (alt24) { |
|
5480
|
|
|
case 1 : |
|
5481
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:75: singleton_state_variable_transition_element ';' |
|
5482
|
|
|
{ |
|
5483
|
|
|
pushFollow(FOLLOW_singleton_state_variable_transition_element_in_singleton_state_variable_transition_constraint1258); |
|
5484
|
|
|
singleton_state_variable_transition_element186=singleton_state_variable_transition_element(); |
|
5485
|
|
|
state._fsp--; |
|
5486
|
|
|
if (state.failed) return retval; |
|
5487
|
|
|
if ( state.backtracking==0 ) stream_singleton_state_variable_transition_element.add(singleton_state_variable_transition_element186.getTree()); |
|
5488
|
|
|
char_literal187=(Token)match(input,19,FOLLOW_19_in_singleton_state_variable_transition_constraint1260); if (state.failed) return retval; |
|
5489
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal187); |
|
5490
|
|
|
|
|
5491
|
|
|
} |
|
5492
|
|
|
break; |
|
5493
|
|
|
|
|
5494
|
|
|
default : |
|
5495
|
|
|
break loop24; |
|
5496
|
|
|
} |
|
5497
|
|
|
} |
|
5498
|
|
|
|
|
5499
|
|
|
char_literal188=(Token)match(input,81,FOLLOW_81_in_singleton_state_variable_transition_constraint1264); if (state.failed) return retval; |
|
5500
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal188); |
|
5501
|
|
|
|
|
5502
|
|
|
// AST REWRITE |
|
5503
|
|
|
// elements: singleton_state_variable_component_decision, range, 75, singleton_state_variable_transition_element |
|
5504
|
|
|
// token labels: |
|
5505
|
|
|
// rule labels: retval |
|
5506
|
|
|
// token list labels: |
|
5507
|
|
|
// rule list labels: |
|
5508
|
|
|
// wildcard labels: |
|
5509
|
|
|
if ( state.backtracking==0 ) { |
|
5510
|
|
|
retval.tree = root_0; |
|
5511
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
5512
|
|
|
|
|
5513
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5514
|
|
|
// 118:129: -> ^( 'VALUE' singleton_state_variable_component_decision range ( singleton_state_variable_transition_element )* ) |
|
5515
|
|
|
{ |
|
5516
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:131: ^( 'VALUE' singleton_state_variable_component_decision range ( singleton_state_variable_transition_element )* ) |
|
5517
|
|
|
{ |
|
5518
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
5519
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSingletonStateVariableTransitionConstraint(stream_75.nextToken()), root_1); |
|
5520
|
|
|
adaptor.addChild(root_1, stream_singleton_state_variable_component_decision.nextTree()); |
|
5521
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
5522
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:118:238: ( singleton_state_variable_transition_element )* |
|
5523
|
|
|
while ( stream_singleton_state_variable_transition_element.hasNext() ) { |
|
5524
|
|
|
adaptor.addChild(root_1, stream_singleton_state_variable_transition_element.nextTree()); |
|
5525
|
|
|
} |
|
5526
|
|
|
stream_singleton_state_variable_transition_element.reset(); |
|
5527
|
|
|
|
|
5528
|
|
|
adaptor.addChild(root_0, root_1); |
|
5529
|
|
|
} |
|
5530
|
|
|
|
|
5531
|
|
|
} |
|
5532
|
|
|
|
|
5533
|
|
|
|
|
5534
|
|
|
retval.tree = root_0; |
|
5535
|
|
|
} |
|
5536
|
|
|
|
|
5537
|
|
|
} |
|
5538
|
|
|
|
|
5539
|
|
|
retval.stop = input.LT(-1); |
|
5540
|
|
|
|
|
5541
|
|
|
if ( state.backtracking==0 ) { |
|
5542
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5543
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5544
|
|
|
} |
|
5545
|
|
|
} |
|
5546
|
|
|
catch (RecognitionException re) { |
|
5547
|
|
|
reportError(re); |
|
5548
|
|
|
recover(input,re); |
|
5549
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5550
|
|
|
} |
|
5551
|
|
|
finally { |
|
5552
|
|
|
// do for sure before leaving |
|
5553
|
|
|
if ( state.backtracking>0 ) { memoize(input, 25, singleton_state_variable_transition_constraint_StartIndex); } |
|
5554
|
|
|
|
|
5555
|
|
|
} |
|
5556
|
|
|
return retval; |
|
5557
|
|
|
} |
|
5558
|
|
|
// $ANTLR end "singleton_state_variable_transition_constraint" |
|
5559
|
|
|
|
|
5560
|
|
|
|
|
5561
|
|
|
public static class singleton_state_variable_transition_element_return extends ParserRuleReturnScope { |
|
5562
|
|
|
Object tree; |
|
5563
|
|
|
@Override |
|
5564
|
|
|
public Object getTree() { return tree; } |
|
5565
|
|
|
}; |
|
5566
|
|
|
|
|
5567
|
|
|
|
|
5568
|
|
|
// $ANTLR start "singleton_state_variable_transition_element" |
|
5569
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:120:1: singleton_state_variable_transition_element : ( singleton_state_variable_component_decision | parameter_constraint ); |
|
5570
|
|
|
public final ddl3Parser.singleton_state_variable_transition_element_return singleton_state_variable_transition_element() throws RecognitionException { |
|
5571
|
|
|
ddl3Parser.singleton_state_variable_transition_element_return retval = new ddl3Parser.singleton_state_variable_transition_element_return(); |
|
5572
|
|
|
retval.start = input.LT(1); |
|
5573
|
|
|
int singleton_state_variable_transition_element_StartIndex = input.index(); |
|
5574
|
|
|
|
|
5575
|
|
|
Object root_0 = null; |
|
5576
|
|
|
|
|
5577
|
|
|
ParserRuleReturnScope singleton_state_variable_component_decision189 =null; |
|
5578
|
|
|
ParserRuleReturnScope parameter_constraint190 =null; |
|
5579
|
|
|
|
|
5580
|
|
|
|
|
5581
|
|
|
try { |
|
5582
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return retval; } |
|
5583
|
|
|
|
|
5584
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:121:2: ( singleton_state_variable_component_decision | parameter_constraint ) |
|
5585
|
|
|
int alt25=2; |
|
5586
|
|
|
int LA25_0 = input.LA(1); |
|
5587
|
|
View Code Duplication |
if ( (LA25_0==ID||LA25_0==20) ) { |
|
|
|
|
|
|
5588
|
|
|
alt25=1; |
|
5589
|
|
|
} |
|
5590
|
|
|
else if ( ((LA25_0 >= INT && LA25_0 <= VarID)||LA25_0==14||LA25_0==16||LA25_0==54) ) { |
|
5591
|
|
|
alt25=2; |
|
5592
|
|
|
} |
|
5593
|
|
|
|
|
5594
|
|
|
else { |
|
5595
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
5596
|
|
|
NoViableAltException nvae = |
|
5597
|
|
|
new NoViableAltException("", 25, 0, input); |
|
5598
|
|
|
throw nvae; |
|
5599
|
|
|
} |
|
5600
|
|
|
|
|
5601
|
|
|
switch (alt25) { |
|
5602
|
|
|
case 1 : |
|
5603
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:121:4: singleton_state_variable_component_decision |
|
5604
|
|
|
{ |
|
5605
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5606
|
|
|
|
|
5607
|
|
|
|
|
5608
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_in_singleton_state_variable_transition_element1290); |
|
5609
|
|
|
singleton_state_variable_component_decision189=singleton_state_variable_component_decision(); |
|
5610
|
|
|
state._fsp--; |
|
5611
|
|
|
if (state.failed) return retval; |
|
5612
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, singleton_state_variable_component_decision189.getTree()); |
|
5613
|
|
|
|
|
5614
|
|
|
} |
|
5615
|
|
|
break; |
|
5616
|
|
|
case 2 : |
|
5617
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:121:50: parameter_constraint |
|
5618
|
|
|
{ |
|
5619
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5620
|
|
|
|
|
5621
|
|
|
|
|
5622
|
|
|
pushFollow(FOLLOW_parameter_constraint_in_singleton_state_variable_transition_element1294); |
|
5623
|
|
|
parameter_constraint190=parameter_constraint(); |
|
5624
|
|
|
state._fsp--; |
|
5625
|
|
|
if (state.failed) return retval; |
|
5626
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_constraint190.getTree()); |
|
5627
|
|
|
|
|
5628
|
|
|
} |
|
5629
|
|
|
break; |
|
5630
|
|
|
|
|
5631
|
|
|
} |
|
5632
|
|
|
retval.stop = input.LT(-1); |
|
5633
|
|
|
|
|
5634
|
|
|
if ( state.backtracking==0 ) { |
|
5635
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5636
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5637
|
|
|
} |
|
5638
|
|
|
} |
|
5639
|
|
|
catch (RecognitionException re) { |
|
5640
|
|
|
reportError(re); |
|
5641
|
|
|
recover(input,re); |
|
5642
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5643
|
|
|
} |
|
5644
|
|
|
finally { |
|
5645
|
|
|
// do for sure before leaving |
|
5646
|
|
|
if ( state.backtracking>0 ) { memoize(input, 26, singleton_state_variable_transition_element_StartIndex); } |
|
5647
|
|
|
|
|
5648
|
|
|
} |
|
5649
|
|
|
return retval; |
|
5650
|
|
|
} |
|
5651
|
|
|
// $ANTLR end "singleton_state_variable_transition_element" |
|
5652
|
|
|
|
|
5653
|
|
|
|
|
5654
|
|
|
public static class renewable_resource_component_type_return extends ParserRuleReturnScope { |
|
5655
|
|
|
Object tree; |
|
5656
|
|
|
@Override |
|
5657
|
|
|
public Object getTree() { return tree; } |
|
5658
|
|
|
}; |
|
5659
|
|
|
|
|
5660
|
|
|
|
|
5661
|
|
|
// $ANTLR start "renewable_resource_component_type" |
|
5662
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:124:1: renewable_resource_component_type : 'COMP_TYPE' 'RenewableResource' ID '(' positive_number ')' -> ^( ID positive_number ) ; |
|
5663
|
|
|
public final ddl3Parser.renewable_resource_component_type_return renewable_resource_component_type() throws RecognitionException { |
|
5664
|
|
|
ddl3Parser.renewable_resource_component_type_return retval = new ddl3Parser.renewable_resource_component_type_return(); |
|
5665
|
|
|
retval.start = input.LT(1); |
|
5666
|
|
|
int renewable_resource_component_type_StartIndex = input.index(); |
|
5667
|
|
|
|
|
5668
|
|
|
Object root_0 = null; |
|
5669
|
|
|
|
|
5670
|
|
|
Token string_literal191=null; |
|
5671
|
|
|
Token string_literal192=null; |
|
5672
|
|
|
Token ID193=null; |
|
5673
|
|
|
Token char_literal194=null; |
|
5674
|
|
|
Token char_literal196=null; |
|
5675
|
|
|
ParserRuleReturnScope positive_number195 =null; |
|
5676
|
|
|
|
|
5677
|
|
|
Object string_literal191_tree=null; |
|
5678
|
|
|
Object string_literal192_tree=null; |
|
5679
|
|
|
Object ID193_tree=null; |
|
5680
|
|
|
Object char_literal194_tree=null; |
|
5681
|
|
|
Object char_literal196_tree=null; |
|
5682
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
5683
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
5684
|
|
|
RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35"); |
|
5685
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
5686
|
|
|
RewriteRuleTokenStream stream_64=new RewriteRuleTokenStream(adaptor,"token 64"); |
|
5687
|
|
|
RewriteRuleSubtreeStream stream_positive_number=new RewriteRuleSubtreeStream(adaptor,"rule positive_number"); |
|
5688
|
|
|
|
|
5689
|
|
View Code Duplication |
try { |
|
|
|
|
|
|
5690
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; } |
|
5691
|
|
|
|
|
5692
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:125:2: ( 'COMP_TYPE' 'RenewableResource' ID '(' positive_number ')' -> ^( ID positive_number ) ) |
|
5693
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:125:4: 'COMP_TYPE' 'RenewableResource' ID '(' positive_number ')' |
|
5694
|
|
|
{ |
|
5695
|
|
|
string_literal191=(Token)match(input,35,FOLLOW_35_in_renewable_resource_component_type1304); if (state.failed) return retval; |
|
5696
|
|
|
if ( state.backtracking==0 ) stream_35.add(string_literal191); |
|
5697
|
|
|
|
|
5698
|
|
|
string_literal192=(Token)match(input,64,FOLLOW_64_in_renewable_resource_component_type1306); if (state.failed) return retval; |
|
5699
|
|
|
if ( state.backtracking==0 ) stream_64.add(string_literal192); |
|
5700
|
|
|
|
|
5701
|
|
|
ID193=(Token)match(input,ID,FOLLOW_ID_in_renewable_resource_component_type1308); if (state.failed) return retval; |
|
5702
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID193); |
|
5703
|
|
|
|
|
5704
|
|
|
char_literal194=(Token)match(input,11,FOLLOW_11_in_renewable_resource_component_type1310); if (state.failed) return retval; |
|
5705
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal194); |
|
5706
|
|
|
|
|
5707
|
|
|
pushFollow(FOLLOW_positive_number_in_renewable_resource_component_type1312); |
|
5708
|
|
|
positive_number195=positive_number(); |
|
5709
|
|
|
state._fsp--; |
|
5710
|
|
|
if (state.failed) return retval; |
|
5711
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number195.getTree()); |
|
5712
|
|
|
char_literal196=(Token)match(input,12,FOLLOW_12_in_renewable_resource_component_type1314); if (state.failed) return retval; |
|
5713
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal196); |
|
5714
|
|
|
|
|
5715
|
|
|
// AST REWRITE |
|
5716
|
|
|
// elements: positive_number, ID |
|
5717
|
|
|
// token labels: |
|
5718
|
|
|
// rule labels: retval |
|
5719
|
|
|
// token list labels: |
|
5720
|
|
|
// rule list labels: |
|
5721
|
|
|
// wildcard labels: |
|
5722
|
|
|
if ( state.backtracking==0 ) { |
|
5723
|
|
|
retval.tree = root_0; |
|
5724
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
5725
|
|
|
|
|
5726
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5727
|
|
|
// 125:63: -> ^( ID positive_number ) |
|
5728
|
|
|
{ |
|
5729
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:125:65: ^( ID positive_number ) |
|
5730
|
|
|
{ |
|
5731
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
5732
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLRenewableResourceComponentType(stream_ID.nextToken()), root_1); |
|
5733
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
5734
|
|
|
adaptor.addChild(root_0, root_1); |
|
5735
|
|
|
} |
|
5736
|
|
|
|
|
5737
|
|
|
} |
|
5738
|
|
|
|
|
5739
|
|
|
|
|
5740
|
|
|
retval.tree = root_0; |
|
5741
|
|
|
} |
|
5742
|
|
|
|
|
5743
|
|
|
} |
|
5744
|
|
|
|
|
5745
|
|
|
retval.stop = input.LT(-1); |
|
5746
|
|
|
|
|
5747
|
|
|
if ( state.backtracking==0 ) { |
|
5748
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5749
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5750
|
|
|
} |
|
5751
|
|
|
} |
|
5752
|
|
|
catch (RecognitionException re) { |
|
5753
|
|
|
reportError(re); |
|
5754
|
|
|
recover(input,re); |
|
5755
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5756
|
|
|
} |
|
5757
|
|
|
finally { |
|
5758
|
|
|
// do for sure before leaving |
|
5759
|
|
|
if ( state.backtracking>0 ) { memoize(input, 27, renewable_resource_component_type_StartIndex); } |
|
5760
|
|
|
|
|
5761
|
|
|
} |
|
5762
|
|
|
return retval; |
|
5763
|
|
|
} |
|
5764
|
|
|
// $ANTLR end "renewable_resource_component_type" |
|
5765
|
|
|
|
|
5766
|
|
|
|
|
5767
|
|
|
public static class consumable_resource_component_type_return extends ParserRuleReturnScope { |
|
5768
|
|
|
Object tree; |
|
5769
|
|
|
@Override |
|
5770
|
|
|
public Object getTree() { return tree; } |
|
5771
|
|
|
}; |
|
5772
|
|
|
|
|
5773
|
|
|
|
|
5774
|
|
|
// $ANTLR start "consumable_resource_component_type" |
|
5775
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:128:1: consumable_resource_component_type : 'COMP_TYPE' 'ConsumableResource' ID '(' positive_number ',' positive_number ',' positive_number ')' -> ^( ID positive_number positive_number positive_number ) ; |
|
5776
|
|
|
public final ddl3Parser.consumable_resource_component_type_return consumable_resource_component_type() throws RecognitionException { |
|
5777
|
|
|
ddl3Parser.consumable_resource_component_type_return retval = new ddl3Parser.consumable_resource_component_type_return(); |
|
5778
|
|
|
retval.start = input.LT(1); |
|
5779
|
|
|
int consumable_resource_component_type_StartIndex = input.index(); |
|
5780
|
|
|
|
|
5781
|
|
|
Object root_0 = null; |
|
5782
|
|
|
|
|
5783
|
|
|
Token string_literal197=null; |
|
5784
|
|
|
Token string_literal198=null; |
|
5785
|
|
|
Token ID199=null; |
|
5786
|
|
|
Token char_literal200=null; |
|
5787
|
|
|
Token char_literal202=null; |
|
5788
|
|
|
Token char_literal204=null; |
|
5789
|
|
|
Token char_literal206=null; |
|
5790
|
|
|
ParserRuleReturnScope positive_number201 =null; |
|
5791
|
|
|
ParserRuleReturnScope positive_number203 =null; |
|
5792
|
|
|
ParserRuleReturnScope positive_number205 =null; |
|
5793
|
|
|
|
|
5794
|
|
|
Object string_literal197_tree=null; |
|
5795
|
|
|
Object string_literal198_tree=null; |
|
5796
|
|
|
Object ID199_tree=null; |
|
5797
|
|
|
Object char_literal200_tree=null; |
|
5798
|
|
|
Object char_literal202_tree=null; |
|
5799
|
|
|
Object char_literal204_tree=null; |
|
5800
|
|
|
Object char_literal206_tree=null; |
|
5801
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
5802
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
5803
|
|
|
RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35"); |
|
5804
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
5805
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
5806
|
|
|
RewriteRuleTokenStream stream_40=new RewriteRuleTokenStream(adaptor,"token 40"); |
|
5807
|
|
|
RewriteRuleSubtreeStream stream_positive_number=new RewriteRuleSubtreeStream(adaptor,"rule positive_number"); |
|
5808
|
|
|
|
|
5809
|
|
View Code Duplication |
try { |
|
|
|
|
|
|
5810
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; } |
|
5811
|
|
|
|
|
5812
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:129:2: ( 'COMP_TYPE' 'ConsumableResource' ID '(' positive_number ',' positive_number ',' positive_number ')' -> ^( ID positive_number positive_number positive_number ) ) |
|
5813
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:129:4: 'COMP_TYPE' 'ConsumableResource' ID '(' positive_number ',' positive_number ',' positive_number ')' |
|
5814
|
|
|
{ |
|
5815
|
|
|
string_literal197=(Token)match(input,35,FOLLOW_35_in_consumable_resource_component_type1334); if (state.failed) return retval; |
|
5816
|
|
|
if ( state.backtracking==0 ) stream_35.add(string_literal197); |
|
5817
|
|
|
|
|
5818
|
|
|
string_literal198=(Token)match(input,40,FOLLOW_40_in_consumable_resource_component_type1336); if (state.failed) return retval; |
|
5819
|
|
|
if ( state.backtracking==0 ) stream_40.add(string_literal198); |
|
5820
|
|
|
|
|
5821
|
|
|
ID199=(Token)match(input,ID,FOLLOW_ID_in_consumable_resource_component_type1338); if (state.failed) return retval; |
|
5822
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID199); |
|
5823
|
|
|
|
|
5824
|
|
|
char_literal200=(Token)match(input,11,FOLLOW_11_in_consumable_resource_component_type1340); if (state.failed) return retval; |
|
5825
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal200); |
|
5826
|
|
|
|
|
5827
|
|
|
pushFollow(FOLLOW_positive_number_in_consumable_resource_component_type1342); |
|
5828
|
|
|
positive_number201=positive_number(); |
|
5829
|
|
|
state._fsp--; |
|
5830
|
|
|
if (state.failed) return retval; |
|
5831
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number201.getTree()); |
|
5832
|
|
|
char_literal202=(Token)match(input,15,FOLLOW_15_in_consumable_resource_component_type1344); if (state.failed) return retval; |
|
5833
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal202); |
|
5834
|
|
|
|
|
5835
|
|
|
pushFollow(FOLLOW_positive_number_in_consumable_resource_component_type1346); |
|
5836
|
|
|
positive_number203=positive_number(); |
|
5837
|
|
|
state._fsp--; |
|
5838
|
|
|
if (state.failed) return retval; |
|
5839
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number203.getTree()); |
|
5840
|
|
|
char_literal204=(Token)match(input,15,FOLLOW_15_in_consumable_resource_component_type1348); if (state.failed) return retval; |
|
5841
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal204); |
|
5842
|
|
|
|
|
5843
|
|
|
pushFollow(FOLLOW_positive_number_in_consumable_resource_component_type1350); |
|
5844
|
|
|
positive_number205=positive_number(); |
|
5845
|
|
|
state._fsp--; |
|
5846
|
|
|
if (state.failed) return retval; |
|
5847
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number205.getTree()); |
|
5848
|
|
|
char_literal206=(Token)match(input,12,FOLLOW_12_in_consumable_resource_component_type1352); if (state.failed) return retval; |
|
5849
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal206); |
|
5850
|
|
|
|
|
5851
|
|
|
// AST REWRITE |
|
5852
|
|
|
// elements: ID, positive_number, positive_number, positive_number |
|
5853
|
|
|
// token labels: |
|
5854
|
|
|
// rule labels: retval |
|
5855
|
|
|
// token list labels: |
|
5856
|
|
|
// rule list labels: |
|
5857
|
|
|
// wildcard labels: |
|
5858
|
|
|
if ( state.backtracking==0 ) { |
|
5859
|
|
|
retval.tree = root_0; |
|
5860
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
5861
|
|
|
|
|
5862
|
|
|
root_0 = (Object)adaptor.nil(); |
|
5863
|
|
|
// 129:104: -> ^( ID positive_number positive_number positive_number ) |
|
5864
|
|
|
{ |
|
5865
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:129:106: ^( ID positive_number positive_number positive_number ) |
|
5866
|
|
|
{ |
|
5867
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
5868
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLConsumableResourceComponentType(stream_ID.nextToken()), root_1); |
|
5869
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
5870
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
5871
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
5872
|
|
|
adaptor.addChild(root_0, root_1); |
|
5873
|
|
|
} |
|
5874
|
|
|
|
|
5875
|
|
|
} |
|
5876
|
|
|
|
|
5877
|
|
|
|
|
5878
|
|
|
retval.tree = root_0; |
|
5879
|
|
|
} |
|
5880
|
|
|
|
|
5881
|
|
|
} |
|
5882
|
|
|
|
|
5883
|
|
|
retval.stop = input.LT(-1); |
|
5884
|
|
|
|
|
5885
|
|
|
if ( state.backtracking==0 ) { |
|
5886
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
5887
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
5888
|
|
|
} |
|
5889
|
|
|
} |
|
5890
|
|
|
catch (RecognitionException re) { |
|
5891
|
|
|
reportError(re); |
|
5892
|
|
|
recover(input,re); |
|
5893
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
5894
|
|
|
} |
|
5895
|
|
|
finally { |
|
5896
|
|
|
// do for sure before leaving |
|
5897
|
|
|
if ( state.backtracking>0 ) { memoize(input, 28, consumable_resource_component_type_StartIndex); } |
|
5898
|
|
|
|
|
5899
|
|
|
} |
|
5900
|
|
|
return retval; |
|
5901
|
|
|
} |
|
5902
|
|
|
// $ANTLR end "consumable_resource_component_type" |
|
5903
|
|
|
|
|
5904
|
|
|
|
|
5905
|
|
|
public static class component_return extends ParserRuleReturnScope { |
|
5906
|
|
|
Object tree; |
|
5907
|
|
|
@Override |
|
5908
|
|
|
public Object getTree() { return tree; } |
|
5909
|
|
|
}; |
|
5910
|
|
|
|
|
5911
|
|
|
|
|
5912
|
|
|
// $ANTLR start "component" |
|
5913
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:132:1: component : 'COMPONENT' ID '{' ( timeline )* '}' ':' ID ';' -> ^( ID ID ( timeline )* ) ; |
|
5914
|
|
|
public final ddl3Parser.component_return component() throws RecognitionException { |
|
5915
|
|
|
ddl3Parser.component_return retval = new ddl3Parser.component_return(); |
|
5916
|
|
|
retval.start = input.LT(1); |
|
5917
|
|
|
int component_StartIndex = input.index(); |
|
5918
|
|
|
|
|
5919
|
|
|
Object root_0 = null; |
|
5920
|
|
|
|
|
5921
|
|
|
Token string_literal207=null; |
|
5922
|
|
|
Token ID208=null; |
|
5923
|
|
|
Token char_literal209=null; |
|
5924
|
|
|
Token char_literal211=null; |
|
5925
|
|
|
Token char_literal212=null; |
|
5926
|
|
|
Token ID213=null; |
|
5927
|
|
|
Token char_literal214=null; |
|
5928
|
|
|
ParserRuleReturnScope timeline210 =null; |
|
5929
|
|
|
|
|
5930
|
|
|
Object string_literal207_tree=null; |
|
5931
|
|
|
Object ID208_tree=null; |
|
5932
|
|
|
Object char_literal209_tree=null; |
|
5933
|
|
|
Object char_literal211_tree=null; |
|
5934
|
|
|
Object char_literal212_tree=null; |
|
5935
|
|
|
Object ID213_tree=null; |
|
5936
|
|
|
Object char_literal214_tree=null; |
|
5937
|
|
|
RewriteRuleTokenStream stream_34=new RewriteRuleTokenStream(adaptor,"token 34"); |
|
5938
|
|
|
RewriteRuleTokenStream stream_18=new RewriteRuleTokenStream(adaptor,"token 18"); |
|
5939
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
5940
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
5941
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
5942
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
5943
|
|
|
RewriteRuleSubtreeStream stream_timeline=new RewriteRuleSubtreeStream(adaptor,"rule timeline"); |
|
5944
|
|
|
|
|
5945
|
|
|
try { |
|
5946
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return retval; } |
|
5947
|
|
|
|
|
5948
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:2: ( 'COMPONENT' ID '{' ( timeline )* '}' ':' ID ';' -> ^( ID ID ( timeline )* ) ) |
|
5949
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:4: 'COMPONENT' ID '{' ( timeline )* '}' ':' ID ';' |
|
5950
|
|
|
{ |
|
5951
|
|
|
string_literal207=(Token)match(input,34,FOLLOW_34_in_component1376); if (state.failed) return retval; |
|
5952
|
|
|
if ( state.backtracking==0 ) stream_34.add(string_literal207); |
|
5953
|
|
|
|
|
5954
|
|
|
ID208=(Token)match(input,ID,FOLLOW_ID_in_component1378); if (state.failed) return retval; |
|
5955
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID208); |
|
5956
|
|
|
|
|
5957
|
|
|
char_literal209=(Token)match(input,80,FOLLOW_80_in_component1380); if (state.failed) return retval; |
|
5958
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal209); |
|
5959
|
|
|
|
|
5960
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:23: ( timeline )* |
|
5961
|
|
|
loop26: |
|
5962
|
|
|
while (true) { |
|
5963
|
|
|
int alt26=2; |
|
5964
|
|
|
int LA26_0 = input.LA(1); |
|
5965
|
|
|
if ( (LA26_0==33||(LA26_0 >= 48 && LA26_0 <= 49)||LA26_0==53) ) { |
|
5966
|
|
|
alt26=1; |
|
5967
|
|
|
} |
|
5968
|
|
|
|
|
5969
|
|
|
switch (alt26) { |
|
5970
|
|
|
case 1 : |
|
5971
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:24: timeline |
|
5972
|
|
|
{ |
|
5973
|
|
|
pushFollow(FOLLOW_timeline_in_component1383); |
|
5974
|
|
|
timeline210=timeline(); |
|
5975
|
|
|
state._fsp--; |
|
5976
|
|
|
if (state.failed) return retval; |
|
5977
|
|
|
if ( state.backtracking==0 ) stream_timeline.add(timeline210.getTree()); |
|
5978
|
|
|
} |
|
5979
|
|
|
break; |
|
5980
|
|
|
|
|
5981
|
|
|
default : |
|
5982
|
|
|
break loop26; |
|
5983
|
|
|
} |
|
5984
|
|
|
} |
|
5985
|
|
|
|
|
5986
|
|
|
char_literal211=(Token)match(input,81,FOLLOW_81_in_component1387); if (state.failed) return retval; |
|
5987
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal211); |
|
5988
|
|
|
|
|
5989
|
|
|
char_literal212=(Token)match(input,18,FOLLOW_18_in_component1389); if (state.failed) return retval; |
|
5990
|
|
|
if ( state.backtracking==0 ) stream_18.add(char_literal212); |
|
5991
|
|
|
|
|
5992
|
|
|
ID213=(Token)match(input,ID,FOLLOW_ID_in_component1391); if (state.failed) return retval; |
|
5993
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID213); |
|
5994
|
|
|
|
|
5995
|
|
|
char_literal214=(Token)match(input,19,FOLLOW_19_in_component1393); if (state.failed) return retval; |
|
5996
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal214); |
|
5997
|
|
|
|
|
5998
|
|
|
// AST REWRITE |
|
5999
|
|
|
// elements: ID, timeline, ID |
|
6000
|
|
|
// token labels: |
|
6001
|
|
|
// rule labels: retval |
|
6002
|
|
|
// token list labels: |
|
6003
|
|
|
// rule list labels: |
|
6004
|
|
|
// wildcard labels: |
|
6005
|
|
|
if ( state.backtracking==0 ) { |
|
6006
|
|
|
retval.tree = root_0; |
|
6007
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6008
|
|
|
|
|
6009
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6010
|
|
|
// 133:49: -> ^( ID ID ( timeline )* ) |
|
6011
|
|
|
{ |
|
6012
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:51: ^( ID ID ( timeline )* ) |
|
6013
|
|
|
{ |
|
6014
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6015
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLComponent(stream_ID.nextToken()), root_1); |
|
6016
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6017
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:133:73: ( timeline )* |
|
6018
|
|
|
while ( stream_timeline.hasNext() ) { |
|
6019
|
|
|
adaptor.addChild(root_1, stream_timeline.nextTree()); |
|
6020
|
|
|
} |
|
6021
|
|
|
stream_timeline.reset(); |
|
6022
|
|
|
|
|
6023
|
|
|
adaptor.addChild(root_0, root_1); |
|
6024
|
|
|
} |
|
6025
|
|
|
|
|
6026
|
|
|
} |
|
6027
|
|
|
|
|
6028
|
|
|
|
|
6029
|
|
|
retval.tree = root_0; |
|
6030
|
|
|
} |
|
6031
|
|
|
|
|
6032
|
|
|
} |
|
6033
|
|
|
|
|
6034
|
|
|
retval.stop = input.LT(-1); |
|
6035
|
|
|
|
|
6036
|
|
|
if ( state.backtracking==0 ) { |
|
6037
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
6038
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
6039
|
|
|
} |
|
6040
|
|
|
} |
|
6041
|
|
|
catch (RecognitionException re) { |
|
6042
|
|
|
reportError(re); |
|
6043
|
|
|
recover(input,re); |
|
6044
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
6045
|
|
|
} |
|
6046
|
|
|
finally { |
|
6047
|
|
|
// do for sure before leaving |
|
6048
|
|
|
if ( state.backtracking>0 ) { memoize(input, 29, component_StartIndex); } |
|
6049
|
|
|
|
|
6050
|
|
|
} |
|
6051
|
|
|
return retval; |
|
6052
|
|
|
} |
|
6053
|
|
|
// $ANTLR end "component" |
|
6054
|
|
|
|
|
6055
|
|
|
|
|
6056
|
|
|
public static class timeline_return extends ParserRuleReturnScope { |
|
6057
|
|
|
Object tree; |
|
6058
|
|
|
@Override |
|
6059
|
|
|
public Object getTree() { return tree; } |
|
6060
|
|
|
}; |
|
6061
|
|
|
|
|
6062
|
|
|
|
|
6063
|
|
|
// $ANTLR start "timeline" |
|
6064
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:135:1: timeline : ( 'ESTA_LIGHT' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'ESTA_LIGHT' ID ( parameter )* ) | 'BOUNDED' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'BOUNDED' ID ( parameter )* ) | 'FLEXIBLE' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'FLEXIBLE' ID ( parameter )* ) | 'ESTA_LIGHT_MAX_CONSUMPTION' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'ESTA_LIGHT_MAX_CONSUMPTION' ID ( parameter )* ) ); |
|
6065
|
|
|
public final ddl3Parser.timeline_return timeline() throws RecognitionException { |
|
6066
|
|
|
ddl3Parser.timeline_return retval = new ddl3Parser.timeline_return(); |
|
6067
|
|
|
retval.start = input.LT(1); |
|
6068
|
|
|
int timeline_StartIndex = input.index(); |
|
6069
|
|
|
|
|
6070
|
|
|
Object root_0 = null; |
|
6071
|
|
|
|
|
6072
|
|
|
Token string_literal215=null; |
|
6073
|
|
|
Token ID216=null; |
|
6074
|
|
|
Token char_literal217=null; |
|
6075
|
|
|
Token char_literal219=null; |
|
6076
|
|
|
Token char_literal221=null; |
|
6077
|
|
|
Token string_literal222=null; |
|
6078
|
|
|
Token ID223=null; |
|
6079
|
|
|
Token char_literal224=null; |
|
6080
|
|
|
Token char_literal226=null; |
|
6081
|
|
|
Token char_literal228=null; |
|
6082
|
|
|
Token string_literal229=null; |
|
6083
|
|
|
Token ID230=null; |
|
6084
|
|
|
Token char_literal231=null; |
|
6085
|
|
|
Token char_literal233=null; |
|
6086
|
|
|
Token char_literal235=null; |
|
6087
|
|
|
Token string_literal236=null; |
|
6088
|
|
|
Token ID237=null; |
|
6089
|
|
|
Token char_literal238=null; |
|
6090
|
|
|
Token char_literal240=null; |
|
6091
|
|
|
Token char_literal242=null; |
|
6092
|
|
|
ParserRuleReturnScope parameter218 =null; |
|
6093
|
|
|
ParserRuleReturnScope parameter220 =null; |
|
6094
|
|
|
ParserRuleReturnScope parameter225 =null; |
|
6095
|
|
|
ParserRuleReturnScope parameter227 =null; |
|
6096
|
|
|
ParserRuleReturnScope parameter232 =null; |
|
6097
|
|
|
ParserRuleReturnScope parameter234 =null; |
|
6098
|
|
|
ParserRuleReturnScope parameter239 =null; |
|
6099
|
|
|
ParserRuleReturnScope parameter241 =null; |
|
6100
|
|
|
|
|
6101
|
|
|
Object string_literal215_tree=null; |
|
6102
|
|
|
Object ID216_tree=null; |
|
6103
|
|
|
Object char_literal217_tree=null; |
|
6104
|
|
|
Object char_literal219_tree=null; |
|
6105
|
|
|
Object char_literal221_tree=null; |
|
6106
|
|
|
Object string_literal222_tree=null; |
|
6107
|
|
|
Object ID223_tree=null; |
|
6108
|
|
|
Object char_literal224_tree=null; |
|
6109
|
|
|
Object char_literal226_tree=null; |
|
6110
|
|
|
Object char_literal228_tree=null; |
|
6111
|
|
|
Object string_literal229_tree=null; |
|
6112
|
|
|
Object ID230_tree=null; |
|
6113
|
|
|
Object char_literal231_tree=null; |
|
6114
|
|
|
Object char_literal233_tree=null; |
|
6115
|
|
|
Object char_literal235_tree=null; |
|
6116
|
|
|
Object string_literal236_tree=null; |
|
6117
|
|
|
Object ID237_tree=null; |
|
6118
|
|
|
Object char_literal238_tree=null; |
|
6119
|
|
|
Object char_literal240_tree=null; |
|
6120
|
|
|
Object char_literal242_tree=null; |
|
6121
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
6122
|
|
|
RewriteRuleTokenStream stream_33=new RewriteRuleTokenStream(adaptor,"token 33"); |
|
6123
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
6124
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
6125
|
|
|
RewriteRuleTokenStream stream_48=new RewriteRuleTokenStream(adaptor,"token 48"); |
|
6126
|
|
|
RewriteRuleTokenStream stream_49=new RewriteRuleTokenStream(adaptor,"token 49"); |
|
6127
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
6128
|
|
|
RewriteRuleTokenStream stream_53=new RewriteRuleTokenStream(adaptor,"token 53"); |
|
6129
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
6130
|
|
|
|
|
6131
|
|
|
try { |
|
6132
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return retval; } |
|
6133
|
|
|
|
|
6134
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:2: ( 'ESTA_LIGHT' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'ESTA_LIGHT' ID ( parameter )* ) | 'BOUNDED' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'BOUNDED' ID ( parameter )* ) | 'FLEXIBLE' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'FLEXIBLE' ID ( parameter )* ) | 'ESTA_LIGHT_MAX_CONSUMPTION' ID '(' ( parameter ( ',' parameter )* )? ')' -> ^( 'ESTA_LIGHT_MAX_CONSUMPTION' ID ( parameter )* ) ) |
|
6135
|
|
|
int alt35=4; |
|
6136
|
|
View Code Duplication |
switch ( input.LA(1) ) { |
|
|
|
|
|
|
6137
|
|
|
case 48: |
|
6138
|
|
|
{ |
|
6139
|
|
|
alt35=1; |
|
6140
|
|
|
} |
|
6141
|
|
|
break; |
|
6142
|
|
|
case 33: |
|
6143
|
|
|
{ |
|
6144
|
|
|
alt35=2; |
|
6145
|
|
|
} |
|
6146
|
|
|
break; |
|
6147
|
|
|
case 53: |
|
6148
|
|
|
{ |
|
6149
|
|
|
alt35=3; |
|
6150
|
|
|
} |
|
6151
|
|
|
break; |
|
6152
|
|
|
case 49: |
|
6153
|
|
|
{ |
|
6154
|
|
|
alt35=4; |
|
6155
|
|
|
} |
|
6156
|
|
|
break; |
|
6157
|
|
|
default: |
|
6158
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
6159
|
|
|
NoViableAltException nvae = |
|
6160
|
|
|
new NoViableAltException("", 35, 0, input); |
|
6161
|
|
|
throw nvae; |
|
6162
|
|
|
} |
|
6163
|
|
|
switch (alt35) { |
|
6164
|
|
|
case 1 : |
|
6165
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:4: 'ESTA_LIGHT' ID '(' ( parameter ( ',' parameter )* )? ')' |
|
6166
|
|
|
{ |
|
6167
|
|
|
string_literal215=(Token)match(input,48,FOLLOW_48_in_timeline1416); if (state.failed) return retval; |
|
6168
|
|
|
if ( state.backtracking==0 ) stream_48.add(string_literal215); |
|
6169
|
|
|
|
|
6170
|
|
|
ID216=(Token)match(input,ID,FOLLOW_ID_in_timeline1418); if (state.failed) return retval; |
|
6171
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID216); |
|
6172
|
|
|
|
|
6173
|
|
|
char_literal217=(Token)match(input,11,FOLLOW_11_in_timeline1420); if (state.failed) return retval; |
|
6174
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal217); |
|
6175
|
|
|
|
|
6176
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:24: ( parameter ( ',' parameter )* )? |
|
6177
|
|
|
int alt28=2; |
|
6178
|
|
|
int LA28_0 = input.LA(1); |
|
6179
|
|
|
if ( (LA28_0==ID||LA28_0==9||LA28_0==25||(LA28_0 >= 78 && LA28_0 <= 79)) ) { |
|
6180
|
|
|
alt28=1; |
|
6181
|
|
|
} |
|
6182
|
|
View Code Duplication |
switch (alt28) { |
|
|
|
|
|
|
6183
|
|
|
case 1 : |
|
6184
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:25: parameter ( ',' parameter )* |
|
6185
|
|
|
{ |
|
6186
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1423); |
|
6187
|
|
|
parameter218=parameter(); |
|
6188
|
|
|
state._fsp--; |
|
6189
|
|
|
if (state.failed) return retval; |
|
6190
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter218.getTree()); |
|
6191
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:35: ( ',' parameter )* |
|
6192
|
|
|
loop27: |
|
6193
|
|
|
while (true) { |
|
6194
|
|
|
int alt27=2; |
|
6195
|
|
|
int LA27_0 = input.LA(1); |
|
6196
|
|
|
if ( (LA27_0==15) ) { |
|
6197
|
|
|
alt27=1; |
|
6198
|
|
|
} |
|
6199
|
|
|
|
|
6200
|
|
|
switch (alt27) { |
|
6201
|
|
|
case 1 : |
|
6202
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:36: ',' parameter |
|
6203
|
|
|
{ |
|
6204
|
|
|
char_literal219=(Token)match(input,15,FOLLOW_15_in_timeline1426); if (state.failed) return retval; |
|
6205
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal219); |
|
6206
|
|
|
|
|
6207
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1428); |
|
6208
|
|
|
parameter220=parameter(); |
|
6209
|
|
|
state._fsp--; |
|
6210
|
|
|
if (state.failed) return retval; |
|
6211
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter220.getTree()); |
|
6212
|
|
|
} |
|
6213
|
|
|
break; |
|
6214
|
|
|
|
|
6215
|
|
|
default : |
|
6216
|
|
|
break loop27; |
|
6217
|
|
|
} |
|
6218
|
|
|
} |
|
6219
|
|
|
|
|
6220
|
|
|
} |
|
6221
|
|
|
break; |
|
6222
|
|
|
|
|
6223
|
|
|
} |
|
6224
|
|
|
|
|
6225
|
|
|
char_literal221=(Token)match(input,12,FOLLOW_12_in_timeline1434); if (state.failed) return retval; |
|
6226
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal221); |
|
6227
|
|
|
|
|
6228
|
|
|
// AST REWRITE |
|
6229
|
|
|
// elements: parameter, 48, ID |
|
6230
|
|
|
// token labels: |
|
6231
|
|
|
// rule labels: retval |
|
6232
|
|
|
// token list labels: |
|
6233
|
|
|
// rule list labels: |
|
6234
|
|
|
// wildcard labels: |
|
6235
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
6236
|
|
|
retval.tree = root_0; |
|
6237
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6238
|
|
|
|
|
6239
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6240
|
|
|
// 136:58: -> ^( 'ESTA_LIGHT' ID ( parameter )* ) |
|
6241
|
|
|
{ |
|
6242
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:60: ^( 'ESTA_LIGHT' ID ( parameter )* ) |
|
6243
|
|
|
{ |
|
6244
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6245
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTimeline(stream_48.nextToken()), root_1); |
|
6246
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6247
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:91: ( parameter )* |
|
6248
|
|
|
while ( stream_parameter.hasNext() ) { |
|
6249
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
6250
|
|
|
} |
|
6251
|
|
|
stream_parameter.reset(); |
|
6252
|
|
|
|
|
6253
|
|
|
adaptor.addChild(root_0, root_1); |
|
6254
|
|
|
} |
|
6255
|
|
|
|
|
6256
|
|
|
} |
|
6257
|
|
|
|
|
6258
|
|
|
|
|
6259
|
|
|
retval.tree = root_0; |
|
6260
|
|
|
} |
|
6261
|
|
|
|
|
6262
|
|
|
} |
|
6263
|
|
|
break; |
|
6264
|
|
|
case 2 : |
|
6265
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:105: 'BOUNDED' ID '(' ( parameter ( ',' parameter )* )? ')' |
|
6266
|
|
|
{ |
|
6267
|
|
|
string_literal222=(Token)match(input,33,FOLLOW_33_in_timeline1451); if (state.failed) return retval; |
|
6268
|
|
|
if ( state.backtracking==0 ) stream_33.add(string_literal222); |
|
6269
|
|
|
|
|
6270
|
|
|
ID223=(Token)match(input,ID,FOLLOW_ID_in_timeline1453); if (state.failed) return retval; |
|
6271
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID223); |
|
6272
|
|
|
|
|
6273
|
|
|
char_literal224=(Token)match(input,11,FOLLOW_11_in_timeline1455); if (state.failed) return retval; |
|
6274
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal224); |
|
6275
|
|
|
|
|
6276
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:122: ( parameter ( ',' parameter )* )? |
|
6277
|
|
|
int alt30=2; |
|
6278
|
|
|
int LA30_0 = input.LA(1); |
|
6279
|
|
|
if ( (LA30_0==ID||LA30_0==9||LA30_0==25||(LA30_0 >= 78 && LA30_0 <= 79)) ) { |
|
6280
|
|
|
alt30=1; |
|
6281
|
|
|
} |
|
6282
|
|
View Code Duplication |
switch (alt30) { |
|
|
|
|
|
|
6283
|
|
|
case 1 : |
|
6284
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:123: parameter ( ',' parameter )* |
|
6285
|
|
|
{ |
|
6286
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1458); |
|
6287
|
|
|
parameter225=parameter(); |
|
6288
|
|
|
state._fsp--; |
|
6289
|
|
|
if (state.failed) return retval; |
|
6290
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter225.getTree()); |
|
6291
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:133: ( ',' parameter )* |
|
6292
|
|
|
loop29: |
|
6293
|
|
|
while (true) { |
|
6294
|
|
|
int alt29=2; |
|
6295
|
|
|
int LA29_0 = input.LA(1); |
|
6296
|
|
|
if ( (LA29_0==15) ) { |
|
6297
|
|
|
alt29=1; |
|
6298
|
|
|
} |
|
6299
|
|
|
|
|
6300
|
|
|
switch (alt29) { |
|
6301
|
|
|
case 1 : |
|
6302
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:134: ',' parameter |
|
6303
|
|
|
{ |
|
6304
|
|
|
char_literal226=(Token)match(input,15,FOLLOW_15_in_timeline1461); if (state.failed) return retval; |
|
6305
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal226); |
|
6306
|
|
|
|
|
6307
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1463); |
|
6308
|
|
|
parameter227=parameter(); |
|
6309
|
|
|
state._fsp--; |
|
6310
|
|
|
if (state.failed) return retval; |
|
6311
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter227.getTree()); |
|
6312
|
|
|
} |
|
6313
|
|
|
break; |
|
6314
|
|
|
|
|
6315
|
|
|
default : |
|
6316
|
|
|
break loop29; |
|
6317
|
|
|
} |
|
6318
|
|
|
} |
|
6319
|
|
|
|
|
6320
|
|
|
} |
|
6321
|
|
|
break; |
|
6322
|
|
|
|
|
6323
|
|
|
} |
|
6324
|
|
|
|
|
6325
|
|
|
char_literal228=(Token)match(input,12,FOLLOW_12_in_timeline1469); if (state.failed) return retval; |
|
6326
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal228); |
|
6327
|
|
|
|
|
6328
|
|
|
// AST REWRITE |
|
6329
|
|
|
// elements: 33, parameter, ID |
|
6330
|
|
|
// token labels: |
|
6331
|
|
|
// rule labels: retval |
|
6332
|
|
|
// token list labels: |
|
6333
|
|
|
// rule list labels: |
|
6334
|
|
|
// wildcard labels: |
|
6335
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
6336
|
|
|
retval.tree = root_0; |
|
6337
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6338
|
|
|
|
|
6339
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6340
|
|
|
// 136:156: -> ^( 'BOUNDED' ID ( parameter )* ) |
|
6341
|
|
|
{ |
|
6342
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:158: ^( 'BOUNDED' ID ( parameter )* ) |
|
6343
|
|
|
{ |
|
6344
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6345
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTimeline(stream_33.nextToken()), root_1); |
|
6346
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6347
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:186: ( parameter )* |
|
6348
|
|
|
while ( stream_parameter.hasNext() ) { |
|
6349
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
6350
|
|
|
} |
|
6351
|
|
|
stream_parameter.reset(); |
|
6352
|
|
|
|
|
6353
|
|
|
adaptor.addChild(root_0, root_1); |
|
6354
|
|
|
} |
|
6355
|
|
|
|
|
6356
|
|
|
} |
|
6357
|
|
|
|
|
6358
|
|
|
|
|
6359
|
|
|
retval.tree = root_0; |
|
6360
|
|
|
} |
|
6361
|
|
|
|
|
6362
|
|
|
} |
|
6363
|
|
|
break; |
|
6364
|
|
|
case 3 : |
|
6365
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:200: 'FLEXIBLE' ID '(' ( parameter ( ',' parameter )* )? ')' |
|
6366
|
|
|
{ |
|
6367
|
|
|
string_literal229=(Token)match(input,53,FOLLOW_53_in_timeline1486); if (state.failed) return retval; |
|
6368
|
|
|
if ( state.backtracking==0 ) stream_53.add(string_literal229); |
|
6369
|
|
|
|
|
6370
|
|
|
ID230=(Token)match(input,ID,FOLLOW_ID_in_timeline1488); if (state.failed) return retval; |
|
6371
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID230); |
|
6372
|
|
|
|
|
6373
|
|
|
char_literal231=(Token)match(input,11,FOLLOW_11_in_timeline1490); if (state.failed) return retval; |
|
6374
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal231); |
|
6375
|
|
|
|
|
6376
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:218: ( parameter ( ',' parameter )* )? |
|
6377
|
|
|
int alt32=2; |
|
6378
|
|
|
int LA32_0 = input.LA(1); |
|
6379
|
|
|
if ( (LA32_0==ID||LA32_0==9||LA32_0==25||(LA32_0 >= 78 && LA32_0 <= 79)) ) { |
|
6380
|
|
|
alt32=1; |
|
6381
|
|
|
} |
|
6382
|
|
View Code Duplication |
switch (alt32) { |
|
|
|
|
|
|
6383
|
|
|
case 1 : |
|
6384
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:219: parameter ( ',' parameter )* |
|
6385
|
|
|
{ |
|
6386
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1493); |
|
6387
|
|
|
parameter232=parameter(); |
|
6388
|
|
|
state._fsp--; |
|
6389
|
|
|
if (state.failed) return retval; |
|
6390
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter232.getTree()); |
|
6391
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:229: ( ',' parameter )* |
|
6392
|
|
|
loop31: |
|
6393
|
|
|
while (true) { |
|
6394
|
|
|
int alt31=2; |
|
6395
|
|
|
int LA31_0 = input.LA(1); |
|
6396
|
|
|
if ( (LA31_0==15) ) { |
|
6397
|
|
|
alt31=1; |
|
6398
|
|
|
} |
|
6399
|
|
|
|
|
6400
|
|
|
switch (alt31) { |
|
6401
|
|
|
case 1 : |
|
6402
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:230: ',' parameter |
|
6403
|
|
|
{ |
|
6404
|
|
|
char_literal233=(Token)match(input,15,FOLLOW_15_in_timeline1496); if (state.failed) return retval; |
|
6405
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal233); |
|
6406
|
|
|
|
|
6407
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1498); |
|
6408
|
|
|
parameter234=parameter(); |
|
6409
|
|
|
state._fsp--; |
|
6410
|
|
|
if (state.failed) return retval; |
|
6411
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter234.getTree()); |
|
6412
|
|
|
} |
|
6413
|
|
|
break; |
|
6414
|
|
|
|
|
6415
|
|
|
default : |
|
6416
|
|
|
break loop31; |
|
6417
|
|
|
} |
|
6418
|
|
|
} |
|
6419
|
|
|
|
|
6420
|
|
|
} |
|
6421
|
|
|
break; |
|
6422
|
|
|
|
|
6423
|
|
|
} |
|
6424
|
|
|
|
|
6425
|
|
|
char_literal235=(Token)match(input,12,FOLLOW_12_in_timeline1504); if (state.failed) return retval; |
|
6426
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal235); |
|
6427
|
|
|
|
|
6428
|
|
|
// AST REWRITE |
|
6429
|
|
|
// elements: parameter, 53, ID |
|
6430
|
|
|
// token labels: |
|
6431
|
|
|
// rule labels: retval |
|
6432
|
|
|
// token list labels: |
|
6433
|
|
|
// rule list labels: |
|
6434
|
|
|
// wildcard labels: |
|
6435
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
6436
|
|
|
retval.tree = root_0; |
|
6437
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6438
|
|
|
|
|
6439
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6440
|
|
|
// 136:252: -> ^( 'FLEXIBLE' ID ( parameter )* ) |
|
6441
|
|
|
{ |
|
6442
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:254: ^( 'FLEXIBLE' ID ( parameter )* ) |
|
6443
|
|
|
{ |
|
6444
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6445
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTimeline(stream_53.nextToken()), root_1); |
|
6446
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6447
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:283: ( parameter )* |
|
6448
|
|
|
while ( stream_parameter.hasNext() ) { |
|
6449
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
6450
|
|
|
} |
|
6451
|
|
|
stream_parameter.reset(); |
|
6452
|
|
|
|
|
6453
|
|
|
adaptor.addChild(root_0, root_1); |
|
6454
|
|
|
} |
|
6455
|
|
|
|
|
6456
|
|
|
} |
|
6457
|
|
|
|
|
6458
|
|
|
|
|
6459
|
|
|
retval.tree = root_0; |
|
6460
|
|
|
} |
|
6461
|
|
|
|
|
6462
|
|
|
} |
|
6463
|
|
|
break; |
|
6464
|
|
|
case 4 : |
|
6465
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:297: 'ESTA_LIGHT_MAX_CONSUMPTION' ID '(' ( parameter ( ',' parameter )* )? ')' |
|
6466
|
|
|
{ |
|
6467
|
|
|
string_literal236=(Token)match(input,49,FOLLOW_49_in_timeline1521); if (state.failed) return retval; |
|
6468
|
|
|
if ( state.backtracking==0 ) stream_49.add(string_literal236); |
|
6469
|
|
|
|
|
6470
|
|
|
ID237=(Token)match(input,ID,FOLLOW_ID_in_timeline1523); if (state.failed) return retval; |
|
6471
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID237); |
|
6472
|
|
|
|
|
6473
|
|
|
char_literal238=(Token)match(input,11,FOLLOW_11_in_timeline1525); if (state.failed) return retval; |
|
6474
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal238); |
|
6475
|
|
|
|
|
6476
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:333: ( parameter ( ',' parameter )* )? |
|
6477
|
|
|
int alt34=2; |
|
6478
|
|
|
int LA34_0 = input.LA(1); |
|
6479
|
|
|
if ( (LA34_0==ID||LA34_0==9||LA34_0==25||(LA34_0 >= 78 && LA34_0 <= 79)) ) { |
|
6480
|
|
|
alt34=1; |
|
6481
|
|
|
} |
|
6482
|
|
View Code Duplication |
switch (alt34) { |
|
|
|
|
|
|
6483
|
|
|
case 1 : |
|
6484
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:334: parameter ( ',' parameter )* |
|
6485
|
|
|
{ |
|
6486
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1528); |
|
6487
|
|
|
parameter239=parameter(); |
|
6488
|
|
|
state._fsp--; |
|
6489
|
|
|
if (state.failed) return retval; |
|
6490
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter239.getTree()); |
|
6491
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:344: ( ',' parameter )* |
|
6492
|
|
|
loop33: |
|
6493
|
|
|
while (true) { |
|
6494
|
|
|
int alt33=2; |
|
6495
|
|
|
int LA33_0 = input.LA(1); |
|
6496
|
|
|
if ( (LA33_0==15) ) { |
|
6497
|
|
|
alt33=1; |
|
6498
|
|
|
} |
|
6499
|
|
|
|
|
6500
|
|
|
switch (alt33) { |
|
6501
|
|
|
case 1 : |
|
6502
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:345: ',' parameter |
|
6503
|
|
|
{ |
|
6504
|
|
|
char_literal240=(Token)match(input,15,FOLLOW_15_in_timeline1531); if (state.failed) return retval; |
|
6505
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal240); |
|
6506
|
|
|
|
|
6507
|
|
|
pushFollow(FOLLOW_parameter_in_timeline1533); |
|
6508
|
|
|
parameter241=parameter(); |
|
6509
|
|
|
state._fsp--; |
|
6510
|
|
|
if (state.failed) return retval; |
|
6511
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter241.getTree()); |
|
6512
|
|
|
} |
|
6513
|
|
|
break; |
|
6514
|
|
|
|
|
6515
|
|
|
default : |
|
6516
|
|
|
break loop33; |
|
6517
|
|
|
} |
|
6518
|
|
|
} |
|
6519
|
|
|
|
|
6520
|
|
|
} |
|
6521
|
|
|
break; |
|
6522
|
|
|
|
|
6523
|
|
|
} |
|
6524
|
|
|
|
|
6525
|
|
|
char_literal242=(Token)match(input,12,FOLLOW_12_in_timeline1539); if (state.failed) return retval; |
|
6526
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal242); |
|
6527
|
|
|
|
|
6528
|
|
|
// AST REWRITE |
|
6529
|
|
|
// elements: ID, parameter, 49 |
|
6530
|
|
|
// token labels: |
|
6531
|
|
|
// rule labels: retval |
|
6532
|
|
|
// token list labels: |
|
6533
|
|
|
// rule list labels: |
|
6534
|
|
|
// wildcard labels: |
|
6535
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
6536
|
|
|
retval.tree = root_0; |
|
6537
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6538
|
|
|
|
|
6539
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6540
|
|
|
// 136:367: -> ^( 'ESTA_LIGHT_MAX_CONSUMPTION' ID ( parameter )* ) |
|
6541
|
|
|
{ |
|
6542
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:369: ^( 'ESTA_LIGHT_MAX_CONSUMPTION' ID ( parameter )* ) |
|
6543
|
|
|
{ |
|
6544
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6545
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTimeline(stream_49.nextToken()), root_1); |
|
6546
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6547
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:136:416: ( parameter )* |
|
6548
|
|
|
while ( stream_parameter.hasNext() ) { |
|
6549
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
6550
|
|
|
} |
|
6551
|
|
|
stream_parameter.reset(); |
|
6552
|
|
|
|
|
6553
|
|
|
adaptor.addChild(root_0, root_1); |
|
6554
|
|
|
} |
|
6555
|
|
|
|
|
6556
|
|
|
} |
|
6557
|
|
|
|
|
6558
|
|
|
|
|
6559
|
|
|
retval.tree = root_0; |
|
6560
|
|
|
} |
|
6561
|
|
|
|
|
6562
|
|
|
} |
|
6563
|
|
|
break; |
|
6564
|
|
|
|
|
6565
|
|
|
} |
|
6566
|
|
|
retval.stop = input.LT(-1); |
|
6567
|
|
|
|
|
6568
|
|
|
if ( state.backtracking==0 ) { |
|
6569
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
6570
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
6571
|
|
|
} |
|
6572
|
|
|
} |
|
6573
|
|
|
catch (RecognitionException re) { |
|
6574
|
|
|
reportError(re); |
|
6575
|
|
|
recover(input,re); |
|
6576
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
6577
|
|
|
} |
|
6578
|
|
|
finally { |
|
6579
|
|
|
// do for sure before leaving |
|
6580
|
|
|
if ( state.backtracking>0 ) { memoize(input, 30, timeline_StartIndex); } |
|
6581
|
|
|
|
|
6582
|
|
|
} |
|
6583
|
|
|
return retval; |
|
6584
|
|
|
} |
|
6585
|
|
|
// $ANTLR end "timeline" |
|
6586
|
|
|
|
|
6587
|
|
|
|
|
6588
|
|
|
public static class timeline_synchronization_return extends ParserRuleReturnScope { |
|
6589
|
|
|
Object tree; |
|
6590
|
|
|
@Override |
|
6591
|
|
|
public Object getTree() { return tree; } |
|
6592
|
|
|
}; |
|
6593
|
|
|
|
|
6594
|
|
|
|
|
6595
|
|
|
// $ANTLR start "timeline_synchronization" |
|
6596
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:140:1: timeline_synchronization : 'SYNCHRONIZE' ID '.' ID '{' ( synchronization )+ '}' -> ^( 'SYNCHRONIZE' ID ID ( synchronization )+ ) ; |
|
6597
|
|
|
public final ddl3Parser.timeline_synchronization_return timeline_synchronization() throws RecognitionException { |
|
6598
|
|
|
ddl3Parser.timeline_synchronization_return retval = new ddl3Parser.timeline_synchronization_return(); |
|
6599
|
|
|
retval.start = input.LT(1); |
|
6600
|
|
|
int timeline_synchronization_StartIndex = input.index(); |
|
6601
|
|
|
|
|
6602
|
|
|
Object root_0 = null; |
|
6603
|
|
|
|
|
6604
|
|
|
Token string_literal243=null; |
|
6605
|
|
|
Token ID244=null; |
|
6606
|
|
|
Token char_literal245=null; |
|
6607
|
|
|
Token ID246=null; |
|
6608
|
|
|
Token char_literal247=null; |
|
6609
|
|
|
Token char_literal249=null; |
|
6610
|
|
|
ParserRuleReturnScope synchronization248 =null; |
|
6611
|
|
|
|
|
6612
|
|
|
Object string_literal243_tree=null; |
|
6613
|
|
|
Object ID244_tree=null; |
|
6614
|
|
|
Object char_literal245_tree=null; |
|
6615
|
|
|
Object ID246_tree=null; |
|
6616
|
|
|
Object char_literal247_tree=null; |
|
6617
|
|
|
Object char_literal249_tree=null; |
|
6618
|
|
|
RewriteRuleTokenStream stream_17=new RewriteRuleTokenStream(adaptor,"token 17"); |
|
6619
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
6620
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
6621
|
|
|
RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71"); |
|
6622
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
6623
|
|
|
RewriteRuleSubtreeStream stream_synchronization=new RewriteRuleSubtreeStream(adaptor,"rule synchronization"); |
|
6624
|
|
|
|
|
6625
|
|
|
try { |
|
6626
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; } |
|
6627
|
|
|
|
|
6628
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:141:2: ( 'SYNCHRONIZE' ID '.' ID '{' ( synchronization )+ '}' -> ^( 'SYNCHRONIZE' ID ID ( synchronization )+ ) ) |
|
6629
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:141:4: 'SYNCHRONIZE' ID '.' ID '{' ( synchronization )+ '}' |
|
6630
|
|
|
{ |
|
6631
|
|
|
string_literal243=(Token)match(input,71,FOLLOW_71_in_timeline_synchronization1563); if (state.failed) return retval; |
|
6632
|
|
|
if ( state.backtracking==0 ) stream_71.add(string_literal243); |
|
6633
|
|
|
|
|
6634
|
|
|
ID244=(Token)match(input,ID,FOLLOW_ID_in_timeline_synchronization1565); if (state.failed) return retval; |
|
6635
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID244); |
|
6636
|
|
|
|
|
6637
|
|
|
char_literal245=(Token)match(input,17,FOLLOW_17_in_timeline_synchronization1567); if (state.failed) return retval; |
|
6638
|
|
|
if ( state.backtracking==0 ) stream_17.add(char_literal245); |
|
6639
|
|
|
|
|
6640
|
|
|
ID246=(Token)match(input,ID,FOLLOW_ID_in_timeline_synchronization1569); if (state.failed) return retval; |
|
6641
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID246); |
|
6642
|
|
|
|
|
6643
|
|
|
char_literal247=(Token)match(input,80,FOLLOW_80_in_timeline_synchronization1571); if (state.failed) return retval; |
|
6644
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal247); |
|
6645
|
|
|
|
|
6646
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:141:32: ( synchronization )+ |
|
6647
|
|
|
int cnt36=0; |
|
6648
|
|
|
loop36: |
|
6649
|
|
|
while (true) { |
|
6650
|
|
|
int alt36=2; |
|
6651
|
|
|
int LA36_0 = input.LA(1); |
|
6652
|
|
|
if ( (LA36_0==75) ) { |
|
6653
|
|
|
alt36=1; |
|
6654
|
|
|
} |
|
6655
|
|
|
|
|
6656
|
|
|
switch (alt36) { |
|
6657
|
|
|
case 1 : |
|
6658
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:141:33: synchronization |
|
6659
|
|
|
{ |
|
6660
|
|
|
pushFollow(FOLLOW_synchronization_in_timeline_synchronization1574); |
|
6661
|
|
|
synchronization248=synchronization(); |
|
6662
|
|
|
state._fsp--; |
|
6663
|
|
|
if (state.failed) return retval; |
|
6664
|
|
|
if ( state.backtracking==0 ) stream_synchronization.add(synchronization248.getTree()); |
|
6665
|
|
|
} |
|
6666
|
|
|
break; |
|
6667
|
|
|
|
|
6668
|
|
|
default : |
|
6669
|
|
|
if ( cnt36 >= 1 ) break loop36; |
|
6670
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
6671
|
|
|
EarlyExitException eee = new EarlyExitException(36, input); |
|
6672
|
|
|
throw eee; |
|
6673
|
|
|
} |
|
6674
|
|
|
cnt36++; |
|
6675
|
|
|
} |
|
6676
|
|
|
|
|
6677
|
|
|
char_literal249=(Token)match(input,81,FOLLOW_81_in_timeline_synchronization1578); if (state.failed) return retval; |
|
6678
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal249); |
|
6679
|
|
|
|
|
6680
|
|
|
// AST REWRITE |
|
6681
|
|
|
// elements: ID, ID, 71, synchronization |
|
6682
|
|
|
// token labels: |
|
6683
|
|
|
// rule labels: retval |
|
6684
|
|
|
// token list labels: |
|
6685
|
|
|
// rule list labels: |
|
6686
|
|
|
// wildcard labels: |
|
6687
|
|
|
if ( state.backtracking==0 ) { |
|
6688
|
|
|
retval.tree = root_0; |
|
6689
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6690
|
|
|
|
|
6691
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6692
|
|
|
// 141:55: -> ^( 'SYNCHRONIZE' ID ID ( synchronization )+ ) |
|
6693
|
|
|
{ |
|
6694
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:141:57: ^( 'SYNCHRONIZE' ID ID ( synchronization )+ ) |
|
6695
|
|
|
{ |
|
6696
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6697
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTimelineSynchronization(stream_71.nextToken()), root_1); |
|
6698
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6699
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
6700
|
|
|
if ( !(stream_synchronization.hasNext()) ) { |
|
6701
|
|
|
throw new RewriteEarlyExitException(); |
|
6702
|
|
|
} |
|
6703
|
|
|
while ( stream_synchronization.hasNext() ) { |
|
6704
|
|
|
adaptor.addChild(root_1, stream_synchronization.nextTree()); |
|
6705
|
|
|
} |
|
6706
|
|
|
stream_synchronization.reset(); |
|
6707
|
|
|
|
|
6708
|
|
|
adaptor.addChild(root_0, root_1); |
|
6709
|
|
|
} |
|
6710
|
|
|
|
|
6711
|
|
|
} |
|
6712
|
|
|
|
|
6713
|
|
|
|
|
6714
|
|
|
retval.tree = root_0; |
|
6715
|
|
|
} |
|
6716
|
|
|
|
|
6717
|
|
|
} |
|
6718
|
|
|
|
|
6719
|
|
|
retval.stop = input.LT(-1); |
|
6720
|
|
|
|
|
6721
|
|
|
if ( state.backtracking==0 ) { |
|
6722
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
6723
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
6724
|
|
|
} |
|
6725
|
|
|
} |
|
6726
|
|
|
catch (RecognitionException re) { |
|
6727
|
|
|
reportError(re); |
|
6728
|
|
|
recover(input,re); |
|
6729
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
6730
|
|
|
} |
|
6731
|
|
|
finally { |
|
6732
|
|
|
// do for sure before leaving |
|
6733
|
|
|
if ( state.backtracking>0 ) { memoize(input, 31, timeline_synchronization_StartIndex); } |
|
6734
|
|
|
|
|
6735
|
|
|
} |
|
6736
|
|
|
return retval; |
|
6737
|
|
|
} |
|
6738
|
|
|
// $ANTLR end "timeline_synchronization" |
|
6739
|
|
|
|
|
6740
|
|
|
|
|
6741
|
|
|
public static class synchronization_return extends ParserRuleReturnScope { |
|
6742
|
|
|
Object tree; |
|
6743
|
|
|
@Override |
|
6744
|
|
|
public Object getTree() { return tree; } |
|
6745
|
|
|
}; |
|
6746
|
|
|
|
|
6747
|
|
|
|
|
6748
|
|
|
// $ANTLR start "synchronization" |
|
6749
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:143:1: synchronization : 'VALUE' component_decision '{' ( synchronization_element )* '}' -> ^( 'VALUE' component_decision ( synchronization_element )* ) ; |
|
6750
|
|
|
public final ddl3Parser.synchronization_return synchronization() throws RecognitionException { |
|
6751
|
|
|
ddl3Parser.synchronization_return retval = new ddl3Parser.synchronization_return(); |
|
6752
|
|
|
retval.start = input.LT(1); |
|
6753
|
|
|
int synchronization_StartIndex = input.index(); |
|
6754
|
|
|
|
|
6755
|
|
|
Object root_0 = null; |
|
6756
|
|
|
|
|
6757
|
|
|
Token string_literal250=null; |
|
6758
|
|
|
Token char_literal252=null; |
|
6759
|
|
|
Token char_literal254=null; |
|
6760
|
|
|
ParserRuleReturnScope component_decision251 =null; |
|
6761
|
|
|
ParserRuleReturnScope synchronization_element253 =null; |
|
6762
|
|
|
|
|
6763
|
|
|
Object string_literal250_tree=null; |
|
6764
|
|
|
Object char_literal252_tree=null; |
|
6765
|
|
|
Object char_literal254_tree=null; |
|
6766
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
6767
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
6768
|
|
|
RewriteRuleTokenStream stream_75=new RewriteRuleTokenStream(adaptor,"token 75"); |
|
6769
|
|
|
RewriteRuleSubtreeStream stream_synchronization_element=new RewriteRuleSubtreeStream(adaptor,"rule synchronization_element"); |
|
6770
|
|
|
RewriteRuleSubtreeStream stream_component_decision=new RewriteRuleSubtreeStream(adaptor,"rule component_decision"); |
|
6771
|
|
|
|
|
6772
|
|
|
try { |
|
6773
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return retval; } |
|
6774
|
|
|
|
|
6775
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:2: ( 'VALUE' component_decision '{' ( synchronization_element )* '}' -> ^( 'VALUE' component_decision ( synchronization_element )* ) ) |
|
6776
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:4: 'VALUE' component_decision '{' ( synchronization_element )* '}' |
|
6777
|
|
|
{ |
|
6778
|
|
|
string_literal250=(Token)match(input,75,FOLLOW_75_in_synchronization1604); if (state.failed) return retval; |
|
6779
|
|
|
if ( state.backtracking==0 ) stream_75.add(string_literal250); |
|
6780
|
|
|
|
|
6781
|
|
|
pushFollow(FOLLOW_component_decision_in_synchronization1606); |
|
6782
|
|
|
component_decision251=component_decision(); |
|
6783
|
|
|
state._fsp--; |
|
6784
|
|
|
if (state.failed) return retval; |
|
6785
|
|
|
if ( state.backtracking==0 ) stream_component_decision.add(component_decision251.getTree()); |
|
6786
|
|
|
char_literal252=(Token)match(input,80,FOLLOW_80_in_synchronization1608); if (state.failed) return retval; |
|
6787
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal252); |
|
6788
|
|
|
|
|
6789
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:35: ( synchronization_element )* |
|
6790
|
|
|
loop37: |
|
6791
|
|
|
while (true) { |
|
6792
|
|
|
int alt37=2; |
|
6793
|
|
|
int LA37_0 = input.LA(1); |
|
6794
|
|
|
if ( ((LA37_0 >= ID && LA37_0 <= VarID)||LA37_0==14||LA37_0==16||(LA37_0 >= 26 && LA37_0 <= 27)||(LA37_0 >= 29 && LA37_0 <= 32)||(LA37_0 >= 37 && LA37_0 <= 39)||(LA37_0 >= 42 && LA37_0 <= 47)||(LA37_0 >= 51 && LA37_0 <= 52)||(LA37_0 >= 54 && LA37_0 <= 56)||(LA37_0 >= 58 && LA37_0 <= 59)||(LA37_0 >= 65 && LA37_0 <= 70)) ) { |
|
6795
|
|
|
alt37=1; |
|
6796
|
|
|
} |
|
6797
|
|
|
|
|
6798
|
|
|
switch (alt37) { |
|
6799
|
|
|
case 1 : |
|
6800
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:36: synchronization_element |
|
6801
|
|
|
{ |
|
6802
|
|
|
pushFollow(FOLLOW_synchronization_element_in_synchronization1611); |
|
6803
|
|
|
synchronization_element253=synchronization_element(); |
|
6804
|
|
|
state._fsp--; |
|
6805
|
|
|
if (state.failed) return retval; |
|
6806
|
|
|
if ( state.backtracking==0 ) stream_synchronization_element.add(synchronization_element253.getTree()); |
|
6807
|
|
|
} |
|
6808
|
|
|
break; |
|
6809
|
|
|
|
|
6810
|
|
|
default : |
|
6811
|
|
|
break loop37; |
|
6812
|
|
|
} |
|
6813
|
|
|
} |
|
6814
|
|
|
|
|
6815
|
|
|
char_literal254=(Token)match(input,81,FOLLOW_81_in_synchronization1615); if (state.failed) return retval; |
|
6816
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal254); |
|
6817
|
|
|
|
|
6818
|
|
|
// AST REWRITE |
|
6819
|
|
|
// elements: synchronization_element, 75, component_decision |
|
6820
|
|
|
// token labels: |
|
6821
|
|
|
// rule labels: retval |
|
6822
|
|
|
// token list labels: |
|
6823
|
|
|
// rule list labels: |
|
6824
|
|
|
// wildcard labels: |
|
6825
|
|
|
if ( state.backtracking==0 ) { |
|
6826
|
|
|
retval.tree = root_0; |
|
6827
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
6828
|
|
|
|
|
6829
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6830
|
|
|
// 144:66: -> ^( 'VALUE' component_decision ( synchronization_element )* ) |
|
6831
|
|
|
{ |
|
6832
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:68: ^( 'VALUE' component_decision ( synchronization_element )* ) |
|
6833
|
|
|
{ |
|
6834
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
6835
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSynchronization(stream_75.nextToken()), root_1); |
|
6836
|
|
|
adaptor.addChild(root_1, stream_component_decision.nextTree()); |
|
6837
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:144:117: ( synchronization_element )* |
|
6838
|
|
|
while ( stream_synchronization_element.hasNext() ) { |
|
6839
|
|
|
adaptor.addChild(root_1, stream_synchronization_element.nextTree()); |
|
6840
|
|
|
} |
|
6841
|
|
|
stream_synchronization_element.reset(); |
|
6842
|
|
|
|
|
6843
|
|
|
adaptor.addChild(root_0, root_1); |
|
6844
|
|
|
} |
|
6845
|
|
|
|
|
6846
|
|
|
} |
|
6847
|
|
|
|
|
6848
|
|
|
|
|
6849
|
|
|
retval.tree = root_0; |
|
6850
|
|
|
} |
|
6851
|
|
|
|
|
6852
|
|
|
} |
|
6853
|
|
|
|
|
6854
|
|
|
retval.stop = input.LT(-1); |
|
6855
|
|
|
|
|
6856
|
|
|
if ( state.backtracking==0 ) { |
|
6857
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
6858
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
6859
|
|
|
} |
|
6860
|
|
|
} |
|
6861
|
|
|
catch (RecognitionException re) { |
|
6862
|
|
|
reportError(re); |
|
6863
|
|
|
recover(input,re); |
|
6864
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
6865
|
|
|
} |
|
6866
|
|
|
finally { |
|
6867
|
|
|
// do for sure before leaving |
|
6868
|
|
|
if ( state.backtracking>0 ) { memoize(input, 32, synchronization_StartIndex); } |
|
6869
|
|
|
|
|
6870
|
|
|
} |
|
6871
|
|
|
return retval; |
|
6872
|
|
|
} |
|
6873
|
|
|
// $ANTLR end "synchronization" |
|
6874
|
|
|
|
|
6875
|
|
|
|
|
6876
|
|
|
public static class component_decision_return extends ParserRuleReturnScope { |
|
6877
|
|
|
Object tree; |
|
6878
|
|
|
@Override |
|
6879
|
|
|
public Object getTree() { return tree; } |
|
6880
|
|
|
}; |
|
6881
|
|
|
|
|
6882
|
|
|
|
|
6883
|
|
|
// $ANTLR start "component_decision" |
|
6884
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:146:1: component_decision : ( simple_ground_state_variable_component_decision | singleton_state_variable_component_decision | renewable_resource_component_decision | consumable_resource_component_decision ); |
|
6885
|
|
|
public final ddl3Parser.component_decision_return component_decision() throws RecognitionException { |
|
6886
|
|
|
ddl3Parser.component_decision_return retval = new ddl3Parser.component_decision_return(); |
|
6887
|
|
|
retval.start = input.LT(1); |
|
6888
|
|
|
int component_decision_StartIndex = input.index(); |
|
6889
|
|
|
|
|
6890
|
|
|
Object root_0 = null; |
|
6891
|
|
|
|
|
6892
|
|
|
ParserRuleReturnScope simple_ground_state_variable_component_decision255 =null; |
|
6893
|
|
|
ParserRuleReturnScope singleton_state_variable_component_decision256 =null; |
|
6894
|
|
|
ParserRuleReturnScope renewable_resource_component_decision257 =null; |
|
6895
|
|
|
ParserRuleReturnScope consumable_resource_component_decision258 =null; |
|
6896
|
|
|
|
|
6897
|
|
|
|
|
6898
|
|
|
try { |
|
6899
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return retval; } |
|
6900
|
|
|
|
|
6901
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:2: ( simple_ground_state_variable_component_decision | singleton_state_variable_component_decision | renewable_resource_component_decision | consumable_resource_component_decision ) |
|
6902
|
|
|
int alt38=4; |
|
6903
|
|
|
alt38 = dfa38.predict(input); |
|
6904
|
|
|
switch (alt38) { |
|
6905
|
|
|
case 1 : |
|
6906
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:4: simple_ground_state_variable_component_decision |
|
6907
|
|
|
{ |
|
6908
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6909
|
|
|
|
|
6910
|
|
|
|
|
6911
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_in_component_decision1639); |
|
6912
|
|
|
simple_ground_state_variable_component_decision255=simple_ground_state_variable_component_decision(); |
|
6913
|
|
|
state._fsp--; |
|
6914
|
|
|
if (state.failed) return retval; |
|
6915
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, simple_ground_state_variable_component_decision255.getTree()); |
|
6916
|
|
|
|
|
6917
|
|
|
} |
|
6918
|
|
|
break; |
|
6919
|
|
|
case 2 : |
|
6920
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:54: singleton_state_variable_component_decision |
|
6921
|
|
|
{ |
|
6922
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6923
|
|
|
|
|
6924
|
|
|
|
|
6925
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_in_component_decision1643); |
|
6926
|
|
|
singleton_state_variable_component_decision256=singleton_state_variable_component_decision(); |
|
6927
|
|
|
state._fsp--; |
|
6928
|
|
|
if (state.failed) return retval; |
|
6929
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, singleton_state_variable_component_decision256.getTree()); |
|
6930
|
|
|
|
|
6931
|
|
|
} |
|
6932
|
|
|
break; |
|
6933
|
|
|
case 3 : |
|
6934
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:100: renewable_resource_component_decision |
|
6935
|
|
|
{ |
|
6936
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6937
|
|
|
|
|
6938
|
|
|
|
|
6939
|
|
|
pushFollow(FOLLOW_renewable_resource_component_decision_in_component_decision1647); |
|
6940
|
|
|
renewable_resource_component_decision257=renewable_resource_component_decision(); |
|
6941
|
|
|
state._fsp--; |
|
6942
|
|
|
if (state.failed) return retval; |
|
6943
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, renewable_resource_component_decision257.getTree()); |
|
6944
|
|
|
|
|
6945
|
|
|
} |
|
6946
|
|
|
break; |
|
6947
|
|
|
case 4 : |
|
6948
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:140: consumable_resource_component_decision |
|
6949
|
|
|
{ |
|
6950
|
|
|
root_0 = (Object)adaptor.nil(); |
|
6951
|
|
|
|
|
6952
|
|
|
|
|
6953
|
|
|
pushFollow(FOLLOW_consumable_resource_component_decision_in_component_decision1651); |
|
6954
|
|
|
consumable_resource_component_decision258=consumable_resource_component_decision(); |
|
6955
|
|
|
state._fsp--; |
|
6956
|
|
|
if (state.failed) return retval; |
|
6957
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, consumable_resource_component_decision258.getTree()); |
|
6958
|
|
|
|
|
6959
|
|
|
} |
|
6960
|
|
|
break; |
|
6961
|
|
|
|
|
6962
|
|
|
} |
|
6963
|
|
|
retval.stop = input.LT(-1); |
|
6964
|
|
|
|
|
6965
|
|
|
if ( state.backtracking==0 ) { |
|
6966
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
6967
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
6968
|
|
|
} |
|
6969
|
|
|
} |
|
6970
|
|
|
catch (RecognitionException re) { |
|
6971
|
|
|
reportError(re); |
|
6972
|
|
|
recover(input,re); |
|
6973
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
6974
|
|
|
} |
|
6975
|
|
|
finally { |
|
6976
|
|
|
// do for sure before leaving |
|
6977
|
|
|
if ( state.backtracking>0 ) { memoize(input, 33, component_decision_StartIndex); } |
|
6978
|
|
|
|
|
6979
|
|
|
} |
|
6980
|
|
|
return retval; |
|
6981
|
|
|
} |
|
6982
|
|
|
// $ANTLR end "component_decision" |
|
6983
|
|
|
|
|
6984
|
|
|
|
|
6985
|
|
|
public static class instantiated_component_decision_return extends ParserRuleReturnScope { |
|
6986
|
|
|
Object tree; |
|
6987
|
|
|
@Override |
|
6988
|
|
|
public Object getTree() { return tree; } |
|
6989
|
|
|
}; |
|
6990
|
|
|
|
|
6991
|
|
|
|
|
6992
|
|
|
// $ANTLR start "instantiated_component_decision" |
|
6993
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:149:1: instantiated_component_decision : ID ( '<' parameter ( ',' parameter )* '>' )? ID '.' ID '.' component_decision ( 'AT' range range range )? -> ^( ID ID ID component_decision ( parameter )* ( range range range )? ) ; |
|
6994
|
|
|
public final ddl3Parser.instantiated_component_decision_return instantiated_component_decision() throws RecognitionException { |
|
6995
|
|
|
ddl3Parser.instantiated_component_decision_return retval = new ddl3Parser.instantiated_component_decision_return(); |
|
6996
|
|
|
retval.start = input.LT(1); |
|
6997
|
|
|
int instantiated_component_decision_StartIndex = input.index(); |
|
6998
|
|
|
|
|
6999
|
|
|
Object root_0 = null; |
|
7000
|
|
|
|
|
7001
|
|
|
Token ID259=null; |
|
7002
|
|
|
Token char_literal260=null; |
|
7003
|
|
|
Token char_literal262=null; |
|
7004
|
|
|
Token char_literal264=null; |
|
7005
|
|
|
Token ID265=null; |
|
7006
|
|
|
Token char_literal266=null; |
|
7007
|
|
|
Token ID267=null; |
|
7008
|
|
|
Token char_literal268=null; |
|
7009
|
|
|
Token string_literal270=null; |
|
7010
|
|
|
ParserRuleReturnScope parameter261 =null; |
|
7011
|
|
|
ParserRuleReturnScope parameter263 =null; |
|
7012
|
|
|
ParserRuleReturnScope component_decision269 =null; |
|
7013
|
|
|
ParserRuleReturnScope range271 =null; |
|
7014
|
|
|
ParserRuleReturnScope range272 =null; |
|
7015
|
|
|
ParserRuleReturnScope range273 =null; |
|
7016
|
|
|
|
|
7017
|
|
|
Object ID259_tree=null; |
|
7018
|
|
|
Object char_literal260_tree=null; |
|
7019
|
|
|
Object char_literal262_tree=null; |
|
7020
|
|
|
Object char_literal264_tree=null; |
|
7021
|
|
|
Object ID265_tree=null; |
|
7022
|
|
|
Object char_literal266_tree=null; |
|
7023
|
|
|
Object ID267_tree=null; |
|
7024
|
|
|
Object char_literal268_tree=null; |
|
7025
|
|
|
Object string_literal270_tree=null; |
|
7026
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
7027
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
7028
|
|
|
RewriteRuleTokenStream stream_17=new RewriteRuleTokenStream(adaptor,"token 17"); |
|
7029
|
|
|
RewriteRuleTokenStream stream_28=new RewriteRuleTokenStream(adaptor,"token 28"); |
|
7030
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
7031
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
7032
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
7033
|
|
|
RewriteRuleSubtreeStream stream_range=new RewriteRuleSubtreeStream(adaptor,"rule range"); |
|
7034
|
|
|
RewriteRuleSubtreeStream stream_component_decision=new RewriteRuleSubtreeStream(adaptor,"rule component_decision"); |
|
7035
|
|
|
|
|
7036
|
|
|
try { |
|
7037
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return retval; } |
|
7038
|
|
|
|
|
7039
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:2: ( ID ( '<' parameter ( ',' parameter )* '>' )? ID '.' ID '.' component_decision ( 'AT' range range range )? -> ^( ID ID ID component_decision ( parameter )* ( range range range )? ) ) |
|
7040
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:4: ID ( '<' parameter ( ',' parameter )* '>' )? ID '.' ID '.' component_decision ( 'AT' range range range )? |
|
7041
|
|
|
{ |
|
7042
|
|
|
ID259=(Token)match(input,ID,FOLLOW_ID_in_instantiated_component_decision1660); if (state.failed) return retval; |
|
7043
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID259); |
|
7044
|
|
|
|
|
7045
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:7: ( '<' parameter ( ',' parameter )* '>' )? |
|
7046
|
|
|
int alt40=2; |
|
7047
|
|
|
int LA40_0 = input.LA(1); |
|
7048
|
|
|
if ( (LA40_0==20) ) { |
|
7049
|
|
|
alt40=1; |
|
7050
|
|
|
} |
|
7051
|
|
|
switch (alt40) { |
|
7052
|
|
|
case 1 : |
|
7053
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:8: '<' parameter ( ',' parameter )* '>' |
|
7054
|
|
|
{ |
|
7055
|
|
|
char_literal260=(Token)match(input,20,FOLLOW_20_in_instantiated_component_decision1663); if (state.failed) return retval; |
|
7056
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal260); |
|
7057
|
|
|
|
|
7058
|
|
|
pushFollow(FOLLOW_parameter_in_instantiated_component_decision1665); |
|
7059
|
|
|
parameter261=parameter(); |
|
7060
|
|
|
state._fsp--; |
|
7061
|
|
|
if (state.failed) return retval; |
|
7062
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter261.getTree()); |
|
7063
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:22: ( ',' parameter )* |
|
7064
|
|
|
loop39: |
|
7065
|
|
|
while (true) { |
|
7066
|
|
|
int alt39=2; |
|
7067
|
|
|
int LA39_0 = input.LA(1); |
|
7068
|
|
|
if ( (LA39_0==15) ) { |
|
7069
|
|
|
alt39=1; |
|
7070
|
|
|
} |
|
7071
|
|
|
|
|
7072
|
|
|
switch (alt39) { |
|
7073
|
|
|
case 1 : |
|
7074
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:23: ',' parameter |
|
7075
|
|
|
{ |
|
7076
|
|
|
char_literal262=(Token)match(input,15,FOLLOW_15_in_instantiated_component_decision1668); if (state.failed) return retval; |
|
7077
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal262); |
|
7078
|
|
|
|
|
7079
|
|
|
pushFollow(FOLLOW_parameter_in_instantiated_component_decision1670); |
|
7080
|
|
|
parameter263=parameter(); |
|
7081
|
|
|
state._fsp--; |
|
7082
|
|
|
if (state.failed) return retval; |
|
7083
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter263.getTree()); |
|
7084
|
|
|
} |
|
7085
|
|
|
break; |
|
7086
|
|
|
|
|
7087
|
|
|
default : |
|
7088
|
|
|
break loop39; |
|
7089
|
|
|
} |
|
7090
|
|
|
} |
|
7091
|
|
|
|
|
7092
|
|
|
char_literal264=(Token)match(input,23,FOLLOW_23_in_instantiated_component_decision1674); if (state.failed) return retval; |
|
7093
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal264); |
|
7094
|
|
|
|
|
7095
|
|
|
} |
|
7096
|
|
|
break; |
|
7097
|
|
|
|
|
7098
|
|
|
} |
|
7099
|
|
|
|
|
7100
|
|
|
ID265=(Token)match(input,ID,FOLLOW_ID_in_instantiated_component_decision1678); if (state.failed) return retval; |
|
7101
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID265); |
|
7102
|
|
|
|
|
7103
|
|
|
char_literal266=(Token)match(input,17,FOLLOW_17_in_instantiated_component_decision1680); if (state.failed) return retval; |
|
7104
|
|
|
if ( state.backtracking==0 ) stream_17.add(char_literal266); |
|
7105
|
|
|
|
|
7106
|
|
|
ID267=(Token)match(input,ID,FOLLOW_ID_in_instantiated_component_decision1682); if (state.failed) return retval; |
|
7107
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID267); |
|
7108
|
|
|
|
|
7109
|
|
|
char_literal268=(Token)match(input,17,FOLLOW_17_in_instantiated_component_decision1684); if (state.failed) return retval; |
|
7110
|
|
|
if ( state.backtracking==0 ) stream_17.add(char_literal268); |
|
7111
|
|
|
|
|
7112
|
|
|
pushFollow(FOLLOW_component_decision_in_instantiated_component_decision1686); |
|
7113
|
|
|
component_decision269=component_decision(); |
|
7114
|
|
|
state._fsp--; |
|
7115
|
|
|
if (state.failed) return retval; |
|
7116
|
|
|
if ( state.backtracking==0 ) stream_component_decision.add(component_decision269.getTree()); |
|
7117
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:78: ( 'AT' range range range )? |
|
7118
|
|
|
int alt41=2; |
|
7119
|
|
|
int LA41_0 = input.LA(1); |
|
7120
|
|
|
if ( (LA41_0==28) ) { |
|
7121
|
|
|
alt41=1; |
|
7122
|
|
|
} |
|
7123
|
|
|
switch (alt41) { |
|
7124
|
|
|
case 1 : |
|
7125
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:79: 'AT' range range range |
|
7126
|
|
|
{ |
|
7127
|
|
|
string_literal270=(Token)match(input,28,FOLLOW_28_in_instantiated_component_decision1689); if (state.failed) return retval; |
|
7128
|
|
|
if ( state.backtracking==0 ) stream_28.add(string_literal270); |
|
7129
|
|
|
|
|
7130
|
|
|
pushFollow(FOLLOW_range_in_instantiated_component_decision1691); |
|
7131
|
|
|
range271=range(); |
|
7132
|
|
|
state._fsp--; |
|
7133
|
|
|
if (state.failed) return retval; |
|
7134
|
|
|
if ( state.backtracking==0 ) stream_range.add(range271.getTree()); |
|
7135
|
|
|
pushFollow(FOLLOW_range_in_instantiated_component_decision1693); |
|
7136
|
|
|
range272=range(); |
|
7137
|
|
|
state._fsp--; |
|
7138
|
|
|
if (state.failed) return retval; |
|
7139
|
|
|
if ( state.backtracking==0 ) stream_range.add(range272.getTree()); |
|
7140
|
|
|
pushFollow(FOLLOW_range_in_instantiated_component_decision1695); |
|
7141
|
|
|
range273=range(); |
|
7142
|
|
|
state._fsp--; |
|
7143
|
|
|
if (state.failed) return retval; |
|
7144
|
|
|
if ( state.backtracking==0 ) stream_range.add(range273.getTree()); |
|
7145
|
|
|
} |
|
7146
|
|
|
break; |
|
7147
|
|
|
|
|
7148
|
|
|
} |
|
7149
|
|
|
|
|
7150
|
|
|
// AST REWRITE |
|
7151
|
|
|
// elements: range, component_decision, ID, ID, parameter, range, ID, range |
|
7152
|
|
|
// token labels: |
|
7153
|
|
|
// rule labels: retval |
|
7154
|
|
|
// token list labels: |
|
7155
|
|
|
// rule list labels: |
|
7156
|
|
|
// wildcard labels: |
|
7157
|
|
|
if ( state.backtracking==0 ) { |
|
7158
|
|
|
retval.tree = root_0; |
|
7159
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
7160
|
|
|
|
|
7161
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7162
|
|
|
// 150:104: -> ^( ID ID ID component_decision ( parameter )* ( range range range )? ) |
|
7163
|
|
|
{ |
|
7164
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:106: ^( ID ID ID component_decision ( parameter )* ( range range range )? ) |
|
7165
|
|
|
{ |
|
7166
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
7167
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLInstantiatedComponentDecision(stream_ID.nextToken()), root_1); |
|
7168
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
7169
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
7170
|
|
|
adaptor.addChild(root_1, stream_component_decision.nextTree()); |
|
7171
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:170: ( parameter )* |
|
7172
|
|
|
while ( stream_parameter.hasNext() ) { |
|
7173
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
7174
|
|
|
} |
|
7175
|
|
|
stream_parameter.reset(); |
|
7176
|
|
|
|
|
7177
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:150:183: ( range range range )? |
|
7178
|
|
|
if ( stream_range.hasNext()||stream_range.hasNext()||stream_range.hasNext() ) { |
|
7179
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
7180
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
7181
|
|
|
adaptor.addChild(root_1, stream_range.nextTree()); |
|
7182
|
|
|
} |
|
7183
|
|
|
stream_range.reset(); |
|
7184
|
|
|
stream_range.reset(); |
|
7185
|
|
|
stream_range.reset(); |
|
7186
|
|
|
|
|
7187
|
|
|
adaptor.addChild(root_0, root_1); |
|
7188
|
|
|
} |
|
7189
|
|
|
|
|
7190
|
|
|
} |
|
7191
|
|
|
|
|
7192
|
|
|
|
|
7193
|
|
|
retval.tree = root_0; |
|
7194
|
|
|
} |
|
7195
|
|
|
|
|
7196
|
|
|
} |
|
7197
|
|
|
|
|
7198
|
|
|
retval.stop = input.LT(-1); |
|
7199
|
|
|
|
|
7200
|
|
|
if ( state.backtracking==0 ) { |
|
7201
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7202
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7203
|
|
|
} |
|
7204
|
|
|
} |
|
7205
|
|
|
catch (RecognitionException re) { |
|
7206
|
|
|
reportError(re); |
|
7207
|
|
|
recover(input,re); |
|
7208
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7209
|
|
|
} |
|
7210
|
|
|
finally { |
|
7211
|
|
|
// do for sure before leaving |
|
7212
|
|
|
if ( state.backtracking>0 ) { memoize(input, 34, instantiated_component_decision_StartIndex); } |
|
7213
|
|
|
|
|
7214
|
|
|
} |
|
7215
|
|
|
return retval; |
|
7216
|
|
|
} |
|
7217
|
|
|
// $ANTLR end "instantiated_component_decision" |
|
7218
|
|
|
|
|
7219
|
|
|
|
|
7220
|
|
|
public static class parameter_return extends ParserRuleReturnScope { |
|
7221
|
|
|
Object tree; |
|
7222
|
|
|
@Override |
|
7223
|
|
|
public Object getTree() { return tree; } |
|
7224
|
|
|
}; |
|
7225
|
|
|
|
|
7226
|
|
|
|
|
7227
|
|
|
// $ANTLR start "parameter" |
|
7228
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:152:1: parameter : ( ID | '!' | '?' | 'c' | 'u' ); |
|
7229
|
|
View Code Duplication |
public final ddl3Parser.parameter_return parameter() throws RecognitionException { |
|
|
|
|
|
|
7230
|
|
|
ddl3Parser.parameter_return retval = new ddl3Parser.parameter_return(); |
|
7231
|
|
|
retval.start = input.LT(1); |
|
7232
|
|
|
int parameter_StartIndex = input.index(); |
|
7233
|
|
|
|
|
7234
|
|
|
Object root_0 = null; |
|
7235
|
|
|
|
|
7236
|
|
|
Token set274=null; |
|
7237
|
|
|
|
|
7238
|
|
|
Object set274_tree=null; |
|
7239
|
|
|
|
|
7240
|
|
|
try { |
|
7241
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return retval; } |
|
7242
|
|
|
|
|
7243
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:153:2: ( ID | '!' | '?' | 'c' | 'u' ) |
|
7244
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g: |
|
7245
|
|
|
{ |
|
7246
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7247
|
|
|
|
|
7248
|
|
|
|
|
7249
|
|
|
set274=input.LT(1); |
|
7250
|
|
|
if ( input.LA(1)==ID||input.LA(1)==9||input.LA(1)==25||(input.LA(1) >= 78 && input.LA(1) <= 79) ) { |
|
7251
|
|
|
input.consume(); |
|
7252
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set274)); |
|
7253
|
|
|
state.errorRecovery=false; |
|
7254
|
|
|
state.failed=false; |
|
7255
|
|
|
} |
|
7256
|
|
|
else { |
|
7257
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
7258
|
|
|
MismatchedSetException mse = new MismatchedSetException(null,input); |
|
7259
|
|
|
throw mse; |
|
7260
|
|
|
} |
|
7261
|
|
|
} |
|
7262
|
|
|
|
|
7263
|
|
|
retval.stop = input.LT(-1); |
|
7264
|
|
|
|
|
7265
|
|
|
if ( state.backtracking==0 ) { |
|
7266
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7267
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7268
|
|
|
} |
|
7269
|
|
|
} |
|
7270
|
|
|
catch (RecognitionException re) { |
|
7271
|
|
|
reportError(re); |
|
7272
|
|
|
recover(input,re); |
|
7273
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7274
|
|
|
} |
|
7275
|
|
|
finally { |
|
7276
|
|
|
// do for sure before leaving |
|
7277
|
|
|
if ( state.backtracking>0 ) { memoize(input, 35, parameter_StartIndex); } |
|
7278
|
|
|
|
|
7279
|
|
|
} |
|
7280
|
|
|
return retval; |
|
7281
|
|
|
} |
|
7282
|
|
|
// $ANTLR end "parameter" |
|
7283
|
|
|
|
|
7284
|
|
|
|
|
7285
|
|
|
public static class simple_ground_state_variable_component_decision_return extends ParserRuleReturnScope { |
|
7286
|
|
|
Object tree; |
|
7287
|
|
|
@Override |
|
7288
|
|
|
public Object getTree() { return tree; } |
|
7289
|
|
|
}; |
|
7290
|
|
|
|
|
7291
|
|
|
|
|
7292
|
|
|
// $ANTLR start "simple_ground_state_variable_component_decision" |
|
7293
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:155:1: simple_ground_state_variable_component_decision : ( '<' parameter ( ',' parameter )* '>' )? ID '(' ')' -> ^( ID ( parameter )* ) ; |
|
7294
|
|
View Code Duplication |
public final ddl3Parser.simple_ground_state_variable_component_decision_return simple_ground_state_variable_component_decision() throws RecognitionException { |
|
|
|
|
|
|
7295
|
|
|
ddl3Parser.simple_ground_state_variable_component_decision_return retval = new ddl3Parser.simple_ground_state_variable_component_decision_return(); |
|
7296
|
|
|
retval.start = input.LT(1); |
|
7297
|
|
|
int simple_ground_state_variable_component_decision_StartIndex = input.index(); |
|
7298
|
|
|
|
|
7299
|
|
|
Object root_0 = null; |
|
7300
|
|
|
|
|
7301
|
|
|
Token char_literal275=null; |
|
7302
|
|
|
Token char_literal277=null; |
|
7303
|
|
|
Token char_literal279=null; |
|
7304
|
|
|
Token ID280=null; |
|
7305
|
|
|
Token char_literal281=null; |
|
7306
|
|
|
Token char_literal282=null; |
|
7307
|
|
|
ParserRuleReturnScope parameter276 =null; |
|
7308
|
|
|
ParserRuleReturnScope parameter278 =null; |
|
7309
|
|
|
|
|
7310
|
|
|
Object char_literal275_tree=null; |
|
7311
|
|
|
Object char_literal277_tree=null; |
|
7312
|
|
|
Object char_literal279_tree=null; |
|
7313
|
|
|
Object ID280_tree=null; |
|
7314
|
|
|
Object char_literal281_tree=null; |
|
7315
|
|
|
Object char_literal282_tree=null; |
|
7316
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
7317
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
7318
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
7319
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
7320
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
7321
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
7322
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
7323
|
|
|
|
|
7324
|
|
|
try { |
|
7325
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return retval; } |
|
7326
|
|
|
|
|
7327
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:2: ( ( '<' parameter ( ',' parameter )* '>' )? ID '(' ')' -> ^( ID ( parameter )* ) ) |
|
7328
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:4: ( '<' parameter ( ',' parameter )* '>' )? ID '(' ')' |
|
7329
|
|
|
{ |
|
7330
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:4: ( '<' parameter ( ',' parameter )* '>' )? |
|
7331
|
|
|
int alt43=2; |
|
7332
|
|
|
int LA43_0 = input.LA(1); |
|
7333
|
|
|
if ( (LA43_0==20) ) { |
|
7334
|
|
|
alt43=1; |
|
7335
|
|
|
} |
|
7336
|
|
|
switch (alt43) { |
|
7337
|
|
|
case 1 : |
|
7338
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:5: '<' parameter ( ',' parameter )* '>' |
|
7339
|
|
|
{ |
|
7340
|
|
|
char_literal275=(Token)match(input,20,FOLLOW_20_in_simple_ground_state_variable_component_decision1761); if (state.failed) return retval; |
|
7341
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal275); |
|
7342
|
|
|
|
|
7343
|
|
|
pushFollow(FOLLOW_parameter_in_simple_ground_state_variable_component_decision1763); |
|
7344
|
|
|
parameter276=parameter(); |
|
7345
|
|
|
state._fsp--; |
|
7346
|
|
|
if (state.failed) return retval; |
|
7347
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter276.getTree()); |
|
7348
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:19: ( ',' parameter )* |
|
7349
|
|
|
loop42: |
|
7350
|
|
|
while (true) { |
|
7351
|
|
|
int alt42=2; |
|
7352
|
|
|
int LA42_0 = input.LA(1); |
|
7353
|
|
|
if ( (LA42_0==15) ) { |
|
7354
|
|
|
alt42=1; |
|
7355
|
|
|
} |
|
7356
|
|
|
|
|
7357
|
|
|
switch (alt42) { |
|
7358
|
|
|
case 1 : |
|
7359
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:20: ',' parameter |
|
7360
|
|
|
{ |
|
7361
|
|
|
char_literal277=(Token)match(input,15,FOLLOW_15_in_simple_ground_state_variable_component_decision1766); if (state.failed) return retval; |
|
7362
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal277); |
|
7363
|
|
|
|
|
7364
|
|
|
pushFollow(FOLLOW_parameter_in_simple_ground_state_variable_component_decision1768); |
|
7365
|
|
|
parameter278=parameter(); |
|
7366
|
|
|
state._fsp--; |
|
7367
|
|
|
if (state.failed) return retval; |
|
7368
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter278.getTree()); |
|
7369
|
|
|
} |
|
7370
|
|
|
break; |
|
7371
|
|
|
|
|
7372
|
|
|
default : |
|
7373
|
|
|
break loop42; |
|
7374
|
|
|
} |
|
7375
|
|
|
} |
|
7376
|
|
|
|
|
7377
|
|
|
char_literal279=(Token)match(input,23,FOLLOW_23_in_simple_ground_state_variable_component_decision1772); if (state.failed) return retval; |
|
7378
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal279); |
|
7379
|
|
|
|
|
7380
|
|
|
} |
|
7381
|
|
|
break; |
|
7382
|
|
|
|
|
7383
|
|
|
} |
|
7384
|
|
|
|
|
7385
|
|
|
ID280=(Token)match(input,ID,FOLLOW_ID_in_simple_ground_state_variable_component_decision1776); if (state.failed) return retval; |
|
7386
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID280); |
|
7387
|
|
|
|
|
7388
|
|
|
char_literal281=(Token)match(input,11,FOLLOW_11_in_simple_ground_state_variable_component_decision1778); if (state.failed) return retval; |
|
7389
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal281); |
|
7390
|
|
|
|
|
7391
|
|
|
char_literal282=(Token)match(input,12,FOLLOW_12_in_simple_ground_state_variable_component_decision1780); if (state.failed) return retval; |
|
7392
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal282); |
|
7393
|
|
|
|
|
7394
|
|
|
// AST REWRITE |
|
7395
|
|
|
// elements: ID, parameter |
|
7396
|
|
|
// token labels: |
|
7397
|
|
|
// rule labels: retval |
|
7398
|
|
|
// token list labels: |
|
7399
|
|
|
// rule list labels: |
|
7400
|
|
|
// wildcard labels: |
|
7401
|
|
|
if ( state.backtracking==0 ) { |
|
7402
|
|
|
retval.tree = root_0; |
|
7403
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
7404
|
|
|
|
|
7405
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7406
|
|
|
// 156:53: -> ^( ID ( parameter )* ) |
|
7407
|
|
|
{ |
|
7408
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:55: ^( ID ( parameter )* ) |
|
7409
|
|
|
{ |
|
7410
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
7411
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSimpleGroundStateVariableComponentDecision(stream_ID.nextToken()), root_1); |
|
7412
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:156:107: ( parameter )* |
|
7413
|
|
|
while ( stream_parameter.hasNext() ) { |
|
7414
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
7415
|
|
|
} |
|
7416
|
|
|
stream_parameter.reset(); |
|
7417
|
|
|
|
|
7418
|
|
|
adaptor.addChild(root_0, root_1); |
|
7419
|
|
|
} |
|
7420
|
|
|
|
|
7421
|
|
|
} |
|
7422
|
|
|
|
|
7423
|
|
|
|
|
7424
|
|
|
retval.tree = root_0; |
|
7425
|
|
|
} |
|
7426
|
|
|
|
|
7427
|
|
|
} |
|
7428
|
|
|
|
|
7429
|
|
|
retval.stop = input.LT(-1); |
|
7430
|
|
|
|
|
7431
|
|
|
if ( state.backtracking==0 ) { |
|
7432
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7433
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7434
|
|
|
} |
|
7435
|
|
|
} |
|
7436
|
|
|
catch (RecognitionException re) { |
|
7437
|
|
|
reportError(re); |
|
7438
|
|
|
recover(input,re); |
|
7439
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7440
|
|
|
} |
|
7441
|
|
|
finally { |
|
7442
|
|
|
// do for sure before leaving |
|
7443
|
|
|
if ( state.backtracking>0 ) { memoize(input, 36, simple_ground_state_variable_component_decision_StartIndex); } |
|
7444
|
|
|
|
|
7445
|
|
|
} |
|
7446
|
|
|
return retval; |
|
7447
|
|
|
} |
|
7448
|
|
|
// $ANTLR end "simple_ground_state_variable_component_decision" |
|
7449
|
|
|
|
|
7450
|
|
|
|
|
7451
|
|
|
public static class singleton_state_variable_component_decision_return extends ParserRuleReturnScope { |
|
7452
|
|
|
Object tree; |
|
7453
|
|
|
@Override |
|
7454
|
|
|
public Object getTree() { return tree; } |
|
7455
|
|
|
}; |
|
7456
|
|
|
|
|
7457
|
|
|
|
|
7458
|
|
|
// $ANTLR start "singleton_state_variable_component_decision" |
|
7459
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:158:1: singleton_state_variable_component_decision : ( '<' parameter ( ',' parameter )* '>' )? ID '(' ( par_value ( ',' par_value )* )? ')' -> ^( ID ( par_value )* '(' ( parameter )* ) ; |
|
7460
|
|
|
public final ddl3Parser.singleton_state_variable_component_decision_return singleton_state_variable_component_decision() throws RecognitionException { |
|
7461
|
|
|
ddl3Parser.singleton_state_variable_component_decision_return retval = new ddl3Parser.singleton_state_variable_component_decision_return(); |
|
7462
|
|
|
retval.start = input.LT(1); |
|
7463
|
|
|
int singleton_state_variable_component_decision_StartIndex = input.index(); |
|
7464
|
|
|
|
|
7465
|
|
|
Object root_0 = null; |
|
7466
|
|
|
|
|
7467
|
|
|
Token char_literal283=null; |
|
7468
|
|
|
Token char_literal285=null; |
|
7469
|
|
|
Token char_literal287=null; |
|
7470
|
|
|
Token ID288=null; |
|
7471
|
|
|
Token char_literal289=null; |
|
7472
|
|
|
Token char_literal291=null; |
|
7473
|
|
|
Token char_literal293=null; |
|
7474
|
|
|
ParserRuleReturnScope parameter284 =null; |
|
7475
|
|
|
ParserRuleReturnScope parameter286 =null; |
|
7476
|
|
|
ParserRuleReturnScope par_value290 =null; |
|
7477
|
|
|
ParserRuleReturnScope par_value292 =null; |
|
7478
|
|
|
|
|
7479
|
|
|
Object char_literal283_tree=null; |
|
7480
|
|
|
Object char_literal285_tree=null; |
|
7481
|
|
|
Object char_literal287_tree=null; |
|
7482
|
|
|
Object ID288_tree=null; |
|
7483
|
|
|
Object char_literal289_tree=null; |
|
7484
|
|
|
Object char_literal291_tree=null; |
|
7485
|
|
|
Object char_literal293_tree=null; |
|
7486
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
7487
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
7488
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
7489
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
7490
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
7491
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
7492
|
|
|
RewriteRuleSubtreeStream stream_par_value=new RewriteRuleSubtreeStream(adaptor,"rule par_value"); |
|
7493
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
7494
|
|
|
|
|
7495
|
|
|
try { |
|
7496
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return retval; } |
|
7497
|
|
|
|
|
7498
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:2: ( ( '<' parameter ( ',' parameter )* '>' )? ID '(' ( par_value ( ',' par_value )* )? ')' -> ^( ID ( par_value )* '(' ( parameter )* ) ) |
|
7499
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:4: ( '<' parameter ( ',' parameter )* '>' )? ID '(' ( par_value ( ',' par_value )* )? ')' |
|
7500
|
|
|
{ |
|
7501
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:4: ( '<' parameter ( ',' parameter )* '>' )? |
|
7502
|
|
|
int alt45=2; |
|
7503
|
|
|
int LA45_0 = input.LA(1); |
|
7504
|
|
|
if ( (LA45_0==20) ) { |
|
7505
|
|
|
alt45=1; |
|
7506
|
|
|
} |
|
7507
|
|
|
switch (alt45) { |
|
7508
|
|
|
case 1 : |
|
7509
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:5: '<' parameter ( ',' parameter )* '>' |
|
7510
|
|
|
{ |
|
7511
|
|
|
char_literal283=(Token)match(input,20,FOLLOW_20_in_singleton_state_variable_component_decision1802); if (state.failed) return retval; |
|
7512
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal283); |
|
7513
|
|
|
|
|
7514
|
|
|
pushFollow(FOLLOW_parameter_in_singleton_state_variable_component_decision1804); |
|
7515
|
|
|
parameter284=parameter(); |
|
7516
|
|
|
state._fsp--; |
|
7517
|
|
|
if (state.failed) return retval; |
|
7518
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter284.getTree()); |
|
7519
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:19: ( ',' parameter )* |
|
7520
|
|
|
loop44: |
|
7521
|
|
|
while (true) { |
|
7522
|
|
|
int alt44=2; |
|
7523
|
|
|
int LA44_0 = input.LA(1); |
|
7524
|
|
|
if ( (LA44_0==15) ) { |
|
7525
|
|
|
alt44=1; |
|
7526
|
|
|
} |
|
7527
|
|
|
|
|
7528
|
|
|
switch (alt44) { |
|
7529
|
|
|
case 1 : |
|
7530
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:20: ',' parameter |
|
7531
|
|
|
{ |
|
7532
|
|
|
char_literal285=(Token)match(input,15,FOLLOW_15_in_singleton_state_variable_component_decision1807); if (state.failed) return retval; |
|
7533
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal285); |
|
7534
|
|
|
|
|
7535
|
|
|
pushFollow(FOLLOW_parameter_in_singleton_state_variable_component_decision1809); |
|
7536
|
|
|
parameter286=parameter(); |
|
7537
|
|
|
state._fsp--; |
|
7538
|
|
|
if (state.failed) return retval; |
|
7539
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter286.getTree()); |
|
7540
|
|
|
} |
|
7541
|
|
|
break; |
|
7542
|
|
|
|
|
7543
|
|
|
default : |
|
7544
|
|
|
break loop44; |
|
7545
|
|
|
} |
|
7546
|
|
|
} |
|
7547
|
|
|
|
|
7548
|
|
|
char_literal287=(Token)match(input,23,FOLLOW_23_in_singleton_state_variable_component_decision1813); if (state.failed) return retval; |
|
7549
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal287); |
|
7550
|
|
|
|
|
7551
|
|
|
} |
|
7552
|
|
|
break; |
|
7553
|
|
|
|
|
7554
|
|
|
} |
|
7555
|
|
|
|
|
7556
|
|
|
ID288=(Token)match(input,ID,FOLLOW_ID_in_singleton_state_variable_component_decision1817); if (state.failed) return retval; |
|
7557
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID288); |
|
7558
|
|
|
|
|
7559
|
|
|
char_literal289=(Token)match(input,11,FOLLOW_11_in_singleton_state_variable_component_decision1819); if (state.failed) return retval; |
|
7560
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal289); |
|
7561
|
|
|
|
|
7562
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:49: ( par_value ( ',' par_value )* )? |
|
7563
|
|
|
int alt47=2; |
|
7564
|
|
|
int LA47_0 = input.LA(1); |
|
7565
|
|
|
if ( (LA47_0==VarID) ) { |
|
7566
|
|
|
alt47=1; |
|
7567
|
|
|
} |
|
7568
|
|
View Code Duplication |
switch (alt47) { |
|
|
|
|
|
|
7569
|
|
|
case 1 : |
|
7570
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:50: par_value ( ',' par_value )* |
|
7571
|
|
|
{ |
|
7572
|
|
|
pushFollow(FOLLOW_par_value_in_singleton_state_variable_component_decision1822); |
|
7573
|
|
|
par_value290=par_value(); |
|
7574
|
|
|
state._fsp--; |
|
7575
|
|
|
if (state.failed) return retval; |
|
7576
|
|
|
if ( state.backtracking==0 ) stream_par_value.add(par_value290.getTree()); |
|
7577
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:60: ( ',' par_value )* |
|
7578
|
|
|
loop46: |
|
7579
|
|
|
while (true) { |
|
7580
|
|
|
int alt46=2; |
|
7581
|
|
|
int LA46_0 = input.LA(1); |
|
7582
|
|
|
if ( (LA46_0==15) ) { |
|
7583
|
|
|
alt46=1; |
|
7584
|
|
|
} |
|
7585
|
|
|
|
|
7586
|
|
|
switch (alt46) { |
|
7587
|
|
|
case 1 : |
|
7588
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:61: ',' par_value |
|
7589
|
|
|
{ |
|
7590
|
|
|
char_literal291=(Token)match(input,15,FOLLOW_15_in_singleton_state_variable_component_decision1825); if (state.failed) return retval; |
|
7591
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal291); |
|
7592
|
|
|
|
|
7593
|
|
|
pushFollow(FOLLOW_par_value_in_singleton_state_variable_component_decision1827); |
|
7594
|
|
|
par_value292=par_value(); |
|
7595
|
|
|
state._fsp--; |
|
7596
|
|
|
if (state.failed) return retval; |
|
7597
|
|
|
if ( state.backtracking==0 ) stream_par_value.add(par_value292.getTree()); |
|
7598
|
|
|
} |
|
7599
|
|
|
break; |
|
7600
|
|
|
|
|
7601
|
|
|
default : |
|
7602
|
|
|
break loop46; |
|
7603
|
|
|
} |
|
7604
|
|
|
} |
|
7605
|
|
|
|
|
7606
|
|
|
} |
|
7607
|
|
|
break; |
|
7608
|
|
|
|
|
7609
|
|
|
} |
|
7610
|
|
|
|
|
7611
|
|
|
char_literal293=(Token)match(input,12,FOLLOW_12_in_singleton_state_variable_component_decision1833); if (state.failed) return retval; |
|
7612
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal293); |
|
7613
|
|
|
|
|
7614
|
|
|
// AST REWRITE |
|
7615
|
|
|
// elements: 11, parameter, par_value, ID |
|
7616
|
|
|
// token labels: |
|
7617
|
|
|
// rule labels: retval |
|
7618
|
|
|
// token list labels: |
|
7619
|
|
|
// rule list labels: |
|
7620
|
|
|
// wildcard labels: |
|
7621
|
|
|
if ( state.backtracking==0 ) { |
|
7622
|
|
|
retval.tree = root_0; |
|
7623
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
7624
|
|
|
|
|
7625
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7626
|
|
|
// 159:83: -> ^( ID ( par_value )* '(' ( parameter )* ) |
|
7627
|
|
|
{ |
|
7628
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:85: ^( ID ( par_value )* '(' ( parameter )* ) |
|
7629
|
|
|
{ |
|
7630
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
7631
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLSingletonStateVariableComponentDecision(stream_ID.nextToken()), root_1); |
|
7632
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:134: ( par_value )* |
|
7633
|
|
|
while ( stream_par_value.hasNext() ) { |
|
7634
|
|
|
adaptor.addChild(root_1, stream_par_value.nextTree()); |
|
7635
|
|
|
} |
|
7636
|
|
|
stream_par_value.reset(); |
|
7637
|
|
|
|
|
7638
|
|
|
adaptor.addChild(root_1, stream_11.nextNode()); |
|
7639
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:159:149: ( parameter )* |
|
7640
|
|
|
while ( stream_parameter.hasNext() ) { |
|
7641
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
7642
|
|
|
} |
|
7643
|
|
|
stream_parameter.reset(); |
|
7644
|
|
|
|
|
7645
|
|
|
adaptor.addChild(root_0, root_1); |
|
7646
|
|
|
} |
|
7647
|
|
|
|
|
7648
|
|
|
} |
|
7649
|
|
|
|
|
7650
|
|
|
|
|
7651
|
|
|
retval.tree = root_0; |
|
7652
|
|
|
} |
|
7653
|
|
|
|
|
7654
|
|
|
} |
|
7655
|
|
|
|
|
7656
|
|
|
retval.stop = input.LT(-1); |
|
7657
|
|
|
|
|
7658
|
|
|
if ( state.backtracking==0 ) { |
|
7659
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7660
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7661
|
|
|
} |
|
7662
|
|
|
} |
|
7663
|
|
|
catch (RecognitionException re) { |
|
7664
|
|
|
reportError(re); |
|
7665
|
|
|
recover(input,re); |
|
7666
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7667
|
|
|
} |
|
7668
|
|
|
finally { |
|
7669
|
|
|
// do for sure before leaving |
|
7670
|
|
|
if ( state.backtracking>0 ) { memoize(input, 37, singleton_state_variable_component_decision_StartIndex); } |
|
7671
|
|
|
|
|
7672
|
|
|
} |
|
7673
|
|
|
return retval; |
|
7674
|
|
|
} |
|
7675
|
|
|
// $ANTLR end "singleton_state_variable_component_decision" |
|
7676
|
|
|
|
|
7677
|
|
|
|
|
7678
|
|
|
public static class renewable_resource_component_decision_return extends ParserRuleReturnScope { |
|
7679
|
|
|
Object tree; |
|
7680
|
|
|
@Override |
|
7681
|
|
|
public Object getTree() { return tree; } |
|
7682
|
|
|
}; |
|
7683
|
|
|
|
|
7684
|
|
|
|
|
7685
|
|
|
// $ANTLR start "renewable_resource_component_decision" |
|
7686
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:161:1: renewable_resource_component_decision : ( '<' parameter ( ',' parameter )* '>' )? 'REQUIREMENT' '(' par_value ')' -> ^( 'REQUIREMENT' par_value ( parameter )* ) ; |
|
7687
|
|
View Code Duplication |
public final ddl3Parser.renewable_resource_component_decision_return renewable_resource_component_decision() throws RecognitionException { |
|
|
|
|
|
|
7688
|
|
|
ddl3Parser.renewable_resource_component_decision_return retval = new ddl3Parser.renewable_resource_component_decision_return(); |
|
7689
|
|
|
retval.start = input.LT(1); |
|
7690
|
|
|
int renewable_resource_component_decision_StartIndex = input.index(); |
|
7691
|
|
|
|
|
7692
|
|
|
Object root_0 = null; |
|
7693
|
|
|
|
|
7694
|
|
|
Token char_literal294=null; |
|
7695
|
|
|
Token char_literal296=null; |
|
7696
|
|
|
Token char_literal298=null; |
|
7697
|
|
|
Token string_literal299=null; |
|
7698
|
|
|
Token char_literal300=null; |
|
7699
|
|
|
Token char_literal302=null; |
|
7700
|
|
|
ParserRuleReturnScope parameter295 =null; |
|
7701
|
|
|
ParserRuleReturnScope parameter297 =null; |
|
7702
|
|
|
ParserRuleReturnScope par_value301 =null; |
|
7703
|
|
|
|
|
7704
|
|
|
Object char_literal294_tree=null; |
|
7705
|
|
|
Object char_literal296_tree=null; |
|
7706
|
|
|
Object char_literal298_tree=null; |
|
7707
|
|
|
Object string_literal299_tree=null; |
|
7708
|
|
|
Object char_literal300_tree=null; |
|
7709
|
|
|
Object char_literal302_tree=null; |
|
7710
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
7711
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
7712
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
7713
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
7714
|
|
|
RewriteRuleTokenStream stream_63=new RewriteRuleTokenStream(adaptor,"token 63"); |
|
7715
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
7716
|
|
|
RewriteRuleSubtreeStream stream_par_value=new RewriteRuleSubtreeStream(adaptor,"rule par_value"); |
|
7717
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
7718
|
|
|
|
|
7719
|
|
|
try { |
|
7720
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return retval; } |
|
7721
|
|
|
|
|
7722
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:2: ( ( '<' parameter ( ',' parameter )* '>' )? 'REQUIREMENT' '(' par_value ')' -> ^( 'REQUIREMENT' par_value ( parameter )* ) ) |
|
7723
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:4: ( '<' parameter ( ',' parameter )* '>' )? 'REQUIREMENT' '(' par_value ')' |
|
7724
|
|
|
{ |
|
7725
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:4: ( '<' parameter ( ',' parameter )* '>' )? |
|
7726
|
|
|
int alt49=2; |
|
7727
|
|
|
int LA49_0 = input.LA(1); |
|
7728
|
|
|
if ( (LA49_0==20) ) { |
|
7729
|
|
|
alt49=1; |
|
7730
|
|
|
} |
|
7731
|
|
|
switch (alt49) { |
|
7732
|
|
|
case 1 : |
|
7733
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:5: '<' parameter ( ',' parameter )* '>' |
|
7734
|
|
|
{ |
|
7735
|
|
|
char_literal294=(Token)match(input,20,FOLLOW_20_in_renewable_resource_component_decision1860); if (state.failed) return retval; |
|
7736
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal294); |
|
7737
|
|
|
|
|
7738
|
|
|
pushFollow(FOLLOW_parameter_in_renewable_resource_component_decision1862); |
|
7739
|
|
|
parameter295=parameter(); |
|
7740
|
|
|
state._fsp--; |
|
7741
|
|
|
if (state.failed) return retval; |
|
7742
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter295.getTree()); |
|
7743
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:19: ( ',' parameter )* |
|
7744
|
|
|
loop48: |
|
7745
|
|
|
while (true) { |
|
7746
|
|
|
int alt48=2; |
|
7747
|
|
|
int LA48_0 = input.LA(1); |
|
7748
|
|
|
if ( (LA48_0==15) ) { |
|
7749
|
|
|
alt48=1; |
|
7750
|
|
|
} |
|
7751
|
|
|
|
|
7752
|
|
|
switch (alt48) { |
|
7753
|
|
|
case 1 : |
|
7754
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:20: ',' parameter |
|
7755
|
|
|
{ |
|
7756
|
|
|
char_literal296=(Token)match(input,15,FOLLOW_15_in_renewable_resource_component_decision1865); if (state.failed) return retval; |
|
7757
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal296); |
|
7758
|
|
|
|
|
7759
|
|
|
pushFollow(FOLLOW_parameter_in_renewable_resource_component_decision1867); |
|
7760
|
|
|
parameter297=parameter(); |
|
7761
|
|
|
state._fsp--; |
|
7762
|
|
|
if (state.failed) return retval; |
|
7763
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter297.getTree()); |
|
7764
|
|
|
} |
|
7765
|
|
|
break; |
|
7766
|
|
|
|
|
7767
|
|
|
default : |
|
7768
|
|
|
break loop48; |
|
7769
|
|
|
} |
|
7770
|
|
|
} |
|
7771
|
|
|
|
|
7772
|
|
|
char_literal298=(Token)match(input,23,FOLLOW_23_in_renewable_resource_component_decision1871); if (state.failed) return retval; |
|
7773
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal298); |
|
7774
|
|
|
|
|
7775
|
|
|
} |
|
7776
|
|
|
break; |
|
7777
|
|
|
|
|
7778
|
|
|
} |
|
7779
|
|
|
|
|
7780
|
|
|
string_literal299=(Token)match(input,63,FOLLOW_63_in_renewable_resource_component_decision1875); if (state.failed) return retval; |
|
7781
|
|
|
if ( state.backtracking==0 ) stream_63.add(string_literal299); |
|
7782
|
|
|
|
|
7783
|
|
|
char_literal300=(Token)match(input,11,FOLLOW_11_in_renewable_resource_component_decision1877); if (state.failed) return retval; |
|
7784
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal300); |
|
7785
|
|
|
|
|
7786
|
|
|
pushFollow(FOLLOW_par_value_in_renewable_resource_component_decision1879); |
|
7787
|
|
|
par_value301=par_value(); |
|
7788
|
|
|
state._fsp--; |
|
7789
|
|
|
if (state.failed) return retval; |
|
7790
|
|
|
if ( state.backtracking==0 ) stream_par_value.add(par_value301.getTree()); |
|
7791
|
|
|
char_literal302=(Token)match(input,12,FOLLOW_12_in_renewable_resource_component_decision1881); if (state.failed) return retval; |
|
7792
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal302); |
|
7793
|
|
|
|
|
7794
|
|
|
// AST REWRITE |
|
7795
|
|
|
// elements: parameter, 63, par_value |
|
7796
|
|
|
// token labels: |
|
7797
|
|
|
// rule labels: retval |
|
7798
|
|
|
// token list labels: |
|
7799
|
|
|
// rule list labels: |
|
7800
|
|
|
// wildcard labels: |
|
7801
|
|
|
if ( state.backtracking==0 ) { |
|
7802
|
|
|
retval.tree = root_0; |
|
7803
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
7804
|
|
|
|
|
7805
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7806
|
|
|
// 162:74: -> ^( 'REQUIREMENT' par_value ( parameter )* ) |
|
7807
|
|
|
{ |
|
7808
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:76: ^( 'REQUIREMENT' par_value ( parameter )* ) |
|
7809
|
|
|
{ |
|
7810
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
7811
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLRenewableResourceComponentDecision(stream_63.nextToken()), root_1); |
|
7812
|
|
|
adaptor.addChild(root_1, stream_par_value.nextTree()); |
|
7813
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:162:141: ( parameter )* |
|
7814
|
|
|
while ( stream_parameter.hasNext() ) { |
|
7815
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
7816
|
|
|
} |
|
7817
|
|
|
stream_parameter.reset(); |
|
7818
|
|
|
|
|
7819
|
|
|
adaptor.addChild(root_0, root_1); |
|
7820
|
|
|
} |
|
7821
|
|
|
|
|
7822
|
|
|
} |
|
7823
|
|
|
|
|
7824
|
|
|
|
|
7825
|
|
|
retval.tree = root_0; |
|
7826
|
|
|
} |
|
7827
|
|
|
|
|
7828
|
|
|
} |
|
7829
|
|
|
|
|
7830
|
|
|
retval.stop = input.LT(-1); |
|
7831
|
|
|
|
|
7832
|
|
|
if ( state.backtracking==0 ) { |
|
7833
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7834
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7835
|
|
|
} |
|
7836
|
|
|
} |
|
7837
|
|
|
catch (RecognitionException re) { |
|
7838
|
|
|
reportError(re); |
|
7839
|
|
|
recover(input,re); |
|
7840
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7841
|
|
|
} |
|
7842
|
|
|
finally { |
|
7843
|
|
|
// do for sure before leaving |
|
7844
|
|
|
if ( state.backtracking>0 ) { memoize(input, 38, renewable_resource_component_decision_StartIndex); } |
|
7845
|
|
|
|
|
7846
|
|
|
} |
|
7847
|
|
|
return retval; |
|
7848
|
|
|
} |
|
7849
|
|
|
// $ANTLR end "renewable_resource_component_decision" |
|
7850
|
|
|
|
|
7851
|
|
|
|
|
7852
|
|
|
public static class consumable_resource_component_decision_return extends ParserRuleReturnScope { |
|
7853
|
|
|
Object tree; |
|
7854
|
|
|
@Override |
|
7855
|
|
|
public Object getTree() { return tree; } |
|
7856
|
|
|
}; |
|
7857
|
|
|
|
|
7858
|
|
|
|
|
7859
|
|
|
// $ANTLR start "consumable_resource_component_decision" |
|
7860
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:164:1: consumable_resource_component_decision : ( consumable_resource_production_component_decision | consumable_resource_consumption_component_decision ); |
|
7861
|
|
|
public final ddl3Parser.consumable_resource_component_decision_return consumable_resource_component_decision() throws RecognitionException { |
|
7862
|
|
|
ddl3Parser.consumable_resource_component_decision_return retval = new ddl3Parser.consumable_resource_component_decision_return(); |
|
7863
|
|
|
retval.start = input.LT(1); |
|
7864
|
|
|
int consumable_resource_component_decision_StartIndex = input.index(); |
|
7865
|
|
|
|
|
7866
|
|
|
Object root_0 = null; |
|
7867
|
|
|
|
|
7868
|
|
|
ParserRuleReturnScope consumable_resource_production_component_decision303 =null; |
|
7869
|
|
|
ParserRuleReturnScope consumable_resource_consumption_component_decision304 =null; |
|
7870
|
|
|
|
|
7871
|
|
|
|
|
7872
|
|
|
try { |
|
7873
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return retval; } |
|
7874
|
|
|
|
|
7875
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:165:2: ( consumable_resource_production_component_decision | consumable_resource_consumption_component_decision ) |
|
7876
|
|
|
int alt50=2; |
|
7877
|
|
|
alt50 = dfa50.predict(input); |
|
7878
|
|
|
switch (alt50) { |
|
7879
|
|
|
case 1 : |
|
7880
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:165:4: consumable_resource_production_component_decision |
|
7881
|
|
|
{ |
|
7882
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7883
|
|
|
|
|
7884
|
|
|
|
|
7885
|
|
|
pushFollow(FOLLOW_consumable_resource_production_component_decision_in_consumable_resource_component_decision1905); |
|
7886
|
|
|
consumable_resource_production_component_decision303=consumable_resource_production_component_decision(); |
|
7887
|
|
|
state._fsp--; |
|
7888
|
|
|
if (state.failed) return retval; |
|
7889
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, consumable_resource_production_component_decision303.getTree()); |
|
7890
|
|
|
|
|
7891
|
|
|
} |
|
7892
|
|
|
break; |
|
7893
|
|
|
case 2 : |
|
7894
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:165:56: consumable_resource_consumption_component_decision |
|
7895
|
|
|
{ |
|
7896
|
|
|
root_0 = (Object)adaptor.nil(); |
|
7897
|
|
|
|
|
7898
|
|
|
|
|
7899
|
|
|
pushFollow(FOLLOW_consumable_resource_consumption_component_decision_in_consumable_resource_component_decision1909); |
|
7900
|
|
|
consumable_resource_consumption_component_decision304=consumable_resource_consumption_component_decision(); |
|
7901
|
|
|
state._fsp--; |
|
7902
|
|
|
if (state.failed) return retval; |
|
7903
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, consumable_resource_consumption_component_decision304.getTree()); |
|
7904
|
|
|
|
|
7905
|
|
|
} |
|
7906
|
|
|
break; |
|
7907
|
|
|
|
|
7908
|
|
|
} |
|
7909
|
|
|
retval.stop = input.LT(-1); |
|
7910
|
|
|
|
|
7911
|
|
|
if ( state.backtracking==0 ) { |
|
7912
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
7913
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
7914
|
|
|
} |
|
7915
|
|
|
} |
|
7916
|
|
|
catch (RecognitionException re) { |
|
7917
|
|
|
reportError(re); |
|
7918
|
|
|
recover(input,re); |
|
7919
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
7920
|
|
|
} |
|
7921
|
|
|
finally { |
|
7922
|
|
|
// do for sure before leaving |
|
7923
|
|
|
if ( state.backtracking>0 ) { memoize(input, 39, consumable_resource_component_decision_StartIndex); } |
|
7924
|
|
|
|
|
7925
|
|
|
} |
|
7926
|
|
|
return retval; |
|
7927
|
|
|
} |
|
7928
|
|
|
// $ANTLR end "consumable_resource_component_decision" |
|
7929
|
|
|
|
|
7930
|
|
|
|
|
7931
|
|
|
public static class consumable_resource_production_component_decision_return extends ParserRuleReturnScope { |
|
7932
|
|
|
Object tree; |
|
7933
|
|
|
@Override |
|
7934
|
|
|
public Object getTree() { return tree; } |
|
7935
|
|
|
}; |
|
7936
|
|
|
|
|
7937
|
|
|
|
|
7938
|
|
|
// $ANTLR start "consumable_resource_production_component_decision" |
|
7939
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:167:1: consumable_resource_production_component_decision : ( '<' parameter ( ',' parameter )* '>' )? 'PRODUCTION' '(' par_value ')' -> ^( 'PRODUCTION' par_value ( parameter )* ) ; |
|
7940
|
|
View Code Duplication |
public final ddl3Parser.consumable_resource_production_component_decision_return consumable_resource_production_component_decision() throws RecognitionException { |
|
|
|
|
|
|
7941
|
|
|
ddl3Parser.consumable_resource_production_component_decision_return retval = new ddl3Parser.consumable_resource_production_component_decision_return(); |
|
7942
|
|
|
retval.start = input.LT(1); |
|
7943
|
|
|
int consumable_resource_production_component_decision_StartIndex = input.index(); |
|
7944
|
|
|
|
|
7945
|
|
|
Object root_0 = null; |
|
7946
|
|
|
|
|
7947
|
|
|
Token char_literal305=null; |
|
7948
|
|
|
Token char_literal307=null; |
|
7949
|
|
|
Token char_literal309=null; |
|
7950
|
|
|
Token string_literal310=null; |
|
7951
|
|
|
Token char_literal311=null; |
|
7952
|
|
|
Token char_literal313=null; |
|
7953
|
|
|
ParserRuleReturnScope parameter306 =null; |
|
7954
|
|
|
ParserRuleReturnScope parameter308 =null; |
|
7955
|
|
|
ParserRuleReturnScope par_value312 =null; |
|
7956
|
|
|
|
|
7957
|
|
|
Object char_literal305_tree=null; |
|
7958
|
|
|
Object char_literal307_tree=null; |
|
7959
|
|
|
Object char_literal309_tree=null; |
|
7960
|
|
|
Object string_literal310_tree=null; |
|
7961
|
|
|
Object char_literal311_tree=null; |
|
7962
|
|
|
Object char_literal313_tree=null; |
|
7963
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
7964
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
7965
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
7966
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
7967
|
|
|
RewriteRuleTokenStream stream_62=new RewriteRuleTokenStream(adaptor,"token 62"); |
|
7968
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
7969
|
|
|
RewriteRuleSubtreeStream stream_par_value=new RewriteRuleSubtreeStream(adaptor,"rule par_value"); |
|
7970
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
7971
|
|
|
|
|
7972
|
|
|
try { |
|
7973
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return retval; } |
|
7974
|
|
|
|
|
7975
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:2: ( ( '<' parameter ( ',' parameter )* '>' )? 'PRODUCTION' '(' par_value ')' -> ^( 'PRODUCTION' par_value ( parameter )* ) ) |
|
7976
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:4: ( '<' parameter ( ',' parameter )* '>' )? 'PRODUCTION' '(' par_value ')' |
|
7977
|
|
|
{ |
|
7978
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:4: ( '<' parameter ( ',' parameter )* '>' )? |
|
7979
|
|
|
int alt52=2; |
|
7980
|
|
|
int LA52_0 = input.LA(1); |
|
7981
|
|
|
if ( (LA52_0==20) ) { |
|
7982
|
|
|
alt52=1; |
|
7983
|
|
|
} |
|
7984
|
|
|
switch (alt52) { |
|
7985
|
|
|
case 1 : |
|
7986
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:5: '<' parameter ( ',' parameter )* '>' |
|
7987
|
|
|
{ |
|
7988
|
|
|
char_literal305=(Token)match(input,20,FOLLOW_20_in_consumable_resource_production_component_decision1921); if (state.failed) return retval; |
|
7989
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal305); |
|
7990
|
|
|
|
|
7991
|
|
|
pushFollow(FOLLOW_parameter_in_consumable_resource_production_component_decision1923); |
|
7992
|
|
|
parameter306=parameter(); |
|
7993
|
|
|
state._fsp--; |
|
7994
|
|
|
if (state.failed) return retval; |
|
7995
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter306.getTree()); |
|
7996
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:19: ( ',' parameter )* |
|
7997
|
|
|
loop51: |
|
7998
|
|
|
while (true) { |
|
7999
|
|
|
int alt51=2; |
|
8000
|
|
|
int LA51_0 = input.LA(1); |
|
8001
|
|
|
if ( (LA51_0==15) ) { |
|
8002
|
|
|
alt51=1; |
|
8003
|
|
|
} |
|
8004
|
|
|
|
|
8005
|
|
|
switch (alt51) { |
|
8006
|
|
|
case 1 : |
|
8007
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:20: ',' parameter |
|
8008
|
|
|
{ |
|
8009
|
|
|
char_literal307=(Token)match(input,15,FOLLOW_15_in_consumable_resource_production_component_decision1926); if (state.failed) return retval; |
|
8010
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal307); |
|
8011
|
|
|
|
|
8012
|
|
|
pushFollow(FOLLOW_parameter_in_consumable_resource_production_component_decision1928); |
|
8013
|
|
|
parameter308=parameter(); |
|
8014
|
|
|
state._fsp--; |
|
8015
|
|
|
if (state.failed) return retval; |
|
8016
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter308.getTree()); |
|
8017
|
|
|
} |
|
8018
|
|
|
break; |
|
8019
|
|
|
|
|
8020
|
|
|
default : |
|
8021
|
|
|
break loop51; |
|
8022
|
|
|
} |
|
8023
|
|
|
} |
|
8024
|
|
|
|
|
8025
|
|
|
char_literal309=(Token)match(input,23,FOLLOW_23_in_consumable_resource_production_component_decision1932); if (state.failed) return retval; |
|
8026
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal309); |
|
8027
|
|
|
|
|
8028
|
|
|
} |
|
8029
|
|
|
break; |
|
8030
|
|
|
|
|
8031
|
|
|
} |
|
8032
|
|
|
|
|
8033
|
|
|
string_literal310=(Token)match(input,62,FOLLOW_62_in_consumable_resource_production_component_decision1936); if (state.failed) return retval; |
|
8034
|
|
|
if ( state.backtracking==0 ) stream_62.add(string_literal310); |
|
8035
|
|
|
|
|
8036
|
|
|
char_literal311=(Token)match(input,11,FOLLOW_11_in_consumable_resource_production_component_decision1938); if (state.failed) return retval; |
|
8037
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal311); |
|
8038
|
|
|
|
|
8039
|
|
|
pushFollow(FOLLOW_par_value_in_consumable_resource_production_component_decision1940); |
|
8040
|
|
|
par_value312=par_value(); |
|
8041
|
|
|
state._fsp--; |
|
8042
|
|
|
if (state.failed) return retval; |
|
8043
|
|
|
if ( state.backtracking==0 ) stream_par_value.add(par_value312.getTree()); |
|
8044
|
|
|
char_literal313=(Token)match(input,12,FOLLOW_12_in_consumable_resource_production_component_decision1942); if (state.failed) return retval; |
|
8045
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal313); |
|
8046
|
|
|
|
|
8047
|
|
|
// AST REWRITE |
|
8048
|
|
|
// elements: parameter, 62, par_value |
|
8049
|
|
|
// token labels: |
|
8050
|
|
|
// rule labels: retval |
|
8051
|
|
|
// token list labels: |
|
8052
|
|
|
// rule list labels: |
|
8053
|
|
|
// wildcard labels: |
|
8054
|
|
|
if ( state.backtracking==0 ) { |
|
8055
|
|
|
retval.tree = root_0; |
|
8056
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8057
|
|
|
|
|
8058
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8059
|
|
|
// 168:73: -> ^( 'PRODUCTION' par_value ( parameter )* ) |
|
8060
|
|
|
{ |
|
8061
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:75: ^( 'PRODUCTION' par_value ( parameter )* ) |
|
8062
|
|
|
{ |
|
8063
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8064
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLConsumableResourceComponentDecision(stream_62.nextToken()), root_1); |
|
8065
|
|
|
adaptor.addChild(root_1, stream_par_value.nextTree()); |
|
8066
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:168:140: ( parameter )* |
|
8067
|
|
|
while ( stream_parameter.hasNext() ) { |
|
8068
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
8069
|
|
|
} |
|
8070
|
|
|
stream_parameter.reset(); |
|
8071
|
|
|
|
|
8072
|
|
|
adaptor.addChild(root_0, root_1); |
|
8073
|
|
|
} |
|
8074
|
|
|
|
|
8075
|
|
|
} |
|
8076
|
|
|
|
|
8077
|
|
|
|
|
8078
|
|
|
retval.tree = root_0; |
|
8079
|
|
|
} |
|
8080
|
|
|
|
|
8081
|
|
|
} |
|
8082
|
|
|
|
|
8083
|
|
|
retval.stop = input.LT(-1); |
|
8084
|
|
|
|
|
8085
|
|
|
if ( state.backtracking==0 ) { |
|
8086
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
8087
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
8088
|
|
|
} |
|
8089
|
|
|
} |
|
8090
|
|
|
catch (RecognitionException re) { |
|
8091
|
|
|
reportError(re); |
|
8092
|
|
|
recover(input,re); |
|
8093
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
8094
|
|
|
} |
|
8095
|
|
|
finally { |
|
8096
|
|
|
// do for sure before leaving |
|
8097
|
|
|
if ( state.backtracking>0 ) { memoize(input, 40, consumable_resource_production_component_decision_StartIndex); } |
|
8098
|
|
|
|
|
8099
|
|
|
} |
|
8100
|
|
|
return retval; |
|
8101
|
|
|
} |
|
8102
|
|
|
// $ANTLR end "consumable_resource_production_component_decision" |
|
8103
|
|
|
|
|
8104
|
|
|
|
|
8105
|
|
|
public static class consumable_resource_consumption_component_decision_return extends ParserRuleReturnScope { |
|
8106
|
|
|
Object tree; |
|
8107
|
|
|
@Override |
|
8108
|
|
|
public Object getTree() { return tree; } |
|
8109
|
|
|
}; |
|
8110
|
|
|
|
|
8111
|
|
|
|
|
8112
|
|
|
// $ANTLR start "consumable_resource_consumption_component_decision" |
|
8113
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:170:1: consumable_resource_consumption_component_decision : ( '<' parameter ( ',' parameter )* '>' )? 'CONSUMPTION' '(' par_value ')' -> ^( 'CONSUMPTION' par_value ( parameter )* ) ; |
|
8114
|
|
View Code Duplication |
public final ddl3Parser.consumable_resource_consumption_component_decision_return consumable_resource_consumption_component_decision() throws RecognitionException { |
|
|
|
|
|
|
8115
|
|
|
ddl3Parser.consumable_resource_consumption_component_decision_return retval = new ddl3Parser.consumable_resource_consumption_component_decision_return(); |
|
8116
|
|
|
retval.start = input.LT(1); |
|
8117
|
|
|
int consumable_resource_consumption_component_decision_StartIndex = input.index(); |
|
8118
|
|
|
|
|
8119
|
|
|
Object root_0 = null; |
|
8120
|
|
|
|
|
8121
|
|
|
Token char_literal314=null; |
|
8122
|
|
|
Token char_literal316=null; |
|
8123
|
|
|
Token char_literal318=null; |
|
8124
|
|
|
Token string_literal319=null; |
|
8125
|
|
|
Token char_literal320=null; |
|
8126
|
|
|
Token char_literal322=null; |
|
8127
|
|
|
ParserRuleReturnScope parameter315 =null; |
|
8128
|
|
|
ParserRuleReturnScope parameter317 =null; |
|
8129
|
|
|
ParserRuleReturnScope par_value321 =null; |
|
8130
|
|
|
|
|
8131
|
|
|
Object char_literal314_tree=null; |
|
8132
|
|
|
Object char_literal316_tree=null; |
|
8133
|
|
|
Object char_literal318_tree=null; |
|
8134
|
|
|
Object string_literal319_tree=null; |
|
8135
|
|
|
Object char_literal320_tree=null; |
|
8136
|
|
|
Object char_literal322_tree=null; |
|
8137
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
8138
|
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23"); |
|
8139
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
8140
|
|
|
RewriteRuleTokenStream stream_36=new RewriteRuleTokenStream(adaptor,"token 36"); |
|
8141
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
8142
|
|
|
RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20"); |
|
8143
|
|
|
RewriteRuleSubtreeStream stream_par_value=new RewriteRuleSubtreeStream(adaptor,"rule par_value"); |
|
8144
|
|
|
RewriteRuleSubtreeStream stream_parameter=new RewriteRuleSubtreeStream(adaptor,"rule parameter"); |
|
8145
|
|
|
|
|
8146
|
|
|
try { |
|
8147
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return retval; } |
|
8148
|
|
|
|
|
8149
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:2: ( ( '<' parameter ( ',' parameter )* '>' )? 'CONSUMPTION' '(' par_value ')' -> ^( 'CONSUMPTION' par_value ( parameter )* ) ) |
|
8150
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:4: ( '<' parameter ( ',' parameter )* '>' )? 'CONSUMPTION' '(' par_value ')' |
|
8151
|
|
|
{ |
|
8152
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:4: ( '<' parameter ( ',' parameter )* '>' )? |
|
8153
|
|
|
int alt54=2; |
|
8154
|
|
|
int LA54_0 = input.LA(1); |
|
8155
|
|
|
if ( (LA54_0==20) ) { |
|
8156
|
|
|
alt54=1; |
|
8157
|
|
|
} |
|
8158
|
|
|
switch (alt54) { |
|
8159
|
|
|
case 1 : |
|
8160
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:5: '<' parameter ( ',' parameter )* '>' |
|
8161
|
|
|
{ |
|
8162
|
|
|
char_literal314=(Token)match(input,20,FOLLOW_20_in_consumable_resource_consumption_component_decision1967); if (state.failed) return retval; |
|
8163
|
|
|
if ( state.backtracking==0 ) stream_20.add(char_literal314); |
|
8164
|
|
|
|
|
8165
|
|
|
pushFollow(FOLLOW_parameter_in_consumable_resource_consumption_component_decision1969); |
|
8166
|
|
|
parameter315=parameter(); |
|
8167
|
|
|
state._fsp--; |
|
8168
|
|
|
if (state.failed) return retval; |
|
8169
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter315.getTree()); |
|
8170
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:19: ( ',' parameter )* |
|
8171
|
|
|
loop53: |
|
8172
|
|
|
while (true) { |
|
8173
|
|
|
int alt53=2; |
|
8174
|
|
|
int LA53_0 = input.LA(1); |
|
8175
|
|
|
if ( (LA53_0==15) ) { |
|
8176
|
|
|
alt53=1; |
|
8177
|
|
|
} |
|
8178
|
|
|
|
|
8179
|
|
|
switch (alt53) { |
|
8180
|
|
|
case 1 : |
|
8181
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:20: ',' parameter |
|
8182
|
|
|
{ |
|
8183
|
|
|
char_literal316=(Token)match(input,15,FOLLOW_15_in_consumable_resource_consumption_component_decision1972); if (state.failed) return retval; |
|
8184
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal316); |
|
8185
|
|
|
|
|
8186
|
|
|
pushFollow(FOLLOW_parameter_in_consumable_resource_consumption_component_decision1974); |
|
8187
|
|
|
parameter317=parameter(); |
|
8188
|
|
|
state._fsp--; |
|
8189
|
|
|
if (state.failed) return retval; |
|
8190
|
|
|
if ( state.backtracking==0 ) stream_parameter.add(parameter317.getTree()); |
|
8191
|
|
|
} |
|
8192
|
|
|
break; |
|
8193
|
|
|
|
|
8194
|
|
|
default : |
|
8195
|
|
|
break loop53; |
|
8196
|
|
|
} |
|
8197
|
|
|
} |
|
8198
|
|
|
|
|
8199
|
|
|
char_literal318=(Token)match(input,23,FOLLOW_23_in_consumable_resource_consumption_component_decision1978); if (state.failed) return retval; |
|
8200
|
|
|
if ( state.backtracking==0 ) stream_23.add(char_literal318); |
|
8201
|
|
|
|
|
8202
|
|
|
} |
|
8203
|
|
|
break; |
|
8204
|
|
|
|
|
8205
|
|
|
} |
|
8206
|
|
|
|
|
8207
|
|
|
string_literal319=(Token)match(input,36,FOLLOW_36_in_consumable_resource_consumption_component_decision1982); if (state.failed) return retval; |
|
8208
|
|
|
if ( state.backtracking==0 ) stream_36.add(string_literal319); |
|
8209
|
|
|
|
|
8210
|
|
|
char_literal320=(Token)match(input,11,FOLLOW_11_in_consumable_resource_consumption_component_decision1984); if (state.failed) return retval; |
|
8211
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal320); |
|
8212
|
|
|
|
|
8213
|
|
|
pushFollow(FOLLOW_par_value_in_consumable_resource_consumption_component_decision1986); |
|
8214
|
|
|
par_value321=par_value(); |
|
8215
|
|
|
state._fsp--; |
|
8216
|
|
|
if (state.failed) return retval; |
|
8217
|
|
|
if ( state.backtracking==0 ) stream_par_value.add(par_value321.getTree()); |
|
8218
|
|
|
char_literal322=(Token)match(input,12,FOLLOW_12_in_consumable_resource_consumption_component_decision1988); if (state.failed) return retval; |
|
8219
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal322); |
|
8220
|
|
|
|
|
8221
|
|
|
// AST REWRITE |
|
8222
|
|
|
// elements: parameter, 36, par_value |
|
8223
|
|
|
// token labels: |
|
8224
|
|
|
// rule labels: retval |
|
8225
|
|
|
// token list labels: |
|
8226
|
|
|
// rule list labels: |
|
8227
|
|
|
// wildcard labels: |
|
8228
|
|
|
if ( state.backtracking==0 ) { |
|
8229
|
|
|
retval.tree = root_0; |
|
8230
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8231
|
|
|
|
|
8232
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8233
|
|
|
// 171:74: -> ^( 'CONSUMPTION' par_value ( parameter )* ) |
|
8234
|
|
|
{ |
|
8235
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:76: ^( 'CONSUMPTION' par_value ( parameter )* ) |
|
8236
|
|
|
{ |
|
8237
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8238
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLConsumableResourceComponentDecision(stream_36.nextToken()), root_1); |
|
8239
|
|
|
adaptor.addChild(root_1, stream_par_value.nextTree()); |
|
8240
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:171:142: ( parameter )* |
|
8241
|
|
|
while ( stream_parameter.hasNext() ) { |
|
8242
|
|
|
adaptor.addChild(root_1, stream_parameter.nextTree()); |
|
8243
|
|
|
} |
|
8244
|
|
|
stream_parameter.reset(); |
|
8245
|
|
|
|
|
8246
|
|
|
adaptor.addChild(root_0, root_1); |
|
8247
|
|
|
} |
|
8248
|
|
|
|
|
8249
|
|
|
} |
|
8250
|
|
|
|
|
8251
|
|
|
|
|
8252
|
|
|
retval.tree = root_0; |
|
8253
|
|
|
} |
|
8254
|
|
|
|
|
8255
|
|
|
} |
|
8256
|
|
|
|
|
8257
|
|
|
retval.stop = input.LT(-1); |
|
8258
|
|
|
|
|
8259
|
|
|
if ( state.backtracking==0 ) { |
|
8260
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
8261
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
8262
|
|
|
} |
|
8263
|
|
|
} |
|
8264
|
|
|
catch (RecognitionException re) { |
|
8265
|
|
|
reportError(re); |
|
8266
|
|
|
recover(input,re); |
|
8267
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
8268
|
|
|
} |
|
8269
|
|
|
finally { |
|
8270
|
|
|
// do for sure before leaving |
|
8271
|
|
|
if ( state.backtracking>0 ) { memoize(input, 41, consumable_resource_consumption_component_decision_StartIndex); } |
|
8272
|
|
|
|
|
8273
|
|
|
} |
|
8274
|
|
|
return retval; |
|
8275
|
|
|
} |
|
8276
|
|
|
// $ANTLR end "consumable_resource_consumption_component_decision" |
|
8277
|
|
|
|
|
8278
|
|
|
|
|
8279
|
|
|
public static class par_value_return extends ParserRuleReturnScope { |
|
8280
|
|
|
Object tree; |
|
8281
|
|
|
@Override |
|
8282
|
|
|
public Object getTree() { return tree; } |
|
8283
|
|
|
}; |
|
8284
|
|
|
|
|
8285
|
|
|
|
|
8286
|
|
|
// $ANTLR start "par_value" |
|
8287
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:173:1: par_value : ( VarID ( '=' number )? -> ^( VarID ( number )? ) | VarID ( '=' ID )? -> ^( VarID ( ID )? ) ); |
|
8288
|
|
|
public final ddl3Parser.par_value_return par_value() throws RecognitionException { |
|
8289
|
|
|
ddl3Parser.par_value_return retval = new ddl3Parser.par_value_return(); |
|
8290
|
|
|
retval.start = input.LT(1); |
|
8291
|
|
|
int par_value_StartIndex = input.index(); |
|
8292
|
|
|
|
|
8293
|
|
|
Object root_0 = null; |
|
8294
|
|
|
|
|
8295
|
|
|
Token VarID323=null; |
|
8296
|
|
|
Token char_literal324=null; |
|
8297
|
|
|
Token VarID326=null; |
|
8298
|
|
|
Token char_literal327=null; |
|
8299
|
|
|
Token ID328=null; |
|
8300
|
|
|
ParserRuleReturnScope number325 =null; |
|
8301
|
|
|
|
|
8302
|
|
|
Object VarID323_tree=null; |
|
8303
|
|
|
Object char_literal324_tree=null; |
|
8304
|
|
|
Object VarID326_tree=null; |
|
8305
|
|
|
Object char_literal327_tree=null; |
|
8306
|
|
|
Object ID328_tree=null; |
|
8307
|
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22"); |
|
8308
|
|
|
RewriteRuleTokenStream stream_VarID=new RewriteRuleTokenStream(adaptor,"token VarID"); |
|
8309
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
8310
|
|
|
RewriteRuleSubtreeStream stream_number=new RewriteRuleSubtreeStream(adaptor,"rule number"); |
|
8311
|
|
|
|
|
8312
|
|
|
try { |
|
8313
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return retval; } |
|
8314
|
|
|
|
|
8315
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:2: ( VarID ( '=' number )? -> ^( VarID ( number )? ) | VarID ( '=' ID )? -> ^( VarID ( ID )? ) ) |
|
8316
|
|
|
int alt57=2; |
|
8317
|
|
|
int LA57_0 = input.LA(1); |
|
8318
|
|
|
if ( (LA57_0==VarID) ) { |
|
8319
|
|
|
int LA57_1 = input.LA(2); |
|
8320
|
|
|
if ( (synpred101_ddl3()) ) { |
|
8321
|
|
|
alt57=1; |
|
8322
|
|
|
} |
|
8323
|
|
|
else if ( (true) ) { |
|
8324
|
|
|
alt57=2; |
|
8325
|
|
|
} |
|
8326
|
|
|
|
|
8327
|
|
|
} |
|
8328
|
|
|
|
|
8329
|
|
|
else { |
|
8330
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
8331
|
|
|
NoViableAltException nvae = |
|
8332
|
|
|
new NoViableAltException("", 57, 0, input); |
|
8333
|
|
|
throw nvae; |
|
8334
|
|
|
} |
|
8335
|
|
|
|
|
8336
|
|
|
switch (alt57) { |
|
8337
|
|
|
case 1 : |
|
8338
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:4: VarID ( '=' number )? |
|
8339
|
|
|
{ |
|
8340
|
|
|
VarID323=(Token)match(input,VarID,FOLLOW_VarID_in_par_value2010); if (state.failed) return retval; |
|
8341
|
|
|
if ( state.backtracking==0 ) stream_VarID.add(VarID323); |
|
8342
|
|
|
|
|
8343
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:10: ( '=' number )? |
|
8344
|
|
|
int alt55=2; |
|
8345
|
|
|
int LA55_0 = input.LA(1); |
|
8346
|
|
|
if ( (LA55_0==22) ) { |
|
8347
|
|
|
alt55=1; |
|
8348
|
|
|
} |
|
8349
|
|
|
switch (alt55) { |
|
8350
|
|
|
case 1 : |
|
8351
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:11: '=' number |
|
8352
|
|
|
{ |
|
8353
|
|
|
char_literal324=(Token)match(input,22,FOLLOW_22_in_par_value2013); if (state.failed) return retval; |
|
8354
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal324); |
|
8355
|
|
|
|
|
8356
|
|
|
pushFollow(FOLLOW_number_in_par_value2015); |
|
8357
|
|
|
number325=number(); |
|
8358
|
|
|
state._fsp--; |
|
8359
|
|
|
if (state.failed) return retval; |
|
8360
|
|
|
if ( state.backtracking==0 ) stream_number.add(number325.getTree()); |
|
8361
|
|
|
} |
|
8362
|
|
|
break; |
|
8363
|
|
|
|
|
8364
|
|
|
} |
|
8365
|
|
|
|
|
8366
|
|
|
// AST REWRITE |
|
8367
|
|
|
// elements: VarID, number |
|
8368
|
|
|
// token labels: |
|
8369
|
|
|
// rule labels: retval |
|
8370
|
|
|
// token list labels: |
|
8371
|
|
|
// rule list labels: |
|
8372
|
|
|
// wildcard labels: |
|
8373
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
8374
|
|
|
retval.tree = root_0; |
|
8375
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8376
|
|
|
|
|
8377
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8378
|
|
|
// 174:24: -> ^( VarID ( number )? ) |
|
8379
|
|
|
{ |
|
8380
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:26: ^( VarID ( number )? ) |
|
8381
|
|
|
{ |
|
8382
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8383
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_VarID.nextNode(), root_1); |
|
8384
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:34: ( number )? |
|
8385
|
|
|
if ( stream_number.hasNext() ) { |
|
8386
|
|
|
adaptor.addChild(root_1, stream_number.nextTree()); |
|
8387
|
|
|
} |
|
8388
|
|
|
stream_number.reset(); |
|
8389
|
|
|
|
|
8390
|
|
|
adaptor.addChild(root_0, root_1); |
|
8391
|
|
|
} |
|
8392
|
|
|
|
|
8393
|
|
|
} |
|
8394
|
|
|
|
|
8395
|
|
|
|
|
8396
|
|
|
retval.tree = root_0; |
|
8397
|
|
|
} |
|
8398
|
|
|
|
|
8399
|
|
|
} |
|
8400
|
|
|
break; |
|
8401
|
|
|
case 2 : |
|
8402
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:45: VarID ( '=' ID )? |
|
8403
|
|
|
{ |
|
8404
|
|
|
VarID326=(Token)match(input,VarID,FOLLOW_VarID_in_par_value2029); if (state.failed) return retval; |
|
8405
|
|
|
if ( state.backtracking==0 ) stream_VarID.add(VarID326); |
|
8406
|
|
|
|
|
8407
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:51: ( '=' ID )? |
|
8408
|
|
|
int alt56=2; |
|
8409
|
|
|
int LA56_0 = input.LA(1); |
|
8410
|
|
|
if ( (LA56_0==22) ) { |
|
8411
|
|
|
alt56=1; |
|
8412
|
|
|
} |
|
8413
|
|
|
switch (alt56) { |
|
8414
|
|
|
case 1 : |
|
8415
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:52: '=' ID |
|
8416
|
|
|
{ |
|
8417
|
|
|
char_literal327=(Token)match(input,22,FOLLOW_22_in_par_value2032); if (state.failed) return retval; |
|
8418
|
|
|
if ( state.backtracking==0 ) stream_22.add(char_literal327); |
|
8419
|
|
|
|
|
8420
|
|
|
ID328=(Token)match(input,ID,FOLLOW_ID_in_par_value2034); if (state.failed) return retval; |
|
8421
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID328); |
|
8422
|
|
|
|
|
8423
|
|
|
} |
|
8424
|
|
|
break; |
|
8425
|
|
|
|
|
8426
|
|
|
} |
|
8427
|
|
|
|
|
8428
|
|
|
// AST REWRITE |
|
8429
|
|
|
// elements: VarID, ID |
|
8430
|
|
|
// token labels: |
|
8431
|
|
|
// rule labels: retval |
|
8432
|
|
|
// token list labels: |
|
8433
|
|
|
// rule list labels: |
|
8434
|
|
|
// wildcard labels: |
|
8435
|
|
|
if ( state.backtracking==0 ) { |
|
8436
|
|
|
retval.tree = root_0; |
|
8437
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8438
|
|
|
|
|
8439
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8440
|
|
|
// 174:61: -> ^( VarID ( ID )? ) |
|
8441
|
|
|
{ |
|
8442
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:63: ^( VarID ( ID )? ) |
|
8443
|
|
|
{ |
|
8444
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8445
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_VarID.nextNode(), root_1); |
|
8446
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:71: ( ID )? |
|
8447
|
|
|
if ( stream_ID.hasNext() ) { |
|
8448
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
8449
|
|
|
} |
|
8450
|
|
|
stream_ID.reset(); |
|
8451
|
|
|
|
|
8452
|
|
|
adaptor.addChild(root_0, root_1); |
|
8453
|
|
|
} |
|
8454
|
|
|
|
|
8455
|
|
|
} |
|
8456
|
|
|
|
|
8457
|
|
|
|
|
8458
|
|
|
retval.tree = root_0; |
|
8459
|
|
|
} |
|
8460
|
|
|
|
|
8461
|
|
|
} |
|
8462
|
|
|
break; |
|
8463
|
|
|
|
|
8464
|
|
|
} |
|
8465
|
|
|
retval.stop = input.LT(-1); |
|
8466
|
|
|
|
|
8467
|
|
|
if ( state.backtracking==0 ) { |
|
8468
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
8469
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
8470
|
|
|
} |
|
8471
|
|
|
} |
|
8472
|
|
|
catch (RecognitionException re) { |
|
8473
|
|
|
reportError(re); |
|
8474
|
|
|
recover(input,re); |
|
8475
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
8476
|
|
|
} |
|
8477
|
|
|
finally { |
|
8478
|
|
|
// do for sure before leaving |
|
8479
|
|
|
if ( state.backtracking>0 ) { memoize(input, 42, par_value_StartIndex); } |
|
8480
|
|
|
|
|
8481
|
|
|
} |
|
8482
|
|
|
return retval; |
|
8483
|
|
|
} |
|
8484
|
|
|
// $ANTLR end "par_value" |
|
8485
|
|
|
|
|
8486
|
|
|
|
|
8487
|
|
|
public static class synchronization_element_return extends ParserRuleReturnScope { |
|
8488
|
|
|
Object tree; |
|
8489
|
|
|
@Override |
|
8490
|
|
|
public Object getTree() { return tree; } |
|
8491
|
|
|
}; |
|
8492
|
|
|
|
|
8493
|
|
|
|
|
8494
|
|
|
// $ANTLR start "synchronization_element" |
|
8495
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:176:1: synchronization_element : ( instantiated_component_decision ';' | parameter_constraint ';' | (from= ID )? temporal_relation_type to= ID ';' -> ^( ';' temporal_relation_type $to ( $from)? ) ); |
|
8496
|
|
|
public final ddl3Parser.synchronization_element_return synchronization_element() throws RecognitionException { |
|
8497
|
|
|
ddl3Parser.synchronization_element_return retval = new ddl3Parser.synchronization_element_return(); |
|
8498
|
|
|
retval.start = input.LT(1); |
|
8499
|
|
|
int synchronization_element_StartIndex = input.index(); |
|
8500
|
|
|
|
|
8501
|
|
|
Object root_0 = null; |
|
8502
|
|
|
|
|
8503
|
|
|
Token from=null; |
|
8504
|
|
|
Token to=null; |
|
8505
|
|
|
Token char_literal330=null; |
|
8506
|
|
|
Token char_literal332=null; |
|
8507
|
|
|
Token char_literal334=null; |
|
8508
|
|
|
ParserRuleReturnScope instantiated_component_decision329 =null; |
|
8509
|
|
|
ParserRuleReturnScope parameter_constraint331 =null; |
|
8510
|
|
|
ParserRuleReturnScope temporal_relation_type333 =null; |
|
8511
|
|
|
|
|
8512
|
|
|
Object from_tree=null; |
|
8513
|
|
|
Object to_tree=null; |
|
8514
|
|
|
Object char_literal330_tree=null; |
|
8515
|
|
|
Object char_literal332_tree=null; |
|
8516
|
|
|
Object char_literal334_tree=null; |
|
8517
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
8518
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
8519
|
|
|
RewriteRuleSubtreeStream stream_temporal_relation_type=new RewriteRuleSubtreeStream(adaptor,"rule temporal_relation_type"); |
|
8520
|
|
|
|
|
8521
|
|
|
try { |
|
8522
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return retval; } |
|
8523
|
|
|
|
|
8524
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:2: ( instantiated_component_decision ';' | parameter_constraint ';' | (from= ID )? temporal_relation_type to= ID ';' -> ^( ';' temporal_relation_type $to ( $from)? ) ) |
|
8525
|
|
|
int alt59=3; |
|
8526
|
|
|
switch ( input.LA(1) ) { |
|
8527
|
|
|
case ID: |
|
8528
|
|
|
{ |
|
8529
|
|
|
int LA59_1 = input.LA(2); |
|
8530
|
|
View Code Duplication |
if ( (LA59_1==ID||LA59_1==20) ) { |
|
|
|
|
|
|
8531
|
|
|
alt59=1; |
|
8532
|
|
|
} |
|
8533
|
|
|
else if ( ((LA59_1 >= 26 && LA59_1 <= 27)||(LA59_1 >= 29 && LA59_1 <= 32)||(LA59_1 >= 37 && LA59_1 <= 39)||(LA59_1 >= 42 && LA59_1 <= 47)||(LA59_1 >= 51 && LA59_1 <= 52)||(LA59_1 >= 55 && LA59_1 <= 56)||(LA59_1 >= 58 && LA59_1 <= 59)||(LA59_1 >= 65 && LA59_1 <= 70)) ) { |
|
8534
|
|
|
alt59=3; |
|
8535
|
|
|
} |
|
8536
|
|
|
|
|
8537
|
|
|
else { |
|
8538
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
8539
|
|
|
int nvaeMark = input.mark(); |
|
8540
|
|
|
try { |
|
8541
|
|
|
input.consume(); |
|
8542
|
|
|
NoViableAltException nvae = |
|
8543
|
|
|
new NoViableAltException("", 59, 1, input); |
|
8544
|
|
|
throw nvae; |
|
8545
|
|
|
} finally { |
|
8546
|
|
|
input.rewind(nvaeMark); |
|
8547
|
|
|
} |
|
8548
|
|
|
} |
|
8549
|
|
|
|
|
8550
|
|
|
} |
|
8551
|
|
|
break; |
|
8552
|
|
|
case INT: |
|
8553
|
|
|
case VarID: |
|
8554
|
|
|
case 14: |
|
8555
|
|
|
case 16: |
|
8556
|
|
|
case 54: |
|
8557
|
|
|
{ |
|
8558
|
|
|
alt59=2; |
|
8559
|
|
|
} |
|
8560
|
|
|
break; |
|
8561
|
|
|
case 26: |
|
8562
|
|
|
case 27: |
|
8563
|
|
|
case 29: |
|
8564
|
|
|
case 30: |
|
8565
|
|
|
case 31: |
|
8566
|
|
|
case 32: |
|
8567
|
|
|
case 37: |
|
8568
|
|
|
case 38: |
|
8569
|
|
|
case 39: |
|
8570
|
|
|
case 42: |
|
8571
|
|
|
case 43: |
|
8572
|
|
|
case 44: |
|
8573
|
|
|
case 45: |
|
8574
|
|
|
case 46: |
|
8575
|
|
|
case 47: |
|
8576
|
|
|
case 51: |
|
8577
|
|
|
case 52: |
|
8578
|
|
|
case 55: |
|
8579
|
|
|
case 56: |
|
8580
|
|
|
case 58: |
|
8581
|
|
|
case 59: |
|
8582
|
|
|
case 65: |
|
8583
|
|
|
case 66: |
|
8584
|
|
|
case 67: |
|
8585
|
|
|
case 68: |
|
8586
|
|
|
case 69: |
|
8587
|
|
|
case 70: |
|
8588
|
|
|
{ |
|
8589
|
|
|
alt59=3; |
|
8590
|
|
|
} |
|
8591
|
|
|
break; |
|
8592
|
|
|
default: |
|
8593
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
8594
|
|
|
NoViableAltException nvae = |
|
8595
|
|
|
new NoViableAltException("", 59, 0, input); |
|
8596
|
|
|
throw nvae; |
|
8597
|
|
|
} |
|
8598
|
|
|
switch (alt59) { |
|
8599
|
|
|
case 1 : |
|
8600
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:4: instantiated_component_decision ';' |
|
8601
|
|
|
{ |
|
8602
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8603
|
|
|
|
|
8604
|
|
|
|
|
8605
|
|
|
pushFollow(FOLLOW_instantiated_component_decision_in_synchronization_element2053); |
|
8606
|
|
|
instantiated_component_decision329=instantiated_component_decision(); |
|
8607
|
|
|
state._fsp--; |
|
8608
|
|
|
if (state.failed) return retval; |
|
8609
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, instantiated_component_decision329.getTree()); |
|
8610
|
|
|
|
|
8611
|
|
|
char_literal330=(Token)match(input,19,FOLLOW_19_in_synchronization_element2055); if (state.failed) return retval; |
|
8612
|
|
|
if ( state.backtracking==0 ) { |
|
8613
|
|
|
char_literal330_tree = (Object)adaptor.create(char_literal330); |
|
8614
|
|
|
adaptor.addChild(root_0, char_literal330_tree); |
|
8615
|
|
|
} |
|
8616
|
|
|
|
|
8617
|
|
|
} |
|
8618
|
|
|
break; |
|
8619
|
|
|
case 2 : |
|
8620
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:42: parameter_constraint ';' |
|
8621
|
|
|
{ |
|
8622
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8623
|
|
|
|
|
8624
|
|
|
|
|
8625
|
|
|
pushFollow(FOLLOW_parameter_constraint_in_synchronization_element2059); |
|
8626
|
|
|
parameter_constraint331=parameter_constraint(); |
|
8627
|
|
|
state._fsp--; |
|
8628
|
|
|
if (state.failed) return retval; |
|
8629
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_constraint331.getTree()); |
|
8630
|
|
|
|
|
8631
|
|
|
char_literal332=(Token)match(input,19,FOLLOW_19_in_synchronization_element2061); if (state.failed) return retval; |
|
8632
|
|
|
if ( state.backtracking==0 ) { |
|
8633
|
|
|
char_literal332_tree = (Object)adaptor.create(char_literal332); |
|
8634
|
|
|
adaptor.addChild(root_0, char_literal332_tree); |
|
8635
|
|
|
} |
|
8636
|
|
|
|
|
8637
|
|
|
} |
|
8638
|
|
|
break; |
|
8639
|
|
|
case 3 : |
|
8640
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:69: (from= ID )? temporal_relation_type to= ID ';' |
|
8641
|
|
|
{ |
|
8642
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:69: (from= ID )? |
|
8643
|
|
|
int alt58=2; |
|
8644
|
|
|
int LA58_0 = input.LA(1); |
|
8645
|
|
|
if ( (LA58_0==ID) ) { |
|
8646
|
|
|
alt58=1; |
|
8647
|
|
|
} |
|
8648
|
|
|
switch (alt58) { |
|
8649
|
|
|
case 1 : |
|
8650
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:70: from= ID |
|
8651
|
|
|
{ |
|
8652
|
|
|
from=(Token)match(input,ID,FOLLOW_ID_in_synchronization_element2068); if (state.failed) return retval; |
|
8653
|
|
|
if ( state.backtracking==0 ) stream_ID.add(from); |
|
8654
|
|
|
|
|
8655
|
|
|
} |
|
8656
|
|
|
break; |
|
8657
|
|
|
|
|
8658
|
|
|
} |
|
8659
|
|
|
|
|
8660
|
|
|
pushFollow(FOLLOW_temporal_relation_type_in_synchronization_element2072); |
|
8661
|
|
|
temporal_relation_type333=temporal_relation_type(); |
|
8662
|
|
|
state._fsp--; |
|
8663
|
|
|
if (state.failed) return retval; |
|
8664
|
|
|
if ( state.backtracking==0 ) stream_temporal_relation_type.add(temporal_relation_type333.getTree()); |
|
8665
|
|
|
to=(Token)match(input,ID,FOLLOW_ID_in_synchronization_element2076); if (state.failed) return retval; |
|
8666
|
|
|
if ( state.backtracking==0 ) stream_ID.add(to); |
|
8667
|
|
|
|
|
8668
|
|
|
char_literal334=(Token)match(input,19,FOLLOW_19_in_synchronization_element2078); if (state.failed) return retval; |
|
8669
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal334); |
|
8670
|
|
|
|
|
8671
|
|
|
// AST REWRITE |
|
8672
|
|
|
// elements: 19, from, temporal_relation_type, to |
|
8673
|
|
|
// token labels: from, to |
|
8674
|
|
|
// rule labels: retval |
|
8675
|
|
|
// token list labels: |
|
8676
|
|
|
// rule list labels: |
|
8677
|
|
|
// wildcard labels: |
|
8678
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
8679
|
|
|
retval.tree = root_0; |
|
8680
|
|
|
RewriteRuleTokenStream stream_from=new RewriteRuleTokenStream(adaptor,"token from",from); |
|
8681
|
|
|
RewriteRuleTokenStream stream_to=new RewriteRuleTokenStream(adaptor,"token to",to); |
|
8682
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8683
|
|
|
|
|
8684
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8685
|
|
|
// 177:113: -> ^( ';' temporal_relation_type $to ( $from)? ) |
|
8686
|
|
|
{ |
|
8687
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:115: ^( ';' temporal_relation_type $to ( $from)? ) |
|
8688
|
|
|
{ |
|
8689
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8690
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelation(stream_19.nextToken()), root_1); |
|
8691
|
|
|
adaptor.addChild(root_1, stream_temporal_relation_type.nextTree()); |
|
8692
|
|
|
adaptor.addChild(root_1, stream_to.nextNode()); |
|
8693
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:177:170: ( $from)? |
|
8694
|
|
|
if ( stream_from.hasNext() ) { |
|
8695
|
|
|
adaptor.addChild(root_1, stream_from.nextNode()); |
|
8696
|
|
|
} |
|
8697
|
|
|
stream_from.reset(); |
|
8698
|
|
|
|
|
8699
|
|
|
adaptor.addChild(root_0, root_1); |
|
8700
|
|
|
} |
|
8701
|
|
|
|
|
8702
|
|
|
} |
|
8703
|
|
|
|
|
8704
|
|
|
|
|
8705
|
|
|
retval.tree = root_0; |
|
8706
|
|
|
} |
|
8707
|
|
|
|
|
8708
|
|
|
} |
|
8709
|
|
|
break; |
|
8710
|
|
|
|
|
8711
|
|
|
} |
|
8712
|
|
|
retval.stop = input.LT(-1); |
|
8713
|
|
|
|
|
8714
|
|
|
if ( state.backtracking==0 ) { |
|
8715
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
8716
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
8717
|
|
|
} |
|
8718
|
|
|
} |
|
8719
|
|
|
catch (RecognitionException re) { |
|
8720
|
|
|
reportError(re); |
|
8721
|
|
|
recover(input,re); |
|
8722
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
8723
|
|
|
} |
|
8724
|
|
|
finally { |
|
8725
|
|
|
// do for sure before leaving |
|
8726
|
|
|
if ( state.backtracking>0 ) { memoize(input, 43, synchronization_element_StartIndex); } |
|
8727
|
|
|
|
|
8728
|
|
|
} |
|
8729
|
|
|
return retval; |
|
8730
|
|
|
} |
|
8731
|
|
|
// $ANTLR end "synchronization_element" |
|
8732
|
|
|
|
|
8733
|
|
|
|
|
8734
|
|
|
public static class problem_return extends ParserRuleReturnScope { |
|
8735
|
|
|
Object tree; |
|
8736
|
|
|
@Override |
|
8737
|
|
|
public Object getTree() { return tree; } |
|
8738
|
|
|
}; |
|
8739
|
|
|
|
|
8740
|
|
|
|
|
8741
|
|
|
// $ANTLR start "problem" |
|
8742
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:1: problem : 'PROBLEM' ID '(' 'DOMAIN' ID ')' '{' ( problem_element )* '}' -> ^( ID ID ( problem_element )* ) ; |
|
8743
|
|
|
public final ddl3Parser.problem_return problem() throws RecognitionException { |
|
8744
|
|
|
ddl3Parser.problem_return retval = new ddl3Parser.problem_return(); |
|
8745
|
|
|
retval.start = input.LT(1); |
|
8746
|
|
|
int problem_StartIndex = input.index(); |
|
8747
|
|
|
|
|
8748
|
|
|
Object root_0 = null; |
|
8749
|
|
|
|
|
8750
|
|
|
Token string_literal335=null; |
|
8751
|
|
|
Token ID336=null; |
|
8752
|
|
|
Token char_literal337=null; |
|
8753
|
|
|
Token string_literal338=null; |
|
8754
|
|
|
Token ID339=null; |
|
8755
|
|
|
Token char_literal340=null; |
|
8756
|
|
|
Token char_literal341=null; |
|
8757
|
|
|
Token char_literal343=null; |
|
8758
|
|
|
ParserRuleReturnScope problem_element342 =null; |
|
8759
|
|
|
|
|
8760
|
|
|
Object string_literal335_tree=null; |
|
8761
|
|
|
Object ID336_tree=null; |
|
8762
|
|
|
Object char_literal337_tree=null; |
|
8763
|
|
|
Object string_literal338_tree=null; |
|
8764
|
|
|
Object ID339_tree=null; |
|
8765
|
|
|
Object char_literal340_tree=null; |
|
8766
|
|
|
Object char_literal341_tree=null; |
|
8767
|
|
|
Object char_literal343_tree=null; |
|
8768
|
|
|
RewriteRuleTokenStream stream_11=new RewriteRuleTokenStream(adaptor,"token 11"); |
|
8769
|
|
|
RewriteRuleTokenStream stream_12=new RewriteRuleTokenStream(adaptor,"token 12"); |
|
8770
|
|
|
RewriteRuleTokenStream stream_80=new RewriteRuleTokenStream(adaptor,"token 80"); |
|
8771
|
|
|
RewriteRuleTokenStream stream_81=new RewriteRuleTokenStream(adaptor,"token 81"); |
|
8772
|
|
|
RewriteRuleTokenStream stream_61=new RewriteRuleTokenStream(adaptor,"token 61"); |
|
8773
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
8774
|
|
|
RewriteRuleTokenStream stream_41=new RewriteRuleTokenStream(adaptor,"token 41"); |
|
8775
|
|
|
RewriteRuleSubtreeStream stream_problem_element=new RewriteRuleSubtreeStream(adaptor,"rule problem_element"); |
|
8776
|
|
|
|
|
8777
|
|
|
try { |
|
8778
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return retval; } |
|
8779
|
|
|
|
|
8780
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:9: ( 'PROBLEM' ID '(' 'DOMAIN' ID ')' '{' ( problem_element )* '}' -> ^( ID ID ( problem_element )* ) ) |
|
8781
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:11: 'PROBLEM' ID '(' 'DOMAIN' ID ')' '{' ( problem_element )* '}' |
|
8782
|
|
|
{ |
|
8783
|
|
|
string_literal335=(Token)match(input,61,FOLLOW_61_in_problem2103); if (state.failed) return retval; |
|
8784
|
|
|
if ( state.backtracking==0 ) stream_61.add(string_literal335); |
|
8785
|
|
|
|
|
8786
|
|
|
ID336=(Token)match(input,ID,FOLLOW_ID_in_problem2105); if (state.failed) return retval; |
|
8787
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID336); |
|
8788
|
|
|
|
|
8789
|
|
|
char_literal337=(Token)match(input,11,FOLLOW_11_in_problem2107); if (state.failed) return retval; |
|
8790
|
|
|
if ( state.backtracking==0 ) stream_11.add(char_literal337); |
|
8791
|
|
|
|
|
8792
|
|
|
string_literal338=(Token)match(input,41,FOLLOW_41_in_problem2109); if (state.failed) return retval; |
|
8793
|
|
|
if ( state.backtracking==0 ) stream_41.add(string_literal338); |
|
8794
|
|
|
|
|
8795
|
|
|
ID339=(Token)match(input,ID,FOLLOW_ID_in_problem2111); if (state.failed) return retval; |
|
8796
|
|
|
if ( state.backtracking==0 ) stream_ID.add(ID339); |
|
8797
|
|
|
|
|
8798
|
|
|
char_literal340=(Token)match(input,12,FOLLOW_12_in_problem2113); if (state.failed) return retval; |
|
8799
|
|
|
if ( state.backtracking==0 ) stream_12.add(char_literal340); |
|
8800
|
|
|
|
|
8801
|
|
|
char_literal341=(Token)match(input,80,FOLLOW_80_in_problem2115); if (state.failed) return retval; |
|
8802
|
|
|
if ( state.backtracking==0 ) stream_80.add(char_literal341); |
|
8803
|
|
|
|
|
8804
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:48: ( problem_element )* |
|
8805
|
|
|
loop60: |
|
8806
|
|
|
while (true) { |
|
8807
|
|
|
int alt60=2; |
|
8808
|
|
|
int LA60_0 = input.LA(1); |
|
8809
|
|
|
if ( ((LA60_0 >= ID && LA60_0 <= VarID)||LA60_0==14||LA60_0==16||LA60_0==54) ) { |
|
8810
|
|
|
alt60=1; |
|
8811
|
|
|
} |
|
8812
|
|
|
|
|
8813
|
|
|
switch (alt60) { |
|
8814
|
|
|
case 1 : |
|
8815
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:48: problem_element |
|
8816
|
|
|
{ |
|
8817
|
|
|
pushFollow(FOLLOW_problem_element_in_problem2117); |
|
8818
|
|
|
problem_element342=problem_element(); |
|
8819
|
|
|
state._fsp--; |
|
8820
|
|
|
if (state.failed) return retval; |
|
8821
|
|
|
if ( state.backtracking==0 ) stream_problem_element.add(problem_element342.getTree()); |
|
8822
|
|
|
} |
|
8823
|
|
|
break; |
|
8824
|
|
|
|
|
8825
|
|
|
default : |
|
8826
|
|
|
break loop60; |
|
8827
|
|
|
} |
|
8828
|
|
|
} |
|
8829
|
|
|
|
|
8830
|
|
|
char_literal343=(Token)match(input,81,FOLLOW_81_in_problem2120); if (state.failed) return retval; |
|
8831
|
|
|
if ( state.backtracking==0 ) stream_81.add(char_literal343); |
|
8832
|
|
|
|
|
8833
|
|
|
// AST REWRITE |
|
8834
|
|
|
// elements: ID, problem_element, ID |
|
8835
|
|
|
// token labels: |
|
8836
|
|
|
// rule labels: retval |
|
8837
|
|
|
// token list labels: |
|
8838
|
|
|
// rule list labels: |
|
8839
|
|
|
// wildcard labels: |
|
8840
|
|
|
if ( state.backtracking==0 ) { |
|
8841
|
|
|
retval.tree = root_0; |
|
8842
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
8843
|
|
|
|
|
8844
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8845
|
|
|
// 179:69: -> ^( ID ID ( problem_element )* ) |
|
8846
|
|
|
{ |
|
8847
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:71: ^( ID ID ( problem_element )* ) |
|
8848
|
|
|
{ |
|
8849
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
8850
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLProblem(stream_ID.nextToken()), root_1); |
|
8851
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode()); |
|
8852
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:179:91: ( problem_element )* |
|
8853
|
|
|
while ( stream_problem_element.hasNext() ) { |
|
8854
|
|
|
adaptor.addChild(root_1, stream_problem_element.nextTree()); |
|
8855
|
|
|
} |
|
8856
|
|
|
stream_problem_element.reset(); |
|
8857
|
|
|
|
|
8858
|
|
|
adaptor.addChild(root_0, root_1); |
|
8859
|
|
|
} |
|
8860
|
|
|
|
|
8861
|
|
|
} |
|
8862
|
|
|
|
|
8863
|
|
|
|
|
8864
|
|
|
retval.tree = root_0; |
|
8865
|
|
|
} |
|
8866
|
|
|
|
|
8867
|
|
|
} |
|
8868
|
|
|
|
|
8869
|
|
|
retval.stop = input.LT(-1); |
|
8870
|
|
|
|
|
8871
|
|
|
if ( state.backtracking==0 ) { |
|
8872
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
8873
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
8874
|
|
|
} |
|
8875
|
|
|
} |
|
8876
|
|
|
catch (RecognitionException re) { |
|
8877
|
|
|
reportError(re); |
|
8878
|
|
|
recover(input,re); |
|
8879
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
8880
|
|
|
} |
|
8881
|
|
|
finally { |
|
8882
|
|
|
// do for sure before leaving |
|
8883
|
|
|
if ( state.backtracking>0 ) { memoize(input, 44, problem_StartIndex); } |
|
8884
|
|
|
|
|
8885
|
|
|
} |
|
8886
|
|
|
return retval; |
|
8887
|
|
|
} |
|
8888
|
|
|
// $ANTLR end "problem" |
|
8889
|
|
|
|
|
8890
|
|
|
|
|
8891
|
|
|
public static class problem_element_return extends ParserRuleReturnScope { |
|
8892
|
|
|
Object tree; |
|
8893
|
|
|
@Override |
|
8894
|
|
|
public Object getTree() { return tree; } |
|
8895
|
|
|
}; |
|
8896
|
|
|
|
|
8897
|
|
|
|
|
8898
|
|
|
// $ANTLR start "problem_element" |
|
8899
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:181:1: problem_element : ( instantiated_component_decision ';' |from= ID temporal_relation_type to= ID ';' -> ^( ';' temporal_relation_type $to ( $from)? ) | parameter_constraint ';' ); |
|
8900
|
|
|
public final ddl3Parser.problem_element_return problem_element() throws RecognitionException { |
|
8901
|
|
|
ddl3Parser.problem_element_return retval = new ddl3Parser.problem_element_return(); |
|
8902
|
|
|
retval.start = input.LT(1); |
|
8903
|
|
|
int problem_element_StartIndex = input.index(); |
|
8904
|
|
|
|
|
8905
|
|
|
Object root_0 = null; |
|
8906
|
|
|
|
|
8907
|
|
|
Token from=null; |
|
8908
|
|
|
Token to=null; |
|
8909
|
|
|
Token char_literal345=null; |
|
8910
|
|
|
Token char_literal347=null; |
|
8911
|
|
|
Token char_literal349=null; |
|
8912
|
|
|
ParserRuleReturnScope instantiated_component_decision344 =null; |
|
8913
|
|
|
ParserRuleReturnScope temporal_relation_type346 =null; |
|
8914
|
|
|
ParserRuleReturnScope parameter_constraint348 =null; |
|
8915
|
|
|
|
|
8916
|
|
|
Object from_tree=null; |
|
8917
|
|
|
Object to_tree=null; |
|
8918
|
|
|
Object char_literal345_tree=null; |
|
8919
|
|
|
Object char_literal347_tree=null; |
|
8920
|
|
|
Object char_literal349_tree=null; |
|
8921
|
|
|
RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19"); |
|
8922
|
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID"); |
|
8923
|
|
|
RewriteRuleSubtreeStream stream_temporal_relation_type=new RewriteRuleSubtreeStream(adaptor,"rule temporal_relation_type"); |
|
8924
|
|
|
|
|
8925
|
|
|
try { |
|
8926
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return retval; } |
|
8927
|
|
|
|
|
8928
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:2: ( instantiated_component_decision ';' |from= ID temporal_relation_type to= ID ';' -> ^( ';' temporal_relation_type $to ( $from)? ) | parameter_constraint ';' ) |
|
8929
|
|
|
int alt61=3; |
|
8930
|
|
|
int LA61_0 = input.LA(1); |
|
8931
|
|
|
if ( (LA61_0==ID) ) { |
|
8932
|
|
|
int LA61_1 = input.LA(2); |
|
8933
|
|
View Code Duplication |
if ( (LA61_1==ID||LA61_1==20) ) { |
|
|
|
|
|
|
8934
|
|
|
alt61=1; |
|
8935
|
|
|
} |
|
8936
|
|
|
else if ( ((LA61_1 >= 26 && LA61_1 <= 27)||(LA61_1 >= 29 && LA61_1 <= 32)||(LA61_1 >= 37 && LA61_1 <= 39)||(LA61_1 >= 42 && LA61_1 <= 47)||(LA61_1 >= 51 && LA61_1 <= 52)||(LA61_1 >= 55 && LA61_1 <= 56)||(LA61_1 >= 58 && LA61_1 <= 59)||(LA61_1 >= 65 && LA61_1 <= 70)) ) { |
|
8937
|
|
|
alt61=2; |
|
8938
|
|
|
} |
|
8939
|
|
|
|
|
8940
|
|
|
else { |
|
8941
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
8942
|
|
|
int nvaeMark = input.mark(); |
|
8943
|
|
|
try { |
|
8944
|
|
|
input.consume(); |
|
8945
|
|
|
NoViableAltException nvae = |
|
8946
|
|
|
new NoViableAltException("", 61, 1, input); |
|
8947
|
|
|
throw nvae; |
|
8948
|
|
|
} finally { |
|
8949
|
|
|
input.rewind(nvaeMark); |
|
8950
|
|
|
} |
|
8951
|
|
|
} |
|
8952
|
|
|
|
|
8953
|
|
|
} |
|
8954
|
|
View Code Duplication |
else if ( ((LA61_0 >= INT && LA61_0 <= VarID)||LA61_0==14||LA61_0==16||LA61_0==54) ) { |
|
|
|
|
|
|
8955
|
|
|
alt61=3; |
|
8956
|
|
|
} |
|
8957
|
|
|
|
|
8958
|
|
|
else { |
|
8959
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
8960
|
|
|
NoViableAltException nvae = |
|
8961
|
|
|
new NoViableAltException("", 61, 0, input); |
|
8962
|
|
|
throw nvae; |
|
8963
|
|
|
} |
|
8964
|
|
|
|
|
8965
|
|
|
switch (alt61) { |
|
8966
|
|
|
case 1 : |
|
8967
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:4: instantiated_component_decision ';' |
|
8968
|
|
|
{ |
|
8969
|
|
|
root_0 = (Object)adaptor.nil(); |
|
8970
|
|
|
|
|
8971
|
|
|
|
|
8972
|
|
|
pushFollow(FOLLOW_instantiated_component_decision_in_problem_element2142); |
|
8973
|
|
|
instantiated_component_decision344=instantiated_component_decision(); |
|
8974
|
|
|
state._fsp--; |
|
8975
|
|
|
if (state.failed) return retval; |
|
8976
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, instantiated_component_decision344.getTree()); |
|
8977
|
|
|
|
|
8978
|
|
|
char_literal345=(Token)match(input,19,FOLLOW_19_in_problem_element2144); if (state.failed) return retval; |
|
8979
|
|
|
if ( state.backtracking==0 ) { |
|
8980
|
|
|
char_literal345_tree = (Object)adaptor.create(char_literal345); |
|
8981
|
|
|
adaptor.addChild(root_0, char_literal345_tree); |
|
8982
|
|
|
} |
|
8983
|
|
|
|
|
8984
|
|
|
} |
|
8985
|
|
|
break; |
|
8986
|
|
|
case 2 : |
|
8987
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:42: from= ID temporal_relation_type to= ID ';' |
|
8988
|
|
|
{ |
|
8989
|
|
|
from=(Token)match(input,ID,FOLLOW_ID_in_problem_element2150); if (state.failed) return retval; |
|
8990
|
|
|
if ( state.backtracking==0 ) stream_ID.add(from); |
|
8991
|
|
|
|
|
8992
|
|
|
pushFollow(FOLLOW_temporal_relation_type_in_problem_element2152); |
|
8993
|
|
|
temporal_relation_type346=temporal_relation_type(); |
|
8994
|
|
|
state._fsp--; |
|
8995
|
|
|
if (state.failed) return retval; |
|
8996
|
|
|
if ( state.backtracking==0 ) stream_temporal_relation_type.add(temporal_relation_type346.getTree()); |
|
8997
|
|
|
to=(Token)match(input,ID,FOLLOW_ID_in_problem_element2156); if (state.failed) return retval; |
|
8998
|
|
|
if ( state.backtracking==0 ) stream_ID.add(to); |
|
8999
|
|
|
|
|
9000
|
|
|
char_literal347=(Token)match(input,19,FOLLOW_19_in_problem_element2158); if (state.failed) return retval; |
|
9001
|
|
|
if ( state.backtracking==0 ) stream_19.add(char_literal347); |
|
9002
|
|
|
|
|
9003
|
|
|
// AST REWRITE |
|
9004
|
|
|
// elements: to, 19, from, temporal_relation_type |
|
9005
|
|
|
// token labels: from, to |
|
9006
|
|
|
// rule labels: retval |
|
9007
|
|
|
// token list labels: |
|
9008
|
|
|
// rule list labels: |
|
9009
|
|
|
// wildcard labels: |
|
9010
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
9011
|
|
|
retval.tree = root_0; |
|
9012
|
|
|
RewriteRuleTokenStream stream_from=new RewriteRuleTokenStream(adaptor,"token from",from); |
|
9013
|
|
|
RewriteRuleTokenStream stream_to=new RewriteRuleTokenStream(adaptor,"token to",to); |
|
9014
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9015
|
|
|
|
|
9016
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9017
|
|
|
// 182:83: -> ^( ';' temporal_relation_type $to ( $from)? ) |
|
9018
|
|
|
{ |
|
9019
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:85: ^( ';' temporal_relation_type $to ( $from)? ) |
|
9020
|
|
|
{ |
|
9021
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9022
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLTemporalRelation(stream_19.nextToken()), root_1); |
|
9023
|
|
|
adaptor.addChild(root_1, stream_temporal_relation_type.nextTree()); |
|
9024
|
|
|
adaptor.addChild(root_1, stream_to.nextNode()); |
|
9025
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:140: ( $from)? |
|
9026
|
|
|
if ( stream_from.hasNext() ) { |
|
9027
|
|
|
adaptor.addChild(root_1, stream_from.nextNode()); |
|
9028
|
|
|
} |
|
9029
|
|
|
stream_from.reset(); |
|
9030
|
|
|
|
|
9031
|
|
|
adaptor.addChild(root_0, root_1); |
|
9032
|
|
|
} |
|
9033
|
|
|
|
|
9034
|
|
|
} |
|
9035
|
|
|
|
|
9036
|
|
|
|
|
9037
|
|
|
retval.tree = root_0; |
|
9038
|
|
|
} |
|
9039
|
|
|
|
|
9040
|
|
|
} |
|
9041
|
|
|
break; |
|
9042
|
|
|
case 3 : |
|
9043
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:182:149: parameter_constraint ';' |
|
9044
|
|
|
{ |
|
9045
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9046
|
|
|
|
|
9047
|
|
|
|
|
9048
|
|
|
pushFollow(FOLLOW_parameter_constraint_in_problem_element2179); |
|
9049
|
|
|
parameter_constraint348=parameter_constraint(); |
|
9050
|
|
|
state._fsp--; |
|
9051
|
|
|
if (state.failed) return retval; |
|
9052
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_constraint348.getTree()); |
|
9053
|
|
|
|
|
9054
|
|
|
char_literal349=(Token)match(input,19,FOLLOW_19_in_problem_element2181); if (state.failed) return retval; |
|
9055
|
|
|
if ( state.backtracking==0 ) { |
|
9056
|
|
|
char_literal349_tree = (Object)adaptor.create(char_literal349); |
|
9057
|
|
|
adaptor.addChild(root_0, char_literal349_tree); |
|
9058
|
|
|
} |
|
9059
|
|
|
|
|
9060
|
|
|
} |
|
9061
|
|
|
break; |
|
9062
|
|
|
|
|
9063
|
|
|
} |
|
9064
|
|
|
retval.stop = input.LT(-1); |
|
9065
|
|
|
|
|
9066
|
|
|
if ( state.backtracking==0 ) { |
|
9067
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
9068
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
9069
|
|
|
} |
|
9070
|
|
|
} |
|
9071
|
|
|
catch (RecognitionException re) { |
|
9072
|
|
|
reportError(re); |
|
9073
|
|
|
recover(input,re); |
|
9074
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
9075
|
|
|
} |
|
9076
|
|
|
finally { |
|
9077
|
|
|
// do for sure before leaving |
|
9078
|
|
|
if ( state.backtracking>0 ) { memoize(input, 45, problem_element_StartIndex); } |
|
9079
|
|
|
|
|
9080
|
|
|
} |
|
9081
|
|
|
return retval; |
|
9082
|
|
|
} |
|
9083
|
|
|
// $ANTLR end "problem_element" |
|
9084
|
|
|
|
|
9085
|
|
|
|
|
9086
|
|
|
public static class range_return extends ParserRuleReturnScope { |
|
9087
|
|
|
Object tree; |
|
9088
|
|
|
@Override |
|
9089
|
|
|
public Object getTree() { return tree; } |
|
9090
|
|
|
}; |
|
9091
|
|
|
|
|
9092
|
|
|
|
|
9093
|
|
|
// $ANTLR start "range" |
|
9094
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:184:1: range : '[' positive_number ',' positive_number ']' -> ^( '[' positive_number positive_number ) ; |
|
9095
|
|
|
public final ddl3Parser.range_return range() throws RecognitionException { |
|
9096
|
|
|
ddl3Parser.range_return retval = new ddl3Parser.range_return(); |
|
9097
|
|
|
retval.start = input.LT(1); |
|
9098
|
|
|
int range_StartIndex = input.index(); |
|
9099
|
|
|
|
|
9100
|
|
|
Object root_0 = null; |
|
9101
|
|
|
|
|
9102
|
|
|
Token char_literal350=null; |
|
9103
|
|
|
Token char_literal352=null; |
|
9104
|
|
|
Token char_literal354=null; |
|
9105
|
|
|
ParserRuleReturnScope positive_number351 =null; |
|
9106
|
|
|
ParserRuleReturnScope positive_number353 =null; |
|
9107
|
|
|
|
|
9108
|
|
|
Object char_literal350_tree=null; |
|
9109
|
|
|
Object char_literal352_tree=null; |
|
9110
|
|
|
Object char_literal354_tree=null; |
|
9111
|
|
|
RewriteRuleTokenStream stream_77=new RewriteRuleTokenStream(adaptor,"token 77"); |
|
9112
|
|
|
RewriteRuleTokenStream stream_15=new RewriteRuleTokenStream(adaptor,"token 15"); |
|
9113
|
|
|
RewriteRuleTokenStream stream_76=new RewriteRuleTokenStream(adaptor,"token 76"); |
|
9114
|
|
|
RewriteRuleSubtreeStream stream_positive_number=new RewriteRuleSubtreeStream(adaptor,"rule positive_number"); |
|
9115
|
|
|
|
|
9116
|
|
|
try { |
|
9117
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return retval; } |
|
9118
|
|
|
|
|
9119
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:184:7: ( '[' positive_number ',' positive_number ']' -> ^( '[' positive_number positive_number ) ) |
|
9120
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:184:9: '[' positive_number ',' positive_number ']' |
|
9121
|
|
|
{ |
|
9122
|
|
|
char_literal350=(Token)match(input,76,FOLLOW_76_in_range2189); if (state.failed) return retval; |
|
9123
|
|
|
if ( state.backtracking==0 ) stream_76.add(char_literal350); |
|
9124
|
|
|
|
|
9125
|
|
|
pushFollow(FOLLOW_positive_number_in_range2191); |
|
9126
|
|
|
positive_number351=positive_number(); |
|
9127
|
|
|
state._fsp--; |
|
9128
|
|
|
if (state.failed) return retval; |
|
9129
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number351.getTree()); |
|
9130
|
|
|
char_literal352=(Token)match(input,15,FOLLOW_15_in_range2193); if (state.failed) return retval; |
|
9131
|
|
|
if ( state.backtracking==0 ) stream_15.add(char_literal352); |
|
9132
|
|
|
|
|
9133
|
|
|
pushFollow(FOLLOW_positive_number_in_range2195); |
|
9134
|
|
|
positive_number353=positive_number(); |
|
9135
|
|
|
state._fsp--; |
|
9136
|
|
|
if (state.failed) return retval; |
|
9137
|
|
|
if ( state.backtracking==0 ) stream_positive_number.add(positive_number353.getTree()); |
|
9138
|
|
|
char_literal354=(Token)match(input,77,FOLLOW_77_in_range2197); if (state.failed) return retval; |
|
9139
|
|
|
if ( state.backtracking==0 ) stream_77.add(char_literal354); |
|
9140
|
|
|
|
|
9141
|
|
|
// AST REWRITE |
|
9142
|
|
|
// elements: 76, positive_number, positive_number |
|
9143
|
|
|
// token labels: |
|
9144
|
|
|
// rule labels: retval |
|
9145
|
|
|
// token list labels: |
|
9146
|
|
|
// rule list labels: |
|
9147
|
|
|
// wildcard labels: |
|
9148
|
|
|
if ( state.backtracking==0 ) { |
|
9149
|
|
|
retval.tree = root_0; |
|
9150
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9151
|
|
|
|
|
9152
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9153
|
|
|
// 184:53: -> ^( '[' positive_number positive_number ) |
|
9154
|
|
|
{ |
|
9155
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:184:55: ^( '[' positive_number positive_number ) |
|
9156
|
|
|
{ |
|
9157
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9158
|
|
|
root_1 = (Object)adaptor.becomeRoot(new DDLRange(stream_76.nextToken()), root_1); |
|
9159
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
9160
|
|
|
adaptor.addChild(root_1, stream_positive_number.nextTree()); |
|
9161
|
|
|
adaptor.addChild(root_0, root_1); |
|
9162
|
|
|
} |
|
9163
|
|
|
|
|
9164
|
|
|
} |
|
9165
|
|
|
|
|
9166
|
|
|
|
|
9167
|
|
|
retval.tree = root_0; |
|
9168
|
|
|
} |
|
9169
|
|
|
|
|
9170
|
|
|
} |
|
9171
|
|
|
|
|
9172
|
|
|
retval.stop = input.LT(-1); |
|
9173
|
|
|
|
|
9174
|
|
|
if ( state.backtracking==0 ) { |
|
9175
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
9176
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
9177
|
|
|
} |
|
9178
|
|
|
} |
|
9179
|
|
|
catch (RecognitionException re) { |
|
9180
|
|
|
reportError(re); |
|
9181
|
|
|
recover(input,re); |
|
9182
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
9183
|
|
|
} |
|
9184
|
|
|
finally { |
|
9185
|
|
|
// do for sure before leaving |
|
9186
|
|
|
if ( state.backtracking>0 ) { memoize(input, 46, range_StartIndex); } |
|
9187
|
|
|
|
|
9188
|
|
|
} |
|
9189
|
|
|
return retval; |
|
9190
|
|
|
} |
|
9191
|
|
|
// $ANTLR end "range" |
|
9192
|
|
|
|
|
9193
|
|
|
|
|
9194
|
|
|
public static class positive_number_return extends ParserRuleReturnScope { |
|
9195
|
|
|
Object tree; |
|
9196
|
|
|
@Override |
|
9197
|
|
|
public Object getTree() { return tree; } |
|
9198
|
|
|
}; |
|
9199
|
|
|
|
|
9200
|
|
|
|
|
9201
|
|
|
// $ANTLR start "positive_number" |
|
9202
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:186:1: positive_number : ( ( '+' )? INT -> ^( INT ) | ( '+' )? 'INF' -> ^( 'INF' ) ); |
|
9203
|
|
|
public final ddl3Parser.positive_number_return positive_number() throws RecognitionException { |
|
9204
|
|
|
ddl3Parser.positive_number_return retval = new ddl3Parser.positive_number_return(); |
|
9205
|
|
|
retval.start = input.LT(1); |
|
9206
|
|
|
int positive_number_StartIndex = input.index(); |
|
9207
|
|
|
|
|
9208
|
|
|
Object root_0 = null; |
|
9209
|
|
|
|
|
9210
|
|
|
Token char_literal355=null; |
|
9211
|
|
|
Token INT356=null; |
|
9212
|
|
|
Token char_literal357=null; |
|
9213
|
|
|
Token string_literal358=null; |
|
9214
|
|
|
|
|
9215
|
|
|
Object char_literal355_tree=null; |
|
9216
|
|
|
Object INT356_tree=null; |
|
9217
|
|
|
Object char_literal357_tree=null; |
|
9218
|
|
|
Object string_literal358_tree=null; |
|
9219
|
|
|
RewriteRuleTokenStream stream_14=new RewriteRuleTokenStream(adaptor,"token 14"); |
|
9220
|
|
|
RewriteRuleTokenStream stream_INT=new RewriteRuleTokenStream(adaptor,"token INT"); |
|
9221
|
|
|
RewriteRuleTokenStream stream_54=new RewriteRuleTokenStream(adaptor,"token 54"); |
|
9222
|
|
|
|
|
9223
|
|
|
try { |
|
9224
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return retval; } |
|
9225
|
|
|
|
|
9226
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:2: ( ( '+' )? INT -> ^( INT ) | ( '+' )? 'INF' -> ^( 'INF' ) ) |
|
9227
|
|
|
int alt64=2; |
|
9228
|
|
View Code Duplication |
switch ( input.LA(1) ) { |
|
|
|
|
|
|
9229
|
|
|
case 14: |
|
9230
|
|
|
{ |
|
9231
|
|
|
int LA64_1 = input.LA(2); |
|
9232
|
|
|
if ( (LA64_1==INT) ) { |
|
9233
|
|
|
alt64=1; |
|
9234
|
|
|
} |
|
9235
|
|
|
else if ( (LA64_1==54) ) { |
|
9236
|
|
|
alt64=2; |
|
9237
|
|
|
} |
|
9238
|
|
|
|
|
9239
|
|
|
else { |
|
9240
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
9241
|
|
|
int nvaeMark = input.mark(); |
|
9242
|
|
|
try { |
|
9243
|
|
|
input.consume(); |
|
9244
|
|
|
NoViableAltException nvae = |
|
9245
|
|
|
new NoViableAltException("", 64, 1, input); |
|
9246
|
|
|
throw nvae; |
|
9247
|
|
|
} finally { |
|
9248
|
|
|
input.rewind(nvaeMark); |
|
9249
|
|
|
} |
|
9250
|
|
|
} |
|
9251
|
|
|
|
|
9252
|
|
|
} |
|
9253
|
|
|
break; |
|
9254
|
|
|
case INT: |
|
9255
|
|
|
{ |
|
9256
|
|
|
alt64=1; |
|
9257
|
|
|
} |
|
9258
|
|
|
break; |
|
9259
|
|
|
case 54: |
|
9260
|
|
|
{ |
|
9261
|
|
|
alt64=2; |
|
9262
|
|
|
} |
|
9263
|
|
|
break; |
|
9264
|
|
|
default: |
|
9265
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
9266
|
|
|
NoViableAltException nvae = |
|
9267
|
|
|
new NoViableAltException("", 64, 0, input); |
|
9268
|
|
|
throw nvae; |
|
9269
|
|
|
} |
|
9270
|
|
|
switch (alt64) { |
|
9271
|
|
|
case 1 : |
|
9272
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:4: ( '+' )? INT |
|
9273
|
|
|
{ |
|
9274
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:4: ( '+' )? |
|
9275
|
|
|
int alt62=2; |
|
9276
|
|
|
int LA62_0 = input.LA(1); |
|
9277
|
|
|
if ( (LA62_0==14) ) { |
|
9278
|
|
|
alt62=1; |
|
9279
|
|
|
} |
|
9280
|
|
|
switch (alt62) { |
|
9281
|
|
|
case 1 : |
|
9282
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:5: '+' |
|
9283
|
|
|
{ |
|
9284
|
|
|
char_literal355=(Token)match(input,14,FOLLOW_14_in_positive_number2219); if (state.failed) return retval; |
|
9285
|
|
|
if ( state.backtracking==0 ) stream_14.add(char_literal355); |
|
9286
|
|
|
|
|
9287
|
|
|
} |
|
9288
|
|
|
break; |
|
9289
|
|
|
|
|
9290
|
|
|
} |
|
9291
|
|
|
|
|
9292
|
|
|
INT356=(Token)match(input,INT,FOLLOW_INT_in_positive_number2223); if (state.failed) return retval; |
|
9293
|
|
|
if ( state.backtracking==0 ) stream_INT.add(INT356); |
|
9294
|
|
|
|
|
9295
|
|
|
// AST REWRITE |
|
9296
|
|
|
// elements: INT |
|
9297
|
|
|
// token labels: |
|
9298
|
|
|
// rule labels: retval |
|
9299
|
|
|
// token list labels: |
|
9300
|
|
|
// rule list labels: |
|
9301
|
|
|
// wildcard labels: |
|
9302
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
9303
|
|
|
retval.tree = root_0; |
|
9304
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9305
|
|
|
|
|
9306
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9307
|
|
|
// 187:15: -> ^( INT ) |
|
9308
|
|
|
{ |
|
9309
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:17: ^( INT ) |
|
9310
|
|
|
{ |
|
9311
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9312
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_INT.nextNode(), root_1); |
|
9313
|
|
|
adaptor.addChild(root_0, root_1); |
|
9314
|
|
|
} |
|
9315
|
|
|
|
|
9316
|
|
|
} |
|
9317
|
|
|
|
|
9318
|
|
|
|
|
9319
|
|
|
retval.tree = root_0; |
|
9320
|
|
|
} |
|
9321
|
|
|
|
|
9322
|
|
|
} |
|
9323
|
|
|
break; |
|
9324
|
|
|
case 2 : |
|
9325
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:26: ( '+' )? 'INF' |
|
9326
|
|
|
{ |
|
9327
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:26: ( '+' )? |
|
9328
|
|
|
int alt63=2; |
|
9329
|
|
|
int LA63_0 = input.LA(1); |
|
9330
|
|
|
if ( (LA63_0==14) ) { |
|
9331
|
|
|
alt63=1; |
|
9332
|
|
|
} |
|
9333
|
|
|
switch (alt63) { |
|
9334
|
|
|
case 1 : |
|
9335
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:27: '+' |
|
9336
|
|
|
{ |
|
9337
|
|
|
char_literal357=(Token)match(input,14,FOLLOW_14_in_positive_number2233); if (state.failed) return retval; |
|
9338
|
|
|
if ( state.backtracking==0 ) stream_14.add(char_literal357); |
|
9339
|
|
|
|
|
9340
|
|
|
} |
|
9341
|
|
|
break; |
|
9342
|
|
|
|
|
9343
|
|
|
} |
|
9344
|
|
|
|
|
9345
|
|
|
string_literal358=(Token)match(input,54,FOLLOW_54_in_positive_number2237); if (state.failed) return retval; |
|
9346
|
|
|
if ( state.backtracking==0 ) stream_54.add(string_literal358); |
|
9347
|
|
|
|
|
9348
|
|
|
// AST REWRITE |
|
9349
|
|
|
// elements: 54 |
|
9350
|
|
|
// token labels: |
|
9351
|
|
|
// rule labels: retval |
|
9352
|
|
|
// token list labels: |
|
9353
|
|
|
// rule list labels: |
|
9354
|
|
|
// wildcard labels: |
|
9355
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
9356
|
|
|
retval.tree = root_0; |
|
9357
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9358
|
|
|
|
|
9359
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9360
|
|
|
// 187:39: -> ^( 'INF' ) |
|
9361
|
|
|
{ |
|
9362
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:187:41: ^( 'INF' ) |
|
9363
|
|
|
{ |
|
9364
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9365
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_54.nextNode(), root_1); |
|
9366
|
|
|
adaptor.addChild(root_0, root_1); |
|
9367
|
|
|
} |
|
9368
|
|
|
|
|
9369
|
|
|
} |
|
9370
|
|
|
|
|
9371
|
|
|
|
|
9372
|
|
|
retval.tree = root_0; |
|
9373
|
|
|
} |
|
9374
|
|
|
|
|
9375
|
|
|
} |
|
9376
|
|
|
break; |
|
9377
|
|
|
|
|
9378
|
|
|
} |
|
9379
|
|
|
retval.stop = input.LT(-1); |
|
9380
|
|
|
|
|
9381
|
|
|
if ( state.backtracking==0 ) { |
|
9382
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
9383
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
9384
|
|
|
} |
|
9385
|
|
|
} |
|
9386
|
|
|
catch (RecognitionException re) { |
|
9387
|
|
|
reportError(re); |
|
9388
|
|
|
recover(input,re); |
|
9389
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
9390
|
|
|
} |
|
9391
|
|
|
finally { |
|
9392
|
|
|
// do for sure before leaving |
|
9393
|
|
|
if ( state.backtracking>0 ) { memoize(input, 47, positive_number_StartIndex); } |
|
9394
|
|
|
|
|
9395
|
|
|
} |
|
9396
|
|
|
return retval; |
|
9397
|
|
|
} |
|
9398
|
|
|
// $ANTLR end "positive_number" |
|
9399
|
|
|
|
|
9400
|
|
|
|
|
9401
|
|
|
public static class number_return extends ParserRuleReturnScope { |
|
9402
|
|
|
Object tree; |
|
9403
|
|
|
@Override |
|
9404
|
|
|
public Object getTree() { return tree; } |
|
9405
|
|
|
}; |
|
9406
|
|
|
|
|
9407
|
|
|
|
|
9408
|
|
|
// $ANTLR start "number" |
|
9409
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:1: number : ( ( sign )? INT -> ^( INT ( sign )? ) | ( sign )? 'INF' -> ^( 'INF' ( sign )? ) ); |
|
9410
|
|
|
public final ddl3Parser.number_return number() throws RecognitionException { |
|
9411
|
|
|
ddl3Parser.number_return retval = new ddl3Parser.number_return(); |
|
9412
|
|
|
retval.start = input.LT(1); |
|
9413
|
|
|
int number_StartIndex = input.index(); |
|
9414
|
|
|
|
|
9415
|
|
|
Object root_0 = null; |
|
9416
|
|
|
|
|
9417
|
|
|
Token INT360=null; |
|
9418
|
|
|
Token string_literal362=null; |
|
9419
|
|
|
ParserRuleReturnScope sign359 =null; |
|
9420
|
|
|
ParserRuleReturnScope sign361 =null; |
|
9421
|
|
|
|
|
9422
|
|
|
Object INT360_tree=null; |
|
9423
|
|
|
Object string_literal362_tree=null; |
|
9424
|
|
|
RewriteRuleTokenStream stream_INT=new RewriteRuleTokenStream(adaptor,"token INT"); |
|
9425
|
|
|
RewriteRuleTokenStream stream_54=new RewriteRuleTokenStream(adaptor,"token 54"); |
|
9426
|
|
|
RewriteRuleSubtreeStream stream_sign=new RewriteRuleSubtreeStream(adaptor,"rule sign"); |
|
9427
|
|
|
|
|
9428
|
|
|
try { |
|
9429
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return retval; } |
|
9430
|
|
|
|
|
9431
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:8: ( ( sign )? INT -> ^( INT ( sign )? ) | ( sign )? 'INF' -> ^( 'INF' ( sign )? ) ) |
|
9432
|
|
|
int alt67=2; |
|
9433
|
|
View Code Duplication |
switch ( input.LA(1) ) { |
|
|
|
|
|
|
9434
|
|
|
case 14: |
|
9435
|
|
|
case 16: |
|
9436
|
|
|
{ |
|
9437
|
|
|
int LA67_1 = input.LA(2); |
|
9438
|
|
|
if ( (LA67_1==INT) ) { |
|
9439
|
|
|
alt67=1; |
|
9440
|
|
|
} |
|
9441
|
|
|
else if ( (LA67_1==54) ) { |
|
9442
|
|
|
alt67=2; |
|
9443
|
|
|
} |
|
9444
|
|
|
|
|
9445
|
|
|
else { |
|
9446
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
9447
|
|
|
int nvaeMark = input.mark(); |
|
9448
|
|
|
try { |
|
9449
|
|
|
input.consume(); |
|
9450
|
|
|
NoViableAltException nvae = |
|
9451
|
|
|
new NoViableAltException("", 67, 1, input); |
|
9452
|
|
|
throw nvae; |
|
9453
|
|
|
} finally { |
|
9454
|
|
|
input.rewind(nvaeMark); |
|
9455
|
|
|
} |
|
9456
|
|
|
} |
|
9457
|
|
|
|
|
9458
|
|
|
} |
|
9459
|
|
|
break; |
|
9460
|
|
|
case INT: |
|
9461
|
|
|
{ |
|
9462
|
|
|
alt67=1; |
|
9463
|
|
|
} |
|
9464
|
|
|
break; |
|
9465
|
|
|
case 54: |
|
9466
|
|
|
{ |
|
9467
|
|
|
alt67=2; |
|
9468
|
|
|
} |
|
9469
|
|
|
break; |
|
9470
|
|
|
default: |
|
9471
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
9472
|
|
|
NoViableAltException nvae = |
|
9473
|
|
|
new NoViableAltException("", 67, 0, input); |
|
9474
|
|
|
throw nvae; |
|
9475
|
|
|
} |
|
9476
|
|
|
switch (alt67) { |
|
9477
|
|
|
case 1 : |
|
9478
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:10: ( sign )? INT |
|
9479
|
|
|
{ |
|
9480
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:10: ( sign )? |
|
9481
|
|
|
int alt65=2; |
|
9482
|
|
|
int LA65_0 = input.LA(1); |
|
9483
|
|
|
if ( (LA65_0==14||LA65_0==16) ) { |
|
9484
|
|
|
alt65=1; |
|
9485
|
|
|
} |
|
9486
|
|
|
switch (alt65) { |
|
9487
|
|
|
case 1 : |
|
9488
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:11: sign |
|
9489
|
|
|
{ |
|
9490
|
|
|
pushFollow(FOLLOW_sign_in_number2251); |
|
9491
|
|
|
sign359=sign(); |
|
9492
|
|
|
state._fsp--; |
|
9493
|
|
|
if (state.failed) return retval; |
|
9494
|
|
|
if ( state.backtracking==0 ) stream_sign.add(sign359.getTree()); |
|
9495
|
|
|
} |
|
9496
|
|
|
break; |
|
9497
|
|
|
|
|
9498
|
|
|
} |
|
9499
|
|
|
|
|
9500
|
|
|
INT360=(Token)match(input,INT,FOLLOW_INT_in_number2255); if (state.failed) return retval; |
|
9501
|
|
|
if ( state.backtracking==0 ) stream_INT.add(INT360); |
|
9502
|
|
|
|
|
9503
|
|
|
// AST REWRITE |
|
9504
|
|
|
// elements: INT, sign |
|
9505
|
|
|
// token labels: |
|
9506
|
|
|
// rule labels: retval |
|
9507
|
|
|
// token list labels: |
|
9508
|
|
|
// rule list labels: |
|
9509
|
|
|
// wildcard labels: |
|
9510
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
9511
|
|
|
retval.tree = root_0; |
|
9512
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9513
|
|
|
|
|
9514
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9515
|
|
|
// 189:22: -> ^( INT ( sign )? ) |
|
9516
|
|
|
{ |
|
9517
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:24: ^( INT ( sign )? ) |
|
9518
|
|
|
{ |
|
9519
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9520
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_INT.nextNode(), root_1); |
|
9521
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:30: ( sign )? |
|
9522
|
|
|
if ( stream_sign.hasNext() ) { |
|
9523
|
|
|
adaptor.addChild(root_1, stream_sign.nextTree()); |
|
9524
|
|
|
} |
|
9525
|
|
|
stream_sign.reset(); |
|
9526
|
|
|
|
|
9527
|
|
|
adaptor.addChild(root_0, root_1); |
|
9528
|
|
|
} |
|
9529
|
|
|
|
|
9530
|
|
|
} |
|
9531
|
|
|
|
|
9532
|
|
|
|
|
9533
|
|
|
retval.tree = root_0; |
|
9534
|
|
|
} |
|
9535
|
|
|
|
|
9536
|
|
|
} |
|
9537
|
|
|
break; |
|
9538
|
|
|
case 2 : |
|
9539
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:41: ( sign )? 'INF' |
|
9540
|
|
|
{ |
|
9541
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:41: ( sign )? |
|
9542
|
|
|
int alt66=2; |
|
9543
|
|
|
int LA66_0 = input.LA(1); |
|
9544
|
|
|
if ( (LA66_0==14||LA66_0==16) ) { |
|
9545
|
|
|
alt66=1; |
|
9546
|
|
|
} |
|
9547
|
|
|
switch (alt66) { |
|
9548
|
|
|
case 1 : |
|
9549
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:42: sign |
|
9550
|
|
|
{ |
|
9551
|
|
|
pushFollow(FOLLOW_sign_in_number2270); |
|
9552
|
|
|
sign361=sign(); |
|
9553
|
|
|
state._fsp--; |
|
9554
|
|
|
if (state.failed) return retval; |
|
9555
|
|
|
if ( state.backtracking==0 ) stream_sign.add(sign361.getTree()); |
|
9556
|
|
|
} |
|
9557
|
|
|
break; |
|
9558
|
|
|
|
|
9559
|
|
|
} |
|
9560
|
|
|
|
|
9561
|
|
|
string_literal362=(Token)match(input,54,FOLLOW_54_in_number2274); if (state.failed) return retval; |
|
9562
|
|
|
if ( state.backtracking==0 ) stream_54.add(string_literal362); |
|
9563
|
|
|
|
|
9564
|
|
|
// AST REWRITE |
|
9565
|
|
|
// elements: 54, sign |
|
9566
|
|
|
// token labels: |
|
9567
|
|
|
// rule labels: retval |
|
9568
|
|
|
// token list labels: |
|
9569
|
|
|
// rule list labels: |
|
9570
|
|
|
// wildcard labels: |
|
9571
|
|
View Code Duplication |
if ( state.backtracking==0 ) { |
|
|
|
|
|
|
9572
|
|
|
retval.tree = root_0; |
|
9573
|
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null); |
|
9574
|
|
|
|
|
9575
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9576
|
|
|
// 189:55: -> ^( 'INF' ( sign )? ) |
|
9577
|
|
|
{ |
|
9578
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:57: ^( 'INF' ( sign )? ) |
|
9579
|
|
|
{ |
|
9580
|
|
|
Object root_1 = (Object)adaptor.nil(); |
|
9581
|
|
|
root_1 = (Object)adaptor.becomeRoot(stream_54.nextNode(), root_1); |
|
9582
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:189:65: ( sign )? |
|
9583
|
|
|
if ( stream_sign.hasNext() ) { |
|
9584
|
|
|
adaptor.addChild(root_1, stream_sign.nextTree()); |
|
9585
|
|
|
} |
|
9586
|
|
|
stream_sign.reset(); |
|
9587
|
|
|
|
|
9588
|
|
|
adaptor.addChild(root_0, root_1); |
|
9589
|
|
|
} |
|
9590
|
|
|
|
|
9591
|
|
|
} |
|
9592
|
|
|
|
|
9593
|
|
|
|
|
9594
|
|
|
retval.tree = root_0; |
|
9595
|
|
|
} |
|
9596
|
|
|
|
|
9597
|
|
|
} |
|
9598
|
|
|
break; |
|
9599
|
|
|
|
|
9600
|
|
|
} |
|
9601
|
|
|
retval.stop = input.LT(-1); |
|
9602
|
|
|
|
|
9603
|
|
|
if ( state.backtracking==0 ) { |
|
9604
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
9605
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
9606
|
|
|
} |
|
9607
|
|
|
} |
|
9608
|
|
|
catch (RecognitionException re) { |
|
9609
|
|
|
reportError(re); |
|
9610
|
|
|
recover(input,re); |
|
9611
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
9612
|
|
|
} |
|
9613
|
|
|
finally { |
|
9614
|
|
|
// do for sure before leaving |
|
9615
|
|
|
if ( state.backtracking>0 ) { memoize(input, 48, number_StartIndex); } |
|
9616
|
|
|
|
|
9617
|
|
|
} |
|
9618
|
|
|
return retval; |
|
9619
|
|
|
} |
|
9620
|
|
|
// $ANTLR end "number" |
|
9621
|
|
|
|
|
9622
|
|
|
|
|
9623
|
|
|
public static class sign_return extends ParserRuleReturnScope { |
|
9624
|
|
|
Object tree; |
|
9625
|
|
|
@Override |
|
9626
|
|
|
public Object getTree() { return tree; } |
|
9627
|
|
|
}; |
|
9628
|
|
|
|
|
9629
|
|
|
|
|
9630
|
|
|
// $ANTLR start "sign" |
|
9631
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:191:1: sign : ( '+' | '-' ); |
|
9632
|
|
View Code Duplication |
public final ddl3Parser.sign_return sign() throws RecognitionException { |
|
|
|
|
|
|
9633
|
|
|
ddl3Parser.sign_return retval = new ddl3Parser.sign_return(); |
|
9634
|
|
|
retval.start = input.LT(1); |
|
9635
|
|
|
int sign_StartIndex = input.index(); |
|
9636
|
|
|
|
|
9637
|
|
|
Object root_0 = null; |
|
9638
|
|
|
|
|
9639
|
|
|
Token set363=null; |
|
9640
|
|
|
|
|
9641
|
|
|
Object set363_tree=null; |
|
9642
|
|
|
|
|
9643
|
|
|
try { |
|
9644
|
|
|
if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return retval; } |
|
9645
|
|
|
|
|
9646
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:191:6: ( '+' | '-' ) |
|
9647
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g: |
|
9648
|
|
|
{ |
|
9649
|
|
|
root_0 = (Object)adaptor.nil(); |
|
9650
|
|
|
|
|
9651
|
|
|
|
|
9652
|
|
|
set363=input.LT(1); |
|
9653
|
|
|
if ( input.LA(1)==14||input.LA(1)==16 ) { |
|
9654
|
|
|
input.consume(); |
|
9655
|
|
|
if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set363)); |
|
9656
|
|
|
state.errorRecovery=false; |
|
9657
|
|
|
state.failed=false; |
|
9658
|
|
|
} |
|
9659
|
|
|
else { |
|
9660
|
|
|
if (state.backtracking>0) {state.failed=true; return retval;} |
|
9661
|
|
|
MismatchedSetException mse = new MismatchedSetException(null,input); |
|
9662
|
|
|
throw mse; |
|
9663
|
|
|
} |
|
9664
|
|
|
} |
|
9665
|
|
|
|
|
9666
|
|
|
retval.stop = input.LT(-1); |
|
9667
|
|
|
|
|
9668
|
|
|
if ( state.backtracking==0 ) { |
|
9669
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0); |
|
9670
|
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop); |
|
9671
|
|
|
} |
|
9672
|
|
|
} |
|
9673
|
|
|
catch (RecognitionException re) { |
|
9674
|
|
|
reportError(re); |
|
9675
|
|
|
recover(input,re); |
|
9676
|
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re); |
|
9677
|
|
|
} |
|
9678
|
|
|
finally { |
|
9679
|
|
|
// do for sure before leaving |
|
9680
|
|
|
if ( state.backtracking>0 ) { memoize(input, 49, sign_StartIndex); } |
|
9681
|
|
|
|
|
9682
|
|
|
} |
|
9683
|
|
|
return retval; |
|
9684
|
|
|
} |
|
9685
|
|
|
// $ANTLR end "sign" |
|
9686
|
|
|
|
|
9687
|
|
|
// $ANTLR start synpred35_ddl3 |
|
9688
|
|
|
public final void synpred35_ddl3_fragment() throws RecognitionException { |
|
9689
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:62:4: ( numeric_parameter_constraint ) |
|
9690
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:62:4: numeric_parameter_constraint |
|
9691
|
|
|
{ |
|
9692
|
|
|
pushFollow(FOLLOW_numeric_parameter_constraint_in_synpred35_ddl3708); |
|
9693
|
|
|
numeric_parameter_constraint(); |
|
9694
|
|
|
state._fsp--; |
|
9695
|
|
|
if (state.failed) return; |
|
9696
|
|
|
|
|
9697
|
|
|
} |
|
9698
|
|
|
|
|
9699
|
|
|
} |
|
9700
|
|
|
// $ANTLR end synpred35_ddl3 |
|
9701
|
|
|
|
|
9702
|
|
|
// $ANTLR start synpred77_ddl3 |
|
9703
|
|
|
public final void synpred77_ddl3_fragment() throws RecognitionException { |
|
9704
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:4: ( simple_ground_state_variable_component_decision ) |
|
9705
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:4: simple_ground_state_variable_component_decision |
|
9706
|
|
|
{ |
|
9707
|
|
|
pushFollow(FOLLOW_simple_ground_state_variable_component_decision_in_synpred77_ddl31639); |
|
9708
|
|
|
simple_ground_state_variable_component_decision(); |
|
9709
|
|
|
state._fsp--; |
|
9710
|
|
|
if (state.failed) return; |
|
9711
|
|
|
|
|
9712
|
|
|
} |
|
9713
|
|
|
|
|
9714
|
|
|
} |
|
9715
|
|
|
// $ANTLR end synpred77_ddl3 |
|
9716
|
|
|
|
|
9717
|
|
|
// $ANTLR start synpred78_ddl3 |
|
9718
|
|
|
public final void synpred78_ddl3_fragment() throws RecognitionException { |
|
9719
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:54: ( singleton_state_variable_component_decision ) |
|
9720
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:147:54: singleton_state_variable_component_decision |
|
9721
|
|
|
{ |
|
9722
|
|
|
pushFollow(FOLLOW_singleton_state_variable_component_decision_in_synpred78_ddl31643); |
|
9723
|
|
|
singleton_state_variable_component_decision(); |
|
9724
|
|
|
state._fsp--; |
|
9725
|
|
|
if (state.failed) return; |
|
9726
|
|
|
|
|
9727
|
|
|
} |
|
9728
|
|
|
|
|
9729
|
|
|
} |
|
9730
|
|
|
// $ANTLR end synpred78_ddl3 |
|
9731
|
|
|
|
|
9732
|
|
|
// $ANTLR start synpred101_ddl3 |
|
9733
|
|
|
public final void synpred101_ddl3_fragment() throws RecognitionException { |
|
9734
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:4: ( VarID ( '=' number )? ) |
|
9735
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:4: VarID ( '=' number )? |
|
9736
|
|
|
{ |
|
9737
|
|
|
match(input,VarID,FOLLOW_VarID_in_synpred101_ddl32010); if (state.failed) return; |
|
9738
|
|
|
|
|
9739
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:10: ( '=' number )? |
|
9740
|
|
|
int alt88=2; |
|
9741
|
|
|
int LA88_0 = input.LA(1); |
|
9742
|
|
|
if ( (LA88_0==22) ) { |
|
9743
|
|
|
alt88=1; |
|
9744
|
|
|
} |
|
9745
|
|
|
switch (alt88) { |
|
9746
|
|
|
case 1 : |
|
9747
|
|
|
// /home/alessandro/opt/antlr/ddl3/ddl3.g:174:11: '=' number |
|
9748
|
|
|
{ |
|
9749
|
|
|
match(input,22,FOLLOW_22_in_synpred101_ddl32013); if (state.failed) return; |
|
9750
|
|
|
|
|
9751
|
|
|
pushFollow(FOLLOW_number_in_synpred101_ddl32015); |
|
9752
|
|
|
number(); |
|
9753
|
|
|
state._fsp--; |
|
9754
|
|
|
if (state.failed) return; |
|
9755
|
|
|
|
|
9756
|
|
|
} |
|
9757
|
|
|
break; |
|
9758
|
|
|
|
|
9759
|
|
|
} |
|
9760
|
|
|
|
|
9761
|
|
|
} |
|
9762
|
|
|
|
|
9763
|
|
|
} |
|
9764
|
|
|
// $ANTLR end synpred101_ddl3 |
|
9765
|
|
|
|
|
9766
|
|
|
// Delegated rules |
|
9767
|
|
|
|
|
9768
|
|
|
public final boolean synpred78_ddl3() { |
|
9769
|
|
|
state.backtracking++; |
|
9770
|
|
|
int start = input.mark(); |
|
9771
|
|
|
try { |
|
9772
|
|
|
synpred78_ddl3_fragment(); // can never throw exception |
|
9773
|
|
|
} catch (RecognitionException re) { |
|
9774
|
|
|
System.err.println("impossible: "+re); |
|
9775
|
|
|
} |
|
9776
|
|
|
boolean success = !state.failed; |
|
9777
|
|
|
input.rewind(start); |
|
9778
|
|
|
state.backtracking--; |
|
9779
|
|
|
state.failed=false; |
|
9780
|
|
|
return success; |
|
9781
|
|
|
} |
|
9782
|
|
|
public final boolean synpred77_ddl3() { |
|
9783
|
|
|
state.backtracking++; |
|
9784
|
|
|
int start = input.mark(); |
|
9785
|
|
|
try { |
|
9786
|
|
|
synpred77_ddl3_fragment(); // can never throw exception |
|
9787
|
|
|
} catch (RecognitionException re) { |
|
9788
|
|
|
System.err.println("impossible: "+re); |
|
9789
|
|
|
} |
|
9790
|
|
|
boolean success = !state.failed; |
|
9791
|
|
|
input.rewind(start); |
|
9792
|
|
|
state.backtracking--; |
|
9793
|
|
|
state.failed=false; |
|
9794
|
|
|
return success; |
|
9795
|
|
|
} |
|
9796
|
|
|
public final boolean synpred35_ddl3() { |
|
9797
|
|
|
state.backtracking++; |
|
9798
|
|
|
int start = input.mark(); |
|
9799
|
|
|
try { |
|
9800
|
|
|
synpred35_ddl3_fragment(); // can never throw exception |
|
9801
|
|
|
} catch (RecognitionException re) { |
|
9802
|
|
|
System.err.println("impossible: "+re); |
|
9803
|
|
|
} |
|
9804
|
|
|
boolean success = !state.failed; |
|
9805
|
|
|
input.rewind(start); |
|
9806
|
|
|
state.backtracking--; |
|
9807
|
|
|
state.failed=false; |
|
9808
|
|
|
return success; |
|
9809
|
|
|
} |
|
9810
|
|
|
public final boolean synpred101_ddl3() { |
|
9811
|
|
|
state.backtracking++; |
|
9812
|
|
|
int start = input.mark(); |
|
9813
|
|
|
try { |
|
9814
|
|
|
synpred101_ddl3_fragment(); // can never throw exception |
|
9815
|
|
|
} catch (RecognitionException re) { |
|
9816
|
|
|
System.err.println("impossible: "+re); |
|
9817
|
|
|
} |
|
9818
|
|
|
boolean success = !state.failed; |
|
9819
|
|
|
input.rewind(start); |
|
9820
|
|
|
state.backtracking--; |
|
9821
|
|
|
state.failed=false; |
|
9822
|
|
|
return success; |
|
9823
|
|
|
} |
|
9824
|
|
|
|
|
9825
|
|
|
|
|
9826
|
|
|
protected DFA38 dfa38 = new DFA38(this); |
|
9827
|
|
|
protected DFA50 dfa50 = new DFA50(this); |
|
9828
|
|
|
static final String DFA38_eotS = |
|
9829
|
|
|
"\15\uffff"; |
|
9830
|
|
|
static final String DFA38_eofS = |
|
9831
|
|
|
"\15\uffff"; |
|
9832
|
|
|
static final String DFA38_minS = |
|
9833
|
|
|
"\2\5\1\13\2\uffff\1\17\1\7\2\5\1\0\1\uffff\1\17\1\uffff"; |
|
9834
|
|
|
static final String DFA38_maxS = |
|
9835
|
|
|
"\1\77\1\117\1\13\2\uffff\1\27\1\14\1\117\1\77\1\0\1\uffff\1\27\1\uffff"; |
|
9836
|
|
|
static final String DFA38_acceptS = |
|
9837
|
|
|
"\3\uffff\1\3\1\4\5\uffff\1\2\1\uffff\1\1"; |
|
9838
|
|
|
static final String DFA38_specialS = |
|
9839
|
|
|
"\11\uffff\1\0\3\uffff}>"; |
|
9840
|
|
|
static final String[] DFA38_transitionS = { |
|
9841
|
|
|
"\1\2\16\uffff\1\1\17\uffff\1\4\31\uffff\1\4\1\3", |
|
9842
|
|
|
"\1\5\3\uffff\1\5\17\uffff\1\5\64\uffff\2\5", |
|
9843
|
|
|
"\1\6", |
|
9844
|
|
|
"", |
|
9845
|
|
|
"", |
|
9846
|
|
|
"\1\7\7\uffff\1\10", |
|
9847
|
|
|
"\1\12\4\uffff\1\11", |
|
9848
|
|
|
"\1\13\3\uffff\1\13\17\uffff\1\13\64\uffff\2\13", |
|
9849
|
|
|
"\1\2\36\uffff\1\4\31\uffff\1\4\1\3", |
|
9850
|
|
|
"\1\uffff", |
|
9851
|
|
|
"", |
|
9852
|
|
|
"\1\7\7\uffff\1\10", |
|
9853
|
|
|
"" |
|
9854
|
|
|
}; |
|
9855
|
|
|
|
|
9856
|
|
|
static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS); |
|
9857
|
|
|
static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS); |
|
9858
|
|
|
static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS); |
|
9859
|
|
|
static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS); |
|
9860
|
|
|
static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS); |
|
9861
|
|
|
static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS); |
|
9862
|
|
|
static final short[][] DFA38_transition; |
|
9863
|
|
|
|
|
9864
|
|
|
static { |
|
9865
|
|
|
int numStates = DFA38_transitionS.length; |
|
9866
|
|
|
DFA38_transition = new short[numStates][]; |
|
9867
|
|
|
for (int i=0; i<numStates; i++) { |
|
9868
|
|
|
DFA38_transition[i] = DFA.unpackEncodedString(DFA38_transitionS[i]); |
|
9869
|
|
|
} |
|
9870
|
|
|
} |
|
9871
|
|
|
|
|
9872
|
|
|
protected class DFA38 extends DFA { |
|
9873
|
|
|
|
|
9874
|
|
|
public DFA38(BaseRecognizer recognizer) { |
|
9875
|
|
|
this.recognizer = recognizer; |
|
9876
|
|
|
this.decisionNumber = 38; |
|
9877
|
|
|
this.eot = DFA38_eot; |
|
9878
|
|
|
this.eof = DFA38_eof; |
|
9879
|
|
|
this.min = DFA38_min; |
|
9880
|
|
|
this.max = DFA38_max; |
|
9881
|
|
|
this.accept = DFA38_accept; |
|
9882
|
|
|
this.special = DFA38_special; |
|
9883
|
|
|
this.transition = DFA38_transition; |
|
9884
|
|
|
} |
|
9885
|
|
|
@Override |
|
9886
|
|
|
public String getDescription() { |
|
9887
|
|
|
return "146:1: component_decision : ( simple_ground_state_variable_component_decision | singleton_state_variable_component_decision | renewable_resource_component_decision | consumable_resource_component_decision );"; |
|
9888
|
|
|
} |
|
9889
|
|
|
@Override |
|
9890
|
|
|
public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
|
9891
|
|
|
TokenStream input = (TokenStream)_input; |
|
9892
|
|
|
int _s = s; |
|
9893
|
|
|
switch ( s ) { |
|
9894
|
|
|
case 0 : |
|
9895
|
|
|
int LA38_9 = input.LA(1); |
|
9896
|
|
|
|
|
9897
|
|
|
int index38_9 = input.index(); |
|
9898
|
|
|
input.rewind(); |
|
9899
|
|
|
s = -1; |
|
9900
|
|
|
if ( (synpred77_ddl3()) ) {s = 12;} |
|
9901
|
|
|
else if ( (synpred78_ddl3()) ) {s = 10;} |
|
9902
|
|
|
|
|
9903
|
|
|
input.seek(index38_9); |
|
9904
|
|
|
if ( s>=0 ) return s; |
|
9905
|
|
|
break; |
|
9906
|
|
|
} |
|
9907
|
|
|
if (state.backtracking>0) {state.failed=true; return -1;} |
|
9908
|
|
|
NoViableAltException nvae = |
|
9909
|
|
|
new NoViableAltException(getDescription(), 38, _s, input); |
|
9910
|
|
|
error(nvae); |
|
9911
|
|
|
throw nvae; |
|
9912
|
|
|
} |
|
9913
|
|
|
} |
|
9914
|
|
|
|
|
9915
|
|
|
static final String DFA50_eotS = |
|
9916
|
|
|
"\10\uffff"; |
|
9917
|
|
|
static final String DFA50_eofS = |
|
9918
|
|
|
"\10\uffff"; |
|
9919
|
|
|
static final String DFA50_minS = |
|
9920
|
|
|
"\1\24\1\5\2\uffff\1\17\1\5\1\44\1\17"; |
|
9921
|
|
|
static final String DFA50_maxS = |
|
9922
|
|
|
"\1\76\1\117\2\uffff\1\27\1\117\1\76\1\27"; |
|
9923
|
|
|
static final String DFA50_acceptS = |
|
9924
|
|
|
"\2\uffff\1\1\1\2\4\uffff"; |
|
9925
|
|
|
static final String DFA50_specialS = |
|
9926
|
|
|
"\10\uffff}>"; |
|
9927
|
|
|
static final String[] DFA50_transitionS = { |
|
9928
|
|
|
"\1\1\17\uffff\1\3\31\uffff\1\2", |
|
9929
|
|
|
"\1\4\3\uffff\1\4\17\uffff\1\4\64\uffff\2\4", |
|
9930
|
|
|
"", |
|
9931
|
|
|
"", |
|
9932
|
|
|
"\1\5\7\uffff\1\6", |
|
9933
|
|
|
"\1\7\3\uffff\1\7\17\uffff\1\7\64\uffff\2\7", |
|
9934
|
|
|
"\1\3\31\uffff\1\2", |
|
9935
|
|
|
"\1\5\7\uffff\1\6" |
|
9936
|
|
|
}; |
|
9937
|
|
|
|
|
9938
|
|
|
static final short[] DFA50_eot = DFA.unpackEncodedString(DFA50_eotS); |
|
9939
|
|
|
static final short[] DFA50_eof = DFA.unpackEncodedString(DFA50_eofS); |
|
9940
|
|
|
static final char[] DFA50_min = DFA.unpackEncodedStringToUnsignedChars(DFA50_minS); |
|
9941
|
|
|
static final char[] DFA50_max = DFA.unpackEncodedStringToUnsignedChars(DFA50_maxS); |
|
9942
|
|
|
static final short[] DFA50_accept = DFA.unpackEncodedString(DFA50_acceptS); |
|
9943
|
|
|
static final short[] DFA50_special = DFA.unpackEncodedString(DFA50_specialS); |
|
9944
|
|
|
static final short[][] DFA50_transition; |
|
9945
|
|
|
|
|
9946
|
|
|
static { |
|
9947
|
|
|
int numStates = DFA50_transitionS.length; |
|
9948
|
|
|
DFA50_transition = new short[numStates][]; |
|
9949
|
|
|
for (int i=0; i<numStates; i++) { |
|
9950
|
|
|
DFA50_transition[i] = DFA.unpackEncodedString(DFA50_transitionS[i]); |
|
9951
|
|
|
} |
|
9952
|
|
|
} |
|
9953
|
|
|
|
|
9954
|
|
|
protected class DFA50 extends DFA { |
|
9955
|
|
|
|
|
9956
|
|
|
public DFA50(BaseRecognizer recognizer) { |
|
9957
|
|
|
this.recognizer = recognizer; |
|
9958
|
|
|
this.decisionNumber = 50; |
|
9959
|
|
|
this.eot = DFA50_eot; |
|
9960
|
|
|
this.eof = DFA50_eof; |
|
9961
|
|
|
this.min = DFA50_min; |
|
9962
|
|
|
this.max = DFA50_max; |
|
9963
|
|
|
this.accept = DFA50_accept; |
|
9964
|
|
|
this.special = DFA50_special; |
|
9965
|
|
|
this.transition = DFA50_transition; |
|
9966
|
|
|
} |
|
9967
|
|
|
@Override |
|
9968
|
|
|
public String getDescription() { |
|
9969
|
|
|
return "164:1: consumable_resource_component_decision : ( consumable_resource_production_component_decision | consumable_resource_consumption_component_decision );"; |
|
9970
|
|
|
} |
|
9971
|
|
|
} |
|
9972
|
|
|
|
|
9973
|
|
|
public static final BitSet FOLLOW_domain_in_ddl42 = new BitSet(new long[]{0x2000000000000002L}); |
|
9974
|
|
|
public static final BitSet FOLLOW_problem_in_ddl45 = new BitSet(new long[]{0x0000000000000002L}); |
|
9975
|
|
|
public static final BitSet FOLLOW_problem_in_ddl63 = new BitSet(new long[]{0x0000000000000002L}); |
|
9976
|
|
|
public static final BitSet FOLLOW_41_in_domain80 = new BitSet(new long[]{0x0000000000000020L}); |
|
9977
|
|
|
public static final BitSet FOLLOW_ID_in_domain82 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
9978
|
|
|
public static final BitSet FOLLOW_80_in_domain84 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); |
|
9979
|
|
|
public static final BitSet FOLLOW_temporal_module_in_domain86 = new BitSet(new long[]{0x1000000C00000000L,0x0000000000020080L}); |
|
9980
|
|
|
public static final BitSet FOLLOW_domain_element_in_domain88 = new BitSet(new long[]{0x1000000C00000000L,0x0000000000020080L}); |
|
9981
|
|
|
public static final BitSet FOLLOW_81_in_domain91 = new BitSet(new long[]{0x0000000000000002L}); |
|
9982
|
|
|
public static final BitSet FOLLOW_74_in_temporal_module113 = new BitSet(new long[]{0x0000000000000020L}); |
|
9983
|
|
|
public static final BitSet FOLLOW_ID_in_temporal_module115 = new BitSet(new long[]{0x0000000000400000L}); |
|
9984
|
|
|
public static final BitSet FOLLOW_22_in_temporal_module117 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
9985
|
|
|
public static final BitSet FOLLOW_range_in_temporal_module119 = new BitSet(new long[]{0x0000000000008000L}); |
|
9986
|
|
|
public static final BitSet FOLLOW_15_in_temporal_module121 = new BitSet(new long[]{0x0000000000000040L}); |
|
9987
|
|
|
public static final BitSet FOLLOW_INT_in_temporal_module123 = new BitSet(new long[]{0x0000000000080000L}); |
|
9988
|
|
|
public static final BitSet FOLLOW_19_in_temporal_module125 = new BitSet(new long[]{0x0000000000000002L}); |
|
9989
|
|
|
public static final BitSet FOLLOW_parameter_type_in_domain_element146 = new BitSet(new long[]{0x0000000000000002L}); |
|
9990
|
|
|
public static final BitSet FOLLOW_component_type_in_domain_element150 = new BitSet(new long[]{0x0000000000000002L}); |
|
9991
|
|
|
public static final BitSet FOLLOW_component_in_domain_element154 = new BitSet(new long[]{0x0000000000000002L}); |
|
9992
|
|
|
public static final BitSet FOLLOW_timeline_synchronization_in_domain_element158 = new BitSet(new long[]{0x0000000000000002L}); |
|
9993
|
|
|
public static final BitSet FOLLOW_numeric_parameter_type_in_parameter_type168 = new BitSet(new long[]{0x0000000000000002L}); |
|
9994
|
|
|
public static final BitSet FOLLOW_enumeration_parameter_type_in_parameter_type172 = new BitSet(new long[]{0x0000000000000002L}); |
|
9995
|
|
|
public static final BitSet FOLLOW_60_in_numeric_parameter_type182 = new BitSet(new long[]{0x0200000000000000L}); |
|
9996
|
|
|
public static final BitSet FOLLOW_57_in_numeric_parameter_type184 = new BitSet(new long[]{0x0000000000000020L}); |
|
9997
|
|
|
public static final BitSet FOLLOW_ID_in_numeric_parameter_type186 = new BitSet(new long[]{0x0000000000400000L}); |
|
9998
|
|
|
public static final BitSet FOLLOW_22_in_numeric_parameter_type188 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
9999
|
|
|
public static final BitSet FOLLOW_76_in_numeric_parameter_type190 = new BitSet(new long[]{0x0040000000014040L}); |
|
10000
|
|
|
public static final BitSet FOLLOW_number_in_numeric_parameter_type192 = new BitSet(new long[]{0x0000000000008000L}); |
|
10001
|
|
|
public static final BitSet FOLLOW_15_in_numeric_parameter_type194 = new BitSet(new long[]{0x0040000000014040L}); |
|
10002
|
|
|
public static final BitSet FOLLOW_number_in_numeric_parameter_type196 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); |
|
10003
|
|
|
public static final BitSet FOLLOW_77_in_numeric_parameter_type198 = new BitSet(new long[]{0x0000000000080000L}); |
|
10004
|
|
|
public static final BitSet FOLLOW_19_in_numeric_parameter_type200 = new BitSet(new long[]{0x0000000000000002L}); |
|
10005
|
|
|
public static final BitSet FOLLOW_60_in_enumeration_parameter_type222 = new BitSet(new long[]{0x0004000000000000L}); |
|
10006
|
|
|
public static final BitSet FOLLOW_50_in_enumeration_parameter_type224 = new BitSet(new long[]{0x0000000000000020L}); |
|
10007
|
|
|
public static final BitSet FOLLOW_ID_in_enumeration_parameter_type226 = new BitSet(new long[]{0x0000000000400000L}); |
|
10008
|
|
|
public static final BitSet FOLLOW_22_in_enumeration_parameter_type228 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10009
|
|
|
public static final BitSet FOLLOW_80_in_enumeration_parameter_type230 = new BitSet(new long[]{0x0000000000000020L}); |
|
10010
|
|
|
public static final BitSet FOLLOW_ID_in_enumeration_parameter_type232 = new BitSet(new long[]{0x0000000000008000L,0x0000000000020000L}); |
|
10011
|
|
|
public static final BitSet FOLLOW_15_in_enumeration_parameter_type235 = new BitSet(new long[]{0x0000000000000020L}); |
|
10012
|
|
|
public static final BitSet FOLLOW_ID_in_enumeration_parameter_type237 = new BitSet(new long[]{0x0000000000008000L,0x0000000000020000L}); |
|
10013
|
|
|
public static final BitSet FOLLOW_81_in_enumeration_parameter_type241 = new BitSet(new long[]{0x0000000000080000L}); |
|
10014
|
|
|
public static final BitSet FOLLOW_19_in_enumeration_parameter_type243 = new BitSet(new long[]{0x0000000000000002L}); |
|
10015
|
|
|
public static final BitSet FOLLOW_55_in_temporal_relation_type264 = new BitSet(new long[]{0x0000000000000002L}); |
|
10016
|
|
|
public static final BitSet FOLLOW_56_in_temporal_relation_type277 = new BitSet(new long[]{0x0000000000000002L}); |
|
10017
|
|
|
public static final BitSet FOLLOW_31_in_temporal_relation_type290 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10018
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type292 = new BitSet(new long[]{0x0000000000000002L}); |
|
10019
|
|
|
public static final BitSet FOLLOW_26_in_temporal_relation_type307 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10020
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type309 = new BitSet(new long[]{0x0000000000000002L}); |
|
10021
|
|
|
public static final BitSet FOLLOW_47_in_temporal_relation_type324 = new BitSet(new long[]{0x0000000000000002L}); |
|
10022
|
|
|
public static final BitSet FOLLOW_68_in_temporal_relation_type337 = new BitSet(new long[]{0x0000000000000002L}); |
|
10023
|
|
|
public static final BitSet FOLLOW_67_in_temporal_relation_type350 = new BitSet(new long[]{0x0000000000000002L}); |
|
10024
|
|
|
public static final BitSet FOLLOW_52_in_temporal_relation_type363 = new BitSet(new long[]{0x0000000000000002L}); |
|
10025
|
|
|
public static final BitSet FOLLOW_51_in_temporal_relation_type376 = new BitSet(new long[]{0x0000000000000002L}); |
|
10026
|
|
|
public static final BitSet FOLLOW_42_in_temporal_relation_type389 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10027
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type391 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10028
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type393 = new BitSet(new long[]{0x0000000000000002L}); |
|
10029
|
|
|
public static final BitSet FOLLOW_37_in_temporal_relation_type410 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10030
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type412 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10031
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type414 = new BitSet(new long[]{0x0000000000000002L}); |
|
10032
|
|
|
public static final BitSet FOLLOW_59_in_temporal_relation_type431 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10033
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type433 = new BitSet(new long[]{0x0000000000000002L}); |
|
10034
|
|
|
public static final BitSet FOLLOW_58_in_temporal_relation_type448 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10035
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type450 = new BitSet(new long[]{0x0000000000000002L}); |
|
10036
|
|
|
public static final BitSet FOLLOW_69_in_temporal_relation_type465 = new BitSet(new long[]{0x0000000000000002L}); |
|
10037
|
|
|
public static final BitSet FOLLOW_45_in_temporal_relation_type478 = new BitSet(new long[]{0x0000000000000002L}); |
|
10038
|
|
|
public static final BitSet FOLLOW_30_in_temporal_relation_type491 = new BitSet(new long[]{0x0000000000000002L}); |
|
10039
|
|
|
public static final BitSet FOLLOW_29_in_temporal_relation_type504 = new BitSet(new long[]{0x0000000000000002L}); |
|
10040
|
|
|
public static final BitSet FOLLOW_32_in_temporal_relation_type517 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10041
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type519 = new BitSet(new long[]{0x0000000000000002L}); |
|
10042
|
|
|
public static final BitSet FOLLOW_27_in_temporal_relation_type534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10043
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type536 = new BitSet(new long[]{0x0000000000000002L}); |
|
10044
|
|
|
public static final BitSet FOLLOW_66_in_temporal_relation_type551 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10045
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type553 = new BitSet(new long[]{0x0000000000000002L}); |
|
10046
|
|
|
public static final BitSet FOLLOW_65_in_temporal_relation_type568 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10047
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type570 = new BitSet(new long[]{0x0000000000000002L}); |
|
10048
|
|
|
public static final BitSet FOLLOW_44_in_temporal_relation_type585 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10049
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type587 = new BitSet(new long[]{0x0000000000000002L}); |
|
10050
|
|
|
public static final BitSet FOLLOW_43_in_temporal_relation_type602 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10051
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type604 = new BitSet(new long[]{0x0000000000000002L}); |
|
10052
|
|
|
public static final BitSet FOLLOW_39_in_temporal_relation_type619 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10053
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10054
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type623 = new BitSet(new long[]{0x0000000000000002L}); |
|
10055
|
|
|
public static final BitSet FOLLOW_38_in_temporal_relation_type640 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10056
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type642 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10057
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type644 = new BitSet(new long[]{0x0000000000000002L}); |
|
10058
|
|
|
public static final BitSet FOLLOW_70_in_temporal_relation_type661 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10059
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type663 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10060
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type665 = new BitSet(new long[]{0x0000000000000002L}); |
|
10061
|
|
|
public static final BitSet FOLLOW_46_in_temporal_relation_type682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10062
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type684 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10063
|
|
|
public static final BitSet FOLLOW_range_in_temporal_relation_type686 = new BitSet(new long[]{0x0000000000000002L}); |
|
10064
|
|
|
public static final BitSet FOLLOW_numeric_parameter_constraint_in_parameter_constraint708 = new BitSet(new long[]{0x0000000000000002L}); |
|
10065
|
|
|
public static final BitSet FOLLOW_enumeration_parameter_constraint_in_parameter_constraint712 = new BitSet(new long[]{0x0000000000000002L}); |
|
10066
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint722 = new BitSet(new long[]{0x0000000000400000L}); |
|
10067
|
|
|
public static final BitSet FOLLOW_22_in_numeric_parameter_constraint724 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10068
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint726 = new BitSet(new long[]{0x0000000000000002L}); |
|
10069
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint743 = new BitSet(new long[]{0x0000000000100000L}); |
|
10070
|
|
|
public static final BitSet FOLLOW_20_in_numeric_parameter_constraint745 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10071
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint747 = new BitSet(new long[]{0x0000000000000002L}); |
|
10072
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint764 = new BitSet(new long[]{0x0000000000800000L}); |
|
10073
|
|
|
public static final BitSet FOLLOW_23_in_numeric_parameter_constraint766 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10074
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint768 = new BitSet(new long[]{0x0000000000000002L}); |
|
10075
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint785 = new BitSet(new long[]{0x0000000000200000L}); |
|
10076
|
|
|
public static final BitSet FOLLOW_21_in_numeric_parameter_constraint787 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10077
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint789 = new BitSet(new long[]{0x0000000000000002L}); |
|
10078
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint806 = new BitSet(new long[]{0x0000000001000000L}); |
|
10079
|
|
|
public static final BitSet FOLLOW_24_in_numeric_parameter_constraint808 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10080
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint810 = new BitSet(new long[]{0x0000000000000002L}); |
|
10081
|
|
|
public static final BitSet FOLLOW_numeric_comparison_lvalue_in_numeric_parameter_constraint827 = new BitSet(new long[]{0x0000000000000400L}); |
|
10082
|
|
|
public static final BitSet FOLLOW_10_in_numeric_parameter_constraint829 = new BitSet(new long[]{0x00400000000140C0L}); |
|
10083
|
|
|
public static final BitSet FOLLOW_numeric_comparison_rvalue_in_numeric_parameter_constraint831 = new BitSet(new long[]{0x0000000000000002L}); |
|
10084
|
|
|
public static final BitSet FOLLOW_VarID_in_numeric_comparison_lvalue852 = new BitSet(new long[]{0x0000000000000002L}); |
|
10085
|
|
|
public static final BitSet FOLLOW_number_in_numeric_comparison_lvalue856 = new BitSet(new long[]{0x0000000000002000L}); |
|
10086
|
|
|
public static final BitSet FOLLOW_13_in_numeric_comparison_lvalue858 = new BitSet(new long[]{0x0000000000000080L}); |
|
10087
|
|
|
public static final BitSet FOLLOW_VarID_in_numeric_comparison_lvalue861 = new BitSet(new long[]{0x0000000000000002L}); |
|
10088
|
|
|
public static final BitSet FOLLOW_first_numeric_comparison_rvalue_in_numeric_comparison_rvalue870 = new BitSet(new long[]{0x0000000000014002L}); |
|
10089
|
|
|
public static final BitSet FOLLOW_other_numeric_comparison_rvalues_in_numeric_comparison_rvalue873 = new BitSet(new long[]{0x0000000000014002L}); |
|
10090
|
|
|
public static final BitSet FOLLOW_VarID_in_first_numeric_comparison_rvalue884 = new BitSet(new long[]{0x0000000000000002L}); |
|
10091
|
|
|
public static final BitSet FOLLOW_number_in_first_numeric_comparison_rvalue888 = new BitSet(new long[]{0x0000000000002000L}); |
|
10092
|
|
|
public static final BitSet FOLLOW_13_in_first_numeric_comparison_rvalue890 = new BitSet(new long[]{0x0000000000000080L}); |
|
10093
|
|
|
public static final BitSet FOLLOW_VarID_in_first_numeric_comparison_rvalue893 = new BitSet(new long[]{0x0000000000000002L}); |
|
10094
|
|
|
public static final BitSet FOLLOW_number_in_first_numeric_comparison_rvalue897 = new BitSet(new long[]{0x0000000000000002L}); |
|
10095
|
|
|
public static final BitSet FOLLOW_set_in_other_numeric_comparison_rvalues906 = new BitSet(new long[]{0x00000000000000C0L}); |
|
10096
|
|
|
public static final BitSet FOLLOW_numeric_comparison_value_in_other_numeric_comparison_rvalues915 = new BitSet(new long[]{0x0000000000000002L}); |
|
10097
|
|
|
public static final BitSet FOLLOW_VarID_in_numeric_comparison_value924 = new BitSet(new long[]{0x0000000000000002L}); |
|
10098
|
|
|
public static final BitSet FOLLOW_INT_in_numeric_comparison_value928 = new BitSet(new long[]{0x0000000000002000L}); |
|
10099
|
|
|
public static final BitSet FOLLOW_13_in_numeric_comparison_value930 = new BitSet(new long[]{0x0000000000000080L}); |
|
10100
|
|
|
public static final BitSet FOLLOW_VarID_in_numeric_comparison_value933 = new BitSet(new long[]{0x0000000000000002L}); |
|
10101
|
|
|
public static final BitSet FOLLOW_INT_in_numeric_comparison_value937 = new BitSet(new long[]{0x0000000000000002L}); |
|
10102
|
|
|
public static final BitSet FOLLOW_VarID_in_enumeration_parameter_constraint946 = new BitSet(new long[]{0x0000000000400000L}); |
|
10103
|
|
|
public static final BitSet FOLLOW_22_in_enumeration_parameter_constraint948 = new BitSet(new long[]{0x00000000000000A0L}); |
|
10104
|
|
|
public static final BitSet FOLLOW_enumeration_comparison_rvalue_in_enumeration_parameter_constraint950 = new BitSet(new long[]{0x0000000000000002L}); |
|
10105
|
|
|
public static final BitSet FOLLOW_VarID_in_enumeration_parameter_constraint966 = new BitSet(new long[]{0x0000000000000400L}); |
|
10106
|
|
|
public static final BitSet FOLLOW_10_in_enumeration_parameter_constraint968 = new BitSet(new long[]{0x00000000000000A0L}); |
|
10107
|
|
|
public static final BitSet FOLLOW_enumeration_comparison_rvalue_in_enumeration_parameter_constraint970 = new BitSet(new long[]{0x0000000000000002L}); |
|
10108
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_type_in_component_type1006 = new BitSet(new long[]{0x0000000000000002L}); |
|
10109
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_type_in_component_type1010 = new BitSet(new long[]{0x0000000000000002L}); |
|
10110
|
|
|
public static final BitSet FOLLOW_renewable_resource_component_type_in_component_type1014 = new BitSet(new long[]{0x0000000000000002L}); |
|
10111
|
|
|
public static final BitSet FOLLOW_consumable_resource_component_type_in_component_type1018 = new BitSet(new long[]{0x0000000000000002L}); |
|
10112
|
|
|
public static final BitSet FOLLOW_35_in_simple_ground_state_variable_component_type1028 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); |
|
10113
|
|
|
public static final BitSet FOLLOW_72_in_simple_ground_state_variable_component_type1030 = new BitSet(new long[]{0x0000000000000020L}); |
|
10114
|
|
|
public static final BitSet FOLLOW_ID_in_simple_ground_state_variable_component_type1032 = new BitSet(new long[]{0x0000000000000800L}); |
|
10115
|
|
|
public static final BitSet FOLLOW_11_in_simple_ground_state_variable_component_type1034 = new BitSet(new long[]{0x0000000000000020L}); |
|
10116
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_type_in_simple_ground_state_variable_component_type1036 = new BitSet(new long[]{0x0000000000009000L}); |
|
10117
|
|
|
public static final BitSet FOLLOW_15_in_simple_ground_state_variable_component_type1039 = new BitSet(new long[]{0x0000000000000020L}); |
|
10118
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_type_in_simple_ground_state_variable_component_type1041 = new BitSet(new long[]{0x0000000000009000L}); |
|
10119
|
|
|
public static final BitSet FOLLOW_12_in_simple_ground_state_variable_component_type1045 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10120
|
|
|
public static final BitSet FOLLOW_80_in_simple_ground_state_variable_component_type1047 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); |
|
10121
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_transition_constraint_in_simple_ground_state_variable_component_type1050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); |
|
10122
|
|
|
public static final BitSet FOLLOW_81_in_simple_ground_state_variable_component_type1054 = new BitSet(new long[]{0x0000000000000002L}); |
|
10123
|
|
|
public static final BitSet FOLLOW_ID_in_simple_ground_state_variable_component_decision_type1081 = new BitSet(new long[]{0x0000000000000800L}); |
|
10124
|
|
|
public static final BitSet FOLLOW_11_in_simple_ground_state_variable_component_decision_type1083 = new BitSet(new long[]{0x0000000000001000L}); |
|
10125
|
|
|
public static final BitSet FOLLOW_12_in_simple_ground_state_variable_component_decision_type1085 = new BitSet(new long[]{0x0000000000000002L}); |
|
10126
|
|
|
public static final BitSet FOLLOW_75_in_simple_ground_state_variable_transition_constraint1102 = new BitSet(new long[]{0x0000000000100020L}); |
|
10127
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_in_simple_ground_state_variable_transition_constraint1104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10128
|
|
|
public static final BitSet FOLLOW_range_in_simple_ground_state_variable_transition_constraint1106 = new BitSet(new long[]{0x0080000000000002L}); |
|
10129
|
|
|
public static final BitSet FOLLOW_55_in_simple_ground_state_variable_transition_constraint1109 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10130
|
|
|
public static final BitSet FOLLOW_80_in_simple_ground_state_variable_transition_constraint1111 = new BitSet(new long[]{0x0000000000100020L,0x0000000000020000L}); |
|
10131
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_transition_element_in_simple_ground_state_variable_transition_constraint1114 = new BitSet(new long[]{0x0000000000080000L}); |
|
10132
|
|
|
public static final BitSet FOLLOW_19_in_simple_ground_state_variable_transition_constraint1116 = new BitSet(new long[]{0x0000000000100020L,0x0000000000020000L}); |
|
10133
|
|
|
public static final BitSet FOLLOW_81_in_simple_ground_state_variable_transition_constraint1120 = new BitSet(new long[]{0x0000000000000002L}); |
|
10134
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_in_simple_ground_state_variable_transition_element1148 = new BitSet(new long[]{0x0000000000000002L}); |
|
10135
|
|
|
public static final BitSet FOLLOW_35_in_singleton_state_variable_component_type1158 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); |
|
10136
|
|
|
public static final BitSet FOLLOW_73_in_singleton_state_variable_component_type1160 = new BitSet(new long[]{0x0000000000000020L}); |
|
10137
|
|
|
public static final BitSet FOLLOW_ID_in_singleton_state_variable_component_type1162 = new BitSet(new long[]{0x0000000000000800L}); |
|
10138
|
|
|
public static final BitSet FOLLOW_11_in_singleton_state_variable_component_type1164 = new BitSet(new long[]{0x0000000000000020L}); |
|
10139
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_type_in_singleton_state_variable_component_type1166 = new BitSet(new long[]{0x0000000000009000L}); |
|
10140
|
|
|
public static final BitSet FOLLOW_15_in_singleton_state_variable_component_type1169 = new BitSet(new long[]{0x0000000000000020L}); |
|
10141
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_type_in_singleton_state_variable_component_type1171 = new BitSet(new long[]{0x0000000000009000L}); |
|
10142
|
|
|
public static final BitSet FOLLOW_12_in_singleton_state_variable_component_type1175 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10143
|
|
|
public static final BitSet FOLLOW_80_in_singleton_state_variable_component_type1177 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); |
|
10144
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_transition_constraint_in_singleton_state_variable_component_type1180 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); |
|
10145
|
|
|
public static final BitSet FOLLOW_81_in_singleton_state_variable_component_type1184 = new BitSet(new long[]{0x0000000000000002L}); |
|
10146
|
|
|
public static final BitSet FOLLOW_ID_in_singleton_state_variable_component_decision_type1211 = new BitSet(new long[]{0x0000000000000800L}); |
|
10147
|
|
|
public static final BitSet FOLLOW_11_in_singleton_state_variable_component_decision_type1213 = new BitSet(new long[]{0x0000000000001020L}); |
|
10148
|
|
|
public static final BitSet FOLLOW_ID_in_singleton_state_variable_component_decision_type1216 = new BitSet(new long[]{0x0000000000009000L}); |
|
10149
|
|
|
public static final BitSet FOLLOW_15_in_singleton_state_variable_component_decision_type1219 = new BitSet(new long[]{0x0000000000000020L}); |
|
10150
|
|
|
public static final BitSet FOLLOW_ID_in_singleton_state_variable_component_decision_type1221 = new BitSet(new long[]{0x0000000000009000L}); |
|
10151
|
|
|
public static final BitSet FOLLOW_12_in_singleton_state_variable_component_decision_type1227 = new BitSet(new long[]{0x0000000000000002L}); |
|
10152
|
|
|
public static final BitSet FOLLOW_75_in_singleton_state_variable_transition_constraint1247 = new BitSet(new long[]{0x0000000000100020L}); |
|
10153
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_in_singleton_state_variable_transition_constraint1249 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10154
|
|
|
public static final BitSet FOLLOW_range_in_singleton_state_variable_transition_constraint1251 = new BitSet(new long[]{0x0080000000000000L}); |
|
10155
|
|
|
public static final BitSet FOLLOW_55_in_singleton_state_variable_transition_constraint1253 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10156
|
|
|
public static final BitSet FOLLOW_80_in_singleton_state_variable_transition_constraint1255 = new BitSet(new long[]{0x00400000001140E0L,0x0000000000020000L}); |
|
10157
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_transition_element_in_singleton_state_variable_transition_constraint1258 = new BitSet(new long[]{0x0000000000080000L}); |
|
10158
|
|
|
public static final BitSet FOLLOW_19_in_singleton_state_variable_transition_constraint1260 = new BitSet(new long[]{0x00400000001140E0L,0x0000000000020000L}); |
|
10159
|
|
|
public static final BitSet FOLLOW_81_in_singleton_state_variable_transition_constraint1264 = new BitSet(new long[]{0x0000000000000002L}); |
|
10160
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_in_singleton_state_variable_transition_element1290 = new BitSet(new long[]{0x0000000000000002L}); |
|
10161
|
|
|
public static final BitSet FOLLOW_parameter_constraint_in_singleton_state_variable_transition_element1294 = new BitSet(new long[]{0x0000000000000002L}); |
|
10162
|
|
|
public static final BitSet FOLLOW_35_in_renewable_resource_component_type1304 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); |
|
10163
|
|
|
public static final BitSet FOLLOW_64_in_renewable_resource_component_type1306 = new BitSet(new long[]{0x0000000000000020L}); |
|
10164
|
|
|
public static final BitSet FOLLOW_ID_in_renewable_resource_component_type1308 = new BitSet(new long[]{0x0000000000000800L}); |
|
10165
|
|
|
public static final BitSet FOLLOW_11_in_renewable_resource_component_type1310 = new BitSet(new long[]{0x0040000000004040L}); |
|
10166
|
|
|
public static final BitSet FOLLOW_positive_number_in_renewable_resource_component_type1312 = new BitSet(new long[]{0x0000000000001000L}); |
|
10167
|
|
|
public static final BitSet FOLLOW_12_in_renewable_resource_component_type1314 = new BitSet(new long[]{0x0000000000000002L}); |
|
10168
|
|
|
public static final BitSet FOLLOW_35_in_consumable_resource_component_type1334 = new BitSet(new long[]{0x0000010000000000L}); |
|
10169
|
|
|
public static final BitSet FOLLOW_40_in_consumable_resource_component_type1336 = new BitSet(new long[]{0x0000000000000020L}); |
|
10170
|
|
|
public static final BitSet FOLLOW_ID_in_consumable_resource_component_type1338 = new BitSet(new long[]{0x0000000000000800L}); |
|
10171
|
|
|
public static final BitSet FOLLOW_11_in_consumable_resource_component_type1340 = new BitSet(new long[]{0x0040000000004040L}); |
|
10172
|
|
|
public static final BitSet FOLLOW_positive_number_in_consumable_resource_component_type1342 = new BitSet(new long[]{0x0000000000008000L}); |
|
10173
|
|
|
public static final BitSet FOLLOW_15_in_consumable_resource_component_type1344 = new BitSet(new long[]{0x0040000000004040L}); |
|
10174
|
|
|
public static final BitSet FOLLOW_positive_number_in_consumable_resource_component_type1346 = new BitSet(new long[]{0x0000000000008000L}); |
|
10175
|
|
|
public static final BitSet FOLLOW_15_in_consumable_resource_component_type1348 = new BitSet(new long[]{0x0040000000004040L}); |
|
10176
|
|
|
public static final BitSet FOLLOW_positive_number_in_consumable_resource_component_type1350 = new BitSet(new long[]{0x0000000000001000L}); |
|
10177
|
|
|
public static final BitSet FOLLOW_12_in_consumable_resource_component_type1352 = new BitSet(new long[]{0x0000000000000002L}); |
|
10178
|
|
|
public static final BitSet FOLLOW_34_in_component1376 = new BitSet(new long[]{0x0000000000000020L}); |
|
10179
|
|
|
public static final BitSet FOLLOW_ID_in_component1378 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10180
|
|
|
public static final BitSet FOLLOW_80_in_component1380 = new BitSet(new long[]{0x0023000200000000L,0x0000000000020000L}); |
|
10181
|
|
|
public static final BitSet FOLLOW_timeline_in_component1383 = new BitSet(new long[]{0x0023000200000000L,0x0000000000020000L}); |
|
10182
|
|
|
public static final BitSet FOLLOW_81_in_component1387 = new BitSet(new long[]{0x0000000000040000L}); |
|
10183
|
|
|
public static final BitSet FOLLOW_18_in_component1389 = new BitSet(new long[]{0x0000000000000020L}); |
|
10184
|
|
|
public static final BitSet FOLLOW_ID_in_component1391 = new BitSet(new long[]{0x0000000000080000L}); |
|
10185
|
|
|
public static final BitSet FOLLOW_19_in_component1393 = new BitSet(new long[]{0x0000000000000002L}); |
|
10186
|
|
|
public static final BitSet FOLLOW_48_in_timeline1416 = new BitSet(new long[]{0x0000000000000020L}); |
|
10187
|
|
|
public static final BitSet FOLLOW_ID_in_timeline1418 = new BitSet(new long[]{0x0000000000000800L}); |
|
10188
|
|
|
public static final BitSet FOLLOW_11_in_timeline1420 = new BitSet(new long[]{0x0000000002001220L,0x000000000000C000L}); |
|
10189
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1423 = new BitSet(new long[]{0x0000000000009000L}); |
|
10190
|
|
|
public static final BitSet FOLLOW_15_in_timeline1426 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10191
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1428 = new BitSet(new long[]{0x0000000000009000L}); |
|
10192
|
|
|
public static final BitSet FOLLOW_12_in_timeline1434 = new BitSet(new long[]{0x0000000000000002L}); |
|
10193
|
|
|
public static final BitSet FOLLOW_33_in_timeline1451 = new BitSet(new long[]{0x0000000000000020L}); |
|
10194
|
|
|
public static final BitSet FOLLOW_ID_in_timeline1453 = new BitSet(new long[]{0x0000000000000800L}); |
|
10195
|
|
|
public static final BitSet FOLLOW_11_in_timeline1455 = new BitSet(new long[]{0x0000000002001220L,0x000000000000C000L}); |
|
10196
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1458 = new BitSet(new long[]{0x0000000000009000L}); |
|
10197
|
|
|
public static final BitSet FOLLOW_15_in_timeline1461 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10198
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1463 = new BitSet(new long[]{0x0000000000009000L}); |
|
10199
|
|
|
public static final BitSet FOLLOW_12_in_timeline1469 = new BitSet(new long[]{0x0000000000000002L}); |
|
10200
|
|
|
public static final BitSet FOLLOW_53_in_timeline1486 = new BitSet(new long[]{0x0000000000000020L}); |
|
10201
|
|
|
public static final BitSet FOLLOW_ID_in_timeline1488 = new BitSet(new long[]{0x0000000000000800L}); |
|
10202
|
|
|
public static final BitSet FOLLOW_11_in_timeline1490 = new BitSet(new long[]{0x0000000002001220L,0x000000000000C000L}); |
|
10203
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1493 = new BitSet(new long[]{0x0000000000009000L}); |
|
10204
|
|
|
public static final BitSet FOLLOW_15_in_timeline1496 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10205
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1498 = new BitSet(new long[]{0x0000000000009000L}); |
|
10206
|
|
|
public static final BitSet FOLLOW_12_in_timeline1504 = new BitSet(new long[]{0x0000000000000002L}); |
|
10207
|
|
|
public static final BitSet FOLLOW_49_in_timeline1521 = new BitSet(new long[]{0x0000000000000020L}); |
|
10208
|
|
|
public static final BitSet FOLLOW_ID_in_timeline1523 = new BitSet(new long[]{0x0000000000000800L}); |
|
10209
|
|
|
public static final BitSet FOLLOW_11_in_timeline1525 = new BitSet(new long[]{0x0000000002001220L,0x000000000000C000L}); |
|
10210
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1528 = new BitSet(new long[]{0x0000000000009000L}); |
|
10211
|
|
|
public static final BitSet FOLLOW_15_in_timeline1531 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10212
|
|
|
public static final BitSet FOLLOW_parameter_in_timeline1533 = new BitSet(new long[]{0x0000000000009000L}); |
|
10213
|
|
|
public static final BitSet FOLLOW_12_in_timeline1539 = new BitSet(new long[]{0x0000000000000002L}); |
|
10214
|
|
|
public static final BitSet FOLLOW_71_in_timeline_synchronization1563 = new BitSet(new long[]{0x0000000000000020L}); |
|
10215
|
|
|
public static final BitSet FOLLOW_ID_in_timeline_synchronization1565 = new BitSet(new long[]{0x0000000000020000L}); |
|
10216
|
|
|
public static final BitSet FOLLOW_17_in_timeline_synchronization1567 = new BitSet(new long[]{0x0000000000000020L}); |
|
10217
|
|
|
public static final BitSet FOLLOW_ID_in_timeline_synchronization1569 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10218
|
|
|
public static final BitSet FOLLOW_80_in_timeline_synchronization1571 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); |
|
10219
|
|
|
public static final BitSet FOLLOW_synchronization_in_timeline_synchronization1574 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); |
|
10220
|
|
|
public static final BitSet FOLLOW_81_in_timeline_synchronization1578 = new BitSet(new long[]{0x0000000000000002L}); |
|
10221
|
|
|
public static final BitSet FOLLOW_75_in_synchronization1604 = new BitSet(new long[]{0xC000001000100020L}); |
|
10222
|
|
|
public static final BitSet FOLLOW_component_decision_in_synchronization1606 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10223
|
|
|
public static final BitSet FOLLOW_80_in_synchronization1608 = new BitSet(new long[]{0x0DD8FCE1EC0140E0L,0x000000000002007EL}); |
|
10224
|
|
|
public static final BitSet FOLLOW_synchronization_element_in_synchronization1611 = new BitSet(new long[]{0x0DD8FCE1EC0140E0L,0x000000000002007EL}); |
|
10225
|
|
|
public static final BitSet FOLLOW_81_in_synchronization1615 = new BitSet(new long[]{0x0000000000000002L}); |
|
10226
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_in_component_decision1639 = new BitSet(new long[]{0x0000000000000002L}); |
|
10227
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_in_component_decision1643 = new BitSet(new long[]{0x0000000000000002L}); |
|
10228
|
|
|
public static final BitSet FOLLOW_renewable_resource_component_decision_in_component_decision1647 = new BitSet(new long[]{0x0000000000000002L}); |
|
10229
|
|
|
public static final BitSet FOLLOW_consumable_resource_component_decision_in_component_decision1651 = new BitSet(new long[]{0x0000000000000002L}); |
|
10230
|
|
|
public static final BitSet FOLLOW_ID_in_instantiated_component_decision1660 = new BitSet(new long[]{0x0000000000100020L}); |
|
10231
|
|
|
public static final BitSet FOLLOW_20_in_instantiated_component_decision1663 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10232
|
|
|
public static final BitSet FOLLOW_parameter_in_instantiated_component_decision1665 = new BitSet(new long[]{0x0000000000808000L}); |
|
10233
|
|
|
public static final BitSet FOLLOW_15_in_instantiated_component_decision1668 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10234
|
|
|
public static final BitSet FOLLOW_parameter_in_instantiated_component_decision1670 = new BitSet(new long[]{0x0000000000808000L}); |
|
10235
|
|
|
public static final BitSet FOLLOW_23_in_instantiated_component_decision1674 = new BitSet(new long[]{0x0000000000000020L}); |
|
10236
|
|
|
public static final BitSet FOLLOW_ID_in_instantiated_component_decision1678 = new BitSet(new long[]{0x0000000000020000L}); |
|
10237
|
|
|
public static final BitSet FOLLOW_17_in_instantiated_component_decision1680 = new BitSet(new long[]{0x0000000000000020L}); |
|
10238
|
|
|
public static final BitSet FOLLOW_ID_in_instantiated_component_decision1682 = new BitSet(new long[]{0x0000000000020000L}); |
|
10239
|
|
|
public static final BitSet FOLLOW_17_in_instantiated_component_decision1684 = new BitSet(new long[]{0xC000001000100020L}); |
|
10240
|
|
|
public static final BitSet FOLLOW_component_decision_in_instantiated_component_decision1686 = new BitSet(new long[]{0x0000000010000002L}); |
|
10241
|
|
|
public static final BitSet FOLLOW_28_in_instantiated_component_decision1689 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10242
|
|
|
public static final BitSet FOLLOW_range_in_instantiated_component_decision1691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10243
|
|
|
public static final BitSet FOLLOW_range_in_instantiated_component_decision1693 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
|
10244
|
|
|
public static final BitSet FOLLOW_range_in_instantiated_component_decision1695 = new BitSet(new long[]{0x0000000000000002L}); |
|
10245
|
|
|
public static final BitSet FOLLOW_20_in_simple_ground_state_variable_component_decision1761 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10246
|
|
|
public static final BitSet FOLLOW_parameter_in_simple_ground_state_variable_component_decision1763 = new BitSet(new long[]{0x0000000000808000L}); |
|
10247
|
|
|
public static final BitSet FOLLOW_15_in_simple_ground_state_variable_component_decision1766 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10248
|
|
|
public static final BitSet FOLLOW_parameter_in_simple_ground_state_variable_component_decision1768 = new BitSet(new long[]{0x0000000000808000L}); |
|
10249
|
|
|
public static final BitSet FOLLOW_23_in_simple_ground_state_variable_component_decision1772 = new BitSet(new long[]{0x0000000000000020L}); |
|
10250
|
|
|
public static final BitSet FOLLOW_ID_in_simple_ground_state_variable_component_decision1776 = new BitSet(new long[]{0x0000000000000800L}); |
|
10251
|
|
|
public static final BitSet FOLLOW_11_in_simple_ground_state_variable_component_decision1778 = new BitSet(new long[]{0x0000000000001000L}); |
|
10252
|
|
|
public static final BitSet FOLLOW_12_in_simple_ground_state_variable_component_decision1780 = new BitSet(new long[]{0x0000000000000002L}); |
|
10253
|
|
|
public static final BitSet FOLLOW_20_in_singleton_state_variable_component_decision1802 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10254
|
|
|
public static final BitSet FOLLOW_parameter_in_singleton_state_variable_component_decision1804 = new BitSet(new long[]{0x0000000000808000L}); |
|
10255
|
|
|
public static final BitSet FOLLOW_15_in_singleton_state_variable_component_decision1807 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10256
|
|
|
public static final BitSet FOLLOW_parameter_in_singleton_state_variable_component_decision1809 = new BitSet(new long[]{0x0000000000808000L}); |
|
10257
|
|
|
public static final BitSet FOLLOW_23_in_singleton_state_variable_component_decision1813 = new BitSet(new long[]{0x0000000000000020L}); |
|
10258
|
|
|
public static final BitSet FOLLOW_ID_in_singleton_state_variable_component_decision1817 = new BitSet(new long[]{0x0000000000000800L}); |
|
10259
|
|
|
public static final BitSet FOLLOW_11_in_singleton_state_variable_component_decision1819 = new BitSet(new long[]{0x0000000000001080L}); |
|
10260
|
|
|
public static final BitSet FOLLOW_par_value_in_singleton_state_variable_component_decision1822 = new BitSet(new long[]{0x0000000000009000L}); |
|
10261
|
|
|
public static final BitSet FOLLOW_15_in_singleton_state_variable_component_decision1825 = new BitSet(new long[]{0x0000000000000080L}); |
|
10262
|
|
|
public static final BitSet FOLLOW_par_value_in_singleton_state_variable_component_decision1827 = new BitSet(new long[]{0x0000000000009000L}); |
|
10263
|
|
|
public static final BitSet FOLLOW_12_in_singleton_state_variable_component_decision1833 = new BitSet(new long[]{0x0000000000000002L}); |
|
10264
|
|
|
public static final BitSet FOLLOW_20_in_renewable_resource_component_decision1860 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10265
|
|
|
public static final BitSet FOLLOW_parameter_in_renewable_resource_component_decision1862 = new BitSet(new long[]{0x0000000000808000L}); |
|
10266
|
|
|
public static final BitSet FOLLOW_15_in_renewable_resource_component_decision1865 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10267
|
|
|
public static final BitSet FOLLOW_parameter_in_renewable_resource_component_decision1867 = new BitSet(new long[]{0x0000000000808000L}); |
|
10268
|
|
|
public static final BitSet FOLLOW_23_in_renewable_resource_component_decision1871 = new BitSet(new long[]{0x8000000000000000L}); |
|
10269
|
|
|
public static final BitSet FOLLOW_63_in_renewable_resource_component_decision1875 = new BitSet(new long[]{0x0000000000000800L}); |
|
10270
|
|
|
public static final BitSet FOLLOW_11_in_renewable_resource_component_decision1877 = new BitSet(new long[]{0x0000000000000080L}); |
|
10271
|
|
|
public static final BitSet FOLLOW_par_value_in_renewable_resource_component_decision1879 = new BitSet(new long[]{0x0000000000001000L}); |
|
10272
|
|
|
public static final BitSet FOLLOW_12_in_renewable_resource_component_decision1881 = new BitSet(new long[]{0x0000000000000002L}); |
|
10273
|
|
|
public static final BitSet FOLLOW_consumable_resource_production_component_decision_in_consumable_resource_component_decision1905 = new BitSet(new long[]{0x0000000000000002L}); |
|
10274
|
|
|
public static final BitSet FOLLOW_consumable_resource_consumption_component_decision_in_consumable_resource_component_decision1909 = new BitSet(new long[]{0x0000000000000002L}); |
|
10275
|
|
|
public static final BitSet FOLLOW_20_in_consumable_resource_production_component_decision1921 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10276
|
|
|
public static final BitSet FOLLOW_parameter_in_consumable_resource_production_component_decision1923 = new BitSet(new long[]{0x0000000000808000L}); |
|
10277
|
|
|
public static final BitSet FOLLOW_15_in_consumable_resource_production_component_decision1926 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10278
|
|
|
public static final BitSet FOLLOW_parameter_in_consumable_resource_production_component_decision1928 = new BitSet(new long[]{0x0000000000808000L}); |
|
10279
|
|
|
public static final BitSet FOLLOW_23_in_consumable_resource_production_component_decision1932 = new BitSet(new long[]{0x4000000000000000L}); |
|
10280
|
|
|
public static final BitSet FOLLOW_62_in_consumable_resource_production_component_decision1936 = new BitSet(new long[]{0x0000000000000800L}); |
|
10281
|
|
|
public static final BitSet FOLLOW_11_in_consumable_resource_production_component_decision1938 = new BitSet(new long[]{0x0000000000000080L}); |
|
10282
|
|
|
public static final BitSet FOLLOW_par_value_in_consumable_resource_production_component_decision1940 = new BitSet(new long[]{0x0000000000001000L}); |
|
10283
|
|
|
public static final BitSet FOLLOW_12_in_consumable_resource_production_component_decision1942 = new BitSet(new long[]{0x0000000000000002L}); |
|
10284
|
|
|
public static final BitSet FOLLOW_20_in_consumable_resource_consumption_component_decision1967 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10285
|
|
|
public static final BitSet FOLLOW_parameter_in_consumable_resource_consumption_component_decision1969 = new BitSet(new long[]{0x0000000000808000L}); |
|
10286
|
|
|
public static final BitSet FOLLOW_15_in_consumable_resource_consumption_component_decision1972 = new BitSet(new long[]{0x0000000002000220L,0x000000000000C000L}); |
|
10287
|
|
|
public static final BitSet FOLLOW_parameter_in_consumable_resource_consumption_component_decision1974 = new BitSet(new long[]{0x0000000000808000L}); |
|
10288
|
|
|
public static final BitSet FOLLOW_23_in_consumable_resource_consumption_component_decision1978 = new BitSet(new long[]{0x0000001000000000L}); |
|
10289
|
|
|
public static final BitSet FOLLOW_36_in_consumable_resource_consumption_component_decision1982 = new BitSet(new long[]{0x0000000000000800L}); |
|
10290
|
|
|
public static final BitSet FOLLOW_11_in_consumable_resource_consumption_component_decision1984 = new BitSet(new long[]{0x0000000000000080L}); |
|
10291
|
|
|
public static final BitSet FOLLOW_par_value_in_consumable_resource_consumption_component_decision1986 = new BitSet(new long[]{0x0000000000001000L}); |
|
10292
|
|
|
public static final BitSet FOLLOW_12_in_consumable_resource_consumption_component_decision1988 = new BitSet(new long[]{0x0000000000000002L}); |
|
10293
|
|
|
public static final BitSet FOLLOW_VarID_in_par_value2010 = new BitSet(new long[]{0x0000000000400002L}); |
|
10294
|
|
|
public static final BitSet FOLLOW_22_in_par_value2013 = new BitSet(new long[]{0x0040000000014040L}); |
|
10295
|
|
|
public static final BitSet FOLLOW_number_in_par_value2015 = new BitSet(new long[]{0x0000000000000002L}); |
|
10296
|
|
|
public static final BitSet FOLLOW_VarID_in_par_value2029 = new BitSet(new long[]{0x0000000000400002L}); |
|
10297
|
|
|
public static final BitSet FOLLOW_22_in_par_value2032 = new BitSet(new long[]{0x0000000000000020L}); |
|
10298
|
|
|
public static final BitSet FOLLOW_ID_in_par_value2034 = new BitSet(new long[]{0x0000000000000002L}); |
|
10299
|
|
|
public static final BitSet FOLLOW_instantiated_component_decision_in_synchronization_element2053 = new BitSet(new long[]{0x0000000000080000L}); |
|
10300
|
|
|
public static final BitSet FOLLOW_19_in_synchronization_element2055 = new BitSet(new long[]{0x0000000000000002L}); |
|
10301
|
|
|
public static final BitSet FOLLOW_parameter_constraint_in_synchronization_element2059 = new BitSet(new long[]{0x0000000000080000L}); |
|
10302
|
|
|
public static final BitSet FOLLOW_19_in_synchronization_element2061 = new BitSet(new long[]{0x0000000000000002L}); |
|
10303
|
|
|
public static final BitSet FOLLOW_ID_in_synchronization_element2068 = new BitSet(new long[]{0x0D98FCE1EC000000L,0x000000000000007EL}); |
|
10304
|
|
|
public static final BitSet FOLLOW_temporal_relation_type_in_synchronization_element2072 = new BitSet(new long[]{0x0000000000000020L}); |
|
10305
|
|
|
public static final BitSet FOLLOW_ID_in_synchronization_element2076 = new BitSet(new long[]{0x0000000000080000L}); |
|
10306
|
|
|
public static final BitSet FOLLOW_19_in_synchronization_element2078 = new BitSet(new long[]{0x0000000000000002L}); |
|
10307
|
|
|
public static final BitSet FOLLOW_61_in_problem2103 = new BitSet(new long[]{0x0000000000000020L}); |
|
10308
|
|
|
public static final BitSet FOLLOW_ID_in_problem2105 = new BitSet(new long[]{0x0000000000000800L}); |
|
10309
|
|
|
public static final BitSet FOLLOW_11_in_problem2107 = new BitSet(new long[]{0x0000020000000000L}); |
|
10310
|
|
|
public static final BitSet FOLLOW_41_in_problem2109 = new BitSet(new long[]{0x0000000000000020L}); |
|
10311
|
|
|
public static final BitSet FOLLOW_ID_in_problem2111 = new BitSet(new long[]{0x0000000000001000L}); |
|
10312
|
|
|
public static final BitSet FOLLOW_12_in_problem2113 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
|
10313
|
|
|
public static final BitSet FOLLOW_80_in_problem2115 = new BitSet(new long[]{0x00400000000140E0L,0x0000000000020000L}); |
|
10314
|
|
|
public static final BitSet FOLLOW_problem_element_in_problem2117 = new BitSet(new long[]{0x00400000000140E0L,0x0000000000020000L}); |
|
10315
|
|
|
public static final BitSet FOLLOW_81_in_problem2120 = new BitSet(new long[]{0x0000000000000002L}); |
|
10316
|
|
|
public static final BitSet FOLLOW_instantiated_component_decision_in_problem_element2142 = new BitSet(new long[]{0x0000000000080000L}); |
|
10317
|
|
|
public static final BitSet FOLLOW_19_in_problem_element2144 = new BitSet(new long[]{0x0000000000000002L}); |
|
10318
|
|
|
public static final BitSet FOLLOW_ID_in_problem_element2150 = new BitSet(new long[]{0x0D98FCE1EC000000L,0x000000000000007EL}); |
|
10319
|
|
|
public static final BitSet FOLLOW_temporal_relation_type_in_problem_element2152 = new BitSet(new long[]{0x0000000000000020L}); |
|
10320
|
|
|
public static final BitSet FOLLOW_ID_in_problem_element2156 = new BitSet(new long[]{0x0000000000080000L}); |
|
10321
|
|
|
public static final BitSet FOLLOW_19_in_problem_element2158 = new BitSet(new long[]{0x0000000000000002L}); |
|
10322
|
|
|
public static final BitSet FOLLOW_parameter_constraint_in_problem_element2179 = new BitSet(new long[]{0x0000000000080000L}); |
|
10323
|
|
|
public static final BitSet FOLLOW_19_in_problem_element2181 = new BitSet(new long[]{0x0000000000000002L}); |
|
10324
|
|
|
public static final BitSet FOLLOW_76_in_range2189 = new BitSet(new long[]{0x0040000000004040L}); |
|
10325
|
|
|
public static final BitSet FOLLOW_positive_number_in_range2191 = new BitSet(new long[]{0x0000000000008000L}); |
|
10326
|
|
|
public static final BitSet FOLLOW_15_in_range2193 = new BitSet(new long[]{0x0040000000004040L}); |
|
10327
|
|
|
public static final BitSet FOLLOW_positive_number_in_range2195 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); |
|
10328
|
|
|
public static final BitSet FOLLOW_77_in_range2197 = new BitSet(new long[]{0x0000000000000002L}); |
|
10329
|
|
|
public static final BitSet FOLLOW_14_in_positive_number2219 = new BitSet(new long[]{0x0000000000000040L}); |
|
10330
|
|
|
public static final BitSet FOLLOW_INT_in_positive_number2223 = new BitSet(new long[]{0x0000000000000002L}); |
|
10331
|
|
|
public static final BitSet FOLLOW_14_in_positive_number2233 = new BitSet(new long[]{0x0040000000000000L}); |
|
10332
|
|
|
public static final BitSet FOLLOW_54_in_positive_number2237 = new BitSet(new long[]{0x0000000000000002L}); |
|
10333
|
|
|
public static final BitSet FOLLOW_sign_in_number2251 = new BitSet(new long[]{0x0000000000000040L}); |
|
10334
|
|
|
public static final BitSet FOLLOW_INT_in_number2255 = new BitSet(new long[]{0x0000000000000002L}); |
|
10335
|
|
|
public static final BitSet FOLLOW_sign_in_number2270 = new BitSet(new long[]{0x0040000000000000L}); |
|
10336
|
|
|
public static final BitSet FOLLOW_54_in_number2274 = new BitSet(new long[]{0x0000000000000002L}); |
|
10337
|
|
|
public static final BitSet FOLLOW_numeric_parameter_constraint_in_synpred35_ddl3708 = new BitSet(new long[]{0x0000000000000002L}); |
|
10338
|
|
|
public static final BitSet FOLLOW_simple_ground_state_variable_component_decision_in_synpred77_ddl31639 = new BitSet(new long[]{0x0000000000000002L}); |
|
10339
|
|
|
public static final BitSet FOLLOW_singleton_state_variable_component_decision_in_synpred78_ddl31643 = new BitSet(new long[]{0x0000000000000002L}); |
|
10340
|
|
|
public static final BitSet FOLLOW_VarID_in_synpred101_ddl32010 = new BitSet(new long[]{0x0000000000400002L}); |
|
10341
|
|
|
public static final BitSet FOLLOW_22_in_synpred101_ddl32013 = new BitSet(new long[]{0x0040000000014040L}); |
|
10342
|
|
|
public static final BitSet FOLLOW_number_in_synpred101_ddl32015 = new BitSet(new long[]{0x0000000000000002L}); |
|
10343
|
|
|
} |
|
10344
|
|
|
|
pstlab /
PLATINUm
Loading history...