Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.
View | Details | Raw Unified | Return to bug 242153 | Differences between
and this patch

Collapse All | Expand All

(-)src/org/eclipse/ocl/parser/OCLKWLexer.java (-126 / +188 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-27 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
*
14
*
14
* </copyright>
15
* </copyright>
15
*
16
*
16
* $Id: OCLKWLexer.java,v 1.2 2009/01/13 20:31:30 cdamus Exp $
17
* 
17
*/
18
*/
18
19
19
package org.eclipse.ocl.parser;
20
package org.eclipse.ocl.parser;
20
21
21
22
22
/**
23
 * @noextend This class is not intended to be subclassed by clients.
24
 */
25
public class OCLKWLexer extends OCLKWLexerprs implements OCLParsersym
23
public class OCLKWLexer extends OCLKWLexerprs implements OCLParsersym
26
{
24
{
27
    private char[] inputChars;
25
    private char[] inputChars;
Lines 59-124 Link Here
59
    final static int tokenKind[] = new int[128];
57
    final static int tokenKind[] = new int[128];
60
    static
58
    static
61
    {
59
    {
62
        tokenKind['$'] = Char_DollarSign;
60
        tokenKind['$'] = OCLKWLexersym.Char_DollarSign;
63
61
        tokenKind['%'] = OCLKWLexersym.Char_Percent;
64
        tokenKind['a'] = Char_a;
62
        tokenKind['_'] = OCLKWLexersym.Char__;
65
        tokenKind['b'] = Char_b;
63
66
        tokenKind['c'] = Char_c;
64
        tokenKind['a'] = OCLKWLexersym.Char_a;
67
        tokenKind['d'] = Char_d;
65
        tokenKind['b'] = OCLKWLexersym.Char_b;
68
        tokenKind['e'] = Char_e;
66
        tokenKind['c'] = OCLKWLexersym.Char_c;
69
        tokenKind['f'] = Char_f;
67
        tokenKind['d'] = OCLKWLexersym.Char_d;
70
        tokenKind['g'] = Char_g;
68
        tokenKind['e'] = OCLKWLexersym.Char_e;
71
        tokenKind['h'] = Char_h;
69
        tokenKind['f'] = OCLKWLexersym.Char_f;
72
        tokenKind['i'] = Char_i;
70
        tokenKind['g'] = OCLKWLexersym.Char_g;
73
        tokenKind['j'] = Char_j;
71
        tokenKind['h'] = OCLKWLexersym.Char_h;
74
        tokenKind['k'] = Char_k;
72
        tokenKind['i'] = OCLKWLexersym.Char_i;
75
        tokenKind['l'] = Char_l;
73
        tokenKind['j'] = OCLKWLexersym.Char_j;
76
        tokenKind['m'] = Char_m;
74
        tokenKind['k'] = OCLKWLexersym.Char_k;
77
        tokenKind['n'] = Char_n;
75
        tokenKind['l'] = OCLKWLexersym.Char_l;
78
        tokenKind['o'] = Char_o;
76
        tokenKind['m'] = OCLKWLexersym.Char_m;
79
        tokenKind['p'] = Char_p;
77
        tokenKind['n'] = OCLKWLexersym.Char_n;
80
        tokenKind['q'] = Char_q;
78
        tokenKind['o'] = OCLKWLexersym.Char_o;
81
        tokenKind['r'] = Char_r;
79
        tokenKind['p'] = OCLKWLexersym.Char_p;
82
        tokenKind['s'] = Char_s;
80
        tokenKind['q'] = OCLKWLexersym.Char_q;
83
        tokenKind['t'] = Char_t;
81
        tokenKind['r'] = OCLKWLexersym.Char_r;
84
        tokenKind['u'] = Char_u;
82
        tokenKind['s'] = OCLKWLexersym.Char_s;
85
        tokenKind['v'] = Char_v;
83
        tokenKind['t'] = OCLKWLexersym.Char_t;
86
        tokenKind['w'] = Char_w;
84
        tokenKind['u'] = OCLKWLexersym.Char_u;
87
        tokenKind['x'] = Char_x;
85
        tokenKind['v'] = OCLKWLexersym.Char_v;
88
        tokenKind['y'] = Char_y;
86
        tokenKind['w'] = OCLKWLexersym.Char_w;
89
        tokenKind['z'] = Char_z;
87
        tokenKind['x'] = OCLKWLexersym.Char_x;
90
88
        tokenKind['y'] = OCLKWLexersym.Char_y;
91
        tokenKind['A'] = Char_A;
89
        tokenKind['z'] = OCLKWLexersym.Char_z;
92
        tokenKind['B'] = Char_B;
90
93
        tokenKind['C'] = Char_C;
91
        tokenKind['A'] = OCLKWLexersym.Char_A;
94
        tokenKind['D'] = Char_D;
92
        tokenKind['B'] = OCLKWLexersym.Char_B;
95
        tokenKind['E'] = Char_E;
93
        tokenKind['C'] = OCLKWLexersym.Char_C;
96
        tokenKind['F'] = Char_F;
94
        tokenKind['D'] = OCLKWLexersym.Char_D;
97
        tokenKind['G'] = Char_G;
95
        tokenKind['E'] = OCLKWLexersym.Char_E;
98
        tokenKind['H'] = Char_H;
96
        tokenKind['F'] = OCLKWLexersym.Char_F;
99
        tokenKind['I'] = Char_I;
97
        tokenKind['G'] = OCLKWLexersym.Char_G;
100
        tokenKind['J'] = Char_J;
98
        tokenKind['H'] = OCLKWLexersym.Char_H;
101
        tokenKind['K'] = Char_K;
99
        tokenKind['I'] = OCLKWLexersym.Char_I;
102
        tokenKind['L'] = Char_L;
100
        tokenKind['J'] = OCLKWLexersym.Char_J;
103
        tokenKind['M'] = Char_M;
101
        tokenKind['K'] = OCLKWLexersym.Char_K;
104
        tokenKind['N'] = Char_N;
102
        tokenKind['L'] = OCLKWLexersym.Char_L;
105
        tokenKind['O'] = Char_O;
103
        tokenKind['M'] = OCLKWLexersym.Char_M;
106
        tokenKind['P'] = Char_P;
104
        tokenKind['N'] = OCLKWLexersym.Char_N;
107
        tokenKind['Q'] = Char_Q;
105
        tokenKind['O'] = OCLKWLexersym.Char_O;
108
        tokenKind['R'] = Char_R;
106
        tokenKind['P'] = OCLKWLexersym.Char_P;
109
        tokenKind['S'] = Char_S;
107
        tokenKind['Q'] = OCLKWLexersym.Char_Q;
110
        tokenKind['T'] = Char_T;
108
        tokenKind['R'] = OCLKWLexersym.Char_R;
111
        tokenKind['U'] = Char_U;
109
        tokenKind['S'] = OCLKWLexersym.Char_S;
112
        tokenKind['V'] = Char_V;
110
        tokenKind['T'] = OCLKWLexersym.Char_T;
113
        tokenKind['W'] = Char_W;
111
        tokenKind['U'] = OCLKWLexersym.Char_U;
114
        tokenKind['X'] = Char_X;
112
        tokenKind['V'] = OCLKWLexersym.Char_V;
115
        tokenKind['Y'] = Char_Y;
113
        tokenKind['W'] = OCLKWLexersym.Char_W;
116
        tokenKind['Z'] = Char_Z;
114
        tokenKind['X'] = OCLKWLexersym.Char_X;
115
        tokenKind['Y'] = OCLKWLexersym.Char_Y;
116
        tokenKind['Z'] = OCLKWLexersym.Char_Z;
117
    };
117
    };
118
118
119
    final int getKind(char c)
119
    final int getKind(int c)
120
    {
120
    {
121
        return (c < 128 ? tokenKind[c] : 0);
121
        return (((c & 0xFFFFFF80) == 0) /* 0 <= c < 128? */ ? tokenKind[c] : 0);
122
    }
122
    }
123
123
124
124
Lines 130-511 Link Here
130
        //
130
        //
131
        // Rule 1:  KeyWord ::= s e l f
131
        // Rule 1:  KeyWord ::= s e l f
132
        //
132
        //
133
		keywordKind[1] = (TK_self);
133
        
134
		keywordKind[1] = (OCLParsersym.TK_self);
134
	  
135
	  
135
	
136
	
136
        //
137
        //
137
        // Rule 2:  KeyWord ::= i n v
138
        // Rule 2:  KeyWord ::= i n v
138
        //
139
        //
139
		keywordKind[2] = (TK_inv);
140
        
141
		keywordKind[2] = (OCLParsersym.TK_inv);
140
	  
142
	  
141
	
143
	
142
        //
144
        //
143
        // Rule 3:  KeyWord ::= p r e
145
        // Rule 3:  KeyWord ::= p r e
144
        //
146
        //
145
		keywordKind[3] = (TK_pre);
147
        
148
		keywordKind[3] = (OCLParsersym.TK_pre);
146
	  
149
	  
147
	
150
	
148
        //
151
        //
149
        // Rule 4:  KeyWord ::= p o s t
152
        // Rule 4:  KeyWord ::= p o s t
150
        //
153
        //
151
		keywordKind[4] = (TK_post);
154
        
155
		keywordKind[4] = (OCLParsersym.TK_post);
152
	  
156
	  
153
	
157
	
154
        //
158
        //
155
        // Rule 5:  KeyWord ::= b o d y
159
        // Rule 5:  KeyWord ::= b o d y
156
        //
160
        //
157
		keywordKind[5] = (TK_body);
161
        
162
		keywordKind[5] = (OCLParsersym.TK_body);
158
	  
163
	  
159
	
164
	
160
        //
165
        //
161
        // Rule 6:  KeyWord ::= c o n t e x t
166
        // Rule 6:  KeyWord ::= c o n t e x t
162
        //
167
        //
163
		keywordKind[6] = (TK_context);
168
        
169
		keywordKind[6] = (OCLParsersym.TK_context);
164
	  
170
	  
165
	
171
	
166
        //
172
        //
167
        // Rule 7:  KeyWord ::= p a c k a g e
173
        // Rule 7:  KeyWord ::= p a c k a g e
168
        //
174
        //
169
		keywordKind[7] = (TK_package);
175
        
176
		keywordKind[7] = (OCLParsersym.TK_package);
170
	  
177
	  
171
	
178
	
172
        //
179
        //
173
        // Rule 8:  KeyWord ::= e n d p a c k a g e
180
        // Rule 8:  KeyWord ::= e n d p a c k a g e
174
        //
181
        //
175
		keywordKind[8] = (TK_endpackage);
182
        
183
		keywordKind[8] = (OCLParsersym.TK_endpackage);
176
	  
184
	  
177
	
185
	
178
        //
186
        //
179
        // Rule 9:  KeyWord ::= d e f
187
        // Rule 9:  KeyWord ::= d e f
180
        //
188
        //
181
		keywordKind[9] = (TK_def);
189
        
190
		keywordKind[9] = (OCLParsersym.TK_def);
182
	  
191
	  
183
	
192
	
184
        //
193
        //
185
        // Rule 10:  KeyWord ::= d e r i v e
194
        // Rule 10:  KeyWord ::= d e r i v e
186
        //
195
        //
187
		keywordKind[10] = (TK_derive);
196
        
197
		keywordKind[10] = (OCLParsersym.TK_derive);
188
	  
198
	  
189
	
199
	
190
        //
200
        //
191
        // Rule 11:  KeyWord ::= i n i t
201
        // Rule 11:  KeyWord ::= i n i t
192
        //
202
        //
193
		keywordKind[11] = (TK_init);
203
        
204
		keywordKind[11] = (OCLParsersym.TK_init);
194
	  
205
	  
195
	
206
	
196
        //
207
        //
197
        // Rule 12:  KeyWord ::= i f
208
        // Rule 12:  KeyWord ::= i f
198
        //
209
        //
199
		keywordKind[12] = (TK_if);
210
        
211
		keywordKind[12] = (OCLParsersym.TK_if);
200
	  
212
	  
201
	
213
	
202
        //
214
        //
203
        // Rule 13:  KeyWord ::= t h e n
215
        // Rule 13:  KeyWord ::= t h e n
204
        //
216
        //
205
		keywordKind[13] = (TK_then);
217
        
218
		keywordKind[13] = (OCLParsersym.TK_then);
206
	  
219
	  
207
	
220
	
208
        //
221
        //
209
        // Rule 14:  KeyWord ::= e l s e
222
        // Rule 14:  KeyWord ::= e l s e
210
        //
223
        //
211
		keywordKind[14] = (TK_else);
224
        
225
		keywordKind[14] = (OCLParsersym.TK_else);
212
	  
226
	  
213
	
227
	
214
        //
228
        //
215
        // Rule 15:  KeyWord ::= e n d i f
229
        // Rule 15:  KeyWord ::= e n d i f
216
        //
230
        //
217
		keywordKind[15] = (TK_endif);
231
        
232
		keywordKind[15] = (OCLParsersym.TK_endif);
218
	  
233
	  
219
	
234
	
220
        //
235
        //
221
        // Rule 16:  KeyWord ::= a n d
236
        // Rule 16:  KeyWord ::= a n d
222
        //
237
        //
223
		keywordKind[16] = (TK_and);
238
        
239
		keywordKind[16] = (OCLParsersym.TK_and);
224
	  
240
	  
225
	
241
	
226
        //
242
        //
227
        // Rule 17:  KeyWord ::= o r
243
        // Rule 17:  KeyWord ::= o r
228
        //
244
        //
229
		keywordKind[17] = (TK_or);
245
        
246
		keywordKind[17] = (OCLParsersym.TK_or);
230
	  
247
	  
231
	
248
	
232
        //
249
        //
233
        // Rule 18:  KeyWord ::= x o r
250
        // Rule 18:  KeyWord ::= x o r
234
        //
251
        //
235
		keywordKind[18] = (TK_xor);
252
        
253
		keywordKind[18] = (OCLParsersym.TK_xor);
236
	  
254
	  
237
	
255
	
238
        //
256
        //
239
        // Rule 19:  KeyWord ::= n o t
257
        // Rule 19:  KeyWord ::= n o t
240
        //
258
        //
241
		keywordKind[19] = (TK_not);
259
        
260
		keywordKind[19] = (OCLParsersym.TK_not);
242
	  
261
	  
243
	
262
	
244
        //
263
        //
245
        // Rule 20:  KeyWord ::= i m p l i e s
264
        // Rule 20:  KeyWord ::= i m p l i e s
246
        //
265
        //
247
		keywordKind[20] = (TK_implies);
266
        
267
		keywordKind[20] = (OCLParsersym.TK_implies);
248
	  
268
	  
249
	
269
	
250
        //
270
        //
251
        // Rule 21:  KeyWord ::= l e t
271
        // Rule 21:  KeyWord ::= l e t
252
        //
272
        //
253
		keywordKind[21] = (TK_let);
273
        
274
		keywordKind[21] = (OCLParsersym.TK_let);
254
	  
275
	  
255
	
276
	
256
        //
277
        //
257
        // Rule 22:  KeyWord ::= i n
278
        // Rule 22:  KeyWord ::= i n
258
        //
279
        //
259
		keywordKind[22] = (TK_in);
280
        
281
		keywordKind[22] = (OCLParsersym.TK_in);
260
	  
282
	  
261
	
283
	
262
        //
284
        //
263
        // Rule 23:  KeyWord ::= t r u e
285
        // Rule 23:  KeyWord ::= t r u e
264
        //
286
        //
265
		keywordKind[23] = (TK_true);
287
        
288
		keywordKind[23] = (OCLParsersym.TK_true);
266
	  
289
	  
267
	
290
	
268
        //
291
        //
269
        // Rule 24:  KeyWord ::= f a l s e
292
        // Rule 24:  KeyWord ::= f a l s e
270
        //
293
        //
271
		keywordKind[24] = (TK_false);
294
        
295
		keywordKind[24] = (OCLParsersym.TK_false);
272
	  
296
	  
273
	
297
	
274
        //
298
        //
275
        // Rule 25:  KeyWord ::= S e t
299
        // Rule 25:  KeyWord ::= S e t
276
        //
300
        //
277
		keywordKind[25] = (TK_Set);
301
        
302
		keywordKind[25] = (OCLParsersym.TK_Set);
278
	  
303
	  
279
	
304
	
280
        //
305
        //
281
        // Rule 26:  KeyWord ::= B a g
306
        // Rule 26:  KeyWord ::= B a g
282
        //
307
        //
283
		keywordKind[26] = (TK_Bag);
308
        
309
		keywordKind[26] = (OCLParsersym.TK_Bag);
284
	  
310
	  
285
	
311
	
286
        //
312
        //
287
        // Rule 27:  KeyWord ::= S e q u e n c e
313
        // Rule 27:  KeyWord ::= S e q u e n c e
288
        //
314
        //
289
		keywordKind[27] = (TK_Sequence);
315
        
316
		keywordKind[27] = (OCLParsersym.TK_Sequence);
290
	  
317
	  
291
	
318
	
292
        //
319
        //
293
        // Rule 28:  KeyWord ::= C o l l e c t i o n
320
        // Rule 28:  KeyWord ::= C o l l e c t i o n
294
        //
321
        //
295
		keywordKind[28] = (TK_Collection);
322
        
323
		keywordKind[28] = (OCLParsersym.TK_Collection);
296
	  
324
	  
297
	
325
	
298
        //
326
        //
299
        // Rule 29:  KeyWord ::= O r d e r e d S e t
327
        // Rule 29:  KeyWord ::= O r d e r e d S e t
300
        //
328
        //
301
		keywordKind[29] = (TK_OrderedSet);
329
        
330
		keywordKind[29] = (OCLParsersym.TK_OrderedSet);
302
	  
331
	  
303
	
332
	
304
        //
333
        //
305
        // Rule 30:  KeyWord ::= i t e r a t e
334
        // Rule 30:  KeyWord ::= i t e r a t e
306
        //
335
        //
307
		keywordKind[30] = (TK_iterate);
336
        
337
		keywordKind[30] = (OCLParsersym.TK_iterate);
308
	  
338
	  
309
	
339
	
310
        //
340
        //
311
        // Rule 31:  KeyWord ::= f o r A l l
341
        // Rule 31:  KeyWord ::= f o r A l l
312
        //
342
        //
313
		keywordKind[31] = (TK_forAll);
343
        
344
		keywordKind[31] = (OCLParsersym.TK_forAll);
314
	  
345
	  
315
	
346
	
316
        //
347
        //
317
        // Rule 32:  KeyWord ::= e x i s t s
348
        // Rule 32:  KeyWord ::= e x i s t s
318
        //
349
        //
319
		keywordKind[32] = (TK_exists);
350
        
351
		keywordKind[32] = (OCLParsersym.TK_exists);
320
	  
352
	  
321
	
353
	
322
        //
354
        //
323
        // Rule 33:  KeyWord ::= i s U n i q u e
355
        // Rule 33:  KeyWord ::= i s U n i q u e
324
        //
356
        //
325
		keywordKind[33] = (TK_isUnique);
357
        
358
		keywordKind[33] = (OCLParsersym.TK_isUnique);
326
	  
359
	  
327
	
360
	
328
        //
361
        //
329
        // Rule 34:  KeyWord ::= a n y
362
        // Rule 34:  KeyWord ::= a n y
330
        //
363
        //
331
		keywordKind[34] = (TK_any);
364
        
365
		keywordKind[34] = (OCLParsersym.TK_any);
332
	  
366
	  
333
	
367
	
334
        //
368
        //
335
        // Rule 35:  KeyWord ::= o n e
369
        // Rule 35:  KeyWord ::= o n e
336
        //
370
        //
337
		keywordKind[35] = (TK_one);
371
        
372
		keywordKind[35] = (OCLParsersym.TK_one);
338
	  
373
	  
339
	
374
	
340
        //
375
        //
341
        // Rule 36:  KeyWord ::= c o l l e c t
376
        // Rule 36:  KeyWord ::= c o l l e c t
342
        //
377
        //
343
		keywordKind[36] = (TK_collect);
378
        
379
		keywordKind[36] = (OCLParsersym.TK_collect);
344
	  
380
	  
345
	
381
	
346
        //
382
        //
347
        // Rule 37:  KeyWord ::= s e l e c t
383
        // Rule 37:  KeyWord ::= s e l e c t
348
        //
384
        //
349
		keywordKind[37] = (TK_select);
385
        
386
		keywordKind[37] = (OCLParsersym.TK_select);
350
	  
387
	  
351
	
388
	
352
        //
389
        //
353
        // Rule 38:  KeyWord ::= r e j e c t
390
        // Rule 38:  KeyWord ::= r e j e c t
354
        //
391
        //
355
		keywordKind[38] = (TK_reject);
392
        
393
		keywordKind[38] = (OCLParsersym.TK_reject);
356
	  
394
	  
357
	
395
	
358
        //
396
        //
359
        // Rule 39:  KeyWord ::= c o l l e c t N e s t e d
397
        // Rule 39:  KeyWord ::= c o l l e c t N e s t e d
360
        //
398
        //
361
		keywordKind[39] = (TK_collectNested);
399
        
400
		keywordKind[39] = (OCLParsersym.TK_collectNested);
362
	  
401
	  
363
	
402
	
364
        //
403
        //
365
        // Rule 40:  KeyWord ::= s o r t e d B y
404
        // Rule 40:  KeyWord ::= s o r t e d B y
366
        //
405
        //
367
		keywordKind[40] = (TK_sortedBy);
406
        
407
		keywordKind[40] = (OCLParsersym.TK_sortedBy);
368
	  
408
	  
369
	
409
	
370
        //
410
        //
371
        // Rule 41:  KeyWord ::= c l o s u r e
411
        // Rule 41:  KeyWord ::= c l o s u r e
372
        //
412
        //
373
		keywordKind[41] = (TK_closure);
413
        
414
		keywordKind[41] = (OCLParsersym.TK_closure);
374
	  
415
	  
375
	
416
	
376
        //
417
        //
377
        // Rule 42:  KeyWord ::= o c l I s K i n d O f
418
        // Rule 42:  KeyWord ::= o c l I s K i n d O f
378
        //
419
        //
379
		keywordKind[42] = (TK_oclIsKindOf);
420
        
421
		keywordKind[42] = (OCLParsersym.TK_oclIsKindOf);
380
	  
422
	  
381
	
423
	
382
        //
424
        //
383
        // Rule 43:  KeyWord ::= o c l I s T y p e O f
425
        // Rule 43:  KeyWord ::= o c l I s T y p e O f
384
        //
426
        //
385
		keywordKind[43] = (TK_oclIsTypeOf);
427
        
428
		keywordKind[43] = (OCLParsersym.TK_oclIsTypeOf);
386
	  
429
	  
387
	
430
	
388
        //
431
        //
389
        // Rule 44:  KeyWord ::= o c l A s T y p e
432
        // Rule 44:  KeyWord ::= o c l A s T y p e
390
        //
433
        //
391
		keywordKind[44] = (TK_oclAsType);
434
        
435
		keywordKind[44] = (OCLParsersym.TK_oclAsType);
392
	  
436
	  
393
	
437
	
394
        //
438
        //
395
        // Rule 45:  KeyWord ::= o c l I s N e w
439
        // Rule 45:  KeyWord ::= o c l I s N e w
396
        //
440
        //
397
		keywordKind[45] = (TK_oclIsNew);
441
        
442
		keywordKind[45] = (OCLParsersym.TK_oclIsNew);
398
	  
443
	  
399
	
444
	
400
        //
445
        //
401
        // Rule 46:  KeyWord ::= o c l I s U n d e f i n e d
446
        // Rule 46:  KeyWord ::= o c l I s U n d e f i n e d
402
        //
447
        //
403
		keywordKind[46] = (TK_oclIsUndefined);
448
        
449
		keywordKind[46] = (OCLParsersym.TK_oclIsUndefined);
404
	  
450
	  
405
	
451
	
406
        //
452
        //
407
        // Rule 47:  KeyWord ::= o c l I s I n v a l i d
453
        // Rule 47:  KeyWord ::= o c l I s I n v a l i d
408
        //
454
        //
409
		keywordKind[47] = (TK_oclIsInvalid);
455
        
456
		keywordKind[47] = (OCLParsersym.TK_oclIsInvalid);
410
	  
457
	  
411
	
458
	
412
        //
459
        //
413
        // Rule 48:  KeyWord ::= o c l I s I n S t a t e
460
        // Rule 48:  KeyWord ::= o c l I s I n S t a t e
414
        //
461
        //
415
		keywordKind[48] = (TK_oclIsInState);
462
        
463
		keywordKind[48] = (OCLParsersym.TK_oclIsInState);
416
	  
464
	  
417
	
465
	
418
        //
466
        //
419
        // Rule 49:  KeyWord ::= a l l I n s t a n c e s
467
        // Rule 49:  KeyWord ::= a l l I n s t a n c e s
420
        //
468
        //
421
		keywordKind[49] = (TK_allInstances);
469
        
470
		keywordKind[49] = (OCLParsersym.TK_allInstances);
422
	  
471
	  
423
	
472
	
424
        //
473
        //
425
        // Rule 50:  KeyWord ::= S t r i n g
474
        // Rule 50:  KeyWord ::= S t r i n g
426
        //
475
        //
427
		keywordKind[50] = (TK_String);
476
        
477
		keywordKind[50] = (OCLParsersym.TK_String);
428
	  
478
	  
429
	
479
	
430
        //
480
        //
431
        // Rule 51:  KeyWord ::= I n t e g e r
481
        // Rule 51:  KeyWord ::= I n t e g e r
432
        //
482
        //
433
		keywordKind[51] = (TK_Integer);
483
        
484
		keywordKind[51] = (OCLParsersym.TK_Integer);
434
	  
485
	  
435
	
486
	
436
        //
487
        //
437
        // Rule 52:  KeyWord ::= U n l i m i t e d N a t u r a l
488
        // Rule 52:  KeyWord ::= U n l i m i t e d N a t u r a l
438
        //
489
        //
439
		keywordKind[52] = (TK_UnlimitedNatural);
490
        
491
		keywordKind[52] = (OCLParsersym.TK_UnlimitedNatural);
440
	  
492
	  
441
	
493
	
442
        //
494
        //
443
        // Rule 53:  KeyWord ::= R e a l
495
        // Rule 53:  KeyWord ::= R e a l
444
        //
496
        //
445
		keywordKind[53] = (TK_Real);
497
        
498
		keywordKind[53] = (OCLParsersym.TK_Real);
446
	  
499
	  
447
	
500
	
448
        //
501
        //
449
        // Rule 54:  KeyWord ::= B o o l e a n
502
        // Rule 54:  KeyWord ::= B o o l e a n
450
        //
503
        //
451
		keywordKind[54] = (TK_Boolean);
504
        
505
		keywordKind[54] = (OCLParsersym.TK_Boolean);
452
	  
506
	  
453
	
507
	
454
        //
508
        //
455
        // Rule 55:  KeyWord ::= T u p l e
509
        // Rule 55:  KeyWord ::= T u p l e
456
        //
510
        //
457
		keywordKind[55] = (TK_Tuple);
511
        
512
		keywordKind[55] = (OCLParsersym.TK_Tuple);
458
	  
513
	  
459
	
514
	
460
        //
515
        //
461
        // Rule 56:  KeyWord ::= O c l A n y
516
        // Rule 56:  KeyWord ::= O c l A n y
462
        //
517
        //
463
		keywordKind[56] = (TK_OclAny);
518
        
519
		keywordKind[56] = (OCLParsersym.TK_OclAny);
464
	  
520
	  
465
	
521
	
466
        //
522
        //
467
        // Rule 57:  KeyWord ::= O c l V o i d
523
        // Rule 57:  KeyWord ::= O c l V o i d
468
        //
524
        //
469
		keywordKind[57] = (TK_OclVoid);
525
        
526
		keywordKind[57] = (OCLParsersym.TK_OclVoid);
470
	  
527
	  
471
	
528
	
472
        //
529
        //
473
        // Rule 58:  KeyWord ::= I n v a l i d
530
        // Rule 58:  KeyWord ::= I n v a l i d
474
        //
531
        //
475
		keywordKind[58] = (TK_Invalid);
532
        
533
		keywordKind[58] = (OCLParsersym.TK_Invalid);
476
	  
534
	  
477
	
535
	
478
        //
536
        //
479
        // Rule 59:  KeyWord ::= O c l M e s s a g e
537
        // Rule 59:  KeyWord ::= O c l M e s s a g e
480
        //
538
        //
481
		keywordKind[59] = (TK_OclMessage);
539
        
540
		keywordKind[59] = (OCLParsersym.TK_OclMessage);
482
	  
541
	  
483
	
542
	
484
        //
543
        //
485
        // Rule 60:  KeyWord ::= n u l l
544
        // Rule 60:  KeyWord ::= n u l l
486
        //
545
        //
487
		keywordKind[60] = (TK_null);
546
        
547
		keywordKind[60] = (OCLParsersym.TK_null);
488
	  
548
	  
489
	
549
	
490
        //
550
        //
491
        // Rule 61:  KeyWord ::= O c l I n v a l i d
551
        // Rule 61:  KeyWord ::= O c l I n v a l i d
492
        //
552
        //
493
		keywordKind[61] = (TK_OclInvalid);
553
        
554
		keywordKind[61] = (OCLParsersym.TK_OclInvalid);
494
	  
555
	  
495
	
556
	
496
        //
557
        //
497
        // Rule 62:  KeyWord ::= a t t r
558
        // Rule 62:  KeyWord ::= a t t r
498
        //
559
        //
499
		keywordKind[62] = (TK_attr);
560
        
561
		keywordKind[62] = (OCLParsersym.TK_attr);
500
	  
562
	  
501
	
563
	
502
        //
564
        //
503
        // Rule 63:  KeyWord ::= o p e r
565
        // Rule 63:  KeyWord ::= o p e r
504
        //
566
        //
505
		keywordKind[63] = (TK_oper);
567
        
568
		keywordKind[63] = (OCLParsersym.TK_oper);
506
	  
569
	  
507
	
570
	
508
509
        for (int i = 0; i < keywordKind.length; i++)
571
        for (int i = 0; i < keywordKind.length; i++)
510
        {
572
        {
511
            if (keywordKind[i] == 0)
573
            if (keywordKind[i] == 0)
(-)src/org/eclipse/ocl/parser/OCLParser.java (-196 / +81 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 14-23 Link Here
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
16
*   Borland - Bug 242880
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
17
*
19
*
18
* </copyright>
20
* </copyright>
19
*
21
*
20
* $Id: OCLParser.java,v 1.7 2009/03/05 14:12:14 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
21
*/
23
*/
22
24
23
package org.eclipse.ocl.parser;
25
package org.eclipse.ocl.parser;
Lines 44-58 Link Here
44
import org.eclipse.ocl.util.OCLStandardLibraryUtil;
46
import org.eclipse.ocl.util.OCLStandardLibraryUtil;
45
import org.eclipse.ocl.utilities.PredefinedType;
47
import org.eclipse.ocl.utilities.PredefinedType;
46
48
47
import lpg.lpgjavaruntime.BadParseException;
49
import lpg.runtime.BadParseException;
48
import lpg.lpgjavaruntime.BadParseSymFileException;
50
import lpg.runtime.BadParseSymFileException;
49
import lpg.lpgjavaruntime.DeterministicParser;
51
import lpg.runtime.DeterministicParser;
50
import lpg.lpgjavaruntime.DiagnoseParser;
52
import lpg.runtime.DiagnoseParser;
51
import lpg.lpgjavaruntime.IToken;
53
import lpg.runtime.IToken;
52
import lpg.lpgjavaruntime.Monitor;
54
import lpg.runtime.Monitor;
53
import lpg.lpgjavaruntime.NotDeterministicParseTableException;
55
import lpg.runtime.NotDeterministicParseTableException;
54
import lpg.lpgjavaruntime.ParseTable;
56
import lpg.runtime.ParseTable;
55
import lpg.lpgjavaruntime.RuleAction;
57
import lpg.runtime.RuleAction;
56
58
57
import org.eclipse.ocl.Environment;
59
import org.eclipse.ocl.Environment;
58
import org.eclipse.ocl.cst.DefExpressionCS;
60
import org.eclipse.ocl.cst.DefExpressionCS;
Lines 138-164 Link Here
138
	{
140
	{
139
		switch (ruleNumber) {
141
		switch (ruleNumber) {
140
		
142
		
141
 
143
  
142
			//
144
			//
143
			// Rule 46:  binaryName ::= binaryIdentifier
145
			// Rule 46:  binaryName ::= binaryIdentifier
144
			//
146
			//
145
			case 46:
147
			case 46:
146
 
148
   
147
			//
149
			//
148
			// Rule 47:  keywordAsName ::= keywordAsIdentifier
150
			// Rule 47:  keywordAsName ::= keywordAsIdentifier
149
			//
151
			//
150
			case 47:
152
			case 47:
151
 
153
   
152
			//
154
			//
153
			// Rule 48:  keywordAsName1 ::= keywordAsIdentifier1
155
			// Rule 48:  keywordAsName1 ::= keywordAsIdentifier1
154
			//
156
			//
155
			case 48:
157
			case 48:
156
 
158
  
157
			//
159
			//
158
			// Rule 49:  unaryName ::= unaryIdentifier
160
			// Rule 49:  unaryName ::= unaryIdentifier
159
			//
161
			//
160
			case 49: {
162
			case 49: {
161
				
162
				SimpleNameCS result = createSimpleNameCS(
163
				SimpleNameCS result = createSimpleNameCS(
163
							SimpleTypeEnum.IDENTIFIER_LITERAL,
164
							SimpleTypeEnum.IDENTIFIER_LITERAL,
164
							getTokenText(dtParser.getToken(1))
165
							getTokenText(dtParser.getToken(1))
Lines 167-188 Link Here
167
				dtParser.setSym1(result);
168
				dtParser.setSym1(result);
168
	  		  break;
169
	  		  break;
169
			}
170
			}
170
	 
171
	  
171
			//
172
			//
172
			// Rule 50:  iterateName ::= iterate
173
			// Rule 50:  iterateName ::= iterate
173
			//
174
			//
174
			case 50:
175
			case 50:
175
 
176
   
176
			//
177
			//
177
			// Rule 51:  iteratorName ::= iteratorIdentifier
178
			// Rule 51:  iteratorName ::= iteratorIdentifier
178
			//
179
			//
179
			case 51:
180
			case 51:
180
 
181
  
181
			//
182
			//
182
			// Rule 52:  oclIsInStateName ::= oclIsInState
183
			// Rule 52:  oclIsInStateName ::= oclIsInState
183
			//
184
			//
184
			case 52: {
185
			case 52: {
185
				
186
				SimpleNameCS result = createSimpleNameCS(
186
				SimpleNameCS result = createSimpleNameCS(
187
							SimpleTypeEnum.KEYWORD_LITERAL,
187
							SimpleTypeEnum.KEYWORD_LITERAL,
188
							getTokenText(dtParser.getToken(1))
188
							getTokenText(dtParser.getToken(1))
Lines 196-202 Link Here
196
			// Rule 55:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) : typeCSopt
196
			// Rule 55:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) : typeCSopt
197
			//
197
			//
198
			case 55: {
198
			case 55: {
199
				
200
				CSTNode result = createOperationCS(
199
				CSTNode result = createOperationCS(
201
						getTokenText(dtParser.getToken(1)),
200
						getTokenText(dtParser.getToken(1)),
202
						(EList)dtParser.getSym(3),
201
						(EList)dtParser.getSym(3),
Lines 215-221 Link Here
215
			// Rule 56:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) : typeCSopt
214
			// Rule 56:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) : typeCSopt
216
			//
215
			//
217
			case 56: {
216
			case 56: {
218
				
219
				CSTNode result = createOperationCS(
217
				CSTNode result = createOperationCS(
220
						(PathNameCS)dtParser.getSym(1),
218
						(PathNameCS)dtParser.getSym(1),
221
						(SimpleNameCS)dtParser.getSym(3),
219
						(SimpleNameCS)dtParser.getSym(3),
Lines 230-248 Link Here
230
				dtParser.setSym1(result);
228
				dtParser.setSym1(result);
231
	  		  break;
229
	  		  break;
232
			}
230
			}
233
	 
231
	  
234
			//
232
			//
235
			// Rule 57:  parametersCSopt ::= $Empty
233
			// Rule 57:  parametersCSopt ::= $Empty
236
			//
234
			//
237
			case 57:
235
			case 57:
238
				dtParser.setSym1(new BasicEList());
236
				dtParser.setSym1(new BasicEList());
239
				break;
237
				break;
240
 
238
  
241
			//
239
			//
242
			// Rule 59:  parametersCS ::= variableCS
240
			// Rule 59:  parametersCS ::= variableCS
243
			//
241
			//
244
			case 59: {
242
			case 59: {
245
				
246
				EList result = new BasicEList();
243
				EList result = new BasicEList();
247
				result.add(dtParser.getSym(1));
244
				result.add(dtParser.getSym(1));
248
				dtParser.setSym1(result);
245
				dtParser.setSym1(result);
Lines 253-259 Link Here
253
			// Rule 60:  parametersCS ::= parametersCS , variableCS
250
			// Rule 60:  parametersCS ::= parametersCS , variableCS
254
			//
251
			//
255
			case 60: {
252
			case 60: {
256
				
257
				EList result = (EList)dtParser.getSym(1);
253
				EList result = (EList)dtParser.getSym(1);
258
				result.add(dtParser.getSym(3));
254
				result.add(dtParser.getSym(3));
259
				dtParser.setSym1(result);
255
				dtParser.setSym1(result);
Lines 266-312 Link Here
266
			case 61:
262
			case 61:
267
				dtParser.setSym1(null);
263
				dtParser.setSym1(null);
268
				break;
264
				break;
269
 
265
  
270
			//
266
			//
271
			// Rule 67:  impliesExpCS ::= impliesExpCS implies andOrXorExpCS
267
			// Rule 67:  impliesExpCS ::= impliesExpCS implies andOrXorExpCS
272
			//
268
			//
273
			case 67:
269
			case 67:
274
 
270
   
275
			//
271
			//
276
			// Rule 68:  impliesWithLet ::= impliesExpCS implies andOrXorWithLet
272
			// Rule 68:  impliesWithLet ::= impliesExpCS implies andOrXorWithLet
277
			//
273
			//
278
			case 68:
274
			case 68:
279
 
275
   
280
			//
276
			//
281
			// Rule 71:  andOrXorExpCS ::= andOrXorExpCS and equalityExpCS
277
			// Rule 71:  andOrXorExpCS ::= andOrXorExpCS and equalityExpCS
282
			//
278
			//
283
			case 71:
279
			case 71:
284
 
280
   
285
			//
281
			//
286
			// Rule 72:  andOrXorExpCS ::= andOrXorExpCS or equalityExpCS
282
			// Rule 72:  andOrXorExpCS ::= andOrXorExpCS or equalityExpCS
287
			//
283
			//
288
			case 72:
284
			case 72:
289
 
285
   
290
			//
286
			//
291
			// Rule 73:  andOrXorExpCS ::= andOrXorExpCS xor equalityExpCS
287
			// Rule 73:  andOrXorExpCS ::= andOrXorExpCS xor equalityExpCS
292
			//
288
			//
293
			case 73:
289
			case 73:
294
 
290
   
295
			//
291
			//
296
			// Rule 74:  andOrXorWithLet ::= andOrXorExpCS and equalityWithLet
292
			// Rule 74:  andOrXorWithLet ::= andOrXorExpCS and equalityWithLet
297
			//
293
			//
298
			case 74:
294
			case 74:
299
 
295
   
300
			//
296
			//
301
			// Rule 75:  andOrXorWithLet ::= andOrXorExpCS or equalityWithLet
297
			// Rule 75:  andOrXorWithLet ::= andOrXorExpCS or equalityWithLet
302
			//
298
			//
303
			case 75:
299
			case 75:
304
 
300
  
305
			//
301
			//
306
			// Rule 76:  andOrXorWithLet ::= andOrXorExpCS xor equalityWithLet
302
			// Rule 76:  andOrXorWithLet ::= andOrXorExpCS xor equalityWithLet
307
			//
303
			//
308
			case 76: {
304
			case 76: {
309
				
310
				SimpleNameCS simpleNameCS = createSimpleNameCS(
305
				SimpleNameCS simpleNameCS = createSimpleNameCS(
311
							SimpleTypeEnum.STRING_LITERAL,
306
							SimpleTypeEnum.STRING_LITERAL,
312
							getTokenText(dtParser.getToken(2))
307
							getTokenText(dtParser.getToken(2))
Lines 323-339 Link Here
323
				dtParser.setSym1(result);
318
				dtParser.setSym1(result);
324
	  		  break;
319
	  		  break;
325
			}
320
			}
326
	 
321
	  
327
			//
322
			//
328
			// Rule 79:  equalityExpCS ::= equalityExpCS = relationalExpCS
323
			// Rule 79:  equalityExpCS ::= equalityExpCS = relationalExpCS
329
			//
324
			//
330
			case 79:
325
			case 79:
331
 
326
  
332
			//
327
			//
333
			// Rule 80:  equalityWithLet ::= equalityExpCS = relationalWithLet
328
			// Rule 80:  equalityWithLet ::= equalityExpCS = relationalWithLet
334
			//
329
			//
335
			case 80: {
330
			case 80: {
336
				
337
				SimpleNameCS simpleNameCS = createSimpleNameCS(
331
				SimpleNameCS simpleNameCS = createSimpleNameCS(
338
							SimpleTypeEnum.STRING_LITERAL,
332
							SimpleTypeEnum.STRING_LITERAL,
339
							OCLStandardLibraryUtil.getOperationName(PredefinedType.EQUAL)
333
							OCLStandardLibraryUtil.getOperationName(PredefinedType.EQUAL)
Lines 350-366 Link Here
350
				dtParser.setSym1(result);
344
				dtParser.setSym1(result);
351
	  		  break;
345
	  		  break;
352
			}
346
			}
353
	 
347
	  
354
			//
348
			//
355
			// Rule 81:  equalityExpCS ::= equalityExpCS <> relationalExpCS
349
			// Rule 81:  equalityExpCS ::= equalityExpCS <> relationalExpCS
356
			//
350
			//
357
			case 81:
351
			case 81:
358
 
352
  
359
			//
353
			//
360
			// Rule 82:  equalityWithLet ::= equalityExpCS <> relationalWithLet
354
			// Rule 82:  equalityWithLet ::= equalityExpCS <> relationalWithLet
361
			//
355
			//
362
			case 82: {
356
			case 82: {
363
				
364
				SimpleNameCS simpleNameCS = createSimpleNameCS(
357
				SimpleNameCS simpleNameCS = createSimpleNameCS(
365
							SimpleTypeEnum.STRING_LITERAL,
358
							SimpleTypeEnum.STRING_LITERAL,
366
							OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
359
							OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
Lines 377-393 Link Here
377
				dtParser.setSym1(result);
370
				dtParser.setSym1(result);
378
	  		  break;
371
	  		  break;
379
			}
372
			}
380
	 
373
	  
381
			//
374
			//
382
			// Rule 85:  relationalExpCS ::= relationalExpCS > ifExpCSPrec
375
			// Rule 85:  relationalExpCS ::= relationalExpCS > ifExpCSPrec
383
			//
376
			//
384
			case 85:
377
			case 85:
385
 
378
  
386
			//
379
			//
387
			// Rule 86:  relationalWithLet ::= relationalExpCS > additiveWithLet
380
			// Rule 86:  relationalWithLet ::= relationalExpCS > additiveWithLet
388
			//
381
			//
389
			case 86: {
382
			case 86: {
390
				
391
				SimpleNameCS simpleNameCS = createSimpleNameCS(
383
				SimpleNameCS simpleNameCS = createSimpleNameCS(
392
							SimpleTypeEnum.STRING_LITERAL,
384
							SimpleTypeEnum.STRING_LITERAL,
393
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN)
385
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN)
Lines 404-420 Link Here
404
				dtParser.setSym1(result);
396
				dtParser.setSym1(result);
405
	  		  break;
397
	  		  break;
406
			}
398
			}
407
	 
399
	  
408
			//
400
			//
409
			// Rule 87:  relationalExpCS ::= relationalExpCS < ifExpCSPrec
401
			// Rule 87:  relationalExpCS ::= relationalExpCS < ifExpCSPrec
410
			//
402
			//
411
			case 87:
403
			case 87:
412
 
404
  
413
			//
405
			//
414
			// Rule 88:  relationalWithLet ::= relationalExpCS < additiveWithLet
406
			// Rule 88:  relationalWithLet ::= relationalExpCS < additiveWithLet
415
			//
407
			//
416
			case 88: {
408
			case 88: {
417
				
418
				SimpleNameCS simpleNameCS = createSimpleNameCS(
409
				SimpleNameCS simpleNameCS = createSimpleNameCS(
419
							SimpleTypeEnum.STRING_LITERAL,
410
							SimpleTypeEnum.STRING_LITERAL,
420
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN)
411
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN)
Lines 431-447 Link Here
431
				dtParser.setSym1(result);
422
				dtParser.setSym1(result);
432
	  		  break;
423
	  		  break;
433
			}
424
			}
434
	 
425
	  
435
			//
426
			//
436
			// Rule 89:  relationalExpCS ::= relationalExpCS >= ifExpCSPrec
427
			// Rule 89:  relationalExpCS ::= relationalExpCS >= ifExpCSPrec
437
			//
428
			//
438
			case 89:
429
			case 89:
439
 
430
  
440
			//
431
			//
441
			// Rule 90:  relationalWithLet ::= relationalExpCS >= additiveWithLet
432
			// Rule 90:  relationalWithLet ::= relationalExpCS >= additiveWithLet
442
			//
433
			//
443
			case 90: {
434
			case 90: {
444
				
445
				SimpleNameCS simpleNameCS = createSimpleNameCS(
435
				SimpleNameCS simpleNameCS = createSimpleNameCS(
446
							SimpleTypeEnum.STRING_LITERAL,
436
							SimpleTypeEnum.STRING_LITERAL,
447
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN_EQUAL)
437
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN_EQUAL)
Lines 458-474 Link Here
458
				dtParser.setSym1(result);
448
				dtParser.setSym1(result);
459
	  		  break;
449
	  		  break;
460
			}
450
			}
461
	 
451
	  
462
			//
452
			//
463
			// Rule 91:  relationalExpCS ::= relationalExpCS <= ifExpCSPrec
453
			// Rule 91:  relationalExpCS ::= relationalExpCS <= ifExpCSPrec
464
			//
454
			//
465
			case 91:
455
			case 91:
466
 
456
  
467
			//
457
			//
468
			// Rule 92:  relationalWithLet ::= relationalExpCS <= additiveWithLet
458
			// Rule 92:  relationalWithLet ::= relationalExpCS <= additiveWithLet
469
			//
459
			//
470
			case 92: {
460
			case 92: {
471
				
472
				SimpleNameCS simpleNameCS = createSimpleNameCS(
461
				SimpleNameCS simpleNameCS = createSimpleNameCS(
473
							SimpleTypeEnum.STRING_LITERAL,
462
							SimpleTypeEnum.STRING_LITERAL,
474
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN_EQUAL)
463
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN_EQUAL)
Lines 485-501 Link Here
485
				dtParser.setSym1(result);
474
				dtParser.setSym1(result);
486
	  		  break;
475
	  		  break;
487
			}
476
			}
488
	 
477
	  
489
			//
478
			//
490
			// Rule 97:  additiveExpCS ::= additiveExpCS + multiplicativeExpCS
479
			// Rule 97:  additiveExpCS ::= additiveExpCS + multiplicativeExpCS
491
			//
480
			//
492
			case 97:
481
			case 97:
493
 
482
  
494
			//
483
			//
495
			// Rule 98:  additiveWithLet ::= additiveExpCS + multiplicativeWithLet
484
			// Rule 98:  additiveWithLet ::= additiveExpCS + multiplicativeWithLet
496
			//
485
			//
497
			case 98: {
486
			case 98: {
498
				
499
				SimpleNameCS simpleNameCS = createSimpleNameCS(
487
				SimpleNameCS simpleNameCS = createSimpleNameCS(
500
							SimpleTypeEnum.STRING_LITERAL,
488
							SimpleTypeEnum.STRING_LITERAL,
501
							OCLStandardLibraryUtil.getOperationName(PredefinedType.PLUS)
489
							OCLStandardLibraryUtil.getOperationName(PredefinedType.PLUS)
Lines 512-528 Link Here
512
				dtParser.setSym1(result);
500
				dtParser.setSym1(result);
513
	  		  break;
501
	  		  break;
514
			}
502
			}
515
	 
503
	  
516
			//
504
			//
517
			// Rule 99:  additiveExpCS ::= additiveExpCS - multiplicativeExpCS
505
			// Rule 99:  additiveExpCS ::= additiveExpCS - multiplicativeExpCS
518
			//
506
			//
519
			case 99:
507
			case 99:
520
 
508
  
521
			//
509
			//
522
			// Rule 100:  additiveWithLet ::= additiveExpCS - multiplicativeWithLet
510
			// Rule 100:  additiveWithLet ::= additiveExpCS - multiplicativeWithLet
523
			//
511
			//
524
			case 100: {
512
			case 100: {
525
				
526
				SimpleNameCS simpleNameCS = createSimpleNameCS(
513
				SimpleNameCS simpleNameCS = createSimpleNameCS(
527
							SimpleTypeEnum.STRING_LITERAL,
514
							SimpleTypeEnum.STRING_LITERAL,
528
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
515
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
Lines 539-555 Link Here
539
				dtParser.setSym1(result);
526
				dtParser.setSym1(result);
540
	  		  break;
527
	  		  break;
541
			}
528
			}
542
	 
529
	  
543
			//
530
			//
544
			// Rule 103:  multiplicativeExpCS ::= multiplicativeExpCS * unaryExpCS
531
			// Rule 103:  multiplicativeExpCS ::= multiplicativeExpCS * unaryExpCS
545
			//
532
			//
546
			case 103:
533
			case 103:
547
 
534
  
548
			//
535
			//
549
			// Rule 104:  multiplicativeWithLet ::= multiplicativeExpCS * unaryWithLet
536
			// Rule 104:  multiplicativeWithLet ::= multiplicativeExpCS * unaryWithLet
550
			//
537
			//
551
			case 104: {
538
			case 104: {
552
				
553
				SimpleNameCS simpleNameCS = createSimpleNameCS(
539
				SimpleNameCS simpleNameCS = createSimpleNameCS(
554
							SimpleTypeEnum.STRING_LITERAL,
540
							SimpleTypeEnum.STRING_LITERAL,
555
							OCLStandardLibraryUtil.getOperationName(PredefinedType.TIMES)
541
							OCLStandardLibraryUtil.getOperationName(PredefinedType.TIMES)
Lines 566-582 Link Here
566
				dtParser.setSym1(result);
552
				dtParser.setSym1(result);
567
	  		  break;
553
	  		  break;
568
			}
554
			}
569
	 
555
	  
570
			//
556
			//
571
			// Rule 105:  multiplicativeExpCS ::= multiplicativeExpCS / unaryExpCS
557
			// Rule 105:  multiplicativeExpCS ::= multiplicativeExpCS / unaryExpCS
572
			//
558
			//
573
			case 105:
559
			case 105:
574
 
560
  
575
			//
561
			//
576
			// Rule 106:  multiplicativeWithLet ::= multiplicativeExpCS / unaryWithLet
562
			// Rule 106:  multiplicativeWithLet ::= multiplicativeExpCS / unaryWithLet
577
			//
563
			//
578
			case 106: {
564
			case 106: {
579
				
580
				SimpleNameCS simpleNameCS = createSimpleNameCS(
565
				SimpleNameCS simpleNameCS = createSimpleNameCS(
581
							SimpleTypeEnum.STRING_LITERAL,
566
							SimpleTypeEnum.STRING_LITERAL,
582
							OCLStandardLibraryUtil.getOperationName(PredefinedType.DIVIDE)
567
							OCLStandardLibraryUtil.getOperationName(PredefinedType.DIVIDE)
Lines 598-604 Link Here
598
			// Rule 109:  unaryExpCS ::= - unaryExpCS
583
			// Rule 109:  unaryExpCS ::= - unaryExpCS
599
			//
584
			//
600
			case 109: {
585
			case 109: {
601
				
602
				SimpleNameCS simpleNameCS = createSimpleNameCS(
586
				SimpleNameCS simpleNameCS = createSimpleNameCS(
603
							SimpleTypeEnum.STRING_LITERAL,
587
							SimpleTypeEnum.STRING_LITERAL,
604
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
588
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
Lines 618-624 Link Here
618
			// Rule 110:  unaryExpCS ::= not unaryExpCS
602
			// Rule 110:  unaryExpCS ::= not unaryExpCS
619
			//
603
			//
620
			case 110: {
604
			case 110: {
621
				
622
				SimpleNameCS simpleNameCS = createSimpleNameCS(
605
				SimpleNameCS simpleNameCS = createSimpleNameCS(
623
							SimpleTypeEnum.STRING_LITERAL,
606
							SimpleTypeEnum.STRING_LITERAL,
624
							getTokenText(dtParser.getToken(1))
607
							getTokenText(dtParser.getToken(1))
Lines 638-644 Link Here
638
			// Rule 112:  dotArrowExpCS ::= dotArrowExpCS callExpCS
621
			// Rule 112:  dotArrowExpCS ::= dotArrowExpCS callExpCS
639
			//
622
			//
640
			case 112: {
623
			case 112: {
641
				
642
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
624
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
643
				result.setSource((OCLExpressionCS)dtParser.getSym(1));
625
				result.setSource((OCLExpressionCS)dtParser.getSym(1));
644
				setOffsets(result, (CSTNode)dtParser.getSym(1), result);
626
				setOffsets(result, (CSTNode)dtParser.getSym(1), result);
Lines 650-656 Link Here
650
			// Rule 113:  dotArrowExpCS ::= dotArrowExpCS messageExpCS
632
			// Rule 113:  dotArrowExpCS ::= dotArrowExpCS messageExpCS
651
			//
633
			//
652
			case 113: {
634
			case 113: {
653
				
654
				MessageExpCS result = (MessageExpCS)dtParser.getSym(2);
635
				MessageExpCS result = (MessageExpCS)dtParser.getSym(2);
655
				result.setTarget((OCLExpressionCS)dtParser.getSym(1));
636
				result.setTarget((OCLExpressionCS)dtParser.getSym(1));
656
				setOffsets(result, (CSTNode)dtParser.getSym(1), (CSTNode)dtParser.getSym(2));
637
				setOffsets(result, (CSTNode)dtParser.getSym(1), (CSTNode)dtParser.getSym(2));
Lines 662-668 Link Here
662
			// Rule 114:  dotArrowExpCS ::= NUMERIC_OPERATION ( argumentsCSopt )
643
			// Rule 114:  dotArrowExpCS ::= NUMERIC_OPERATION ( argumentsCSopt )
663
			//
644
			//
664
			case 114: {
645
			case 114: {
665
				
666
				// NUMERIC_OPERATION -> Integer '.' Identifier
646
				// NUMERIC_OPERATION -> Integer '.' Identifier
667
				String text = getTokenText(dtParser.getToken(1));
647
				String text = getTokenText(dtParser.getToken(1));
668
				int index = text.indexOf('.');
648
				int index = text.indexOf('.');
Lines 708-714 Link Here
708
			// Rule 115:  dotArrowExpCS ::= pathNameCS :: simpleNameCS ( argumentsCSopt )
688
			// Rule 115:  dotArrowExpCS ::= pathNameCS :: simpleNameCS ( argumentsCSopt )
709
			//
689
			//
710
			case 115: {
690
			case 115: {
711
				
712
				OperationCallExpCS result = createOperationCallExpCS(
691
				OperationCallExpCS result = createOperationCallExpCS(
713
						(PathNameCS)dtParser.getSym(1),
692
						(PathNameCS)dtParser.getSym(1),
714
						(SimpleNameCS)dtParser.getSym(3),
693
						(SimpleNameCS)dtParser.getSym(3),
Lines 724-746 Link Here
724
			// Rule 120:  oclExpCS ::= ( oclExpressionCS )
703
			// Rule 120:  oclExpCS ::= ( oclExpressionCS )
725
			//
704
			//
726
			case 120: {
705
			case 120: {
727
				
728
				CSTNode result = (CSTNode)dtParser.getSym(2);
706
				CSTNode result = (CSTNode)dtParser.getSym(2);
729
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
707
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
730
				dtParser.setSym1(result);
708
				dtParser.setSym1(result);
731
	  		  break;
709
	  		  break;
732
			}
710
			}
733
	 
711
	  
734
			//
712
			//
735
			// Rule 121:  variableExpCS ::= simpleNameCS isMarkedPreCS
713
			// Rule 121:  variableExpCS ::= simpleNameCS isMarkedPreCS
736
			//
714
			//
737
			case 121:
715
			case 121:
738
 
716
  
739
			//
717
			//
740
			// Rule 122:  variableExpCS ::= keywordAsName1 isMarkedPreCS
718
			// Rule 122:  variableExpCS ::= keywordAsName1 isMarkedPreCS
741
			//
719
			//
742
			case 122: {
720
			case 122: {
743
				
744
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
721
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
745
				CSTNode result = createVariableExpCS(
722
				CSTNode result = createVariableExpCS(
746
						(SimpleNameCS)dtParser.getSym(1),
723
						(SimpleNameCS)dtParser.getSym(1),
Lines 755-771 Link Here
755
				dtParser.setSym1(result);
732
				dtParser.setSym1(result);
756
	  		  break;
733
	  		  break;
757
			}
734
			}
758
	 
735
	  
759
			//
736
			//
760
			// Rule 123:  variableExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
737
			// Rule 123:  variableExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
761
			//
738
			//
762
			case 123:
739
			case 123:
763
 
740
  
764
			//
741
			//
765
			// Rule 124:  variableExpCS ::= keywordAsName1 [ argumentsCS ] isMarkedPreCS
742
			// Rule 124:  variableExpCS ::= keywordAsName1 [ argumentsCS ] isMarkedPreCS
766
			//
743
			//
767
			case 124: {
744
			case 124: {
768
				
769
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
745
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
770
				CSTNode result = createVariableExpCS(
746
				CSTNode result = createVariableExpCS(
771
						(SimpleNameCS)dtParser.getSym(1),
747
						(SimpleNameCS)dtParser.getSym(1),
Lines 785-791 Link Here
785
			// Rule 126:  simpleNameCS ::= self
761
			// Rule 126:  simpleNameCS ::= self
786
			//
762
			//
787
			case 126: {
763
			case 126: {
788
				
789
				CSTNode result = createSimpleNameCS(
764
				CSTNode result = createSimpleNameCS(
790
						SimpleTypeEnum.SELF_LITERAL,
765
						SimpleTypeEnum.SELF_LITERAL,
791
						getTokenText(dtParser.getToken(1))
766
						getTokenText(dtParser.getToken(1))
Lines 799-805 Link Here
799
			// Rule 127:  simpleNameCS ::= IDENTIFIER
774
			// Rule 127:  simpleNameCS ::= IDENTIFIER
800
			//
775
			//
801
			case 127: {
776
			case 127: {
802
				
803
				CSTNode result = createSimpleNameCS(
777
				CSTNode result = createSimpleNameCS(
804
						SimpleTypeEnum.IDENTIFIER_LITERAL,
778
						SimpleTypeEnum.IDENTIFIER_LITERAL,
805
						getTokenText(dtParser.getToken(1))
779
						getTokenText(dtParser.getToken(1))
Lines 813-819 Link Here
813
			// Rule 128:  primitiveTypeCS ::= Integer
787
			// Rule 128:  primitiveTypeCS ::= Integer
814
			//
788
			//
815
			case 128: {
789
			case 128: {
816
				
817
				CSTNode result = createPrimitiveTypeCS(
790
				CSTNode result = createPrimitiveTypeCS(
818
						SimpleTypeEnum.INTEGER_LITERAL,
791
						SimpleTypeEnum.INTEGER_LITERAL,
819
						getTokenText(dtParser.getToken(1))
792
						getTokenText(dtParser.getToken(1))
Lines 827-833 Link Here
827
			// Rule 129:  primitiveTypeCS ::= UnlimitedNatural
800
			// Rule 129:  primitiveTypeCS ::= UnlimitedNatural
828
			//
801
			//
829
			case 129: {
802
			case 129: {
830
				
831
				CSTNode result = createPrimitiveTypeCS(
803
				CSTNode result = createPrimitiveTypeCS(
832
						SimpleTypeEnum.UNLIMITED_NATURAL_LITERAL,
804
						SimpleTypeEnum.UNLIMITED_NATURAL_LITERAL,
833
						getTokenText(dtParser.getToken(1))
805
						getTokenText(dtParser.getToken(1))
Lines 841-847 Link Here
841
			// Rule 130:  primitiveTypeCS ::= String
813
			// Rule 130:  primitiveTypeCS ::= String
842
			//
814
			//
843
			case 130: {
815
			case 130: {
844
				
845
				CSTNode result = createPrimitiveTypeCS(
816
				CSTNode result = createPrimitiveTypeCS(
846
						SimpleTypeEnum.STRING_LITERAL,
817
						SimpleTypeEnum.STRING_LITERAL,
847
						getTokenText(dtParser.getToken(1))
818
						getTokenText(dtParser.getToken(1))
Lines 855-861 Link Here
855
			// Rule 131:  primitiveTypeCS ::= Real
826
			// Rule 131:  primitiveTypeCS ::= Real
856
			//
827
			//
857
			case 131: {
828
			case 131: {
858
				
859
				CSTNode result = createPrimitiveTypeCS(
829
				CSTNode result = createPrimitiveTypeCS(
860
						SimpleTypeEnum.REAL_LITERAL,
830
						SimpleTypeEnum.REAL_LITERAL,
861
						getTokenText(dtParser.getToken(1))
831
						getTokenText(dtParser.getToken(1))
Lines 869-875 Link Here
869
			// Rule 132:  primitiveTypeCS ::= Boolean
839
			// Rule 132:  primitiveTypeCS ::= Boolean
870
			//
840
			//
871
			case 132: {
841
			case 132: {
872
				
873
				CSTNode result = createPrimitiveTypeCS(
842
				CSTNode result = createPrimitiveTypeCS(
874
						SimpleTypeEnum.BOOLEAN_LITERAL,
843
						SimpleTypeEnum.BOOLEAN_LITERAL,
875
						getTokenText(dtParser.getToken(1))
844
						getTokenText(dtParser.getToken(1))
Lines 883-889 Link Here
883
			// Rule 133:  primitiveTypeCS ::= OclAny
852
			// Rule 133:  primitiveTypeCS ::= OclAny
884
			//
853
			//
885
			case 133: {
854
			case 133: {
886
				
887
				CSTNode result = createPrimitiveTypeCS(
855
				CSTNode result = createPrimitiveTypeCS(
888
						SimpleTypeEnum.OCL_ANY_LITERAL,
856
						SimpleTypeEnum.OCL_ANY_LITERAL,
889
						getTokenText(dtParser.getToken(1))
857
						getTokenText(dtParser.getToken(1))
Lines 897-903 Link Here
897
			// Rule 134:  primitiveTypeCS ::= OclVoid
865
			// Rule 134:  primitiveTypeCS ::= OclVoid
898
			//
866
			//
899
			case 134: {
867
			case 134: {
900
				
901
				CSTNode result = createPrimitiveTypeCS(
868
				CSTNode result = createPrimitiveTypeCS(
902
						SimpleTypeEnum.OCL_VOID_LITERAL,
869
						SimpleTypeEnum.OCL_VOID_LITERAL,
903
						getTokenText(dtParser.getToken(1))
870
						getTokenText(dtParser.getToken(1))
Lines 911-917 Link Here
911
			// Rule 135:  primitiveTypeCS ::= Invalid
878
			// Rule 135:  primitiveTypeCS ::= Invalid
912
			//
879
			//
913
			case 135: {
880
			case 135: {
914
				
915
				CSTNode result = createPrimitiveTypeCS(
881
				CSTNode result = createPrimitiveTypeCS(
916
						SimpleTypeEnum.INVALID_LITERAL,
882
						SimpleTypeEnum.INVALID_LITERAL,
917
						getTokenText(dtParser.getToken(1))
883
						getTokenText(dtParser.getToken(1))
Lines 925-931 Link Here
925
			// Rule 136:  primitiveTypeCS ::= OclMessage
891
			// Rule 136:  primitiveTypeCS ::= OclMessage
926
			//
892
			//
927
			case 136: {
893
			case 136: {
928
				
929
				CSTNode result = createPrimitiveTypeCS(
894
				CSTNode result = createPrimitiveTypeCS(
930
						SimpleTypeEnum.OCL_MESSAGE_LITERAL,
895
						SimpleTypeEnum.OCL_MESSAGE_LITERAL,
931
						getTokenText(dtParser.getToken(1))
896
						getTokenText(dtParser.getToken(1))
Lines 939-945 Link Here
939
			// Rule 137:  pathNameCS ::= IDENTIFIER
904
			// Rule 137:  pathNameCS ::= IDENTIFIER
940
			//
905
			//
941
			case 137: {
906
			case 137: {
942
				
943
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
907
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
944
				setOffsets(result, getIToken(dtParser.getToken(1)));
908
				setOffsets(result, getIToken(dtParser.getToken(1)));
945
				dtParser.setSym1(result);
909
				dtParser.setSym1(result);
Lines 950-956 Link Here
950
			// Rule 138:  pathNameCS ::= pathNameCS :: simpleNameCS
914
			// Rule 138:  pathNameCS ::= pathNameCS :: simpleNameCS
951
			//
915
			//
952
			case 138: {
916
			case 138: {
953
				
954
				PathNameCS result = (PathNameCS)dtParser.getSym(1);
917
				PathNameCS result = (PathNameCS)dtParser.getSym(1);
955
				result = extendPathNameCS(result, getTokenText(dtParser.getToken(3)));
918
				result = extendPathNameCS(result, getTokenText(dtParser.getToken(3)));
956
				setOffsets(result, result, (CSTNode)dtParser.getSym(3));
919
				setOffsets(result, result, (CSTNode)dtParser.getSym(3));
Lines 962-983 Link Here
962
			// Rule 139:  pathNameCSOpt ::= $Empty
925
			// Rule 139:  pathNameCSOpt ::= $Empty
963
			//
926
			//
964
			case 139: {
927
			case 139: {
965
				
966
				CSTNode result = createPathNameCS();
928
				CSTNode result = createPathNameCS();
967
				dtParser.setSym1(result);
929
				dtParser.setSym1(result);
968
	  		  break;
930
	  		  break;
969
			}
931
			}
970
	 
932
	  
971
			//
933
			//
972
			// Rule 147:  enumLiteralExpCS ::= pathNameCS :: keywordAsName
934
			// Rule 147:  enumLiteralExpCS ::= pathNameCS :: keywordAsName
973
			//
935
			//
974
			case 147:
936
			case 147:
975
 
937
  
976
			//
938
			//
977
			// Rule 148:  enumLiteralExpCS ::= pathNameCS :: simpleNameCS
939
			// Rule 148:  enumLiteralExpCS ::= pathNameCS :: simpleNameCS
978
			//
940
			//
979
			case 148: {
941
			case 148: {
980
				
981
				CSTNode result = createEnumLiteralExpCS(
942
				CSTNode result = createEnumLiteralExpCS(
982
						(PathNameCS)dtParser.getSym(1),
943
						(PathNameCS)dtParser.getSym(1),
983
						(SimpleNameCS)dtParser.getSym(3)
944
						(SimpleNameCS)dtParser.getSym(3)
Lines 991-997 Link Here
991
			// Rule 149:  collectionLiteralExpCS ::= collectionTypeIdentifierCS { collectionLiteralPartsCSopt }
952
			// Rule 149:  collectionLiteralExpCS ::= collectionTypeIdentifierCS { collectionLiteralPartsCSopt }
992
			//
953
			//
993
			case 149: {
954
			case 149: {
994
				
995
				Object[] objs = (Object[])dtParser.getSym(1);
955
				Object[] objs = (Object[])dtParser.getSym(1);
996
				CSTNode result = createCollectionLiteralExpCS(
956
				CSTNode result = createCollectionLiteralExpCS(
997
						(CollectionTypeIdentifierEnum)objs[1],
957
						(CollectionTypeIdentifierEnum)objs[1],
Lines 1006-1012 Link Here
1006
			// Rule 150:  collectionTypeIdentifierCS ::= Set
966
			// Rule 150:  collectionTypeIdentifierCS ::= Set
1007
			//
967
			//
1008
			case 150: {
968
			case 150: {
1009
				
1010
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SET_LITERAL});
969
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SET_LITERAL});
1011
	  		  break;
970
	  		  break;
1012
			}
971
			}
Lines 1015-1021 Link Here
1015
			// Rule 151:  collectionTypeIdentifierCS ::= Bag
974
			// Rule 151:  collectionTypeIdentifierCS ::= Bag
1016
			//
975
			//
1017
			case 151: {
976
			case 151: {
1018
				
1019
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.BAG_LITERAL});
977
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.BAG_LITERAL});
1020
	  		  break;
978
	  		  break;
1021
			}
979
			}
Lines 1024-1030 Link Here
1024
			// Rule 152:  collectionTypeIdentifierCS ::= Sequence
982
			// Rule 152:  collectionTypeIdentifierCS ::= Sequence
1025
			//
983
			//
1026
			case 152: {
984
			case 152: {
1027
				
1028
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SEQUENCE_LITERAL});
985
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SEQUENCE_LITERAL});
1029
	  		  break;
986
	  		  break;
1030
			}
987
			}
Lines 1033-1039 Link Here
1033
			// Rule 153:  collectionTypeIdentifierCS ::= Collection
990
			// Rule 153:  collectionTypeIdentifierCS ::= Collection
1034
			//
991
			//
1035
			case 153: {
992
			case 153: {
1036
				
1037
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.COLLECTION_LITERAL});
993
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.COLLECTION_LITERAL});
1038
	  		  break;
994
	  		  break;
1039
			}
995
			}
Lines 1042-1064 Link Here
1042
			// Rule 154:  collectionTypeIdentifierCS ::= OrderedSet
998
			// Rule 154:  collectionTypeIdentifierCS ::= OrderedSet
1043
			//
999
			//
1044
			case 154: {
1000
			case 154: {
1045
				
1046
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.ORDERED_SET_LITERAL});
1001
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.ORDERED_SET_LITERAL});
1047
	  		  break;
1002
	  		  break;
1048
			}
1003
			}
1049
	 
1004
	  
1050
			//
1005
			//
1051
			// Rule 155:  collectionLiteralPartsCSopt ::= $Empty
1006
			// Rule 155:  collectionLiteralPartsCSopt ::= $Empty
1052
			//
1007
			//
1053
			case 155:
1008
			case 155:
1054
				dtParser.setSym1(new BasicEList());
1009
				dtParser.setSym1(new BasicEList());
1055
				break;
1010
				break;
1056
 
1011
  
1057
			//
1012
			//
1058
			// Rule 157:  collectionLiteralPartsCS ::= collectionLiteralPartCS
1013
			// Rule 157:  collectionLiteralPartsCS ::= collectionLiteralPartCS
1059
			//
1014
			//
1060
			case 157: {
1015
			case 157: {
1061
				
1062
				EList result = new BasicEList();
1016
				EList result = new BasicEList();
1063
				result.add(dtParser.getSym(1));
1017
				result.add(dtParser.getSym(1));
1064
				dtParser.setSym1(result);
1018
				dtParser.setSym1(result);
Lines 1069-1075 Link Here
1069
			// Rule 158:  collectionLiteralPartsCS ::= collectionLiteralPartsCS , collectionLiteralPartCS
1023
			// Rule 158:  collectionLiteralPartsCS ::= collectionLiteralPartsCS , collectionLiteralPartCS
1070
			//
1024
			//
1071
			case 158: {
1025
			case 158: {
1072
				
1073
				EList result = (EList)dtParser.getSym(1);
1026
				EList result = (EList)dtParser.getSym(1);
1074
				result.add(dtParser.getSym(3));
1027
				result.add(dtParser.getSym(3));
1075
				dtParser.setSym1(result);
1028
				dtParser.setSym1(result);
Lines 1080-1086 Link Here
1080
			// Rule 160:  collectionLiteralPartCS ::= oclExpressionCS
1033
			// Rule 160:  collectionLiteralPartCS ::= oclExpressionCS
1081
			//
1034
			//
1082
			case 160: {
1035
			case 160: {
1083
				
1084
				CSTNode result = createCollectionLiteralPartCS(
1036
				CSTNode result = createCollectionLiteralPartCS(
1085
						(OCLExpressionCS)dtParser.getSym(1)
1037
						(OCLExpressionCS)dtParser.getSym(1)
1086
					);
1038
					);
Lines 1093-1099 Link Here
1093
			// Rule 161:  collectionRangeCS ::= - INTEGER_RANGE_START oclExpressionCS
1045
			// Rule 161:  collectionRangeCS ::= - INTEGER_RANGE_START oclExpressionCS
1094
			//
1046
			//
1095
			case 161: {
1047
			case 161: {
1096
				
1097
				OCLExpressionCS rangeStart = createRangeStart(
1048
				OCLExpressionCS rangeStart = createRangeStart(
1098
						getTokenText(dtParser.getToken(2)), true);
1049
						getTokenText(dtParser.getToken(2)), true);
1099
				CSTNode result = createCollectionRangeCS(
1050
				CSTNode result = createCollectionRangeCS(
Lines 1109-1115 Link Here
1109
			// Rule 162:  collectionRangeCS ::= INTEGER_RANGE_START oclExpressionCS
1060
			// Rule 162:  collectionRangeCS ::= INTEGER_RANGE_START oclExpressionCS
1110
			//
1061
			//
1111
			case 162: {
1062
			case 162: {
1112
				
1113
				OCLExpressionCS rangeStart = createRangeStart(
1063
				OCLExpressionCS rangeStart = createRangeStart(
1114
						getTokenText(dtParser.getToken(1)), false);
1064
						getTokenText(dtParser.getToken(1)), false);
1115
				CSTNode result = createCollectionRangeCS(
1065
				CSTNode result = createCollectionRangeCS(
Lines 1125-1131 Link Here
1125
			// Rule 163:  collectionRangeCS ::= oclExpressionCS .. oclExpressionCS
1075
			// Rule 163:  collectionRangeCS ::= oclExpressionCS .. oclExpressionCS
1126
			//
1076
			//
1127
			case 163: {
1077
			case 163: {
1128
				
1129
				CSTNode result = createCollectionRangeCS(
1078
				CSTNode result = createCollectionRangeCS(
1130
						(OCLExpressionCS)dtParser.getSym(1),
1079
						(OCLExpressionCS)dtParser.getSym(1),
1131
						(OCLExpressionCS)dtParser.getSym(3)
1080
						(OCLExpressionCS)dtParser.getSym(3)
Lines 1139-1145 Link Here
1139
			// Rule 169:  tupleLiteralExpCS ::= Tuple { variableListCS2 }
1088
			// Rule 169:  tupleLiteralExpCS ::= Tuple { variableListCS2 }
1140
			//
1089
			//
1141
			case 169: {
1090
			case 169: {
1142
				
1143
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
1091
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
1144
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1092
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1145
				dtParser.setSym1(result);
1093
				dtParser.setSym1(result);
Lines 1150-1156 Link Here
1150
			// Rule 170:  integerLiteralExpCS ::= INTEGER_LITERAL
1098
			// Rule 170:  integerLiteralExpCS ::= INTEGER_LITERAL
1151
			//
1099
			//
1152
			case 170: {
1100
			case 170: {
1153
				
1154
				CSTNode result = createIntegerLiteralExpCS(getTokenText(dtParser.getToken(1)));
1101
				CSTNode result = createIntegerLiteralExpCS(getTokenText(dtParser.getToken(1)));
1155
				setOffsets(result, getIToken(dtParser.getToken(1)));
1102
				setOffsets(result, getIToken(dtParser.getToken(1)));
1156
				dtParser.setSym1(result);
1103
				dtParser.setSym1(result);
Lines 1161-1167 Link Here
1161
			// Rule 171:  unlimitedNaturalLiteralExpCS ::= *
1108
			// Rule 171:  unlimitedNaturalLiteralExpCS ::= *
1162
			//
1109
			//
1163
			case 171: {
1110
			case 171: {
1164
				
1165
				CSTNode result = createUnlimitedNaturalLiteralExpCS(getTokenText(dtParser.getToken(1)));
1111
				CSTNode result = createUnlimitedNaturalLiteralExpCS(getTokenText(dtParser.getToken(1)));
1166
				setOffsets(result, getIToken(dtParser.getToken(1)));
1112
				setOffsets(result, getIToken(dtParser.getToken(1)));
1167
				dtParser.setSym1(result);
1113
				dtParser.setSym1(result);
Lines 1172-1178 Link Here
1172
			// Rule 172:  realLiteralExpCS ::= REAL_LITERAL
1118
			// Rule 172:  realLiteralExpCS ::= REAL_LITERAL
1173
			//
1119
			//
1174
			case 172: {
1120
			case 172: {
1175
				
1176
				CSTNode result = createRealLiteralExpCS(getTokenText(dtParser.getToken(1)));
1121
				CSTNode result = createRealLiteralExpCS(getTokenText(dtParser.getToken(1)));
1177
				setOffsets(result, getIToken(dtParser.getToken(1)));
1122
				setOffsets(result, getIToken(dtParser.getToken(1)));
1178
				dtParser.setSym1(result);
1123
				dtParser.setSym1(result);
Lines 1183-1189 Link Here
1183
			// Rule 173:  stringLiteralExpCS ::= STRING_LITERAL
1128
			// Rule 173:  stringLiteralExpCS ::= STRING_LITERAL
1184
			//
1129
			//
1185
			case 173: {
1130
			case 173: {
1186
				
1187
				IToken literalToken = getIToken(dtParser.getToken(1));
1131
				IToken literalToken = getIToken(dtParser.getToken(1));
1188
				StringLiteralExpCS result = createStringLiteralExpCS(literalToken.toString());
1132
				StringLiteralExpCS result = createStringLiteralExpCS(literalToken.toString());
1189
				result.setUnescapedStringSymbol(unescape(literalToken));
1133
				result.setUnescapedStringSymbol(unescape(literalToken));
Lines 1196-1202 Link Here
1196
			// Rule 174:  booleanLiteralExpCS ::= true
1140
			// Rule 174:  booleanLiteralExpCS ::= true
1197
			//
1141
			//
1198
			case 174: {
1142
			case 174: {
1199
				
1200
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1143
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1201
				setOffsets(result, getIToken(dtParser.getToken(1)));
1144
				setOffsets(result, getIToken(dtParser.getToken(1)));
1202
				dtParser.setSym1(result);
1145
				dtParser.setSym1(result);
Lines 1207-1213 Link Here
1207
			// Rule 175:  booleanLiteralExpCS ::= false
1150
			// Rule 175:  booleanLiteralExpCS ::= false
1208
			//
1151
			//
1209
			case 175: {
1152
			case 175: {
1210
				
1211
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1153
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1212
				setOffsets(result, getIToken(dtParser.getToken(1)));
1154
				setOffsets(result, getIToken(dtParser.getToken(1)));
1213
				dtParser.setSym1(result);
1155
				dtParser.setSym1(result);
Lines 1218-1224 Link Here
1218
			// Rule 176:  nullLiteralExpCS ::= null
1160
			// Rule 176:  nullLiteralExpCS ::= null
1219
			//
1161
			//
1220
			case 176: {
1162
			case 176: {
1221
				
1222
				CSTNode result = createNullLiteralExpCS(getTokenText(dtParser.getToken(1)));
1163
				CSTNode result = createNullLiteralExpCS(getTokenText(dtParser.getToken(1)));
1223
				setOffsets(result, getIToken(dtParser.getToken(1)));
1164
				setOffsets(result, getIToken(dtParser.getToken(1)));
1224
				dtParser.setSym1(result);
1165
				dtParser.setSym1(result);
Lines 1229-1267 Link Here
1229
			// Rule 177:  invalidLiteralExpCS ::= OclInvalid
1170
			// Rule 177:  invalidLiteralExpCS ::= OclInvalid
1230
			//
1171
			//
1231
			case 177: {
1172
			case 177: {
1232
				
1233
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
1173
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
1234
				setOffsets(result, getIToken(dtParser.getToken(1)));
1174
				setOffsets(result, getIToken(dtParser.getToken(1)));
1235
				dtParser.setSym1(result);
1175
				dtParser.setSym1(result);
1236
	  		  break;
1176
	  		  break;
1237
			}
1177
			}
1238
	 
1178
	  
1239
			//
1179
			//
1240
			// Rule 178:  callExpCS ::= -> featureCallExpCS
1180
			// Rule 178:  callExpCS ::= -> featureCallExpCS
1241
			//
1181
			//
1242
			case 178:
1182
			case 178:
1243
 
1183
  
1244
			//
1184
			//
1245
			// Rule 179:  callExpCS ::= -> loopExpCS
1185
			// Rule 179:  callExpCS ::= -> loopExpCS
1246
			//
1186
			//
1247
			case 179: {
1187
			case 179: {
1248
				
1249
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1188
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1250
				result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
1189
				result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
1251
				dtParser.setSym1(result);
1190
				dtParser.setSym1(result);
1252
	  		  break;
1191
	  		  break;
1253
			}
1192
			}
1254
	 
1193
	  
1255
			//
1194
			//
1256
			// Rule 180:  callExpCS ::= . keywordOperationCallExpCS
1195
			// Rule 180:  callExpCS ::= . keywordOperationCallExpCS
1257
			//
1196
			//
1258
			case 180:
1197
			case 180:
1259
 
1198
  
1260
			//
1199
			//
1261
			// Rule 181:  callExpCS ::= . featureCallExpCS
1200
			// Rule 181:  callExpCS ::= . featureCallExpCS
1262
			//
1201
			//
1263
			case 181: {
1202
			case 181: {
1264
				
1265
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1203
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1266
				result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
1204
				result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
1267
				dtParser.setSym1(result);
1205
				dtParser.setSym1(result);
Lines 1272-1278 Link Here
1272
			// Rule 184:  iteratorExpCS ::= iteratorName ( oclExpressionCS )
1210
			// Rule 184:  iteratorExpCS ::= iteratorName ( oclExpressionCS )
1273
			//
1211
			//
1274
			case 184: {
1212
			case 184: {
1275
				
1276
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1213
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1277
				CSTNode result = createIteratorExpCS(
1214
				CSTNode result = createIteratorExpCS(
1278
						simpleNameCS,
1215
						simpleNameCS,
Lines 1289-1295 Link Here
1289
			// Rule 185:  iteratorExpCS ::= iteratorName ( variableCS | oclExpressionCS )
1226
			// Rule 185:  iteratorExpCS ::= iteratorName ( variableCS | oclExpressionCS )
1290
			//
1227
			//
1291
			case 185: {
1228
			case 185: {
1292
				
1293
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1229
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1294
				CSTNode result = createIteratorExpCS(
1230
				CSTNode result = createIteratorExpCS(
1295
						simpleNameCS,
1231
						simpleNameCS,
Lines 1306-1312 Link Here
1306
			// Rule 186:  iteratorExpCS ::= iteratorName ( variableCS , variableCS | oclExpressionCS )
1242
			// Rule 186:  iteratorExpCS ::= iteratorName ( variableCS , variableCS | oclExpressionCS )
1307
			//
1243
			//
1308
			case 186: {
1244
			case 186: {
1309
				
1310
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1245
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1311
				CSTNode result = createIteratorExpCS(
1246
				CSTNode result = createIteratorExpCS(
1312
						simpleNameCS,
1247
						simpleNameCS,
Lines 1323-1329 Link Here
1323
			// Rule 187:  iterateExpCS ::= iterateName ( variableCS | oclExpressionCS )
1258
			// Rule 187:  iterateExpCS ::= iterateName ( variableCS | oclExpressionCS )
1324
			//
1259
			//
1325
			case 187: {
1260
			case 187: {
1326
				
1327
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1261
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1328
				CSTNode result = createIterateExpCS(
1262
				CSTNode result = createIterateExpCS(
1329
						simpleNameCS,
1263
						simpleNameCS,
Lines 1340-1346 Link Here
1340
			// Rule 188:  iterateExpCS ::= iterateName ( variableCS ; variableCS | oclExpressionCS )
1274
			// Rule 188:  iterateExpCS ::= iterateName ( variableCS ; variableCS | oclExpressionCS )
1341
			//
1275
			//
1342
			case 188: {
1276
			case 188: {
1343
				
1344
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1277
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1345
				CSTNode result = createIterateExpCS(
1278
				CSTNode result = createIterateExpCS(
1346
						simpleNameCS,
1279
						simpleNameCS,
Lines 1357-1363 Link Here
1357
			// Rule 189:  variableCS ::= IDENTIFIER
1290
			// Rule 189:  variableCS ::= IDENTIFIER
1358
			//
1291
			//
1359
			case 189: {
1292
			case 189: {
1360
				
1361
				CSTNode result = createVariableCS(
1293
				CSTNode result = createVariableCS(
1362
						getTokenText(dtParser.getToken(1)),
1294
						getTokenText(dtParser.getToken(1)),
1363
						null,
1295
						null,
Lines 1372-1378 Link Here
1372
			// Rule 190:  typedVariableCS ::= IDENTIFIER : typeCS
1304
			// Rule 190:  typedVariableCS ::= IDENTIFIER : typeCS
1373
			//
1305
			//
1374
			case 190: {
1306
			case 190: {
1375
				
1376
				CSTNode result = createVariableCS(
1307
				CSTNode result = createVariableCS(
1377
						getTokenText(dtParser.getToken(1)),
1308
						getTokenText(dtParser.getToken(1)),
1378
						(TypeCS)dtParser.getSym(3),
1309
						(TypeCS)dtParser.getSym(3),
Lines 1387-1393 Link Here
1387
			// Rule 192:  variableCS ::= IDENTIFIER : typeCS = oclExpressionCS
1318
			// Rule 192:  variableCS ::= IDENTIFIER : typeCS = oclExpressionCS
1388
			//
1319
			//
1389
			case 192: {
1320
			case 192: {
1390
				
1391
				CSTNode result = createVariableCS(
1321
				CSTNode result = createVariableCS(
1392
						getTokenText(dtParser.getToken(1)),
1322
						getTokenText(dtParser.getToken(1)),
1393
						(TypeCS)dtParser.getSym(3),
1323
						(TypeCS)dtParser.getSym(3),
Lines 1402-1408 Link Here
1402
			// Rule 193:  variableCS2 ::= IDENTIFIER = oclExpressionCS
1332
			// Rule 193:  variableCS2 ::= IDENTIFIER = oclExpressionCS
1403
			//
1333
			//
1404
			case 193: {
1334
			case 193: {
1405
				
1406
				CSTNode result = createVariableCS(
1335
				CSTNode result = createVariableCS(
1407
						getTokenText(dtParser.getToken(1)),
1336
						getTokenText(dtParser.getToken(1)),
1408
						null,
1337
						null,
Lines 1424-1430 Link Here
1424
			// Rule 200:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS )
1353
			// Rule 200:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS )
1425
			//
1354
			//
1426
			case 200: {
1355
			case 200: {
1427
				
1428
				Object[] objs = (Object[])dtParser.getSym(1);
1356
				Object[] objs = (Object[])dtParser.getSym(1);
1429
				CSTNode result = createCollectionTypeCS(
1357
				CSTNode result = createCollectionTypeCS(
1430
						(CollectionTypeIdentifierEnum)objs[1],
1358
						(CollectionTypeIdentifierEnum)objs[1],
Lines 1439-1463 Link Here
1439
			// Rule 201:  tupleTypeCS ::= Tuple ( variableListCSopt )
1367
			// Rule 201:  tupleTypeCS ::= Tuple ( variableListCSopt )
1440
			//
1368
			//
1441
			case 201: {
1369
			case 201: {
1442
				
1443
				CSTNode result = createTupleTypeCS((EList)dtParser.getSym(3));
1370
				CSTNode result = createTupleTypeCS((EList)dtParser.getSym(3));
1444
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1371
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1445
				dtParser.setSym1(result);
1372
				dtParser.setSym1(result);
1446
	  		  break;
1373
	  		  break;
1447
			}
1374
			}
1448
	 
1375
	  
1449
			//
1376
			//
1450
			// Rule 202:  variableListCSopt ::= $Empty
1377
			// Rule 202:  variableListCSopt ::= $Empty
1451
			//
1378
			//
1452
			case 202:
1379
			case 202:
1453
				dtParser.setSym1(new BasicEList());
1380
				dtParser.setSym1(new BasicEList());
1454
				break;
1381
				break;
1455
 
1382
  
1456
			//
1383
			//
1457
			// Rule 204:  variableListCS ::= variableCS
1384
			// Rule 204:  variableListCS ::= variableCS
1458
			//
1385
			//
1459
			case 204: {
1386
			case 204: {
1460
				
1461
				EList result = new BasicEList();
1387
				EList result = new BasicEList();
1462
				result.add(dtParser.getSym(1));
1388
				result.add(dtParser.getSym(1));
1463
				dtParser.setSym1(result);
1389
				dtParser.setSym1(result);
Lines 1468-1527 Link Here
1468
			// Rule 205:  variableListCS ::= variableListCS , variableCS
1394
			// Rule 205:  variableListCS ::= variableListCS , variableCS
1469
			//
1395
			//
1470
			case 205: {
1396
			case 205: {
1471
				
1472
				EList result = (EList)dtParser.getSym(1);
1397
				EList result = (EList)dtParser.getSym(1);
1473
				result.add(dtParser.getSym(3));
1398
				result.add(dtParser.getSym(3));
1474
				dtParser.setSym1(result);
1399
				dtParser.setSym1(result);
1475
	  		  break;
1400
	  		  break;
1476
			}
1401
			}
1477
	 
1402
	  
1478
			//
1403
			//
1479
			// Rule 206:  variableListCS2 ::= variableCS2
1404
			// Rule 206:  variableListCS2 ::= variableCS2
1480
			//
1405
			//
1481
			case 206:
1406
			case 206:
1482
 
1407
  
1483
			//
1408
			//
1484
			// Rule 207:  variableListCS2 ::= variableCS
1409
			// Rule 207:  variableListCS2 ::= variableCS
1485
			//
1410
			//
1486
			case 207: {
1411
			case 207: {
1487
				
1488
				EList result = new BasicEList();
1412
				EList result = new BasicEList();
1489
				result.add(dtParser.getSym(1));
1413
				result.add(dtParser.getSym(1));
1490
				dtParser.setSym1(result);
1414
				dtParser.setSym1(result);
1491
	  		  break;
1415
	  		  break;
1492
			}
1416
			}
1493
	 
1417
	  
1494
			//
1418
			//
1495
			// Rule 208:  variableListCS2 ::= variableListCS2 , variableCS2
1419
			// Rule 208:  variableListCS2 ::= variableListCS2 , variableCS2
1496
			//
1420
			//
1497
			case 208:
1421
			case 208:
1498
 
1422
  
1499
			//
1423
			//
1500
			// Rule 209:  variableListCS2 ::= variableListCS2 , variableCS
1424
			// Rule 209:  variableListCS2 ::= variableListCS2 , variableCS
1501
			//
1425
			//
1502
			case 209: {
1426
			case 209: {
1503
				
1504
				EList result = (EList)dtParser.getSym(1);
1427
				EList result = (EList)dtParser.getSym(1);
1505
				result.add(dtParser.getSym(3));
1428
				result.add(dtParser.getSym(3));
1506
				dtParser.setSym1(result);
1429
				dtParser.setSym1(result);
1507
	  		  break;
1430
	  		  break;
1508
			}
1431
			}
1509
	 
1432
	  
1510
			//
1433
			//
1511
			// Rule 212:  featureCallExpCS ::= unaryName isMarkedPreCS ( argumentsCSopt )
1434
			// Rule 212:  featureCallExpCS ::= unaryName isMarkedPreCS ( argumentsCSopt )
1512
			//
1435
			//
1513
			case 212:
1436
			case 212:
1514
 
1437
   
1515
			//
1438
			//
1516
			// Rule 213:  operationCallExpCS ::= binaryName isMarkedPreCS ( argumentsCSopt )
1439
			// Rule 213:  operationCallExpCS ::= binaryName isMarkedPreCS ( argumentsCSopt )
1517
			//
1440
			//
1518
			case 213:
1441
			case 213:
1519
 
1442
  
1520
			//
1443
			//
1521
			// Rule 214:  keywordOperationCallExpCS ::= keywordAsName isMarkedPreCS ( argumentsCSopt )
1444
			// Rule 214:  keywordOperationCallExpCS ::= keywordAsName isMarkedPreCS ( argumentsCSopt )
1522
			//
1445
			//
1523
			case 214: {
1446
			case 214: {
1524
				
1525
				CSTNode result = createOperationCallExpCS(
1447
				CSTNode result = createOperationCallExpCS(
1526
						(SimpleNameCS)dtParser.getSym(1),
1448
						(SimpleNameCS)dtParser.getSym(1),
1527
						(IsMarkedPreCS)dtParser.getSym(2),
1449
						(IsMarkedPreCS)dtParser.getSym(2),
Lines 1536-1542 Link Here
1536
			// Rule 215:  stateExpCS ::= pathNameCSOpt
1458
			// Rule 215:  stateExpCS ::= pathNameCSOpt
1537
			//
1459
			//
1538
			case 215: {
1460
			case 215: {
1539
				
1540
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
1461
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
1541
				StateExpCS result = createStateExpCS(pathNameCS);
1462
				StateExpCS result = createStateExpCS(pathNameCS);
1542
				setOffsets(result, pathNameCS);
1463
				setOffsets(result, pathNameCS);
Lines 1548-1554 Link Here
1548
			// Rule 216:  operationCallExpCS ::= oclIsInStateName isMarkedPreCS ( stateExpCS )
1469
			// Rule 216:  operationCallExpCS ::= oclIsInStateName isMarkedPreCS ( stateExpCS )
1549
			//
1470
			//
1550
			case 216: {
1471
			case 216: {
1551
				
1552
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1472
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1553
				CSTNode result = createOperationCallExpCS(
1473
				CSTNode result = createOperationCallExpCS(
1554
						simpleNameCS,
1474
						simpleNameCS,
Lines 1559-1575 Link Here
1559
				dtParser.setSym1(result);
1479
				dtParser.setSym1(result);
1560
	  		  break;
1480
	  		  break;
1561
			}
1481
			}
1562
	 
1482
	  
1563
			//
1483
			//
1564
			// Rule 217:  attrOrNavCallExpCS ::= simpleNameCS isMarkedPreCS
1484
			// Rule 217:  attrOrNavCallExpCS ::= simpleNameCS isMarkedPreCS
1565
			//
1485
			//
1566
			case 217:
1486
			case 217:
1567
 
1487
  
1568
			//
1488
			//
1569
			// Rule 218:  attrOrNavCallExpCS ::= keywordAsName isMarkedPreCS
1489
			// Rule 218:  attrOrNavCallExpCS ::= keywordAsName isMarkedPreCS
1570
			//
1490
			//
1571
			case 218: {
1491
			case 218: {
1572
				
1573
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
1492
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
1574
				CSTNode result = createFeatureCallExpCS(
1493
				CSTNode result = createFeatureCallExpCS(
1575
						(SimpleNameCS)dtParser.getSym(1),
1494
						(SimpleNameCS)dtParser.getSym(1),
Lines 1589-1595 Link Here
1589
			// Rule 219:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
1508
			// Rule 219:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
1590
			//
1509
			//
1591
			case 219: {
1510
			case 219: {
1592
				
1593
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
1511
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
1594
				CSTNode result = createFeatureCallExpCS(
1512
				CSTNode result = createFeatureCallExpCS(
1595
						(SimpleNameCS)dtParser.getSym(1),
1513
						(SimpleNameCS)dtParser.getSym(1),
Lines 1609-1615 Link Here
1609
			// Rule 220:  isMarkedPreCS ::= $Empty
1527
			// Rule 220:  isMarkedPreCS ::= $Empty
1610
			//
1528
			//
1611
			case 220: {
1529
			case 220: {
1612
				
1613
				CSTNode result = createIsMarkedPreCS(false);
1530
				CSTNode result = createIsMarkedPreCS(false);
1614
				setOffsets(result, getIToken(dtParser.getToken(1)));
1531
				setOffsets(result, getIToken(dtParser.getToken(1)));
1615
				dtParser.setSym1(result);
1532
				dtParser.setSym1(result);
Lines 1620-1644 Link Here
1620
			// Rule 221:  isMarkedPreCS ::= @pre
1537
			// Rule 221:  isMarkedPreCS ::= @pre
1621
			//
1538
			//
1622
			case 221: {
1539
			case 221: {
1623
				
1624
				CSTNode result = createIsMarkedPreCS(true);
1540
				CSTNode result = createIsMarkedPreCS(true);
1625
				setOffsets(result, getIToken(dtParser.getToken(1)));
1541
				setOffsets(result, getIToken(dtParser.getToken(1)));
1626
				dtParser.setSym1(result);
1542
				dtParser.setSym1(result);
1627
	  		  break;
1543
	  		  break;
1628
			}
1544
			}
1629
	 
1545
	  
1630
			//
1546
			//
1631
			// Rule 222:  argumentsCSopt ::= $Empty
1547
			// Rule 222:  argumentsCSopt ::= $Empty
1632
			//
1548
			//
1633
			case 222:
1549
			case 222:
1634
				dtParser.setSym1(new BasicEList());
1550
				dtParser.setSym1(new BasicEList());
1635
				break;
1551
				break;
1636
 
1552
  
1637
			//
1553
			//
1638
			// Rule 224:  argumentsCS ::= oclExpressionCS
1554
			// Rule 224:  argumentsCS ::= oclExpressionCS
1639
			//
1555
			//
1640
			case 224: {
1556
			case 224: {
1641
				
1642
				EList result = new BasicEList();
1557
				EList result = new BasicEList();
1643
				result.add(dtParser.getSym(1));
1558
				result.add(dtParser.getSym(1));
1644
				dtParser.setSym1(result);
1559
				dtParser.setSym1(result);
Lines 1649-1655 Link Here
1649
			// Rule 225:  argumentsCS ::= argumentsCS , oclExpressionCS
1564
			// Rule 225:  argumentsCS ::= argumentsCS , oclExpressionCS
1650
			//
1565
			//
1651
			case 225: {
1566
			case 225: {
1652
				
1653
				EList result = (EList)dtParser.getSym(1);
1567
				EList result = (EList)dtParser.getSym(1);
1654
				result.add(dtParser.getSym(3));
1568
				result.add(dtParser.getSym(3));
1655
				dtParser.setSym1(result);
1569
				dtParser.setSym1(result);
Lines 1660-1666 Link Here
1660
			// Rule 226:  letExpCS ::= let variableListCS in oclExpressionCS
1574
			// Rule 226:  letExpCS ::= let variableListCS in oclExpressionCS
1661
			//
1575
			//
1662
			case 226: {
1576
			case 226: {
1663
				
1664
				CSTNode result = createLetExpCS(
1577
				CSTNode result = createLetExpCS(
1665
						(EList)dtParser.getSym(2),
1578
						(EList)dtParser.getSym(2),
1666
						(OCLExpressionCS)dtParser.getSym(4)
1579
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1674-1680 Link Here
1674
			// Rule 227:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS endif
1587
			// Rule 227:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS endif
1675
			//
1588
			//
1676
			case 227: {
1589
			case 227: {
1677
				
1678
				CSTNode result = createIfExpCS(
1590
				CSTNode result = createIfExpCS(
1679
						(OCLExpressionCS)dtParser.getSym(2),
1591
						(OCLExpressionCS)dtParser.getSym(2),
1680
						(OCLExpressionCS)dtParser.getSym(4),
1592
						(OCLExpressionCS)dtParser.getSym(4),
Lines 1684-1700 Link Here
1684
				dtParser.setSym1(result);
1596
				dtParser.setSym1(result);
1685
	  		  break;
1597
	  		  break;
1686
			}
1598
			}
1687
	 
1599
	  
1688
			//
1600
			//
1689
			// Rule 228:  messageExpCS ::= ^ simpleNameCS ( oclMessageArgumentsCSopt )
1601
			// Rule 228:  messageExpCS ::= ^ simpleNameCS ( oclMessageArgumentsCSopt )
1690
			//
1602
			//
1691
			case 228:
1603
			case 228:
1692
 
1604
  
1693
			//
1605
			//
1694
			// Rule 229:  messageExpCS ::= ^^ simpleNameCS ( oclMessageArgumentsCSopt )
1606
			// Rule 229:  messageExpCS ::= ^^ simpleNameCS ( oclMessageArgumentsCSopt )
1695
			//
1607
			//
1696
			case 229: {
1608
			case 229: {
1697
				
1698
				CSTNode result = createMessageExpCS(
1609
				CSTNode result = createMessageExpCS(
1699
						getIToken(dtParser.getToken(1)).getKind() == OCLParsersym.TK_CARET,
1610
						getIToken(dtParser.getToken(1)).getKind() == OCLParsersym.TK_CARET,
1700
						(SimpleNameCS)dtParser.getSym(2),
1611
						(SimpleNameCS)dtParser.getSym(2),
Lines 1704-1722 Link Here
1704
				dtParser.setSym1(result);
1615
				dtParser.setSym1(result);
1705
	  		  break;
1616
	  		  break;
1706
			}
1617
			}
1707
	 
1618
	  
1708
			//
1619
			//
1709
			// Rule 230:  oclMessageArgumentsCSopt ::= $Empty
1620
			// Rule 230:  oclMessageArgumentsCSopt ::= $Empty
1710
			//
1621
			//
1711
			case 230:
1622
			case 230:
1712
				dtParser.setSym1(new BasicEList());
1623
				dtParser.setSym1(new BasicEList());
1713
				break;
1624
				break;
1714
 
1625
  
1715
			//
1626
			//
1716
			// Rule 232:  oclMessageArgumentsCS ::= oclMessageArgCS
1627
			// Rule 232:  oclMessageArgumentsCS ::= oclMessageArgCS
1717
			//
1628
			//
1718
			case 232: {
1629
			case 232: {
1719
				
1720
				EList result = new BasicEList();
1630
				EList result = new BasicEList();
1721
				result.add(dtParser.getSym(1));
1631
				result.add(dtParser.getSym(1));
1722
				dtParser.setSym1(result);
1632
				dtParser.setSym1(result);
Lines 1727-1733 Link Here
1727
			// Rule 233:  oclMessageArgumentsCS ::= oclMessageArgumentsCS , oclMessageArgCS
1637
			// Rule 233:  oclMessageArgumentsCS ::= oclMessageArgumentsCS , oclMessageArgCS
1728
			//
1638
			//
1729
			case 233: {
1639
			case 233: {
1730
				
1731
				EList result = (EList)dtParser.getSym(1);
1640
				EList result = (EList)dtParser.getSym(1);
1732
				result.add(dtParser.getSym(3));
1641
				result.add(dtParser.getSym(3));
1733
				dtParser.setSym1(result);
1642
				dtParser.setSym1(result);
Lines 1738-1744 Link Here
1738
			// Rule 234:  oclMessageArgCS ::= oclExpressionCS
1647
			// Rule 234:  oclMessageArgCS ::= oclExpressionCS
1739
			//
1648
			//
1740
			case 234: {
1649
			case 234: {
1741
				
1742
				CSTNode result = createOCLMessageArgCS(
1650
				CSTNode result = createOCLMessageArgCS(
1743
						null,
1651
						null,
1744
						(OCLExpressionCS)dtParser.getSym(1)
1652
						(OCLExpressionCS)dtParser.getSym(1)
Lines 1752-1758 Link Here
1752
			// Rule 235:  oclMessageArgCS ::= ?
1660
			// Rule 235:  oclMessageArgCS ::= ?
1753
			//
1661
			//
1754
			case 235: {
1662
			case 235: {
1755
				
1756
				CSTNode result = createOCLMessageArgCS(
1663
				CSTNode result = createOCLMessageArgCS(
1757
						null,
1664
						null,
1758
						null
1665
						null
Lines 1766-1772 Link Here
1766
			// Rule 236:  oclMessageArgCS ::= ? : typeCS
1673
			// Rule 236:  oclMessageArgCS ::= ? : typeCS
1767
			//
1674
			//
1768
			case 236: {
1675
			case 236: {
1769
				
1770
				CSTNode result = createOCLMessageArgCS(
1676
				CSTNode result = createOCLMessageArgCS(
1771
						(TypeCS)dtParser.getSym(3),
1677
						(TypeCS)dtParser.getSym(3),
1772
						null
1678
						null
Lines 1780-1786 Link Here
1780
			// Rule 245:  packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
1686
			// Rule 245:  packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
1781
			//
1687
			//
1782
			case 245: {
1688
			case 245: {
1783
				
1784
				PackageDeclarationCS result = (PackageDeclarationCS)dtParser.getSym(2);
1689
				PackageDeclarationCS result = (PackageDeclarationCS)dtParser.getSym(2);
1785
				result.setPackageDeclarationCS((PackageDeclarationCS) dtParser.getSym(1));
1690
				result.setPackageDeclarationCS((PackageDeclarationCS) dtParser.getSym(1));
1786
				dtParser.setSym1(result);
1691
				dtParser.setSym1(result);
Lines 1791-1797 Link Here
1791
			// Rule 246:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
1696
			// Rule 246:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
1792
			//
1697
			//
1793
			case 246: {
1698
			case 246: {
1794
				
1795
				CSTNode result = createPackageDeclarationCS(
1699
				CSTNode result = createPackageDeclarationCS(
1796
						(PathNameCS)dtParser.getSym(2),
1700
						(PathNameCS)dtParser.getSym(2),
1797
						(EList)dtParser.getSym(3)
1701
						(EList)dtParser.getSym(3)
Lines 1805-1811 Link Here
1805
			// Rule 247:  packageDeclarationCS1 ::= contextDeclCSm
1709
			// Rule 247:  packageDeclarationCS1 ::= contextDeclCSm
1806
			//
1710
			//
1807
			case 247: {
1711
			case 247: {
1808
				
1809
				EList contextDecls = (EList)dtParser.getSym(1);
1712
				EList contextDecls = (EList)dtParser.getSym(1);
1810
				CSTNode result = createPackageDeclarationCS(null, contextDecls);
1713
				CSTNode result = createPackageDeclarationCS(null, contextDecls);
1811
				if (!contextDecls.isEmpty()) {
1714
				if (!contextDecls.isEmpty()) {
Lines 1814-1832 Link Here
1814
				dtParser.setSym1(result);
1717
				dtParser.setSym1(result);
1815
	  		  break;
1718
	  		  break;
1816
			}
1719
			}
1817
	 
1720
	  
1818
			//
1721
			//
1819
			// Rule 248:  contextDeclCSmopt ::= $Empty
1722
			// Rule 248:  contextDeclCSmopt ::= $Empty
1820
			//
1723
			//
1821
			case 248:
1724
			case 248:
1822
				dtParser.setSym1(new BasicEList());
1725
				dtParser.setSym1(new BasicEList());
1823
				break;
1726
				break;
1824
 
1727
  
1825
			//
1728
			//
1826
			// Rule 250:  contextDeclCSm ::= contextDeclCS
1729
			// Rule 250:  contextDeclCSm ::= contextDeclCS
1827
			//
1730
			//
1828
			case 250: {
1731
			case 250: {
1829
				
1830
				EList result = new BasicEList();
1732
				EList result = new BasicEList();
1831
				result.add(dtParser.getSym(1));
1733
				result.add(dtParser.getSym(1));
1832
				dtParser.setSym1(result);
1734
				dtParser.setSym1(result);
Lines 1837-1843 Link Here
1837
			// Rule 251:  contextDeclCSm ::= contextDeclCSm contextDeclCS
1739
			// Rule 251:  contextDeclCSm ::= contextDeclCSm contextDeclCS
1838
			//
1740
			//
1839
			case 251: {
1741
			case 251: {
1840
				
1841
				EList result = (EList)dtParser.getSym(1);
1742
				EList result = (EList)dtParser.getSym(1);
1842
				result.add(dtParser.getSym(2));
1743
				result.add(dtParser.getSym(2));
1843
				dtParser.setSym1(result);
1744
				dtParser.setSym1(result);
Lines 1848-1854 Link Here
1848
			// Rule 255:  propertyContextCS ::= context pathNameCS :: simpleNameCS : typeCS initOrDerValueCS
1749
			// Rule 255:  propertyContextCS ::= context pathNameCS :: simpleNameCS : typeCS initOrDerValueCS
1849
			//
1750
			//
1850
			case 255: {
1751
			case 255: {
1851
				
1852
				CSTNode result = createPropertyContextCS(
1752
				CSTNode result = createPropertyContextCS(
1853
						(PathNameCS)dtParser.getSym(2),
1753
						(PathNameCS)dtParser.getSym(2),
1854
						(SimpleNameCS)dtParser.getSym(4),
1754
						(SimpleNameCS)dtParser.getSym(4),
Lines 1864-1870 Link Here
1864
			// Rule 256:  initOrDerValueCS ::= initOrDerValueCSopt init : oclExpressionCS
1764
			// Rule 256:  initOrDerValueCS ::= initOrDerValueCSopt init : oclExpressionCS
1865
			//
1765
			//
1866
			case 256: {
1766
			case 256: {
1867
				
1868
				CSTNode result = createInitValueCS(
1767
				CSTNode result = createInitValueCS(
1869
						(InitOrDerValueCS)dtParser.getSym(1),
1768
						(InitOrDerValueCS)dtParser.getSym(1),
1870
						(OCLExpressionCS)dtParser.getSym(4)
1769
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1882-1888 Link Here
1882
			// Rule 257:  initOrDerValueCS ::= initOrDerValueCSopt derive : oclExpressionCS
1781
			// Rule 257:  initOrDerValueCS ::= initOrDerValueCSopt derive : oclExpressionCS
1883
			//
1782
			//
1884
			case 257: {
1783
			case 257: {
1885
				
1886
				CSTNode result = createDerValueCS(
1784
				CSTNode result = createDerValueCS(
1887
						(InitOrDerValueCS)dtParser.getSym(1),
1785
						(InitOrDerValueCS)dtParser.getSym(1),
1888
						(OCLExpressionCS)dtParser.getSym(4)
1786
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1907-1913 Link Here
1907
			// Rule 260:  classifierContextDeclCS ::= context pathNameCS invOrDefCSm
1805
			// Rule 260:  classifierContextDeclCS ::= context pathNameCS invOrDefCSm
1908
			//
1806
			//
1909
			case 260: {
1807
			case 260: {
1910
				
1911
				EList<InvOrDefCS> list = (EList<InvOrDefCS>)dtParser.getSym(3);
1808
				EList<InvOrDefCS> list = (EList<InvOrDefCS>)dtParser.getSym(3);
1912
				CSTNode result = createClassifierContextDeclCS(
1809
				CSTNode result = createClassifierContextDeclCS(
1913
						(PathNameCS)dtParser.getSym(2),
1810
						(PathNameCS)dtParser.getSym(2),
Lines 1922-1928 Link Here
1922
			// Rule 261:  invOrDefCSm ::= invOrDefCS
1819
			// Rule 261:  invOrDefCSm ::= invOrDefCS
1923
			//
1820
			//
1924
			case 261: {
1821
			case 261: {
1925
				
1926
				EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
1822
				EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
1927
				result.add((InvOrDefCS)dtParser.getSym(1));
1823
				result.add((InvOrDefCS)dtParser.getSym(1));
1928
				dtParser.setSym1(result);
1824
				dtParser.setSym1(result);
Lines 1933-1939 Link Here
1933
			// Rule 262:  invOrDefCSm ::= invOrDefCSm invOrDefCS
1829
			// Rule 262:  invOrDefCSm ::= invOrDefCSm invOrDefCS
1934
			//
1830
			//
1935
			case 262: {
1831
			case 262: {
1936
				
1937
				EList<InvOrDefCS> result = (EList<InvOrDefCS>)dtParser.getSym(1);
1832
				EList<InvOrDefCS> result = (EList<InvOrDefCS>)dtParser.getSym(1);
1938
				result.add((InvOrDefCS)dtParser.getSym(2));
1833
				result.add((InvOrDefCS)dtParser.getSym(2));
1939
				dtParser.setSym1(result);
1834
				dtParser.setSym1(result);
Lines 1944-1950 Link Here
1944
			// Rule 263:  invOrDefCS ::= inv simpleNameCSopt : oclExpressionCS
1839
			// Rule 263:  invOrDefCS ::= inv simpleNameCSopt : oclExpressionCS
1945
			//
1840
			//
1946
			case 263: {
1841
			case 263: {
1947
				
1948
				CSTNode result = createInvCS(
1842
				CSTNode result = createInvCS(
1949
						(SimpleNameCS)dtParser.getSym(2),
1843
						(SimpleNameCS)dtParser.getSym(2),
1950
						(OCLExpressionCS)dtParser.getSym(4)
1844
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1958-1964 Link Here
1958
			// Rule 264:  invOrDefCS ::= def simpleNameCSopt : defExpressionCS
1852
			// Rule 264:  invOrDefCS ::= def simpleNameCSopt : defExpressionCS
1959
			//
1853
			//
1960
			case 264: {
1854
			case 264: {
1961
				
1962
				CSTNode result = createDefCS(
1855
				CSTNode result = createDefCS(
1963
						(SimpleNameCS)dtParser.getSym(2),
1856
						(SimpleNameCS)dtParser.getSym(2),
1964
						(DefExpressionCS)dtParser.getSym(4)
1857
						(DefExpressionCS)dtParser.getSym(4)
Lines 1972-1978 Link Here
1972
			// Rule 265:  defExpressionCS ::= typedVariableCS = oclExpressionCS
1865
			// Rule 265:  defExpressionCS ::= typedVariableCS = oclExpressionCS
1973
			//
1866
			//
1974
			case 265: {
1867
			case 265: {
1975
				
1976
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
1868
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
1977
				OCLExpressionCS expressionCS = (OCLExpressionCS)dtParser.getSym(3);
1869
				OCLExpressionCS expressionCS = (OCLExpressionCS)dtParser.getSym(3);
1978
				CSTNode result = createDefExpressionCS(
1870
				CSTNode result = createDefExpressionCS(
Lines 1989-1995 Link Here
1989
			// Rule 266:  defExpressionCS ::= operationCS1 = oclExpressionCS
1881
			// Rule 266:  defExpressionCS ::= operationCS1 = oclExpressionCS
1990
			//
1882
			//
1991
			case 266: {
1883
			case 266: {
1992
				
1993
				CSTNode result = createDefExpressionCS(
1884
				CSTNode result = createDefExpressionCS(
1994
						null,
1885
						null,
1995
						(OperationCS)dtParser.getSym(1),
1886
						(OperationCS)dtParser.getSym(1),
Lines 2004-2010 Link Here
2004
			// Rule 267:  operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
1895
			// Rule 267:  operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
2005
			//
1896
			//
2006
			case 267: {
1897
			case 267: {
2007
				
2008
				EList prePostOrBodyDecls = (EList)dtParser.getSym(3);
1898
				EList prePostOrBodyDecls = (EList)dtParser.getSym(3);
2009
				CSTNode result = createOperationContextDeclCS(
1899
				CSTNode result = createOperationContextDeclCS(
2010
						(OperationCS)dtParser.getSym(2),
1900
						(OperationCS)dtParser.getSym(2),
Lines 2019-2025 Link Here
2019
			// Rule 268:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
1909
			// Rule 268:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
2020
			//
1910
			//
2021
			case 268: {
1911
			case 268: {
2022
				
2023
				EList result = new BasicEList();
1912
				EList result = new BasicEList();
2024
				result.add(dtParser.getSym(1));
1913
				result.add(dtParser.getSym(1));
2025
				dtParser.setSym1(result);
1914
				dtParser.setSym1(result);
Lines 2030-2036 Link Here
2030
			// Rule 269:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
1919
			// Rule 269:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
2031
			//
1920
			//
2032
			case 269: {
1921
			case 269: {
2033
				
2034
				EList result = (EList)dtParser.getSym(1);
1922
				EList result = (EList)dtParser.getSym(1);
2035
				result.add(dtParser.getSym(2));
1923
				result.add(dtParser.getSym(2));
2036
				dtParser.setSym1(result);
1924
				dtParser.setSym1(result);
Lines 2041-2047 Link Here
2041
			// Rule 270:  prePostOrBodyDeclCS ::= pre simpleNameCSopt : oclExpressionCS
1929
			// Rule 270:  prePostOrBodyDeclCS ::= pre simpleNameCSopt : oclExpressionCS
2042
			//
1930
			//
2043
			case 270: {
1931
			case 270: {
2044
				
2045
				CSTNode result = createPrePostOrBodyDeclCS(
1932
				CSTNode result = createPrePostOrBodyDeclCS(
2046
						PrePostOrBodyEnum.PRE_LITERAL,
1933
						PrePostOrBodyEnum.PRE_LITERAL,
2047
						(SimpleNameCS)dtParser.getSym(2),
1934
						(SimpleNameCS)dtParser.getSym(2),
Lines 2056-2062 Link Here
2056
			// Rule 271:  prePostOrBodyDeclCS ::= post simpleNameCSopt : oclExpressionCS
1943
			// Rule 271:  prePostOrBodyDeclCS ::= post simpleNameCSopt : oclExpressionCS
2057
			//
1944
			//
2058
			case 271: {
1945
			case 271: {
2059
				
2060
				CSTNode result = createPrePostOrBodyDeclCS(
1946
				CSTNode result = createPrePostOrBodyDeclCS(
2061
						PrePostOrBodyEnum.POST_LITERAL,
1947
						PrePostOrBodyEnum.POST_LITERAL,
2062
						(SimpleNameCS)dtParser.getSym(2),
1948
						(SimpleNameCS)dtParser.getSym(2),
Lines 2071-2077 Link Here
2071
			// Rule 272:  prePostOrBodyDeclCS ::= body simpleNameCSopt : oclExpressionCS
1957
			// Rule 272:  prePostOrBodyDeclCS ::= body simpleNameCSopt : oclExpressionCS
2072
			//
1958
			//
2073
			case 272: {
1959
			case 272: {
2074
				
2075
				CSTNode result = createPrePostOrBodyDeclCS(
1960
				CSTNode result = createPrePostOrBodyDeclCS(
2076
						PrePostOrBodyEnum.BODY_LITERAL,
1961
						PrePostOrBodyEnum.BODY_LITERAL,
2077
						(SimpleNameCS)dtParser.getSym(2),
1962
						(SimpleNameCS)dtParser.getSym(2),
(-)src/org/eclipse/ocl/parser/OCLKWLexerprs.java (-49 / +93 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-27 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
*
14
*
14
* </copyright>
15
* </copyright>
15
*
16
*
16
* $Id: OCLKWLexerprs.java,v 1.2 2009/01/13 20:31:30 cdamus Exp $
17
* 
17
*/
18
*/
18
19
19
package org.eclipse.ocl.parser;
20
package org.eclipse.ocl.parser;
20
21
21
/**
22
public class OCLKWLexerprs implements lpg.runtime.ParseTable, OCLKWLexersym {
22
 * @noextend This class is not intended to be subclassed by clients.
23
    public final static int ERROR_SYMBOL = 0;
23
 */
24
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
24
public class OCLKWLexerprs implements lpg.lpgjavaruntime.ParseTable, OCLKWLexersym {
25
26
    public final static int SCOPE_UBOUND = 0;
27
    public final int getScopeUbound() { return SCOPE_UBOUND; }
28
29
    public final static int SCOPE_SIZE = 0;
30
    public final int getScopeSize() { return SCOPE_SIZE; }
31
32
    public final static int MAX_NAME_LENGTH = 0;
33
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
34
35
    public final static int NUM_STATES = 256;
36
    public final int getNumStates() { return NUM_STATES; }
37
38
    public final static int NT_OFFSET = 56;
39
    public final int getNtOffset() { return NT_OFFSET; }
40
41
    public final static int LA_STATE_OFFSET = 386;
42
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
43
44
    public final static int MAX_LA = 1;
45
    public final int getMaxLa() { return MAX_LA; }
46
47
    public final static int NUM_RULES = 63;
48
    public final int getNumRules() { return NUM_RULES; }
49
50
    public final static int NUM_NONTERMINALS = 2;
51
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
52
53
    public final static int NUM_SYMBOLS = 58;
54
    public final int getNumSymbols() { return NUM_SYMBOLS; }
55
56
    public final static int SEGMENT_SIZE = 8192;
57
    public final int getSegmentSize() { return SEGMENT_SIZE; }
58
59
    public final static int START_STATE = 64;
60
    public final int getStartState() { return START_STATE; }
61
62
    public final static int IDENTIFIER_SYMBOL = 0;
63
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
64
65
    public final static int EOFT_SYMBOL = 39;
66
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
67
68
    public final static int EOLT_SYMBOL = 57;
69
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
70
71
    public final static int ACCEPT_ACTION = 322;
72
    public final int getAcceptAction() { return ACCEPT_ACTION; }
73
74
    public final static int ERROR_ACTION = 323;
75
    public final int getErrorAction() { return ERROR_ACTION; }
76
77
    public final static boolean BACKTRACK = false;
78
    public final boolean getBacktrack() { return BACKTRACK; }
79
80
    public final int getStartSymbol() { return lhs(0); }
81
    public final boolean isValidForParser() { return OCLKWLexersym.isValidForParser; }
82
83
84
    public interface IsNullable {
85
        public final static byte isNullable[] = {0,
86
            0,0,0,0,0,0,0,0,0,0,
87
            0,0,0,0,0,0,0,0,0,0,
88
            0,0,0,0,0,0,0,0,0,0,
89
            0,0,0,0,0,0,0,0,0,0,
90
            0,0,0,0,0,0,0,0,0,0,
91
            0,0,0,0,0,0,0,0
92
        };
93
    };
94
    public final static byte isNullable[] = IsNullable.isNullable;
95
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
96
97
    public interface ProsthesesIndex {
98
        public final static byte prosthesesIndex[] = {0,
99
            2,1
100
        };
101
    };
102
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
103
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
25
104
26
    public interface IsKeyword {
105
    public interface IsKeyword {
27
        public final static byte isKeyword[] = {0,
106
        public final static byte isKeyword[] = {0,
Lines 30-36 Link Here
30
            0,0,0,0,0,0,0,0,0,0,
109
            0,0,0,0,0,0,0,0,0,0,
31
            0,0,0,0,0,0,0,0,0,0,
110
            0,0,0,0,0,0,0,0,0,0,
32
            0,0,0,0,0,0,0,0,0,0,
111
            0,0,0,0,0,0,0,0,0,0,
33
            0,0,0,0
112
            0,0,0,0,0,0
34
        };
113
        };
35
    };
114
    };
36
    public final static byte isKeyword[] = IsKeyword.isKeyword;
115
    public final static byte isKeyword[] = IsKeyword.isKeyword;
Lines 159-165 Link Here
159
            0,0,0,0,0,0,0,0,0,0,
238
            0,0,0,0,0,0,0,0,0,0,
160
            0,0,0,0,0,0,0,0,0,0,
239
            0,0,0,0,0,0,0,0,0,0,
161
            0,0,0,0,0,0,0,0,0,0,
240
            0,0,0,0,0,0,0,0,0,0,
162
            0,0,0,0,0
241
            0,0,0,0,0,0,0
163
        };
242
        };
164
    };
243
    };
165
    public final static byte termCheck[] = TermCheck.termCheck;
244
    public final static byte termCheck[] = TermCheck.termCheck;
Lines 245-300 Link Here
245
    public final int scopeState(int index) { return 0;}
324
    public final int scopeState(int index) { return 0;}
246
    public final int inSymb(int index) { return 0;}
325
    public final int inSymb(int index) { return 0;}
247
    public final String name(int index) { return null; }
326
    public final String name(int index) { return null; }
248
    public final int getErrorSymbol() { return 0; }
249
    public final int getScopeUbound() { return 0; }
250
    public final int getScopeSize() { return 0; }
251
    public final int getMaxNameLength() { return 0; }
252
253
    public final static int
254
           NUM_STATES        = 256,
255
           NT_OFFSET         = 54,
256
           LA_STATE_OFFSET   = 386,
257
           MAX_LA            = 1,
258
           NUM_RULES         = 63,
259
           NUM_NONTERMINALS  = 2,
260
           NUM_SYMBOLS       = 56,
261
           SEGMENT_SIZE      = 8192,
262
           START_STATE       = 64,
263
           IDENTIFIER_SYMBOL = 0,
264
           EOFT_SYMBOL       = 39,
265
           EOLT_SYMBOL       = 55,
266
           ACCEPT_ACTION     = 322,
267
           ERROR_ACTION      = 323;
268
269
    public final static boolean BACKTRACK = false;
270
271
    public final int getNumStates() { return NUM_STATES; }
272
    public final int getNtOffset() { return NT_OFFSET; }
273
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
274
    public final int getMaxLa() { return MAX_LA; }
275
    public final int getNumRules() { return NUM_RULES; }
276
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
277
    public final int getNumSymbols() { return NUM_SYMBOLS; }
278
    public final int getSegmentSize() { return SEGMENT_SIZE; }
279
    public final int getStartState() { return START_STATE; }
280
    public final int getStartSymbol() { return lhs[0]; }
281
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
282
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
283
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
284
    public final int getAcceptAction() { return ACCEPT_ACTION; }
285
    public final int getErrorAction() { return ERROR_ACTION; }
286
    public final boolean isValidForParser() { return isValidForParser; }
287
    public final boolean getBacktrack() { return BACKTRACK; }
288
289
    public final int originalState(int state) { return 0; }
327
    public final int originalState(int state) { return 0; }
290
    public final int asi(int state) { return 0; }
328
    public final int asi(int state) { return 0; }
291
    public final int nasi(int state) { return 0; }
329
    public final int nasi(int state) { return 0; }
292
    public final int inSymbol(int state) { return 0; }
330
    public final int inSymbol(int state) { return 0; }
293
331
332
    /**
333
     * assert(! goto_default);
334
     */
294
    public final int ntAction(int state, int sym) {
335
    public final int ntAction(int state, int sym) {
295
        return baseAction[state + sym];
336
        return baseAction[state + sym];
296
    }
337
    }
297
338
339
    /**
340
     * assert(! shift_default);
341
     */
298
    public final int tAction(int state, int sym) {
342
    public final int tAction(int state, int sym) {
299
        int i = baseAction[state],
343
        int i = baseAction[state],
300
            k = i + sym;
344
            k = i + sym;
(-)src/org/eclipse/ocl/parser/OCLParser.g
Lines 1-7 Link Here
1
--/**
1
--/**
2
-- * <copyright>
2
-- * <copyright>
3
-- *
3
-- *
(-)* Copyright (c) 2005, 2009 IBM Corporation and others. (-61 / +62 lines)
Lines 11-16 Link Here
11
-- *   IBM - Initial API and implementation
11
-- *   IBM - Initial API and implementation
12
-- *   E.D. Willink - Elimination of some shift-reduce conflicts
12
-- *   E.D. Willink - Elimination of some shift-reduce conflicts
13
-- *      - Bug 259818
13
-- *      - Bug 259818
14
-- *   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
14
-- *
15
-- *
15
-- * </copyright>
16
-- * </copyright>
16
-- *
17
-- *
Lines 29-55 Link Here
29
%options margin=4
30
%options margin=4
30
%options noserialize
31
%options noserialize
31
%options package=org.eclipse.ocl.parser
32
%options package=org.eclipse.ocl.parser
32
%options import_terminals=OCLLexer.g
33
%options import_terminals=OCLLexer.gi
33
%options ast_type=CSTNode
34
%options ast_type=CSTNode
34
%options programming_language=java
35
%options programming_language=java
35
%options action=("*.java", "/.", "./")
36
%options action-block=("*.java", "/.", "./")
36
%options ParseTable=lpg.lpgjavaruntime.ParseTable
37
%options ParseTable=lpg.runtime.ParseTable
37
%options include_directory=".;../lpg"
38
%options include_directory=".;../lpg"
38
39
39
$Start
40
%Start
40
	goal
41
	goal
41
$End
42
%End
42
43
43
$Include
44
%Include
44
	EssentialOCL.g
45
	EssentialOCL.gi
45
$End
46
%End
46
47
47
$Define
48
%Define
48
    $environment_class /.Environment<?,?,?,?,?,?,?,?,?,?,?,?>./
49
    $environment_class /.Environment<?,?,?,?,?,?,?,?,?,?,?,?>./
49
	$lex_stream_class /.OCLLexer./
50
	$lex_stream_class /.OCLLexer./
50
$End
51
%End
51
52
52
$Globals
53
%Globals
53
	/.
54
	/.
54
	import org.eclipse.ocl.Environment;
55
	import org.eclipse.ocl.Environment;
55
	import org.eclipse.ocl.cst.DefExpressionCS;
56
	import org.eclipse.ocl.cst.DefExpressionCS;
Lines 59-67 Link Here
59
	import org.eclipse.ocl.cst.PackageDeclarationCS;
60
	import org.eclipse.ocl.cst.PackageDeclarationCS;
60
	import org.eclipse.ocl.cst.PrePostOrBodyEnum;
61
	import org.eclipse.ocl.cst.PrePostOrBodyEnum;
61
	./
62
	./
62
$End
63
%End
63
64
64
$KeyWords
65
%KeyWords
65
	context
66
	context
66
	package
67
	package
67
	
68
	
Lines 71-79 Link Here
71
	--
72
	--
72
	attr
73
	attr
73
	oper
74
	oper
74
$End
75
%End
75
76
76
$Rules
77
%Rules
77
	-- opt = optional
78
	-- opt = optional
78
	-- m = multiple
79
	-- m = multiple
79
	
80
	
Lines 83-138 Link Here
83
	goal -> prePostOrBodyDeclCS
84
	goal -> prePostOrBodyDeclCS
84
	goal -> initOrDerValueCS
85
	goal -> initOrDerValueCS
85
	goal -> variableCS
86
	goal -> variableCS
86
	goal -> $empty	
87
	goal -> %empty	
87
88
88
	packageDeclarationCSm -> packageDeclarationCS
89
	packageDeclarationCSm -> packageDeclarationCS
89
	packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
90
	packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
90
		/.$BeginJava
91
		/.$BeginAction
91
					PackageDeclarationCS result = (PackageDeclarationCS)$getSym(2);
92
					PackageDeclarationCS result = (PackageDeclarationCS)$getSym(2);
92
					result.setPackageDeclarationCS((PackageDeclarationCS) $getSym(1));
93
					result.setPackageDeclarationCS((PackageDeclarationCS) $getSym(1));
93
					$setResult(result);
94
					$setResult(result);
94
		  $EndJava
95
		  $EndAction
95
		./
96
		./
96
	packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
97
	packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
97
		/.$BeginJava
98
		/.$BeginAction
98
					CSTNode result = createPackageDeclarationCS(
99
					CSTNode result = createPackageDeclarationCS(
99
							(PathNameCS)$getSym(2),
100
							(PathNameCS)$getSym(2),
100
							(EList)$getSym(3)
101
							(EList)$getSym(3)
101
						);
102
						);
102
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
103
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
103
					$setResult(result);
104
					$setResult(result);
104
		  $EndJava
105
		  $EndAction
105
		./
106
		./
106
	
107
	
107
	packageDeclarationCS1 ::= contextDeclCSm
108
	packageDeclarationCS1 ::= contextDeclCSm
108
		/.$BeginJava
109
		/.$BeginAction
109
					EList contextDecls = (EList)$getSym(1);
110
					EList contextDecls = (EList)$getSym(1);
110
					CSTNode result = createPackageDeclarationCS(null, contextDecls);
111
					CSTNode result = createPackageDeclarationCS(null, contextDecls);
111
					if (!contextDecls.isEmpty()) {
112
					if (!contextDecls.isEmpty()) {
112
						setOffsets(result, (CSTNode)contextDecls.get(0), (CSTNode)contextDecls.get(contextDecls.size()-1));
113
						setOffsets(result, (CSTNode)contextDecls.get(0), (CSTNode)contextDecls.get(contextDecls.size()-1));
113
					}
114
					}
114
					$setResult(result);
115
					$setResult(result);
115
		  $EndJava
116
		  $EndAction
116
		./
117
		./
117
118
118
119
119
	contextDeclCSmopt ::= $empty
120
	contextDeclCSmopt ::= %empty
120
		/.$EmptyListAction./
121
		/.$EmptyListAction./
121
	contextDeclCSmopt -> contextDeclCSm
122
	contextDeclCSmopt -> contextDeclCSm
122
123
123
	contextDeclCSm ::= contextDeclCS
124
	contextDeclCSm ::= contextDeclCS
124
		/.$BeginJava
125
		/.$BeginAction
125
					EList result = new BasicEList();
126
					EList result = new BasicEList();
126
					result.add($getSym(1));
127
					result.add($getSym(1));
127
					$setResult(result);
128
					$setResult(result);
128
		  $EndJava
129
		  $EndAction
129
		./
130
		./
130
	contextDeclCSm ::= contextDeclCSm contextDeclCS
131
	contextDeclCSm ::= contextDeclCSm contextDeclCS
131
		/.$BeginJava
132
		/.$BeginAction
132
					EList result = (EList)$getSym(1);
133
					EList result = (EList)$getSym(1);
133
					result.add($getSym(2));
134
					result.add($getSym(2));
134
					$setResult(result);
135
					$setResult(result);
135
		  $EndJava
136
		  $EndAction
136
		./
137
		./
137
138
138
	contextDeclCS -> classifierContextDeclCS
139
	contextDeclCS -> classifierContextDeclCS
Lines 140-146 Link Here
140
	contextDeclCS -> propertyContextCS
141
	contextDeclCS -> propertyContextCS
141
142
142
	propertyContextCS ::= context pathNameCS '::' simpleNameCS ':' typeCS initOrDerValueCS
143
	propertyContextCS ::= context pathNameCS '::' simpleNameCS ':' typeCS initOrDerValueCS
143
		/.$BeginJava
144
		/.$BeginAction
144
					CSTNode result = createPropertyContextCS(
145
					CSTNode result = createPropertyContextCS(
145
							(PathNameCS)$getSym(2),
146
							(PathNameCS)$getSym(2),
146
							(SimpleNameCS)$getSym(4),
147
							(SimpleNameCS)$getSym(4),
Lines 149-159 Link Here
149
						);
150
						);
150
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(7));
151
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(7));
151
					$setResult(result);
152
					$setResult(result);
152
		  $EndJava
153
		  $EndAction
153
		./
154
		./
154
155
155
	initOrDerValueCS ::= initOrDerValueCSopt init ':' oclExpressionCS
156
	initOrDerValueCS ::= initOrDerValueCSopt init ':' oclExpressionCS
156
		/.$BeginJava
157
		/.$BeginAction
157
					CSTNode result = createInitValueCS(
158
					CSTNode result = createInitValueCS(
158
							(InitOrDerValueCS)$getSym(1),
159
							(InitOrDerValueCS)$getSym(1),
159
							(OCLExpressionCS)$getSym(4)
160
							(OCLExpressionCS)$getSym(4)
Lines 164-174 Link Here
164
						setOffsets(result, getIToken($getToken(2)), (CSTNode)$getSym(4));
165
						setOffsets(result, getIToken($getToken(2)), (CSTNode)$getSym(4));
165
					}
166
					}
166
					$setResult(result);
167
					$setResult(result);
167
		  $EndJava
168
		  $EndAction
168
		./
169
		./
169
170
170
	initOrDerValueCS ::= initOrDerValueCSopt derive ':' oclExpressionCS
171
	initOrDerValueCS ::= initOrDerValueCSopt derive ':' oclExpressionCS
171
		/.$BeginJava
172
		/.$BeginAction
172
					CSTNode result = createDerValueCS(
173
					CSTNode result = createDerValueCS(
173
							(InitOrDerValueCS)$getSym(1),
174
							(InitOrDerValueCS)$getSym(1),
174
							(OCLExpressionCS)$getSym(4)
175
							(OCLExpressionCS)$getSym(4)
Lines 179-193 Link Here
179
						setOffsets(result, getIToken($getToken(2)), (CSTNode)$getSym(4));
180
						setOffsets(result, getIToken($getToken(2)), (CSTNode)$getSym(4));
180
					}
181
					}
181
					$setResult(result);
182
					$setResult(result);
182
		  $EndJava
183
		  $EndAction
183
		./
184
		./
184
185
185
	initOrDerValueCSopt ::= $empty
186
	initOrDerValueCSopt ::= %empty
186
		/.$NullAction./
187
		/.$NullAction./
187
	initOrDerValueCSopt -> initOrDerValueCS
188
	initOrDerValueCSopt -> initOrDerValueCS
188
189
189
	classifierContextDeclCS ::= context pathNameCS invOrDefCSm
190
	classifierContextDeclCS ::= context pathNameCS invOrDefCSm
190
		/.$BeginJava
191
		/.$BeginAction
191
					EList<InvOrDefCS> list = (EList<InvOrDefCS>)$getSym(3);
192
					EList<InvOrDefCS> list = (EList<InvOrDefCS>)$getSym(3);
192
					CSTNode result = createClassifierContextDeclCS(
193
					CSTNode result = createClassifierContextDeclCS(
193
							(PathNameCS)$getSym(2),
194
							(PathNameCS)$getSym(2),
Lines 195-241 Link Here
195
						);
196
						);
196
					setOffsets(result, getIToken($getToken(1)), list.get(list.size()-1));
197
					setOffsets(result, getIToken($getToken(1)), list.get(list.size()-1));
197
					$setResult(result);
198
					$setResult(result);
198
		  $EndJava
199
		  $EndAction
199
		./
200
		./
200
201
201
	invOrDefCSm ::= invOrDefCS
202
	invOrDefCSm ::= invOrDefCS
202
		/.$BeginJava
203
		/.$BeginAction
203
					EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
204
					EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
204
					result.add((InvOrDefCS)$getSym(1));
205
					result.add((InvOrDefCS)$getSym(1));
205
					$setResult(result);
206
					$setResult(result);
206
		  $EndJava
207
		  $EndAction
207
		./
208
		./
208
	invOrDefCSm ::= invOrDefCSm invOrDefCS
209
	invOrDefCSm ::= invOrDefCSm invOrDefCS
209
		/.$BeginJava
210
		/.$BeginAction
210
					EList<InvOrDefCS> result = (EList<InvOrDefCS>)$getSym(1);
211
					EList<InvOrDefCS> result = (EList<InvOrDefCS>)$getSym(1);
211
					result.add((InvOrDefCS)$getSym(2));
212
					result.add((InvOrDefCS)$getSym(2));
212
					$setResult(result);
213
					$setResult(result);
213
		  $EndJava
214
		  $EndAction
214
		./
215
		./
215
	invOrDefCS ::= inv simpleNameCSopt ':' oclExpressionCS
216
	invOrDefCS ::= inv simpleNameCSopt ':' oclExpressionCS
216
		/.$BeginJava
217
		/.$BeginAction
217
					CSTNode result = createInvCS(
218
					CSTNode result = createInvCS(
218
							(SimpleNameCS)$getSym(2),
219
							(SimpleNameCS)$getSym(2),
219
							(OCLExpressionCS)$getSym(4)
220
							(OCLExpressionCS)$getSym(4)
220
						);
221
						);
221
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
222
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
222
					$setResult(result);
223
					$setResult(result);
223
		  $EndJava
224
		  $EndAction
224
		./
225
		./
225
	
226
	
226
	invOrDefCS ::= def simpleNameCSopt ':' defExpressionCS
227
	invOrDefCS ::= def simpleNameCSopt ':' defExpressionCS
227
		/.$BeginJava
228
		/.$BeginAction
228
					CSTNode result = createDefCS(
229
					CSTNode result = createDefCS(
229
							(SimpleNameCS)$getSym(2),
230
							(SimpleNameCS)$getSym(2),
230
							(DefExpressionCS)$getSym(4)
231
							(DefExpressionCS)$getSym(4)
231
						);
232
						);
232
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
233
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
233
					$setResult(result);
234
					$setResult(result);
234
		  $EndJava
235
		  $EndAction
235
		./
236
		./
236
237
237
	defExpressionCS ::= typedVariableCS '=' oclExpressionCS
238
	defExpressionCS ::= typedVariableCS '=' oclExpressionCS
238
		/.$BeginJava
239
		/.$BeginAction
239
					VariableCS variableCS = (VariableCS)$getSym(1);
240
					VariableCS variableCS = (VariableCS)$getSym(1);
240
					OCLExpressionCS expressionCS = (OCLExpressionCS)$getSym(3);
241
					OCLExpressionCS expressionCS = (OCLExpressionCS)$getSym(3);
241
					CSTNode result = createDefExpressionCS(
242
					CSTNode result = createDefExpressionCS(
Lines 245-254 Link Here
245
						);
246
						);
246
					setOffsets(result, variableCS, expressionCS);
247
					setOffsets(result, variableCS, expressionCS);
247
					$setResult(result);
248
					$setResult(result);
248
		  $EndJava
249
		  $EndAction
249
		./
250
		./
250
	defExpressionCS ::= operationCS1 '=' oclExpressionCS
251
	defExpressionCS ::= operationCS1 '=' oclExpressionCS
251
		/.$BeginJava
252
		/.$BeginAction
252
					CSTNode result = createDefExpressionCS(
253
					CSTNode result = createDefExpressionCS(
253
							null,
254
							null,
254
							(OperationCS)$getSym(1),
255
							(OperationCS)$getSym(1),
Lines 256-266 Link Here
256
						);
257
						);
257
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
258
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
258
					$setResult(result);
259
					$setResult(result);
259
		  $EndJava
260
		  $EndAction
260
		./
261
		./
261
262
262
	operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
263
	operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
263
		/.$BeginJava
264
		/.$BeginAction
264
					EList prePostOrBodyDecls = (EList)$getSym(3);
265
					EList prePostOrBodyDecls = (EList)$getSym(3);
265
					CSTNode result = createOperationContextDeclCS(
266
					CSTNode result = createOperationContextDeclCS(
266
							(OperationCS)$getSym(2),
267
							(OperationCS)$getSym(2),
Lines 268-293 Link Here
268
						);
269
						);
269
					setOffsets(result, getIToken($getToken(1)), (CSTNode)prePostOrBodyDecls.get(prePostOrBodyDecls.size()-1));
270
					setOffsets(result, getIToken($getToken(1)), (CSTNode)prePostOrBodyDecls.get(prePostOrBodyDecls.size()-1));
270
					$setResult(result);
271
					$setResult(result);
271
		  $EndJava
272
		  $EndAction
272
		./
273
		./
273
274
274
	prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
275
	prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
275
		/.$BeginJava
276
		/.$BeginAction
276
					EList result = new BasicEList();
277
					EList result = new BasicEList();
277
					result.add($getSym(1));
278
					result.add($getSym(1));
278
					$setResult(result);
279
					$setResult(result);
279
		  $EndJava
280
		  $EndAction
280
		./
281
		./
281
	prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
282
	prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
282
		/.$BeginJava
283
		/.$BeginAction
283
					EList result = (EList)$getSym(1);
284
					EList result = (EList)$getSym(1);
284
					result.add($getSym(2));
285
					result.add($getSym(2));
285
					$setResult(result);
286
					$setResult(result);
286
		  $EndJava
287
		  $EndAction
287
		./
288
		./
288
289
289
	prePostOrBodyDeclCS ::= pre simpleNameCSopt ':' oclExpressionCS
290
	prePostOrBodyDeclCS ::= pre simpleNameCSopt ':' oclExpressionCS
290
		/.$BeginJava
291
		/.$BeginAction
291
					CSTNode result = createPrePostOrBodyDeclCS(
292
					CSTNode result = createPrePostOrBodyDeclCS(
292
							PrePostOrBodyEnum.PRE_LITERAL,
293
							PrePostOrBodyEnum.PRE_LITERAL,
293
							(SimpleNameCS)$getSym(2),
294
							(SimpleNameCS)$getSym(2),
Lines 295-304 Link Here
295
						);
296
						);
296
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
297
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
297
					$setResult(result);
298
					$setResult(result);
298
		  $EndJava
299
		  $EndAction
299
		./
300
		./
300
	prePostOrBodyDeclCS ::= post simpleNameCSopt ':' oclExpressionCS
301
	prePostOrBodyDeclCS ::= post simpleNameCSopt ':' oclExpressionCS
301
		/.$BeginJava
302
		/.$BeginAction
302
					CSTNode result = createPrePostOrBodyDeclCS(
303
					CSTNode result = createPrePostOrBodyDeclCS(
303
							PrePostOrBodyEnum.POST_LITERAL,
304
							PrePostOrBodyEnum.POST_LITERAL,
304
							(SimpleNameCS)$getSym(2),
305
							(SimpleNameCS)$getSym(2),
Lines 306-315 Link Here
306
						);
307
						);
307
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
308
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
308
					$setResult(result);
309
					$setResult(result);
309
		  $EndJava
310
		  $EndAction
310
		./
311
		./
311
	prePostOrBodyDeclCS ::= body simpleNameCSopt ':' oclExpressionCS
312
	prePostOrBodyDeclCS ::= body simpleNameCSopt ':' oclExpressionCS
312
		/.$BeginJava
313
		/.$BeginAction
313
					CSTNode result = createPrePostOrBodyDeclCS(
314
					CSTNode result = createPrePostOrBodyDeclCS(
314
							PrePostOrBodyEnum.BODY_LITERAL,
315
							PrePostOrBodyEnum.BODY_LITERAL,
315
							(SimpleNameCS)$getSym(2),
316
							(SimpleNameCS)$getSym(2),
Lines 317-322 Link Here
317
						);
318
						);
318
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
319
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
319
					$setResult(result);
320
					$setResult(result);
320
		  $EndJava
321
		  $EndAction
321
		./
322
		./
322
$End
323
%End
(-)src/org/eclipse/ocl/parser/AbstractOCLParser.java (-8 / +9 lines)
Lines 20-31 Link Here
20
 */
20
 */
21
package org.eclipse.ocl.parser;
21
package org.eclipse.ocl.parser;
22
22
23
import lpg.lpgjavaruntime.IToken;
23
import lpg.runtime.IToken;
24
import lpg.lpgjavaruntime.NullExportedSymbolsException;
24
import lpg.runtime.NullExportedSymbolsException;
25
import lpg.lpgjavaruntime.NullTerminalSymbolsException;
25
import lpg.runtime.NullTerminalSymbolsException;
26
import lpg.lpgjavaruntime.ParseErrorCodes;
26
import lpg.runtime.ParseErrorCodes;
27
import lpg.lpgjavaruntime.UndefinedEofSymbolException;
27
import lpg.runtime.UndefinedEofSymbolException;
28
import lpg.lpgjavaruntime.UnimplementedTerminalsException;
28
import lpg.runtime.UnimplementedTerminalsException;
29
29
30
import org.eclipse.emf.common.util.EList;
30
import org.eclipse.emf.common.util.EList;
31
import org.eclipse.ocl.cst.BooleanLiteralExpCS;
31
import org.eclipse.ocl.cst.BooleanLiteralExpCS;
Lines 87-92 Link Here
87
import org.eclipse.ocl.options.ParsingOptions;
87
import org.eclipse.ocl.options.ParsingOptions;
88
import org.eclipse.ocl.options.ProblemOption;
88
import org.eclipse.ocl.options.ProblemOption;
89
89
90
90
public abstract class AbstractOCLParser
91
public abstract class AbstractOCLParser
91
		extends AbstractParser {
92
		extends AbstractParser {
92
	
93
	
Lines 743-749 Link Here
743
				if (i >= n) {
744
				if (i >= n) {
744
					reportError(
745
					reportError(
745
						ParseErrorCodes.INVALID_CODE,
746
						ParseErrorCodes.INVALID_CODE,
746
						"", stringLiteral.getTokenIndex(), stringLiteral.getTokenIndex(), //$NON-NLS-1$
747
						stringLiteral.getTokenIndex(), stringLiteral.getTokenIndex(),
747
						OCLMessages.StringNotProperlyClosed_ERROR);
748
						OCLMessages.StringNotProperlyClosed_ERROR);
748
				}
749
				}
749
				char nextCh = rawString.charAt(i);
750
				char nextCh = rawString.charAt(i);
Lines 812-818 Link Here
812
							if (unescapedChar < 0) {
813
							if (unescapedChar < 0) {
813
								reportError(
814
								reportError(
814
									ParseErrorCodes.INVALID_CODE,
815
									ParseErrorCodes.INVALID_CODE,
815
									"", stringLiteral.getTokenIndex(), stringLiteral.getTokenIndex(), //$NON-NLS-1$
816
									stringLiteral.getTokenIndex(), stringLiteral.getTokenIndex(),
816
									OCLMessages.InvalidEscapeSequence_ERROR);
817
									OCLMessages.InvalidEscapeSequence_ERROR);
817
							}
818
							}
818
							break;
819
							break;
(-)src/org/eclipse/ocl/parser/OCLParserprs.java (-72 / +136 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 13-31 Link Here
13
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
16
*
19
*
17
* </copyright>
20
* </copyright>
18
*
21
*
19
* $Id: OCLParserprs.java,v 1.6 2009/01/13 20:31:30 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
20
*/
23
*/
21
24
22
package org.eclipse.ocl.parser;
25
package org.eclipse.ocl.parser;
23
26
24
/**
27
public class OCLParserprs implements lpg.runtime.ParseTable, OCLParsersym {
25
 * @noextend This interface is not intended to be extended by clients.
28
    public final static int ERROR_SYMBOL = 99;
26
 */
29
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
27
@SuppressWarnings("nls")
30
28
public class OCLParserprs implements lpg.lpgjavaruntime.ParseTable, OCLParsersym {
31
    public final static int SCOPE_UBOUND = 43;
32
    public final int getScopeUbound() { return SCOPE_UBOUND; }
33
34
    public final static int SCOPE_SIZE = 44;
35
    public final int getScopeSize() { return SCOPE_SIZE; }
36
37
    public final static int MAX_NAME_LENGTH = 26;
38
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
39
40
    public final static int NUM_STATES = 214;
41
    public final int getNumStates() { return NUM_STATES; }
42
43
    public final static int NT_OFFSET = 99;
44
    public final int getNtOffset() { return NT_OFFSET; }
45
46
    public final static int LA_STATE_OFFSET = 3369;
47
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
48
49
    public final static int MAX_LA = 2;
50
    public final int getMaxLa() { return MAX_LA; }
51
52
    public final static int NUM_RULES = 272;
53
    public final int getNumRules() { return NUM_RULES; }
54
55
    public final static int NUM_NONTERMINALS = 104;
56
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
57
58
    public final static int NUM_SYMBOLS = 203;
59
    public final int getNumSymbols() { return NUM_SYMBOLS; }
60
61
    public final static int SEGMENT_SIZE = 8192;
62
    public final int getSegmentSize() { return SEGMENT_SIZE; }
63
64
    public final static int START_STATE = 2905;
65
    public final int getStartState() { return START_STATE; }
66
67
    public final static int IDENTIFIER_SYMBOL = 2;
68
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
69
70
    public final static int EOFT_SYMBOL = 79;
71
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
72
73
    public final static int EOLT_SYMBOL = 79;
74
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
75
76
    public final static int ACCEPT_ACTION = 3096;
77
    public final int getAcceptAction() { return ACCEPT_ACTION; }
78
79
    public final static int ERROR_ACTION = 3097;
80
    public final int getErrorAction() { return ERROR_ACTION; }
81
82
    public final static boolean BACKTRACK = false;
83
    public final boolean getBacktrack() { return BACKTRACK; }
84
85
    public final int getStartSymbol() { return lhs(0); }
86
    public final boolean isValidForParser() { return OCLParsersym.isValidForParser; }
87
88
89
    public interface IsNullable {
90
        public final static byte isNullable[] = {0,
91
            0,0,0,0,0,0,0,0,0,0,
92
            0,0,0,0,0,0,0,0,0,0,
93
            0,0,0,0,0,0,0,0,0,0,
94
            0,0,0,0,0,0,0,0,0,0,
95
            0,0,0,0,0,0,0,0,0,0,
96
            0,0,0,0,0,0,0,0,0,0,
97
            0,0,0,0,0,0,0,0,0,0,
98
            0,0,0,0,0,0,0,0,0,0,
99
            0,0,0,0,0,0,0,0,0,0,
100
            0,0,0,0,0,0,0,0,0,0,
101
            0,0,0,0,0,0,0,0,0,0,
102
            0,0,0,0,0,0,0,0,0,0,
103
            0,0,0,0,0,0,0,0,0,0,
104
            0,0,0,0,0,0,0,0,0,0,
105
            0,0,0,0,0,0,0,0,1,0,
106
            0,0,0,1,1,0,0,0,0,0,
107
            0,0,0,0,1,1,0,0,0,0,
108
            0,0,0,1,0,0,0,0,1,1,
109
            0,0,0,0,0,0,1,1,0,0,
110
            0,0,0,1,1,0,0,1,0,0,
111
            0,0,0
112
        };
113
    };
114
    public final static byte isNullable[] = IsNullable.isNullable;
115
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
116
117
    public interface ProsthesesIndex {
118
        public final static byte prosthesesIndex[] = {0,
119
            54,9,21,62,5,6,7,10,3,8,
120
            15,50,51,11,40,42,44,48,49,56,
121
            57,58,59,60,61,67,68,69,70,71,
122
            41,43,38,39,34,35,36,37,32,33,
123
            30,31,28,29,25,26,27,77,23,52,
124
            53,78,80,81,24,47,97,98,99,100,
125
            88,91,92,4,12,19,20,22,65,66,
126
            73,79,83,84,86,87,93,94,96,101,
127
            2,13,14,17,18,45,46,55,63,64,
128
            72,74,75,76,82,85,89,90,95,102,
129
            103,104,1,16
130
        };
131
    };
132
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
133
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
29
134
30
    public interface IsKeyword {
135
    public interface IsKeyword {
31
        public final static byte isKeyword[] = {0,
136
        public final static byte isKeyword[] = {0,
Lines 1190-1218 Link Here
1190
1295
1191
    public interface ScopeRhs {
1296
    public interface ScopeRhs {
1192
        public final static char scopeRhs[] = {0,
1297
        public final static char scopeRhs[] = {0,
1193
            174,1,101,88,0,12,0,174,1,101,
1298
            174,1,101,88,0,4,0,174,1,101,
1194
            87,0,144,93,144,92,144,71,0,45,
1299
            87,0,144,93,144,92,144,71,0,94,
1195
            0,144,92,144,71,0,44,116,45,0,
1300
            0,144,92,144,71,0,93,144,94,0,
1196
            144,71,0,43,116,44,116,45,0,172,
1301
            144,71,0,92,144,93,144,94,0,172,
1197
            68,0,52,116,0,150,81,101,0,16,
1302
            68,0,96,144,0,150,81,101,0,74,
1198
            0,0,155,1,149,107,0,155,1,149,
1303
            149,0,155,1,149,107,0,155,1,149,
1199
            109,0,155,1,149,164,0,194,1,59,
1304
            109,0,155,1,149,164,0,194,1,59,
1200
            0,151,1,103,0,151,24,2,0,7,
1305
            0,151,1,103,0,151,24,2,0,3,
1201
            116,0,144,72,148,84,148,1,181,0,
1306
            144,0,144,72,148,84,148,1,181,0,
1202
            148,84,148,1,181,0,18,116,12,0,
1307
            148,84,148,1,181,0,72,144,4,0,
1203
            148,1,181,0,22,115,18,116,12,0,
1308
            148,1,181,0,84,148,72,144,4,0,
1204
            144,72,148,1,181,0,144,72,148,36,
1309
            144,72,148,1,181,0,144,72,148,36,
1205
            148,1,182,0,148,36,148,1,182,0,
1310
            148,1,182,0,148,36,148,1,182,0,
1206
            148,1,182,0,19,115,18,116,12,0,
1311
            148,1,182,0,36,148,72,144,4,0,
1207
            144,72,148,1,182,0,144,1,182,0,
1312
            144,72,148,1,182,0,144,1,182,0,
1208
            190,69,59,0,14,0,188,69,103,0,
1313
            190,69,59,0,80,0,188,69,103,0,
1209
            150,81,113,0,144,1,0,155,1,101,
1314
            150,81,113,0,144,1,0,155,1,101,
1210
            67,102,0,155,1,60,0,132,0,4,
1315
            67,102,0,155,1,60,0,132,0,17,
1211
            130,0,3,130,0,136,0,2,128,0,
1316
            130,0,16,130,0,136,0,35,133,0,
1212
            1,128,0,138,0,9,125,0,8,125,
1317
            34,133,0,138,0,21,135,0,20,135,
1213
            0,6,125,0,5,125,0,140,0,10,
1318
            0,19,135,0,18,135,0,140,0,5,
1214
            123,0,7,123,0,142,0,48,121,0,
1319
            139,0,3,139,0,142,0,28,141,0,
1215
            47,121,0,46,121,0
1320
            27,141,0,26,141,0
1216
        };
1321
        };
1217
    };
1322
    };
1218
    public final static char scopeRhs[] = ScopeRhs.scopeRhs;
1323
    public final static char scopeRhs[] = ScopeRhs.scopeRhs;
Lines 1428-1480 Link Here
1428
    public final static String name[] = Name.name;
1533
    public final static String name[] = Name.name;
1429
    public final String name(int index) { return name[index]; }
1534
    public final String name(int index) { return name[index]; }
1430
1535
1431
    public final static int
1432
           ERROR_SYMBOL      = 99,
1433
           SCOPE_UBOUND      = 43,
1434
           SCOPE_SIZE        = 44,
1435
           MAX_NAME_LENGTH   = 26;
1436
1437
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
1438
    public final int getScopeUbound() { return SCOPE_UBOUND; }
1439
    public final int getScopeSize() { return SCOPE_SIZE; }
1440
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
1441
1442
    public final static int
1443
           NUM_STATES        = 214,
1444
           NT_OFFSET         = 99,
1445
           LA_STATE_OFFSET   = 3369,
1446
           MAX_LA            = 2,
1447
           NUM_RULES         = 272,
1448
           NUM_NONTERMINALS  = 104,
1449
           NUM_SYMBOLS       = 203,
1450
           SEGMENT_SIZE      = 8192,
1451
           START_STATE       = 2905,
1452
           IDENTIFIER_SYMBOL = 2,
1453
           EOFT_SYMBOL       = 79,
1454
           EOLT_SYMBOL       = 79,
1455
           ACCEPT_ACTION     = 3096,
1456
           ERROR_ACTION      = 3097;
1457
1458
    public final static boolean BACKTRACK = false;
1459
1460
    public final int getNumStates() { return NUM_STATES; }
1461
    public final int getNtOffset() { return NT_OFFSET; }
1462
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
1463
    public final int getMaxLa() { return MAX_LA; }
1464
    public final int getNumRules() { return NUM_RULES; }
1465
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
1466
    public final int getNumSymbols() { return NUM_SYMBOLS; }
1467
    public final int getSegmentSize() { return SEGMENT_SIZE; }
1468
    public final int getStartState() { return START_STATE; }
1469
    public final int getStartSymbol() { return lhs[0]; }
1470
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
1471
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
1472
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
1473
    public final int getAcceptAction() { return ACCEPT_ACTION; }
1474
    public final int getErrorAction() { return ERROR_ACTION; }
1475
    public final boolean isValidForParser() { return isValidForParser; }
1476
    public final boolean getBacktrack() { return BACKTRACK; }
1477
1478
    public final int originalState(int state) {
1536
    public final int originalState(int state) {
1479
        return -baseCheck[state];
1537
        return -baseCheck[state];
1480
    }
1538
    }
Lines 1488-1497 Link Here
1488
        return inSymb[originalState(state)];
1546
        return inSymb[originalState(state)];
1489
    }
1547
    }
1490
1548
1549
    /**
1550
     * assert(! goto_default);
1551
     */
1491
    public final int ntAction(int state, int sym) {
1552
    public final int ntAction(int state, int sym) {
1492
        return baseAction[state + sym];
1553
        return baseAction[state + sym];
1493
    }
1554
    }
1494
1555
1556
    /**
1557
     * assert(! shift_default);
1558
     */
1495
    public final int tAction(int state, int sym) {
1559
    public final int tAction(int state, int sym) {
1496
        int i = baseAction[state],
1560
        int i = baseAction[state],
1497
            k = i + sym;
1561
            k = i + sym;
(-)src/org/eclipse/ocl/parser/OCLKWLexersym.java (-22 / +23 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-31 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
*
14
*
14
* </copyright>
15
* </copyright>
15
*
16
*
16
* $Id: OCLKWLexersym.java,v 1.2 2009/01/13 20:31:30 cdamus Exp $
17
* 
17
*/
18
*/
18
19
19
package org.eclipse.ocl.parser;
20
package org.eclipse.ocl.parser;
20
21
21
/**
22
 * @noimplement This interface is not intended to be implemented by clients.
23
 * @noextend This interface is not intended to be extended by clients.
24
 */
25
@SuppressWarnings("nls")
26
public interface OCLKWLexersym {
22
public interface OCLKWLexersym {
27
    public final static int
23
    public final static int
28
      Char_DollarSign = 40,
24
      Char_DollarSign = 40,
25
      Char_Percent = 41,
26
      Char__ = 42,
29
      Char_a = 5,
27
      Char_a = 5,
30
      Char_b = 30,
28
      Char_b = 30,
31
      Char_c = 11,
29
      Char_c = 11,
Lines 51-86 Link Here
51
      Char_w = 33,
49
      Char_w = 33,
52
      Char_x = 19,
50
      Char_x = 19,
53
      Char_y = 16,
51
      Char_y = 16,
54
      Char_z = 41,
52
      Char_z = 43,
55
      Char_A = 20,
53
      Char_A = 20,
56
      Char_B = 29,
54
      Char_B = 29,
57
      Char_C = 34,
55
      Char_C = 34,
58
      Char_D = 42,
56
      Char_D = 44,
59
      Char_E = 43,
57
      Char_E = 45,
60
      Char_F = 44,
58
      Char_F = 46,
61
      Char_G = 45,
59
      Char_G = 47,
62
      Char_H = 46,
60
      Char_H = 48,
63
      Char_I = 18,
61
      Char_I = 18,
64
      Char_J = 47,
62
      Char_J = 49,
65
      Char_K = 35,
63
      Char_K = 35,
66
      Char_L = 48,
64
      Char_L = 50,
67
      Char_M = 36,
65
      Char_M = 36,
68
      Char_N = 21,
66
      Char_N = 21,
69
      Char_O = 22,
67
      Char_O = 22,
70
      Char_P = 49,
68
      Char_P = 51,
71
      Char_Q = 50,
69
      Char_Q = 52,
72
      Char_R = 37,
70
      Char_R = 37,
73
      Char_S = 23,
71
      Char_S = 23,
74
      Char_T = 24,
72
      Char_T = 24,
75
      Char_U = 25,
73
      Char_U = 25,
76
      Char_V = 38,
74
      Char_V = 38,
77
      Char_W = 51,
75
      Char_W = 53,
78
      Char_X = 52,
76
      Char_X = 54,
79
      Char_Y = 53,
77
      Char_Y = 55,
80
      Char_Z = 54,
78
      Char_Z = 56,
81
      Char_EOF = 39;
79
      Char_EOF = 39;
82
80
83
      public final static String orderedTerminalSymbols[] = {
81
    public final static String orderedTerminalSymbols[] = {
84
                 "",
82
                 "",
85
                 "e",
83
                 "e",
86
                 "t",
84
                 "t",
Lines 122-127 Link Here
122
                 "V",
120
                 "V",
123
                 "EOF",
121
                 "EOF",
124
                 "DollarSign",
122
                 "DollarSign",
123
                 "Percent",
124
                 "_",
125
                 "z",
125
                 "z",
126
                 "D",
126
                 "D",
127
                 "E",
127
                 "E",
Lines 138-142 Link Here
138
                 "Z"
138
                 "Z"
139
             };
139
             };
140
140
141
    public final static int numTokenKinds = orderedTerminalSymbols.length;
141
    public final static boolean isValidForParser = true;
142
    public final static boolean isValidForParser = true;
142
}
143
}
(-)src/org/eclipse/ocl/parser/OCLLexerprs.java (-48 / +106 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-28 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*               - Bug 259818
13
*   Borland - Bug 242880
14
*   Borland - Bug 242880
14
*   
15
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
16
*
15
* </copyright>
17
* </copyright>
16
*
18
*
17
* $Id: OCLLexerprs.java,v 1.3 2009/02/12 00:04:09 cdamus Exp $
19
* '$'Id''
18
*/
20
*/
19
21
20
package org.eclipse.ocl.parser;
22
package org.eclipse.ocl.parser;
21
23
22
/**
24
public class OCLLexerprs implements lpg.runtime.ParseTable, OCLLexersym {
23
 * @noextend This class is not intended to be subclassed by clients.
25
    public final static int ERROR_SYMBOL = 0;
24
 */
26
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
25
public class OCLLexerprs implements lpg.lpgjavaruntime.ParseTable, OCLLexersym {
27
28
    public final static int SCOPE_UBOUND = 0;
29
    public final int getScopeUbound() { return SCOPE_UBOUND; }
30
31
    public final static int SCOPE_SIZE = 0;
32
    public final int getScopeSize() { return SCOPE_SIZE; }
33
34
    public final static int MAX_NAME_LENGTH = 0;
35
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
36
37
    public final static int NUM_STATES = 50;
38
    public final int getNumStates() { return NUM_STATES; }
39
40
    public final static int NT_OFFSET = 103;
41
    public final int getNtOffset() { return NT_OFFSET; }
42
43
    public final static int LA_STATE_OFFSET = 824;
44
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
45
46
    public final static int MAX_LA = 1;
47
    public final int getMaxLa() { return MAX_LA; }
48
49
    public final static int NUM_RULES = 309;
50
    public final int getNumRules() { return NUM_RULES; }
51
52
    public final static int NUM_NONTERMINALS = 44;
53
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
54
55
    public final static int NUM_SYMBOLS = 147;
56
    public final int getNumSymbols() { return NUM_SYMBOLS; }
57
58
    public final static int SEGMENT_SIZE = 8192;
59
    public final int getSegmentSize() { return SEGMENT_SIZE; }
60
61
    public final static int START_STATE = 310;
62
    public final int getStartState() { return START_STATE; }
63
64
    public final static int IDENTIFIER_SYMBOL = 0;
65
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
66
67
    public final static int EOFT_SYMBOL = 99;
68
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
69
70
    public final static int EOLT_SYMBOL = 104;
71
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
72
73
    public final static int ACCEPT_ACTION = 514;
74
    public final int getAcceptAction() { return ACCEPT_ACTION; }
75
76
    public final static int ERROR_ACTION = 515;
77
    public final int getErrorAction() { return ERROR_ACTION; }
78
79
    public final static boolean BACKTRACK = false;
80
    public final boolean getBacktrack() { return BACKTRACK; }
81
82
    public final int getStartSymbol() { return lhs(0); }
83
    public final boolean isValidForParser() { return OCLLexersym.isValidForParser; }
84
85
86
    public interface IsNullable {
87
        public final static byte isNullable[] = {0,
88
            0,0,0,0,0,0,0,0,0,0,
89
            0,0,0,0,0,0,0,0,0,0,
90
            0,0,0,0,0,0,0,0,0,0,
91
            0,0,0,0,0,0,0,0,0,0,
92
            0,0,0,0,0,0,0,0,0,0,
93
            0,0,0,0,0,0,0,0,0,0,
94
            0,0,0,0,0,0,0,0,0,0,
95
            0,0,0,0,0,0,0,0,0,0,
96
            0,0,0,0,0,0,0,0,0,0,
97
            0,0,0,0,0,0,0,0,0,0,
98
            0,0,0,0,0,0,0,0,0,0,
99
            0,0,0,0,0,0,1,0,0,0,
100
            0,0,0,0,0,0,0,0,0,0,
101
            0,1,0,0,0,0,0,0,0,0,
102
            0,0,0,0,0,0,0
103
        };
104
    };
105
    public final static byte isNullable[] = IsNullable.isNullable;
106
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
107
108
    public interface ProsthesesIndex {
109
        public final static byte prosthesesIndex[] = {0,
110
            20,25,26,27,35,4,15,37,40,43,
111
            24,5,3,6,17,18,23,32,34,36,
112
            41,42,2,7,8,9,10,11,12,13,
113
            14,16,19,33,38,39,44,1,21,22,
114
            28,29,30,31
115
        };
116
    };
117
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
118
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
26
119
27
    public interface IsKeyword {
120
    public interface IsKeyword {
28
        public final static byte isKeyword[] = {0,
121
        public final static byte isKeyword[] = {0,
Lines 479-534 Link Here
479
    public final int scopeState(int index) { return 0;}
572
    public final int scopeState(int index) { return 0;}
480
    public final int inSymb(int index) { return 0;}
573
    public final int inSymb(int index) { return 0;}
481
    public final String name(int index) { return null; }
574
    public final String name(int index) { return null; }
482
    public final int getErrorSymbol() { return 0; }
483
    public final int getScopeUbound() { return 0; }
484
    public final int getScopeSize() { return 0; }
485
    public final int getMaxNameLength() { return 0; }
486
487
    public final static int
488
           NUM_STATES        = 50,
489
           NT_OFFSET         = 103,
490
           LA_STATE_OFFSET   = 824,
491
           MAX_LA            = 1,
492
           NUM_RULES         = 309,
493
           NUM_NONTERMINALS  = 44,
494
           NUM_SYMBOLS       = 147,
495
           SEGMENT_SIZE      = 8192,
496
           START_STATE       = 310,
497
           IDENTIFIER_SYMBOL = 0,
498
           EOFT_SYMBOL       = 99,
499
           EOLT_SYMBOL       = 104,
500
           ACCEPT_ACTION     = 514,
501
           ERROR_ACTION      = 515;
502
503
    public final static boolean BACKTRACK = false;
504
505
    public final int getNumStates() { return NUM_STATES; }
506
    public final int getNtOffset() { return NT_OFFSET; }
507
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
508
    public final int getMaxLa() { return MAX_LA; }
509
    public final int getNumRules() { return NUM_RULES; }
510
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
511
    public final int getNumSymbols() { return NUM_SYMBOLS; }
512
    public final int getSegmentSize() { return SEGMENT_SIZE; }
513
    public final int getStartState() { return START_STATE; }
514
    public final int getStartSymbol() { return lhs[0]; }
515
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
516
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
517
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
518
    public final int getAcceptAction() { return ACCEPT_ACTION; }
519
    public final int getErrorAction() { return ERROR_ACTION; }
520
    public final boolean isValidForParser() { return isValidForParser; }
521
    public final boolean getBacktrack() { return BACKTRACK; }
522
523
    public final int originalState(int state) { return 0; }
575
    public final int originalState(int state) { return 0; }
524
    public final int asi(int state) { return 0; }
576
    public final int asi(int state) { return 0; }
525
    public final int nasi(int state) { return 0; }
577
    public final int nasi(int state) { return 0; }
526
    public final int inSymbol(int state) { return 0; }
578
    public final int inSymbol(int state) { return 0; }
527
579
580
    /**
581
     * assert(! goto_default);
582
     */
528
    public final int ntAction(int state, int sym) {
583
    public final int ntAction(int state, int sym) {
529
        return baseAction[state + sym];
584
        return baseAction[state + sym];
530
    }
585
    }
531
586
587
    /**
588
     * assert(! shift_default);
589
     */
532
    public final int tAction(int state, int sym) {
590
    public final int tAction(int state, int sym) {
533
        int i = baseAction[state],
591
        int i = baseAction[state],
534
            k = i + sym;
592
            k = i + sym;
(-)src/org/eclipse/ocl/parser/OCLParsersym.java (-13 / +7 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 13-37 Link Here
13
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
16
*
19
*
17
* </copyright>
20
* </copyright>
18
*
21
*
19
* $Id: OCLParsersym.java,v 1.5 2009/01/13 19:44:29 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
20
*/
23
*/
21
24
22
package org.eclipse.ocl.parser;
25
package org.eclipse.ocl.parser;
23
26
24
/**
25
 * @noimplement This interface is not intended to be implemented by clients.
26
 * @noextend This interface is not intended to be extended by clients.
27
 */
28
@SuppressWarnings("nls")
29
public interface OCLParsersym {
27
public interface OCLParsersym {
30
	/**
31
	 * Token kind codes.
32
	 * 
33
	 * @noreference These constants are not intended to be referenced by clients.
34
	 */
35
    public final static int
28
    public final static int
36
      TK_NUMERIC_OPERATION = 60,
29
      TK_NUMERIC_OPERATION = 60,
37
      TK_STRING_LITERAL = 61,
30
      TK_STRING_LITERAL = 61,
Lines 133-139 Link Here
133
      TK_INTEGER_RANGE_START = 82,
126
      TK_INTEGER_RANGE_START = 82,
134
      TK_ERROR_TOKEN = 99;
127
      TK_ERROR_TOKEN = 99;
135
128
136
      public final static String orderedTerminalSymbols[] = {
129
    public final static String orderedTerminalSymbols[] = {
137
                 "",
130
                 "",
138
                 "LPAREN",
131
                 "LPAREN",
139
                 "IDENTIFIER",
132
                 "IDENTIFIER",
Lines 236-240 Link Here
236
                 "ERROR_TOKEN"
229
                 "ERROR_TOKEN"
237
             };
230
             };
238
231
232
    public final static int numTokenKinds = orderedTerminalSymbols.length;
239
    public final static boolean isValidForParser = true;
233
    public final static boolean isValidForParser = true;
240
}
234
}
(-)src/org/eclipse/ocl/parser/OCLLexersym.java (-8 / +7 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-28 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*               - Bug 259818
14
*   Borland - Bug 242880
15
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
*
16
*
14
* </copyright>
17
* </copyright>
15
*
18
*
16
* $Id: OCLLexersym.java,v 1.2 2009/01/13 20:31:30 cdamus Exp $
19
* '$'Id''
17
*/
20
*/
18
21
19
package org.eclipse.ocl.parser;
22
package org.eclipse.ocl.parser;
20
23
21
/**
22
 * @noimplement This interface is not intended to be implemented by clients.
23
 * @noextend This interface is not intended to be extended by clients.
24
 */
25
@SuppressWarnings("nls")
26
public interface OCLLexersym {
24
public interface OCLLexersym {
27
    public final static int
25
    public final static int
28
      Char_CtlCharNotWS = 103,
26
      Char_CtlCharNotWS = 103,
Lines 129-135 Link Here
129
      Char_Equal = 15,
127
      Char_Equal = 15,
130
      Char_EOF = 99;
128
      Char_EOF = 99;
131
129
132
      public final static String orderedTerminalSymbols[] = {
130
    public final static String orderedTerminalSymbols[] = {
133
                 "",
131
                 "",
134
                 "0",
132
                 "0",
135
                 "1",
133
                 "1",
Lines 236-240 Link Here
236
                 "CtlCharNotWS"
234
                 "CtlCharNotWS"
237
             };
235
             };
238
236
237
    public final static int numTokenKinds = orderedTerminalSymbols.length;
239
    public final static boolean isValidForParser = true;
238
    public final static boolean isValidForParser = true;
240
}
239
}
(-)src/org/eclipse/ocl/parser/OCLLexer.java (-46 / +48 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-25 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*               - Bug 259818
14
*      
14
*   Borland - Bug 242880
15
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
16
*
15
* </copyright>
17
* </copyright>
16
*
18
*
17
* $Id: OCLLexer.java,v 1.3 2009/01/13 19:44:29 cdamus Exp $
19
* '$'Id''
18
*/
20
*/
19
21
20
package org.eclipse.ocl.parser;
22
package org.eclipse.ocl.parser;
21
23
22
import lpg.lpgjavaruntime.*;
24
import lpg.runtime.*;
23
import org.eclipse.ocl.lpg.AbstractLexer;
25
import org.eclipse.ocl.lpg.AbstractLexer;
24
import org.eclipse.ocl.lpg.AbstractParser;
26
import org.eclipse.ocl.lpg.AbstractParser;
25
import org.eclipse.ocl.Environment;
27
import org.eclipse.ocl.Environment;
Lines 52-58 Link Here
52
    
54
    
53
	public OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars) {
55
	public OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars) {
54
		this(environment, chars, "OCL", ECLIPSE_TAB_VALUE);
56
		this(environment, chars, "OCL", ECLIPSE_TAB_VALUE);
55
		kwLexer = new OCLKWLexer(getInputChars(), TK_IDENTIFIER);
57
		kwLexer = new OCLKWLexer(getInputChars(), OCLParsersym.TK_IDENTIFIER);
56
	}
58
	}
57
59
58
    public OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)  {
60
    public OCLLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)  {
Lines 81-87 Link Here
81
    {
83
    {
82
        super.initialize(content, filename);
84
        super.initialize(content, filename);
83
        if (kwLexer == null)
85
        if (kwLexer == null)
84
             kwLexer = new OCLKWLexer(getInputChars(), TK_IDENTIFIER);
86
             kwLexer = new OCLKWLexer(getInputChars(), OCLParsersym.TK_IDENTIFIER);
85
        else
87
        else
86
             kwLexer.setInputChars(getInputChars());
88
             kwLexer.setInputChars(getInputChars());
87
    }
89
    }
Lines 92-98 Link Here
92
    @Override
94
    @Override
93
    public void setInputChars(char[] inputChars) {
95
    public void setInputChars(char[] inputChars) {
94
		super.setInputChars(inputChars);
96
		super.setInputChars(inputChars);
95
		kwLexer = new OCLKWLexer(getInputChars(), TK_IDENTIFIER);
97
		kwLexer = new OCLKWLexer(getInputChars(), OCLParsersym.TK_IDENTIFIER);
96
	}
98
	}
97
    
99
    
98
    @Override
100
    @Override
Lines 108-119 Link Here
108
        lexParser.parseCharacters(monitor);  // Lex the input characters
110
        lexParser.parseCharacters(monitor);  // Lex the input characters
109
            
111
            
110
        int i = getStreamIndex();
112
        int i = getStreamIndex();
111
        parser.makeToken(i, i, TK_EOF_TOKEN); // and end with the end of file token
113
        parser.makeToken(i, i, OCLParsersym.TK_EOF_TOKEN); // and end with the end of file token
112
        parser.setStreamLength(parser.getSize());
114
        parser.setStreamLength(parser.getSize());
113
            
115
            
114
        return;
116
        return;
115
    }
117
    }
116
    
118
        
117
    final void makeToken(int kind)
119
    final void makeToken(int kind)
118
    {
120
    {
119
        int startOffset = getLeftSpan(),
121
        int startOffset = getLeftSpan(),
Lines 317-323 Link Here
317
            // Rule 2:  Token ::= EscapedSQ
319
            // Rule 2:  Token ::= EscapedSQ
318
            //
320
            //
319
            case 2: { 
321
            case 2: { 
320
				makeToken(TK_STRING_LITERAL);
322
				makeToken(OCLParsersym.TK_STRING_LITERAL);
321
	            break;
323
	            break;
322
            }
324
            }
323
	 
325
	 
Lines 325-331 Link Here
325
            // Rule 3:  Token ::= SingleQuote SLNotSQ SingleQuote
327
            // Rule 3:  Token ::= SingleQuote SLNotSQ SingleQuote
326
            //
328
            //
327
            case 3: { 
329
            case 3: { 
328
				makeToken(TK_STRING_LITERAL);
330
				makeToken(OCLParsersym.TK_STRING_LITERAL);
329
	            break;
331
	            break;
330
            }
332
            }
331
	 
333
	 
Lines 333-339 Link Here
333
            // Rule 4:  Token ::= Acute SLNotSQOpt Acute
335
            // Rule 4:  Token ::= Acute SLNotSQOpt Acute
334
            //
336
            //
335
            case 4: { 
337
            case 4: { 
336
				makeToken(TK_STRING_LITERAL);
338
				makeToken(OCLParsersym.TK_STRING_LITERAL);
337
	            break;
339
	            break;
338
            }
340
            }
339
	 
341
	 
Lines 341-347 Link Here
341
            // Rule 5:  Token ::= BackQuote SLNotSQOpt Acute
343
            // Rule 5:  Token ::= BackQuote SLNotSQOpt Acute
342
            //
344
            //
343
            case 5: { 
345
            case 5: { 
344
				makeToken(TK_STRING_LITERAL);
346
				makeToken(OCLParsersym.TK_STRING_LITERAL);
345
	            break;
347
	            break;
346
            }
348
            }
347
	 
349
	 
Lines 349-355 Link Here
349
            // Rule 6:  Token ::= IntegerLiteral
351
            // Rule 6:  Token ::= IntegerLiteral
350
            //
352
            //
351
            case 6: { 
353
            case 6: { 
352
				makeToken(TK_INTEGER_LITERAL);
354
				makeToken(OCLParsersym.TK_INTEGER_LITERAL);
353
	            break;
355
	            break;
354
            }
356
            }
355
	 
357
	 
Lines 357-363 Link Here
357
            // Rule 7:  Token ::= RealLiteral
359
            // Rule 7:  Token ::= RealLiteral
358
            //
360
            //
359
            case 7: { 
361
            case 7: { 
360
				makeToken(TK_REAL_LITERAL);
362
				makeToken(OCLParsersym.TK_REAL_LITERAL);
361
	            break;
363
	            break;
362
            }
364
            }
363
	 
365
	 
Lines 365-371 Link Here
365
            // Rule 8:  Token ::= NumericOperation
367
            // Rule 8:  Token ::= NumericOperation
366
            //
368
            //
367
            case 8: { 
369
            case 8: { 
368
				makeToken(TK_NUMERIC_OPERATION);
370
				makeToken(OCLParsersym.TK_NUMERIC_OPERATION);
369
	            break;
371
	            break;
370
            }
372
            }
371
	 
373
	 
Lines 373-379 Link Here
373
            // Rule 9:  Token ::= IntegerRangeStart
375
            // Rule 9:  Token ::= IntegerRangeStart
374
            //
376
            //
375
            case 9: { 
377
            case 9: { 
376
				makeToken(TK_INTEGER_RANGE_START);
378
				makeToken(OCLParsersym.TK_INTEGER_RANGE_START);
377
	            break;
379
	            break;
378
            }
380
            }
379
	 
381
	 
Lines 405-411 Link Here
405
            // Rule 13:  Token ::= +
407
            // Rule 13:  Token ::= +
406
            //
408
            //
407
            case 13: { 
409
            case 13: { 
408
				makeToken(TK_PLUS);
410
				makeToken(OCLParsersym.TK_PLUS);
409
	            break;
411
	            break;
410
            }
412
            }
411
	 
413
	 
Lines 413-419 Link Here
413
            // Rule 14:  Token ::= -
415
            // Rule 14:  Token ::= -
414
            //
416
            //
415
            case 14: { 
417
            case 14: { 
416
				makeToken(TK_MINUS);
418
				makeToken(OCLParsersym.TK_MINUS);
417
	            break;
419
	            break;
418
            }
420
            }
419
	 
421
	 
Lines 421-427 Link Here
421
            // Rule 15:  Token ::= *
423
            // Rule 15:  Token ::= *
422
            //
424
            //
423
            case 15: { 
425
            case 15: { 
424
				makeToken(TK_MULTIPLY);
426
				makeToken(OCLParsersym.TK_MULTIPLY);
425
	            break;
427
	            break;
426
            }
428
            }
427
	 
429
	 
Lines 429-435 Link Here
429
            // Rule 16:  Token ::= /
431
            // Rule 16:  Token ::= /
430
            //
432
            //
431
            case 16: { 
433
            case 16: { 
432
				makeToken(TK_DIVIDE);
434
				makeToken(OCLParsersym.TK_DIVIDE);
433
	            break;
435
	            break;
434
            }
436
            }
435
	 
437
	 
Lines 437-443 Link Here
437
            // Rule 17:  Token ::= (
439
            // Rule 17:  Token ::= (
438
            //
440
            //
439
            case 17: { 
441
            case 17: { 
440
				makeToken(TK_LPAREN);
442
				makeToken(OCLParsersym.TK_LPAREN);
441
	            break;
443
	            break;
442
            }
444
            }
443
	 
445
	 
Lines 445-451 Link Here
445
            // Rule 18:  Token ::= )
447
            // Rule 18:  Token ::= )
446
            //
448
            //
447
            case 18: { 
449
            case 18: { 
448
				makeToken(TK_RPAREN);
450
				makeToken(OCLParsersym.TK_RPAREN);
449
	            break;
451
	            break;
450
            }
452
            }
451
	 
453
	 
Lines 453-459 Link Here
453
            // Rule 19:  Token ::= >
455
            // Rule 19:  Token ::= >
454
            //
456
            //
455
            case 19: { 
457
            case 19: { 
456
				makeToken(TK_GREATER);
458
				makeToken(OCLParsersym.TK_GREATER);
457
	            break;
459
	            break;
458
            }
460
            }
459
	 
461
	 
Lines 461-467 Link Here
461
            // Rule 20:  Token ::= <
463
            // Rule 20:  Token ::= <
462
            //
464
            //
463
            case 20: { 
465
            case 20: { 
464
				makeToken(TK_LESS);
466
				makeToken(OCLParsersym.TK_LESS);
465
	            break;
467
	            break;
466
            }
468
            }
467
	 
469
	 
Lines 469-475 Link Here
469
            // Rule 21:  Token ::= =
471
            // Rule 21:  Token ::= =
470
            //
472
            //
471
            case 21: { 
473
            case 21: { 
472
				makeToken(TK_EQUAL);
474
				makeToken(OCLParsersym.TK_EQUAL);
473
	            break;
475
	            break;
474
            }
476
            }
475
	 
477
	 
Lines 477-483 Link Here
477
            // Rule 22:  Token ::= > =
479
            // Rule 22:  Token ::= > =
478
            //
480
            //
479
            case 22: { 
481
            case 22: { 
480
				makeToken(TK_GREATER_EQUAL);
482
				makeToken(OCLParsersym.TK_GREATER_EQUAL);
481
	            break;
483
	            break;
482
            }
484
            }
483
	 
485
	 
Lines 485-491 Link Here
485
            // Rule 23:  Token ::= < =
487
            // Rule 23:  Token ::= < =
486
            //
488
            //
487
            case 23: { 
489
            case 23: { 
488
				makeToken(TK_LESS_EQUAL);
490
				makeToken(OCLParsersym.TK_LESS_EQUAL);
489
	            break;
491
	            break;
490
            }
492
            }
491
	 
493
	 
Lines 493-499 Link Here
493
            // Rule 24:  Token ::= < >
495
            // Rule 24:  Token ::= < >
494
            //
496
            //
495
            case 24: { 
497
            case 24: { 
496
				makeToken(TK_NOT_EQUAL);
498
				makeToken(OCLParsersym.TK_NOT_EQUAL);
497
	            break;
499
	            break;
498
            }
500
            }
499
	 
501
	 
Lines 501-507 Link Here
501
            // Rule 25:  Token ::= [
503
            // Rule 25:  Token ::= [
502
            //
504
            //
503
            case 25: { 
505
            case 25: { 
504
				makeToken(TK_LBRACKET);
506
				makeToken(OCLParsersym.TK_LBRACKET);
505
	            break;
507
	            break;
506
            }
508
            }
507
	 
509
	 
Lines 509-515 Link Here
509
            // Rule 26:  Token ::= ]
511
            // Rule 26:  Token ::= ]
510
            //
512
            //
511
            case 26: { 
513
            case 26: { 
512
				makeToken(TK_RBRACKET);
514
				makeToken(OCLParsersym.TK_RBRACKET);
513
	            break;
515
	            break;
514
            }
516
            }
515
	 
517
	 
Lines 517-523 Link Here
517
            // Rule 27:  Token ::= {
519
            // Rule 27:  Token ::= {
518
            //
520
            //
519
            case 27: { 
521
            case 27: { 
520
				makeToken(TK_LBRACE);
522
				makeToken(OCLParsersym.TK_LBRACE);
521
	            break;
523
	            break;
522
            }
524
            }
523
	 
525
	 
Lines 525-531 Link Here
525
            // Rule 28:  Token ::= }
527
            // Rule 28:  Token ::= }
526
            //
528
            //
527
            case 28: { 
529
            case 28: { 
528
				makeToken(TK_RBRACE);
530
				makeToken(OCLParsersym.TK_RBRACE);
529
	            break;
531
	            break;
530
            }
532
            }
531
	 
533
	 
Lines 533-539 Link Here
533
            // Rule 29:  Token ::= - >
535
            // Rule 29:  Token ::= - >
534
            //
536
            //
535
            case 29: { 
537
            case 29: { 
536
				makeToken(TK_ARROW);
538
				makeToken(OCLParsersym.TK_ARROW);
537
	            break;
539
	            break;
538
            }
540
            }
539
	 
541
	 
Lines 541-547 Link Here
541
            // Rule 30:  Token ::= |
543
            // Rule 30:  Token ::= |
542
            //
544
            //
543
            case 30: { 
545
            case 30: { 
544
				makeToken(TK_BAR);
546
				makeToken(OCLParsersym.TK_BAR);
545
	            break;
547
	            break;
546
            }
548
            }
547
	 
549
	 
Lines 549-555 Link Here
549
            // Rule 31:  Token ::= ,
551
            // Rule 31:  Token ::= ,
550
            //
552
            //
551
            case 31: { 
553
            case 31: { 
552
				makeToken(TK_COMMA);
554
				makeToken(OCLParsersym.TK_COMMA);
553
	            break;
555
	            break;
554
            }
556
            }
555
	 
557
	 
Lines 557-563 Link Here
557
            // Rule 32:  Token ::= :
559
            // Rule 32:  Token ::= :
558
            //
560
            //
559
            case 32: { 
561
            case 32: { 
560
				makeToken(TK_COLON);
562
				makeToken(OCLParsersym.TK_COLON);
561
	            break;
563
	            break;
562
            }
564
            }
563
	 
565
	 
Lines 565-571 Link Here
565
            // Rule 33:  Token ::= : :
567
            // Rule 33:  Token ::= : :
566
            //
568
            //
567
            case 33: { 
569
            case 33: { 
568
				makeToken(TK_COLONCOLON);
570
				makeToken(OCLParsersym.TK_COLONCOLON);
569
	            break;
571
	            break;
570
            }
572
            }
571
	 
573
	 
Lines 573-579 Link Here
573
            // Rule 34:  Token ::= ;
575
            // Rule 34:  Token ::= ;
574
            //
576
            //
575
            case 34: { 
577
            case 34: { 
576
				makeToken(TK_SEMICOLON);
578
				makeToken(OCLParsersym.TK_SEMICOLON);
577
	            break;
579
	            break;
578
            }
580
            }
579
	 
581
	 
Lines 581-587 Link Here
581
            // Rule 35:  Token ::= .
583
            // Rule 35:  Token ::= .
582
            //
584
            //
583
            case 35: { 
585
            case 35: { 
584
				makeToken(TK_DOT);
586
				makeToken(OCLParsersym.TK_DOT);
585
	            break;
587
	            break;
586
            }
588
            }
587
	 
589
	 
Lines 589-595 Link Here
589
            // Rule 36:  Token ::= . .
591
            // Rule 36:  Token ::= . .
590
            //
592
            //
591
            case 36: { 
593
            case 36: { 
592
				makeToken(TK_DOTDOT);
594
				makeToken(OCLParsersym.TK_DOTDOT);
593
	            break;
595
	            break;
594
            }
596
            }
595
	 
597
	 
Lines 597-603 Link Here
597
            // Rule 37:  Token ::= @ p r e
599
            // Rule 37:  Token ::= @ p r e
598
            //
600
            //
599
            case 37: { 
601
            case 37: { 
600
				makeToken(TK_ATPRE);
602
				makeToken(OCLParsersym.TK_ATPRE);
601
	            break;
603
	            break;
602
            }
604
            }
603
	 
605
	 
Lines 605-611 Link Here
605
            // Rule 38:  Token ::= ^
607
            // Rule 38:  Token ::= ^
606
            //
608
            //
607
            case 38: { 
609
            case 38: { 
608
				makeToken(TK_CARET);
610
				makeToken(OCLParsersym.TK_CARET);
609
	            break;
611
	            break;
610
            }
612
            }
611
	 
613
	 
Lines 613-619 Link Here
613
            // Rule 39:  Token ::= ^ ^
615
            // Rule 39:  Token ::= ^ ^
614
            //
616
            //
615
            case 39: { 
617
            case 39: { 
616
				makeToken(TK_CARETCARET);
618
				makeToken(OCLParsersym.TK_CARETCARET);
617
	            break;
619
	            break;
618
            }
620
            }
619
	 
621
	 
Lines 621-627 Link Here
621
            // Rule 40:  Token ::= ?
623
            // Rule 40:  Token ::= ?
622
            //
624
            //
623
            case 40: { 
625
            case 40: { 
624
				makeToken(TK_QUESTIONMARK);
626
				makeToken(OCLParsersym.TK_QUESTIONMARK);
625
	            break;
627
	            break;
626
            }
628
            }
627
	
629
	
(-)src/org/eclipse/ocl/lpg/AbstractLexer.java (-8 / +19 lines)
Lines 23-31 Link Here
23
import java.io.IOException;
23
import java.io.IOException;
24
import java.io.Reader;
24
import java.io.Reader;
25
25
26
import lpg.lpgjavaruntime.LpgLexStream;
26
import lpg.runtime.LpgLexStream;
27
import lpg.lpgjavaruntime.Monitor;
27
import lpg.runtime.Monitor;
28
import lpg.lpgjavaruntime.RuleAction;
28
import lpg.runtime.RuleAction;
29
29
30
30
31
/**
31
/**
Lines 120-138 Link Here
120
	
120
	
121
	public abstract void lexToTokens(Monitor monitor, AbstractParser parser);
121
	public abstract void lexToTokens(Monitor monitor, AbstractParser parser);
122
122
123
	
124
	/*@Override public void reportError(int leftToken, int rightToken) {
125
		BasicEnvironment environment = getEnvironment();
126
		if (environment != null)
127
			environment.lexerError(computeErrorCode(leftToken, rightToken), leftToken, rightToken);
128
		else
129
			super.reportError(leftToken, rightToken);
130
	}*/
131
	
132
	@Override
123
	/**
133
	/**
124
	 * Errors generated within the lexer are redirected to the error handler if there is one.
134
	 * Errors generated within the lexer are redirected to the error handler if there is one.
125
	 * 
135
	 * 
126
	 * Note that other variants of reportError either feed this one, are fed from a default implementation
136
	 * Note that other variants of reportError either feed this one, are fed from a default implementation
127
	 * of this one or originate in the parser, where a ParserErrorHandler can intercept them.
137
	 * of this one or originate in the parser, where a ParserErrorHandler can intercept them.
128
	 */
138
	 */
129
	@Override public void reportError(int leftToken, int rightToken) {
139
	public void reportError(int errorCode, int leftToken, int errorToken,
140
			int rightToken, String[] errorInfo) {
130
		BasicEnvironment environment = getEnvironment();
141
		BasicEnvironment environment = getEnvironment();
131
		if (environment != null)
142
		if (environment != null)
132
			environment.lexerError(computeErrorCode(leftToken, rightToken), leftToken, rightToken);
143
			environment.lexerError(errorCode, errorToken, rightToken);
133
		else
144
		super.reportError(errorCode, leftToken, errorToken, rightToken, errorInfo);
134
			super.reportError(leftToken, rightToken);
135
	}
145
	}
146
	
136
147
137
    /**
148
    /**
138
	 * Define the input text as a given array of characters.
149
	 * Define the input text as a given array of characters.
Lines 141-147 Link Here
141
	public void initialize(char[] inputChars) {
152
	public void initialize(char[] inputChars) {
142
		setInputChars(inputChars);
153
		setInputChars(inputChars);
143
        setStreamLength(inputChars.length);
154
        setStreamLength(inputChars.length);
144
        computeLineOffsets();        
155
        computeLineOffsets();
145
	}
156
	}
146
157
147
	/**
158
	/**
(-)src/org/eclipse/ocl/lpg/AbstractBasicEnvironment.java (-2 / +2 lines)
Lines 25-32 Link Here
25
import java.util.List;
25
import java.util.List;
26
import java.util.Map;
26
import java.util.Map;
27
27
28
import lpg.lpgjavaruntime.IToken;
28
import lpg.runtime.IToken;
29
import lpg.lpgjavaruntime.ParseErrorCodes;
29
import lpg.runtime.ParseErrorCodes;
30
30
31
import org.eclipse.ocl.cst.CSTNode;
31
import org.eclipse.ocl.cst.CSTNode;
32
import org.eclipse.ocl.internal.OCLDebugOptions;
32
import org.eclipse.ocl.internal.OCLDebugOptions;
(-)src/org/eclipse/ocl/lpg/AbstractParser.java (-18 / +34 lines)
Lines 21-33 Link Here
21
21
22
import java.util.ArrayList;
22
import java.util.ArrayList;
23
23
24
import lpg.lpgjavaruntime.ErrorToken;
24
import lpg.runtime.ErrorToken;
25
import lpg.lpgjavaruntime.IToken;
25
import lpg.runtime.IToken;
26
import lpg.lpgjavaruntime.LexStream;
26
import lpg.runtime.LexStream;
27
import lpg.lpgjavaruntime.Monitor;
27
import lpg.runtime.Monitor;
28
import lpg.lpgjavaruntime.ParseErrorCodes;
28
import lpg.runtime.ParseErrorCodes;
29
import lpg.lpgjavaruntime.PrsStream;
29
import lpg.runtime.PrsStream;
30
import lpg.lpgjavaruntime.Token;
30
import lpg.runtime.Token;
31
31
32
import org.eclipse.ocl.cst.CSTNode;
32
import org.eclipse.ocl.cst.CSTNode;
33
import org.eclipse.ocl.internal.l10n.OCLMessages;
33
import org.eclipse.ocl.internal.l10n.OCLMessages;
Lines 141-147 Link Here
141
	}
141
	}
142
142
143
	public AbstractLexer getLexer() {
143
	public AbstractLexer getLexer() {
144
		return (AbstractLexer) super.getLexStream();
144
		return (AbstractLexer) super.getILexStream();
145
	}
145
	}
146
146
147
	/**
147
	/**
Lines 193-199 Link Here
193
193
194
			@Override
194
			@Override
195
			public String toString() {
195
			public String toString() {
196
				if (getPrsStream() == null) {
196
				if (getIPrsStream() == null) {
197
					return "<toString>"; //$NON-NLS-1$
197
					return "<toString>"; //$NON-NLS-1$
198
				}
198
				}
199
				int startOffset = getStartOffset();
199
				int startOffset = getStartOffset();
Lines 202-211 Link Here
202
					length = -length - 1;
202
					length = -length - 1;
203
					startOffset = getEndOffset();
203
					startOffset = getEndOffset();
204
				}
204
				}
205
				if ((startOffset + length) > getPrsStream().getInputChars().length) {
205
				if ((startOffset + length) > getIPrsStream().getInputChars().length) {
206
					return String.valueOf(IToken.EOF);
206
					return String.valueOf(IToken.EOF);
207
				}
207
				}
208
				return new String(getPrsStream().getInputChars(), startOffset,
208
				return new String(getIPrsStream().getInputChars(), startOffset,
209
					length);
209
					length);
210
			}
210
			}
211
211
Lines 223-229 Link Here
223
	public abstract CSTNode parseTokensToCST(Monitor monitor,
223
	public abstract CSTNode parseTokensToCST(Monitor monitor,
224
			int error_repair_count);
224
			int error_repair_count);
225
225
226
	@Override
226
	/*@Override
227
	public void reportError(int errorCode, String locationInfo, int leftToken,
227
	public void reportError(int errorCode, String locationInfo, int leftToken,
228
			int rightToken, String tokenText) {
228
			int rightToken, String tokenText) {
229
		BasicEnvironment environment = getEnvironment();
229
		BasicEnvironment environment = getEnvironment();
Lines 237-242 Link Here
237
			environment
237
			environment
238
				.parserError(errorCode, leftToken, rightToken, tokenText);
238
				.parserError(errorCode, leftToken, rightToken, tokenText);
239
		}
239
		}
240
	}*/
241
	
242
	@Override
243
	public void reportError(int errorCode, int leftToken, int errorToken,
244
			int rightToken, String[] errorInfo) {
245
		BasicEnvironment environment = getEnvironment();
246
		if (environment == null) {
247
			super.reportError(errorCode, leftToken, errorToken, rightToken, errorInfo);
248
		} else {			
249
			if (errorCode == DELETION_CODE || errorCode == MISPLACED_CODE) {
250
				
251
			} 
252
			environment
253
				.parserError(errorCode, leftToken, rightToken, "");
254
		}
255
		
240
	}
256
	}
241
257
242
	/**
258
	/**
Lines 253-270 Link Here
253
		int firsttok = super.getFirstRealToken(error_token);
269
		int firsttok = super.getFirstRealToken(error_token);
254
		int lasttok = super.getLastRealToken(error_token);
270
		int lasttok = super.getLastRealToken(error_token);
255
		if (firsttok > lasttok) {
271
		if (firsttok > lasttok) {
256
			String location = super.getFileName() + ':'
272
			/*String location = super.getFileName() + ':'
257
				+ super.getEndLine(lasttok) + ':' + super.getEndColumn(lasttok)
273
				+ super.getEndLine(lasttok) + ':' + super.getEndColumn(lasttok)
258
				+ ": "; //$NON-NLS-1$
274
				+ ": "; //$NON-NLS-1$*/
259
			reportError(ParseErrorCodes.INSERTION_CODE, location, lasttok,
275
			reportError(ParseErrorCodes.INSERTION_CODE, lasttok,
260
				lasttok, msg);
276
				lasttok, msg);
261
		} else {
277
		} else {
262
			String location = super.getFileName() + ':'
278
			/*String location = super.getFileName() + ':'
263
				+ super.getLine(error_token) + ':'
279
				+ super.getLine(error_token) + ':'
264
				+ super.getColumn(error_token) + ':'
280
				+ super.getColumn(error_token) + ':'
265
				+ super.getEndLine(error_token) + ':'
281
				+ super.getEndLine(error_token) + ':'
266
				+ super.getEndColumn(error_token) + ": "; //$NON-NLS-1$
282
				+ super.getEndColumn(error_token) + ": "; //$NON-NLS-1$*/
267
			reportError(ParseErrorCodes.SUBSTITUTION_CODE, location, firsttok,
283
			reportError(ParseErrorCodes.SUBSTITUTION_CODE, firsttok,
268
				lasttok, msg);
284
				lasttok, msg);
269
		}
285
		}
270
	}
286
	}
(-)src/org/eclipse/ocl/lpg/AbstractProblemHandler.java (-1 / +1 lines)
Lines 17-23 Link Here
17
 */
17
 */
18
package org.eclipse.ocl.lpg;
18
package org.eclipse.ocl.lpg;
19
19
20
import lpg.lpgjavaruntime.ParseErrorCodes;
20
import lpg.runtime.ParseErrorCodes;
21
21
22
import org.eclipse.emf.common.util.Monitor;
22
import org.eclipse.emf.common.util.Monitor;
23
import org.eclipse.ocl.internal.l10n.OCLMessages;
23
import org.eclipse.ocl.internal.l10n.OCLMessages;
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingLexer.java (-50 / +46 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-36 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Borland - Bug 242880
14
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*
15
*
15
* </copyright>
16
* </copyright>
16
*
17
*
17
* $Id: OCLBacktrackingLexer.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
18
* '$'Id''
18
*/
19
*/
19
20
20
package org.eclipse.ocl.parser.backtracking;
21
package org.eclipse.ocl.parser.backtracking;
21
22
22
import lpg.lpgjavaruntime.*;
23
import lpg.runtime.*;
23
import org.eclipse.ocl.lpg.AbstractLexer;
24
import org.eclipse.ocl.lpg.AbstractLexer;
24
import org.eclipse.ocl.lpg.AbstractParser;
25
import org.eclipse.ocl.lpg.AbstractParser;
25
import org.eclipse.ocl.Environment;
26
import org.eclipse.ocl.Environment;
26
import org.eclipse.ocl.lpg.BasicEnvironment;
27
import org.eclipse.ocl.lpg.BasicEnvironment;
27
import org.eclipse.ocl.util.OCLUtil;
28
import org.eclipse.ocl.util.OCLUtil;
28
29
29
/**
30
 * The backtracking variant of the OCL lexer.
31
 * 
32
 * @since 1.3
33
 */
34
@SuppressWarnings("nls")
30
@SuppressWarnings("nls")
35
public class OCLBacktrackingLexer extends AbstractLexer implements OCLBacktrackingParsersym, OCLBacktrackingLexersym, RuleAction
31
public class OCLBacktrackingLexer extends AbstractLexer implements OCLBacktrackingParsersym, OCLBacktrackingLexersym, RuleAction
36
{
32
{
Lines 57-63 Link Here
57
    
53
    
58
	public OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars) {
54
	public OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] chars) {
59
		this(environment, chars, "OCL", ECLIPSE_TAB_VALUE);
55
		this(environment, chars, "OCL", ECLIPSE_TAB_VALUE);
60
		kwLexer = new OCLBacktrackingKWLexer(getInputChars(), TK_IDENTIFIER);
56
		kwLexer = new OCLBacktrackingKWLexer(getInputChars(), OCLBacktrackingParsersym.TK_IDENTIFIER);
61
	}
57
	}
62
58
63
    public OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)  {
59
    public OCLBacktrackingLexer(Environment<?,?,?,?,?,?,?,?,?,?,?,?> environment, char[] input_chars, String filename, int tab)  {
Lines 86-92 Link Here
86
    {
82
    {
87
        super.initialize(content, filename);
83
        super.initialize(content, filename);
88
        if (kwLexer == null)
84
        if (kwLexer == null)
89
             kwLexer = new OCLBacktrackingKWLexer(getInputChars(), TK_IDENTIFIER);
85
             kwLexer = new OCLBacktrackingKWLexer(getInputChars(), OCLBacktrackingParsersym.TK_IDENTIFIER);
90
        else
86
        else
91
             kwLexer.setInputChars(getInputChars());
87
             kwLexer.setInputChars(getInputChars());
92
    }
88
    }
Lines 97-103 Link Here
97
    @Override
93
    @Override
98
    public void setInputChars(char[] inputChars) {
94
    public void setInputChars(char[] inputChars) {
99
		super.setInputChars(inputChars);
95
		super.setInputChars(inputChars);
100
		kwLexer = new OCLBacktrackingKWLexer(getInputChars(), TK_IDENTIFIER);
96
		kwLexer = new OCLBacktrackingKWLexer(getInputChars(), OCLBacktrackingParsersym.TK_IDENTIFIER);
101
	}
97
	}
102
    
98
    
103
    @Override
99
    @Override
Lines 113-124 Link Here
113
        lexParser.parseCharacters(monitor);  // Lex the input characters
109
        lexParser.parseCharacters(monitor);  // Lex the input characters
114
            
110
            
115
        int i = getStreamIndex();
111
        int i = getStreamIndex();
116
        parser.makeToken(i, i, TK_EOF_TOKEN); // and end with the end of file token
112
        parser.makeToken(i, i, OCLBacktrackingParsersym.TK_EOF_TOKEN); // and end with the end of file token
117
        parser.setStreamLength(parser.getSize());
113
        parser.setStreamLength(parser.getSize());
118
            
114
            
119
        return;
115
        return;
120
    }
116
    }
121
    
117
        
122
    final void makeToken(int kind)
118
    final void makeToken(int kind)
123
    {
119
    {
124
        int startOffset = getLeftSpan(),
120
        int startOffset = getLeftSpan(),
Lines 322-328 Link Here
322
            // Rule 2:  Token ::= EscapedSQ
318
            // Rule 2:  Token ::= EscapedSQ
323
            //
319
            //
324
            case 2: { 
320
            case 2: { 
325
				makeToken(TK_STRING_LITERAL);
321
				makeToken(OCLBacktrackingParsersym.TK_STRING_LITERAL);
326
	            break;
322
	            break;
327
            }
323
            }
328
	 
324
	 
Lines 330-336 Link Here
330
            // Rule 3:  Token ::= SingleQuote SLNotSQ SingleQuote
326
            // Rule 3:  Token ::= SingleQuote SLNotSQ SingleQuote
331
            //
327
            //
332
            case 3: { 
328
            case 3: { 
333
				makeToken(TK_STRING_LITERAL);
329
				makeToken(OCLBacktrackingParsersym.TK_STRING_LITERAL);
334
	            break;
330
	            break;
335
            }
331
            }
336
	 
332
	 
Lines 338-344 Link Here
338
            // Rule 4:  Token ::= Acute SLNotSQOpt Acute
334
            // Rule 4:  Token ::= Acute SLNotSQOpt Acute
339
            //
335
            //
340
            case 4: { 
336
            case 4: { 
341
				makeToken(TK_STRING_LITERAL);
337
				makeToken(OCLBacktrackingParsersym.TK_STRING_LITERAL);
342
	            break;
338
	            break;
343
            }
339
            }
344
	 
340
	 
Lines 346-352 Link Here
346
            // Rule 5:  Token ::= BackQuote SLNotSQOpt Acute
342
            // Rule 5:  Token ::= BackQuote SLNotSQOpt Acute
347
            //
343
            //
348
            case 5: { 
344
            case 5: { 
349
				makeToken(TK_STRING_LITERAL);
345
				makeToken(OCLBacktrackingParsersym.TK_STRING_LITERAL);
350
	            break;
346
	            break;
351
            }
347
            }
352
	 
348
	 
Lines 354-360 Link Here
354
            // Rule 6:  Token ::= IntegerLiteral
350
            // Rule 6:  Token ::= IntegerLiteral
355
            //
351
            //
356
            case 6: { 
352
            case 6: { 
357
				makeToken(TK_INTEGER_LITERAL);
353
				makeToken(OCLBacktrackingParsersym.TK_INTEGER_LITERAL);
358
	            break;
354
	            break;
359
            }
355
            }
360
	 
356
	 
Lines 362-368 Link Here
362
            // Rule 7:  Token ::= RealLiteral
358
            // Rule 7:  Token ::= RealLiteral
363
            //
359
            //
364
            case 7: { 
360
            case 7: { 
365
				makeToken(TK_REAL_LITERAL);
361
				makeToken(OCLBacktrackingParsersym.TK_REAL_LITERAL);
366
	            break;
362
	            break;
367
            }
363
            }
368
	 
364
	 
Lines 370-376 Link Here
370
            // Rule 8:  Token ::= NumericOperation
366
            // Rule 8:  Token ::= NumericOperation
371
            //
367
            //
372
            case 8: { 
368
            case 8: { 
373
				makeToken(TK_NUMERIC_OPERATION);
369
				makeToken(OCLBacktrackingParsersym.TK_NUMERIC_OPERATION);
374
	            break;
370
	            break;
375
            }
371
            }
376
	 
372
	 
Lines 378-384 Link Here
378
            // Rule 9:  Token ::= IntegerRangeStart
374
            // Rule 9:  Token ::= IntegerRangeStart
379
            //
375
            //
380
            case 9: { 
376
            case 9: { 
381
				makeToken(TK_INTEGER_RANGE_START);
377
				makeToken(OCLBacktrackingParsersym.TK_INTEGER_RANGE_START);
382
	            break;
378
	            break;
383
            }
379
            }
384
	 
380
	 
Lines 410-416 Link Here
410
            // Rule 13:  Token ::= +
406
            // Rule 13:  Token ::= +
411
            //
407
            //
412
            case 13: { 
408
            case 13: { 
413
				makeToken(TK_PLUS);
409
				makeToken(OCLBacktrackingParsersym.TK_PLUS);
414
	            break;
410
	            break;
415
            }
411
            }
416
	 
412
	 
Lines 418-424 Link Here
418
            // Rule 14:  Token ::= -
414
            // Rule 14:  Token ::= -
419
            //
415
            //
420
            case 14: { 
416
            case 14: { 
421
				makeToken(TK_MINUS);
417
				makeToken(OCLBacktrackingParsersym.TK_MINUS);
422
	            break;
418
	            break;
423
            }
419
            }
424
	 
420
	 
Lines 426-432 Link Here
426
            // Rule 15:  Token ::= *
422
            // Rule 15:  Token ::= *
427
            //
423
            //
428
            case 15: { 
424
            case 15: { 
429
				makeToken(TK_MULTIPLY);
425
				makeToken(OCLBacktrackingParsersym.TK_MULTIPLY);
430
	            break;
426
	            break;
431
            }
427
            }
432
	 
428
	 
Lines 434-440 Link Here
434
            // Rule 16:  Token ::= /
430
            // Rule 16:  Token ::= /
435
            //
431
            //
436
            case 16: { 
432
            case 16: { 
437
				makeToken(TK_DIVIDE);
433
				makeToken(OCLBacktrackingParsersym.TK_DIVIDE);
438
	            break;
434
	            break;
439
            }
435
            }
440
	 
436
	 
Lines 442-448 Link Here
442
            // Rule 17:  Token ::= (
438
            // Rule 17:  Token ::= (
443
            //
439
            //
444
            case 17: { 
440
            case 17: { 
445
				makeToken(TK_LPAREN);
441
				makeToken(OCLBacktrackingParsersym.TK_LPAREN);
446
	            break;
442
	            break;
447
            }
443
            }
448
	 
444
	 
Lines 450-456 Link Here
450
            // Rule 18:  Token ::= )
446
            // Rule 18:  Token ::= )
451
            //
447
            //
452
            case 18: { 
448
            case 18: { 
453
				makeToken(TK_RPAREN);
449
				makeToken(OCLBacktrackingParsersym.TK_RPAREN);
454
	            break;
450
	            break;
455
            }
451
            }
456
	 
452
	 
Lines 458-464 Link Here
458
            // Rule 19:  Token ::= >
454
            // Rule 19:  Token ::= >
459
            //
455
            //
460
            case 19: { 
456
            case 19: { 
461
				makeToken(TK_GREATER);
457
				makeToken(OCLBacktrackingParsersym.TK_GREATER);
462
	            break;
458
	            break;
463
            }
459
            }
464
	 
460
	 
Lines 466-472 Link Here
466
            // Rule 20:  Token ::= <
462
            // Rule 20:  Token ::= <
467
            //
463
            //
468
            case 20: { 
464
            case 20: { 
469
				makeToken(TK_LESS);
465
				makeToken(OCLBacktrackingParsersym.TK_LESS);
470
	            break;
466
	            break;
471
            }
467
            }
472
	 
468
	 
Lines 474-480 Link Here
474
            // Rule 21:  Token ::= =
470
            // Rule 21:  Token ::= =
475
            //
471
            //
476
            case 21: { 
472
            case 21: { 
477
				makeToken(TK_EQUAL);
473
				makeToken(OCLBacktrackingParsersym.TK_EQUAL);
478
	            break;
474
	            break;
479
            }
475
            }
480
	 
476
	 
Lines 482-488 Link Here
482
            // Rule 22:  Token ::= > =
478
            // Rule 22:  Token ::= > =
483
            //
479
            //
484
            case 22: { 
480
            case 22: { 
485
				makeToken(TK_GREATER_EQUAL);
481
				makeToken(OCLBacktrackingParsersym.TK_GREATER_EQUAL);
486
	            break;
482
	            break;
487
            }
483
            }
488
	 
484
	 
Lines 490-496 Link Here
490
            // Rule 23:  Token ::= < =
486
            // Rule 23:  Token ::= < =
491
            //
487
            //
492
            case 23: { 
488
            case 23: { 
493
				makeToken(TK_LESS_EQUAL);
489
				makeToken(OCLBacktrackingParsersym.TK_LESS_EQUAL);
494
	            break;
490
	            break;
495
            }
491
            }
496
	 
492
	 
Lines 498-504 Link Here
498
            // Rule 24:  Token ::= < >
494
            // Rule 24:  Token ::= < >
499
            //
495
            //
500
            case 24: { 
496
            case 24: { 
501
				makeToken(TK_NOT_EQUAL);
497
				makeToken(OCLBacktrackingParsersym.TK_NOT_EQUAL);
502
	            break;
498
	            break;
503
            }
499
            }
504
	 
500
	 
Lines 506-512 Link Here
506
            // Rule 25:  Token ::= [
502
            // Rule 25:  Token ::= [
507
            //
503
            //
508
            case 25: { 
504
            case 25: { 
509
				makeToken(TK_LBRACKET);
505
				makeToken(OCLBacktrackingParsersym.TK_LBRACKET);
510
	            break;
506
	            break;
511
            }
507
            }
512
	 
508
	 
Lines 514-520 Link Here
514
            // Rule 26:  Token ::= ]
510
            // Rule 26:  Token ::= ]
515
            //
511
            //
516
            case 26: { 
512
            case 26: { 
517
				makeToken(TK_RBRACKET);
513
				makeToken(OCLBacktrackingParsersym.TK_RBRACKET);
518
	            break;
514
	            break;
519
            }
515
            }
520
	 
516
	 
Lines 522-528 Link Here
522
            // Rule 27:  Token ::= {
518
            // Rule 27:  Token ::= {
523
            //
519
            //
524
            case 27: { 
520
            case 27: { 
525
				makeToken(TK_LBRACE);
521
				makeToken(OCLBacktrackingParsersym.TK_LBRACE);
526
	            break;
522
	            break;
527
            }
523
            }
528
	 
524
	 
Lines 530-536 Link Here
530
            // Rule 28:  Token ::= }
526
            // Rule 28:  Token ::= }
531
            //
527
            //
532
            case 28: { 
528
            case 28: { 
533
				makeToken(TK_RBRACE);
529
				makeToken(OCLBacktrackingParsersym.TK_RBRACE);
534
	            break;
530
	            break;
535
            }
531
            }
536
	 
532
	 
Lines 538-544 Link Here
538
            // Rule 29:  Token ::= - >
534
            // Rule 29:  Token ::= - >
539
            //
535
            //
540
            case 29: { 
536
            case 29: { 
541
				makeToken(TK_ARROW);
537
				makeToken(OCLBacktrackingParsersym.TK_ARROW);
542
	            break;
538
	            break;
543
            }
539
            }
544
	 
540
	 
Lines 546-552 Link Here
546
            // Rule 30:  Token ::= |
542
            // Rule 30:  Token ::= |
547
            //
543
            //
548
            case 30: { 
544
            case 30: { 
549
				makeToken(TK_BAR);
545
				makeToken(OCLBacktrackingParsersym.TK_BAR);
550
	            break;
546
	            break;
551
            }
547
            }
552
	 
548
	 
Lines 554-560 Link Here
554
            // Rule 31:  Token ::= ,
550
            // Rule 31:  Token ::= ,
555
            //
551
            //
556
            case 31: { 
552
            case 31: { 
557
				makeToken(TK_COMMA);
553
				makeToken(OCLBacktrackingParsersym.TK_COMMA);
558
	            break;
554
	            break;
559
            }
555
            }
560
	 
556
	 
Lines 562-568 Link Here
562
            // Rule 32:  Token ::= :
558
            // Rule 32:  Token ::= :
563
            //
559
            //
564
            case 32: { 
560
            case 32: { 
565
				makeToken(TK_COLON);
561
				makeToken(OCLBacktrackingParsersym.TK_COLON);
566
	            break;
562
	            break;
567
            }
563
            }
568
	 
564
	 
Lines 570-576 Link Here
570
            // Rule 33:  Token ::= : :
566
            // Rule 33:  Token ::= : :
571
            //
567
            //
572
            case 33: { 
568
            case 33: { 
573
				makeToken(TK_COLONCOLON);
569
				makeToken(OCLBacktrackingParsersym.TK_COLONCOLON);
574
	            break;
570
	            break;
575
            }
571
            }
576
	 
572
	 
Lines 578-584 Link Here
578
            // Rule 34:  Token ::= ;
574
            // Rule 34:  Token ::= ;
579
            //
575
            //
580
            case 34: { 
576
            case 34: { 
581
				makeToken(TK_SEMICOLON);
577
				makeToken(OCLBacktrackingParsersym.TK_SEMICOLON);
582
	            break;
578
	            break;
583
            }
579
            }
584
	 
580
	 
Lines 586-592 Link Here
586
            // Rule 35:  Token ::= .
582
            // Rule 35:  Token ::= .
587
            //
583
            //
588
            case 35: { 
584
            case 35: { 
589
				makeToken(TK_DOT);
585
				makeToken(OCLBacktrackingParsersym.TK_DOT);
590
	            break;
586
	            break;
591
            }
587
            }
592
	 
588
	 
Lines 594-600 Link Here
594
            // Rule 36:  Token ::= . .
590
            // Rule 36:  Token ::= . .
595
            //
591
            //
596
            case 36: { 
592
            case 36: { 
597
				makeToken(TK_DOTDOT);
593
				makeToken(OCLBacktrackingParsersym.TK_DOTDOT);
598
	            break;
594
	            break;
599
            }
595
            }
600
	 
596
	 
Lines 602-608 Link Here
602
            // Rule 37:  Token ::= @ p r e
598
            // Rule 37:  Token ::= @ p r e
603
            //
599
            //
604
            case 37: { 
600
            case 37: { 
605
				makeToken(TK_ATPRE);
601
				makeToken(OCLBacktrackingParsersym.TK_ATPRE);
606
	            break;
602
	            break;
607
            }
603
            }
608
	 
604
	 
Lines 610-616 Link Here
610
            // Rule 38:  Token ::= ^
606
            // Rule 38:  Token ::= ^
611
            //
607
            //
612
            case 38: { 
608
            case 38: { 
613
				makeToken(TK_CARET);
609
				makeToken(OCLBacktrackingParsersym.TK_CARET);
614
	            break;
610
	            break;
615
            }
611
            }
616
	 
612
	 
Lines 618-624 Link Here
618
            // Rule 39:  Token ::= ^ ^
614
            // Rule 39:  Token ::= ^ ^
619
            //
615
            //
620
            case 39: { 
616
            case 39: { 
621
				makeToken(TK_CARETCARET);
617
				makeToken(OCLBacktrackingParsersym.TK_CARETCARET);
622
	            break;
618
	            break;
623
            }
619
            }
624
	 
620
	 
Lines 626-632 Link Here
626
            // Rule 40:  Token ::= ?
622
            // Rule 40:  Token ::= ?
627
            //
623
            //
628
            case 40: { 
624
            case 40: { 
629
				makeToken(TK_QUESTIONMARK);
625
				makeToken(OCLBacktrackingParsersym.TK_QUESTIONMARK);
630
	            break;
626
	            break;
631
            }
627
            }
632
	
628
	
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingKWLexersym.java (-27 / +23 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-36 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*
14
*
15
* </copyright>
15
* </copyright>
16
*
16
*
17
* $Id: OCLBacktrackingKWLexersym.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
17
* 
18
*/
18
*/
19
19
20
package org.eclipse.ocl.parser.backtracking;
20
package org.eclipse.ocl.parser.backtracking;
21
21
22
/**
23
 * The backtracking variant of the OCL keyword lexer symbol table.
24
 * 
25
 * @noimplement This interface is not intended to be implemented by clients.
26
 * @noextend This interface is not intended to be extended by clients.
27
 * 
28
 * @since 1.3
29
 */
30
@SuppressWarnings("nls")
31
public interface OCLBacktrackingKWLexersym {
22
public interface OCLBacktrackingKWLexersym {
32
    public final static int
23
    public final static int
33
      Char_DollarSign = 40,
24
      Char_DollarSign = 40,
25
      Char_Percent = 41,
26
      Char__ = 42,
34
      Char_a = 5,
27
      Char_a = 5,
35
      Char_b = 30,
28
      Char_b = 30,
36
      Char_c = 11,
29
      Char_c = 11,
Lines 56-91 Link Here
56
      Char_w = 33,
49
      Char_w = 33,
57
      Char_x = 19,
50
      Char_x = 19,
58
      Char_y = 16,
51
      Char_y = 16,
59
      Char_z = 41,
52
      Char_z = 43,
60
      Char_A = 20,
53
      Char_A = 20,
61
      Char_B = 29,
54
      Char_B = 29,
62
      Char_C = 34,
55
      Char_C = 34,
63
      Char_D = 42,
56
      Char_D = 44,
64
      Char_E = 43,
57
      Char_E = 45,
65
      Char_F = 44,
58
      Char_F = 46,
66
      Char_G = 45,
59
      Char_G = 47,
67
      Char_H = 46,
60
      Char_H = 48,
68
      Char_I = 18,
61
      Char_I = 18,
69
      Char_J = 47,
62
      Char_J = 49,
70
      Char_K = 35,
63
      Char_K = 35,
71
      Char_L = 48,
64
      Char_L = 50,
72
      Char_M = 36,
65
      Char_M = 36,
73
      Char_N = 21,
66
      Char_N = 21,
74
      Char_O = 22,
67
      Char_O = 22,
75
      Char_P = 49,
68
      Char_P = 51,
76
      Char_Q = 50,
69
      Char_Q = 52,
77
      Char_R = 37,
70
      Char_R = 37,
78
      Char_S = 23,
71
      Char_S = 23,
79
      Char_T = 24,
72
      Char_T = 24,
80
      Char_U = 25,
73
      Char_U = 25,
81
      Char_V = 38,
74
      Char_V = 38,
82
      Char_W = 51,
75
      Char_W = 53,
83
      Char_X = 52,
76
      Char_X = 54,
84
      Char_Y = 53,
77
      Char_Y = 55,
85
      Char_Z = 54,
78
      Char_Z = 56,
86
      Char_EOF = 39;
79
      Char_EOF = 39;
87
80
88
      public final static String orderedTerminalSymbols[] = {
81
    public final static String orderedTerminalSymbols[] = {
89
                 "",
82
                 "",
90
                 "e",
83
                 "e",
91
                 "t",
84
                 "t",
Lines 127-132 Link Here
127
                 "V",
120
                 "V",
128
                 "EOF",
121
                 "EOF",
129
                 "DollarSign",
122
                 "DollarSign",
123
                 "Percent",
124
                 "_",
130
                 "z",
125
                 "z",
131
                 "D",
126
                 "D",
132
                 "E",
127
                 "E",
Lines 143-147 Link Here
143
                 "Z"
138
                 "Z"
144
             };
139
             };
145
140
141
    public final static int numTokenKinds = orderedTerminalSymbols.length;
146
    public final static boolean isValidForParser = true;
142
    public final static boolean isValidForParser = true;
147
}
143
}
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingParser.java (-260 / +92 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 14-23 Link Here
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
16
*   Borland - Bug 242880
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
17
*
19
*
18
* </copyright>
20
* </copyright>
19
*
21
*
20
* $Id: OCLBacktrackingParser.java,v 1.2 2009/03/05 14:12:14 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
21
*/
23
*/
22
24
23
package org.eclipse.ocl.parser.backtracking;
25
package org.eclipse.ocl.parser.backtracking;
Lines 44-58 Link Here
44
import org.eclipse.ocl.util.OCLStandardLibraryUtil;
46
import org.eclipse.ocl.util.OCLStandardLibraryUtil;
45
import org.eclipse.ocl.utilities.PredefinedType;
47
import org.eclipse.ocl.utilities.PredefinedType;
46
48
47
import lpg.lpgjavaruntime.BadParseException;
49
import lpg.runtime.BadParseException;
48
import lpg.lpgjavaruntime.BadParseSymFileException;
50
import lpg.runtime.BadParseSymFileException;
49
import lpg.lpgjavaruntime.BacktrackingParser;
51
import lpg.runtime.BacktrackingParser;
50
import lpg.lpgjavaruntime.DiagnoseParser;
52
import lpg.runtime.DiagnoseParser;
51
import lpg.lpgjavaruntime.IToken;
53
import lpg.runtime.IToken;
52
import lpg.lpgjavaruntime.Monitor;
54
import lpg.runtime.Monitor;
53
import lpg.lpgjavaruntime.NotBacktrackParseTableException;
55
import lpg.runtime.NotBacktrackParseTableException;
54
import lpg.lpgjavaruntime.ParseTable;
56
import lpg.runtime.ParseTable;
55
import lpg.lpgjavaruntime.RuleAction;
57
import lpg.runtime.RuleAction;
56
58
57
import org.eclipse.ocl.Environment;
59
import org.eclipse.ocl.Environment;
58
import org.eclipse.ocl.cst.DefExpressionCS;
60
import org.eclipse.ocl.cst.DefExpressionCS;
Lines 64-74 Link Here
64
66
65
	import org.eclipse.ocl.parser.AbstractOCLParser;
67
	import org.eclipse.ocl.parser.AbstractOCLParser;
66
68
67
/**
68
 * The backtracking variant of the OCL parser.
69
 * 
70
 * @since 1.3
71
 */
72
public class OCLBacktrackingParser extends AbstractOCLParser implements RuleAction
69
public class OCLBacktrackingParser extends AbstractOCLParser implements RuleAction
73
{
70
{
74
	protected static ParseTable prs = new OCLBacktrackingParserprs();
71
	protected static ParseTable prs = new OCLBacktrackingParserprs();
Lines 145-171 Link Here
145
	{
142
	{
146
		switch (ruleNumber) {
143
		switch (ruleNumber) {
147
		
144
		
148
 
145
  
149
			//
146
			//
150
			// Rule 46:  binaryName ::= binaryIdentifier
147
			// Rule 46:  binaryName ::= binaryIdentifier
151
			//
148
			//
152
			case 46:
149
			case 46:
153
 
150
   
154
			//
151
			//
155
			// Rule 47:  keywordAsName ::= keywordAsIdentifier
152
			// Rule 47:  keywordAsName ::= keywordAsIdentifier
156
			//
153
			//
157
			case 47:
154
			case 47:
158
 
155
   
159
			//
156
			//
160
			// Rule 48:  keywordAsName1 ::= keywordAsIdentifier1
157
			// Rule 48:  keywordAsName1 ::= keywordAsIdentifier1
161
			//
158
			//
162
			case 48:
159
			case 48:
163
 
160
  
164
			//
161
			//
165
			// Rule 49:  unaryName ::= unaryIdentifier
162
			// Rule 49:  unaryName ::= unaryIdentifier
166
			//
163
			//
167
			case 49: {
164
			case 49: {
168
				
169
				SimpleNameCS result = createSimpleNameCS(
165
				SimpleNameCS result = createSimpleNameCS(
170
							SimpleTypeEnum.IDENTIFIER_LITERAL,
166
							SimpleTypeEnum.IDENTIFIER_LITERAL,
171
							getTokenText(dtParser.getToken(1))
167
							getTokenText(dtParser.getToken(1))
Lines 174-195 Link Here
174
				dtParser.setSym1(result);
170
				dtParser.setSym1(result);
175
	  		  break;
171
	  		  break;
176
			}
172
			}
177
	 
173
	  
178
			//
174
			//
179
			// Rule 50:  iterateName ::= iterate
175
			// Rule 50:  iterateName ::= iterate
180
			//
176
			//
181
			case 50:
177
			case 50:
182
 
178
   
183
			//
179
			//
184
			// Rule 51:  iteratorName ::= iteratorIdentifier
180
			// Rule 51:  iteratorName ::= iteratorIdentifier
185
			//
181
			//
186
			case 51:
182
			case 51:
187
 
183
  
188
			//
184
			//
189
			// Rule 52:  oclIsInStateName ::= oclIsInState
185
			// Rule 52:  oclIsInStateName ::= oclIsInState
190
			//
186
			//
191
			case 52: {
187
			case 52: {
192
				
193
				SimpleNameCS result = createSimpleNameCS(
188
				SimpleNameCS result = createSimpleNameCS(
194
							SimpleTypeEnum.KEYWORD_LITERAL,
189
							SimpleTypeEnum.KEYWORD_LITERAL,
195
							getTokenText(dtParser.getToken(1))
190
							getTokenText(dtParser.getToken(1))
Lines 203-209 Link Here
203
			// Rule 55:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) : typeCSopt
198
			// Rule 55:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) : typeCSopt
204
			//
199
			//
205
			case 55: {
200
			case 55: {
206
				
207
				CSTNode result = createOperationCS(
201
				CSTNode result = createOperationCS(
208
						getTokenText(dtParser.getToken(1)),
202
						getTokenText(dtParser.getToken(1)),
209
						(EList)dtParser.getSym(3),
203
						(EList)dtParser.getSym(3),
Lines 222-228 Link Here
222
			// Rule 56:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) : typeCSopt
216
			// Rule 56:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) : typeCSopt
223
			//
217
			//
224
			case 56: {
218
			case 56: {
225
				
226
				CSTNode result = createOperationCS(
219
				CSTNode result = createOperationCS(
227
						(PathNameCS)dtParser.getSym(1),
220
						(PathNameCS)dtParser.getSym(1),
228
						(SimpleNameCS)dtParser.getSym(3),
221
						(SimpleNameCS)dtParser.getSym(3),
Lines 237-255 Link Here
237
				dtParser.setSym1(result);
230
				dtParser.setSym1(result);
238
	  		  break;
231
	  		  break;
239
			}
232
			}
240
	 
233
	  
241
			//
234
			//
242
			// Rule 57:  parametersCSopt ::= $Empty
235
			// Rule 57:  parametersCSopt ::= $Empty
243
			//
236
			//
244
			case 57:
237
			case 57:
245
				dtParser.setSym1(new BasicEList());
238
				dtParser.setSym1(new BasicEList());
246
				break;
239
				break;
247
 
240
  
248
			//
241
			//
249
			// Rule 59:  parametersCS ::= variableCS
242
			// Rule 59:  parametersCS ::= variableCS
250
			//
243
			//
251
			case 59: {
244
			case 59: {
252
				
253
				EList result = new BasicEList();
245
				EList result = new BasicEList();
254
				result.add(dtParser.getSym(1));
246
				result.add(dtParser.getSym(1));
255
				dtParser.setSym1(result);
247
				dtParser.setSym1(result);
Lines 260-266 Link Here
260
			// Rule 60:  parametersCS ::= parametersCS , variableCS
252
			// Rule 60:  parametersCS ::= parametersCS , variableCS
261
			//
253
			//
262
			case 60: {
254
			case 60: {
263
				
264
				EList result = (EList)dtParser.getSym(1);
255
				EList result = (EList)dtParser.getSym(1);
265
				result.add(dtParser.getSym(3));
256
				result.add(dtParser.getSym(3));
266
				dtParser.setSym1(result);
257
				dtParser.setSym1(result);
Lines 273-319 Link Here
273
			case 61:
264
			case 61:
274
				dtParser.setSym1(null);
265
				dtParser.setSym1(null);
275
				break;
266
				break;
276
 
267
  
277
			//
268
			//
278
			// Rule 67:  impliesExpCS ::= impliesExpCS implies andOrXorExpCS
269
			// Rule 67:  impliesExpCS ::= impliesExpCS implies andOrXorExpCS
279
			//
270
			//
280
			case 67:
271
			case 67:
281
 
272
   
282
			//
273
			//
283
			// Rule 68:  impliesWithLet ::= impliesExpCS implies andOrXorWithLet
274
			// Rule 68:  impliesWithLet ::= impliesExpCS implies andOrXorWithLet
284
			//
275
			//
285
			case 68:
276
			case 68:
286
 
277
   
287
			//
278
			//
288
			// Rule 71:  andOrXorExpCS ::= andOrXorExpCS and equalityExpCS
279
			// Rule 71:  andOrXorExpCS ::= andOrXorExpCS and equalityExpCS
289
			//
280
			//
290
			case 71:
281
			case 71:
291
 
282
   
292
			//
283
			//
293
			// Rule 72:  andOrXorExpCS ::= andOrXorExpCS or equalityExpCS
284
			// Rule 72:  andOrXorExpCS ::= andOrXorExpCS or equalityExpCS
294
			//
285
			//
295
			case 72:
286
			case 72:
296
 
287
   
297
			//
288
			//
298
			// Rule 73:  andOrXorExpCS ::= andOrXorExpCS xor equalityExpCS
289
			// Rule 73:  andOrXorExpCS ::= andOrXorExpCS xor equalityExpCS
299
			//
290
			//
300
			case 73:
291
			case 73:
301
 
292
   
302
			//
293
			//
303
			// Rule 74:  andOrXorWithLet ::= andOrXorExpCS and equalityWithLet
294
			// Rule 74:  andOrXorWithLet ::= andOrXorExpCS and equalityWithLet
304
			//
295
			//
305
			case 74:
296
			case 74:
306
 
297
   
307
			//
298
			//
308
			// Rule 75:  andOrXorWithLet ::= andOrXorExpCS or equalityWithLet
299
			// Rule 75:  andOrXorWithLet ::= andOrXorExpCS or equalityWithLet
309
			//
300
			//
310
			case 75:
301
			case 75:
311
 
302
  
312
			//
303
			//
313
			// Rule 76:  andOrXorWithLet ::= andOrXorExpCS xor equalityWithLet
304
			// Rule 76:  andOrXorWithLet ::= andOrXorExpCS xor equalityWithLet
314
			//
305
			//
315
			case 76: {
306
			case 76: {
316
				
317
				SimpleNameCS simpleNameCS = createSimpleNameCS(
307
				SimpleNameCS simpleNameCS = createSimpleNameCS(
318
							SimpleTypeEnum.STRING_LITERAL,
308
							SimpleTypeEnum.STRING_LITERAL,
319
							getTokenText(dtParser.getToken(2))
309
							getTokenText(dtParser.getToken(2))
Lines 330-346 Link Here
330
				dtParser.setSym1(result);
320
				dtParser.setSym1(result);
331
	  		  break;
321
	  		  break;
332
			}
322
			}
333
	 
323
	  
334
			//
324
			//
335
			// Rule 79:  equalityExpCS ::= equalityExpCS = relationalExpCS
325
			// Rule 79:  equalityExpCS ::= equalityExpCS = relationalExpCS
336
			//
326
			//
337
			case 79:
327
			case 79:
338
 
328
  
339
			//
329
			//
340
			// Rule 80:  equalityWithLet ::= equalityExpCS = relationalWithLet
330
			// Rule 80:  equalityWithLet ::= equalityExpCS = relationalWithLet
341
			//
331
			//
342
			case 80: {
332
			case 80: {
343
				
344
				SimpleNameCS simpleNameCS = createSimpleNameCS(
333
				SimpleNameCS simpleNameCS = createSimpleNameCS(
345
							SimpleTypeEnum.STRING_LITERAL,
334
							SimpleTypeEnum.STRING_LITERAL,
346
							OCLStandardLibraryUtil.getOperationName(PredefinedType.EQUAL)
335
							OCLStandardLibraryUtil.getOperationName(PredefinedType.EQUAL)
Lines 357-373 Link Here
357
				dtParser.setSym1(result);
346
				dtParser.setSym1(result);
358
	  		  break;
347
	  		  break;
359
			}
348
			}
360
	 
349
	  
361
			//
350
			//
362
			// Rule 81:  equalityExpCS ::= equalityExpCS <> relationalExpCS
351
			// Rule 81:  equalityExpCS ::= equalityExpCS <> relationalExpCS
363
			//
352
			//
364
			case 81:
353
			case 81:
365
 
354
  
366
			//
355
			//
367
			// Rule 82:  equalityWithLet ::= equalityExpCS <> relationalWithLet
356
			// Rule 82:  equalityWithLet ::= equalityExpCS <> relationalWithLet
368
			//
357
			//
369
			case 82: {
358
			case 82: {
370
				
371
				SimpleNameCS simpleNameCS = createSimpleNameCS(
359
				SimpleNameCS simpleNameCS = createSimpleNameCS(
372
							SimpleTypeEnum.STRING_LITERAL,
360
							SimpleTypeEnum.STRING_LITERAL,
373
							OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
361
							OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
Lines 384-400 Link Here
384
				dtParser.setSym1(result);
372
				dtParser.setSym1(result);
385
	  		  break;
373
	  		  break;
386
			}
374
			}
387
	 
375
	  
388
			//
376
			//
389
			// Rule 85:  relationalExpCS ::= relationalExpCS > ifExpCSPrec
377
			// Rule 85:  relationalExpCS ::= relationalExpCS > ifExpCSPrec
390
			//
378
			//
391
			case 85:
379
			case 85:
392
 
380
  
393
			//
381
			//
394
			// Rule 86:  relationalWithLet ::= relationalExpCS > additiveWithLet
382
			// Rule 86:  relationalWithLet ::= relationalExpCS > additiveWithLet
395
			//
383
			//
396
			case 86: {
384
			case 86: {
397
				
398
				SimpleNameCS simpleNameCS = createSimpleNameCS(
385
				SimpleNameCS simpleNameCS = createSimpleNameCS(
399
							SimpleTypeEnum.STRING_LITERAL,
386
							SimpleTypeEnum.STRING_LITERAL,
400
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN)
387
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN)
Lines 411-427 Link Here
411
				dtParser.setSym1(result);
398
				dtParser.setSym1(result);
412
	  		  break;
399
	  		  break;
413
			}
400
			}
414
	 
401
	  
415
			//
402
			//
416
			// Rule 87:  relationalExpCS ::= relationalExpCS < ifExpCSPrec
403
			// Rule 87:  relationalExpCS ::= relationalExpCS < ifExpCSPrec
417
			//
404
			//
418
			case 87:
405
			case 87:
419
 
406
  
420
			//
407
			//
421
			// Rule 88:  relationalWithLet ::= relationalExpCS < additiveWithLet
408
			// Rule 88:  relationalWithLet ::= relationalExpCS < additiveWithLet
422
			//
409
			//
423
			case 88: {
410
			case 88: {
424
				
425
				SimpleNameCS simpleNameCS = createSimpleNameCS(
411
				SimpleNameCS simpleNameCS = createSimpleNameCS(
426
							SimpleTypeEnum.STRING_LITERAL,
412
							SimpleTypeEnum.STRING_LITERAL,
427
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN)
413
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN)
Lines 438-454 Link Here
438
				dtParser.setSym1(result);
424
				dtParser.setSym1(result);
439
	  		  break;
425
	  		  break;
440
			}
426
			}
441
	 
427
	  
442
			//
428
			//
443
			// Rule 89:  relationalExpCS ::= relationalExpCS >= ifExpCSPrec
429
			// Rule 89:  relationalExpCS ::= relationalExpCS >= ifExpCSPrec
444
			//
430
			//
445
			case 89:
431
			case 89:
446
 
432
  
447
			//
433
			//
448
			// Rule 90:  relationalWithLet ::= relationalExpCS >= additiveWithLet
434
			// Rule 90:  relationalWithLet ::= relationalExpCS >= additiveWithLet
449
			//
435
			//
450
			case 90: {
436
			case 90: {
451
				
452
				SimpleNameCS simpleNameCS = createSimpleNameCS(
437
				SimpleNameCS simpleNameCS = createSimpleNameCS(
453
							SimpleTypeEnum.STRING_LITERAL,
438
							SimpleTypeEnum.STRING_LITERAL,
454
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN_EQUAL)
439
							OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN_EQUAL)
Lines 465-481 Link Here
465
				dtParser.setSym1(result);
450
				dtParser.setSym1(result);
466
	  		  break;
451
	  		  break;
467
			}
452
			}
468
	 
453
	  
469
			//
454
			//
470
			// Rule 91:  relationalExpCS ::= relationalExpCS <= ifExpCSPrec
455
			// Rule 91:  relationalExpCS ::= relationalExpCS <= ifExpCSPrec
471
			//
456
			//
472
			case 91:
457
			case 91:
473
 
458
  
474
			//
459
			//
475
			// Rule 92:  relationalWithLet ::= relationalExpCS <= additiveWithLet
460
			// Rule 92:  relationalWithLet ::= relationalExpCS <= additiveWithLet
476
			//
461
			//
477
			case 92: {
462
			case 92: {
478
				
479
				SimpleNameCS simpleNameCS = createSimpleNameCS(
463
				SimpleNameCS simpleNameCS = createSimpleNameCS(
480
							SimpleTypeEnum.STRING_LITERAL,
464
							SimpleTypeEnum.STRING_LITERAL,
481
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN_EQUAL)
465
							OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN_EQUAL)
Lines 492-508 Link Here
492
				dtParser.setSym1(result);
476
				dtParser.setSym1(result);
493
	  		  break;
477
	  		  break;
494
			}
478
			}
495
	 
479
	  
496
			//
480
			//
497
			// Rule 97:  additiveExpCS ::= additiveExpCS + multiplicativeExpCS
481
			// Rule 97:  additiveExpCS ::= additiveExpCS + multiplicativeExpCS
498
			//
482
			//
499
			case 97:
483
			case 97:
500
 
484
  
501
			//
485
			//
502
			// Rule 98:  additiveWithLet ::= additiveExpCS + multiplicativeWithLet
486
			// Rule 98:  additiveWithLet ::= additiveExpCS + multiplicativeWithLet
503
			//
487
			//
504
			case 98: {
488
			case 98: {
505
				
506
				SimpleNameCS simpleNameCS = createSimpleNameCS(
489
				SimpleNameCS simpleNameCS = createSimpleNameCS(
507
							SimpleTypeEnum.STRING_LITERAL,
490
							SimpleTypeEnum.STRING_LITERAL,
508
							OCLStandardLibraryUtil.getOperationName(PredefinedType.PLUS)
491
							OCLStandardLibraryUtil.getOperationName(PredefinedType.PLUS)
Lines 519-535 Link Here
519
				dtParser.setSym1(result);
502
				dtParser.setSym1(result);
520
	  		  break;
503
	  		  break;
521
			}
504
			}
522
	 
505
	  
523
			//
506
			//
524
			// Rule 99:  additiveExpCS ::= additiveExpCS - multiplicativeExpCS
507
			// Rule 99:  additiveExpCS ::= additiveExpCS - multiplicativeExpCS
525
			//
508
			//
526
			case 99:
509
			case 99:
527
 
510
  
528
			//
511
			//
529
			// Rule 100:  additiveWithLet ::= additiveExpCS - multiplicativeWithLet
512
			// Rule 100:  additiveWithLet ::= additiveExpCS - multiplicativeWithLet
530
			//
513
			//
531
			case 100: {
514
			case 100: {
532
				
533
				SimpleNameCS simpleNameCS = createSimpleNameCS(
515
				SimpleNameCS simpleNameCS = createSimpleNameCS(
534
							SimpleTypeEnum.STRING_LITERAL,
516
							SimpleTypeEnum.STRING_LITERAL,
535
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
517
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
Lines 546-562 Link Here
546
				dtParser.setSym1(result);
528
				dtParser.setSym1(result);
547
	  		  break;
529
	  		  break;
548
			}
530
			}
549
	 
531
	  
550
			//
532
			//
551
			// Rule 103:  multiplicativeExpCS ::= multiplicativeExpCS * unaryExpCS
533
			// Rule 103:  multiplicativeExpCS ::= multiplicativeExpCS * unaryExpCS
552
			//
534
			//
553
			case 103:
535
			case 103:
554
 
536
  
555
			//
537
			//
556
			// Rule 104:  multiplicativeWithLet ::= multiplicativeExpCS * unaryWithLet
538
			// Rule 104:  multiplicativeWithLet ::= multiplicativeExpCS * unaryWithLet
557
			//
539
			//
558
			case 104: {
540
			case 104: {
559
				
560
				SimpleNameCS simpleNameCS = createSimpleNameCS(
541
				SimpleNameCS simpleNameCS = createSimpleNameCS(
561
							SimpleTypeEnum.STRING_LITERAL,
542
							SimpleTypeEnum.STRING_LITERAL,
562
							OCLStandardLibraryUtil.getOperationName(PredefinedType.TIMES)
543
							OCLStandardLibraryUtil.getOperationName(PredefinedType.TIMES)
Lines 573-589 Link Here
573
				dtParser.setSym1(result);
554
				dtParser.setSym1(result);
574
	  		  break;
555
	  		  break;
575
			}
556
			}
576
	 
557
	  
577
			//
558
			//
578
			// Rule 105:  multiplicativeExpCS ::= multiplicativeExpCS / unaryExpCS
559
			// Rule 105:  multiplicativeExpCS ::= multiplicativeExpCS / unaryExpCS
579
			//
560
			//
580
			case 105:
561
			case 105:
581
 
562
  
582
			//
563
			//
583
			// Rule 106:  multiplicativeWithLet ::= multiplicativeExpCS / unaryWithLet
564
			// Rule 106:  multiplicativeWithLet ::= multiplicativeExpCS / unaryWithLet
584
			//
565
			//
585
			case 106: {
566
			case 106: {
586
				
587
				SimpleNameCS simpleNameCS = createSimpleNameCS(
567
				SimpleNameCS simpleNameCS = createSimpleNameCS(
588
							SimpleTypeEnum.STRING_LITERAL,
568
							SimpleTypeEnum.STRING_LITERAL,
589
							OCLStandardLibraryUtil.getOperationName(PredefinedType.DIVIDE)
569
							OCLStandardLibraryUtil.getOperationName(PredefinedType.DIVIDE)
Lines 605-611 Link Here
605
			// Rule 109:  unaryExpCS ::= - unaryExpCS
585
			// Rule 109:  unaryExpCS ::= - unaryExpCS
606
			//
586
			//
607
			case 109: {
587
			case 109: {
608
				
609
				SimpleNameCS simpleNameCS = createSimpleNameCS(
588
				SimpleNameCS simpleNameCS = createSimpleNameCS(
610
							SimpleTypeEnum.STRING_LITERAL,
589
							SimpleTypeEnum.STRING_LITERAL,
611
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
590
							OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
Lines 625-631 Link Here
625
			// Rule 110:  unaryExpCS ::= not unaryExpCS
604
			// Rule 110:  unaryExpCS ::= not unaryExpCS
626
			//
605
			//
627
			case 110: {
606
			case 110: {
628
				
629
				SimpleNameCS simpleNameCS = createSimpleNameCS(
607
				SimpleNameCS simpleNameCS = createSimpleNameCS(
630
							SimpleTypeEnum.STRING_LITERAL,
608
							SimpleTypeEnum.STRING_LITERAL,
631
							getTokenText(dtParser.getToken(1))
609
							getTokenText(dtParser.getToken(1))
Lines 645-651 Link Here
645
			// Rule 112:  dotArrowExpCS ::= dotArrowExpCS callExpCS
623
			// Rule 112:  dotArrowExpCS ::= dotArrowExpCS callExpCS
646
			//
624
			//
647
			case 112: {
625
			case 112: {
648
				
649
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
626
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
650
				result.setSource((OCLExpressionCS)dtParser.getSym(1));
627
				result.setSource((OCLExpressionCS)dtParser.getSym(1));
651
				setOffsets(result, (CSTNode)dtParser.getSym(1), result);
628
				setOffsets(result, (CSTNode)dtParser.getSym(1), result);
Lines 657-663 Link Here
657
			// Rule 113:  dotArrowExpCS ::= dotArrowExpCS messageExpCS
634
			// Rule 113:  dotArrowExpCS ::= dotArrowExpCS messageExpCS
658
			//
635
			//
659
			case 113: {
636
			case 113: {
660
				
661
				MessageExpCS result = (MessageExpCS)dtParser.getSym(2);
637
				MessageExpCS result = (MessageExpCS)dtParser.getSym(2);
662
				result.setTarget((OCLExpressionCS)dtParser.getSym(1));
638
				result.setTarget((OCLExpressionCS)dtParser.getSym(1));
663
				setOffsets(result, (CSTNode)dtParser.getSym(1), (CSTNode)dtParser.getSym(2));
639
				setOffsets(result, (CSTNode)dtParser.getSym(1), (CSTNode)dtParser.getSym(2));
Lines 669-675 Link Here
669
			// Rule 114:  dotArrowExpCS ::= NUMERIC_OPERATION ( argumentsCSopt )
645
			// Rule 114:  dotArrowExpCS ::= NUMERIC_OPERATION ( argumentsCSopt )
670
			//
646
			//
671
			case 114: {
647
			case 114: {
672
				
673
				// NUMERIC_OPERATION -> Integer '.' Identifier
648
				// NUMERIC_OPERATION -> Integer '.' Identifier
674
				String text = getTokenText(dtParser.getToken(1));
649
				String text = getTokenText(dtParser.getToken(1));
675
				int index = text.indexOf('.');
650
				int index = text.indexOf('.');
Lines 715-721 Link Here
715
			// Rule 115:  dotArrowExpCS ::= pathNameCS :: simpleNameCS ( argumentsCSopt )
690
			// Rule 115:  dotArrowExpCS ::= pathNameCS :: simpleNameCS ( argumentsCSopt )
716
			//
691
			//
717
			case 115: {
692
			case 115: {
718
				
719
				OperationCallExpCS result = createOperationCallExpCS(
693
				OperationCallExpCS result = createOperationCallExpCS(
720
						(PathNameCS)dtParser.getSym(1),
694
						(PathNameCS)dtParser.getSym(1),
721
						(SimpleNameCS)dtParser.getSym(3),
695
						(SimpleNameCS)dtParser.getSym(3),
Lines 731-753 Link Here
731
			// Rule 120:  oclExpCS ::= ( oclExpressionCS )
705
			// Rule 120:  oclExpCS ::= ( oclExpressionCS )
732
			//
706
			//
733
			case 120: {
707
			case 120: {
734
				
735
				CSTNode result = (CSTNode)dtParser.getSym(2);
708
				CSTNode result = (CSTNode)dtParser.getSym(2);
736
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
709
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
737
				dtParser.setSym1(result);
710
				dtParser.setSym1(result);
738
	  		  break;
711
	  		  break;
739
			}
712
			}
740
	 
713
	  
741
			//
714
			//
742
			// Rule 121:  variableExpCS ::= simpleNameCS isMarkedPreCS
715
			// Rule 121:  variableExpCS ::= simpleNameCS isMarkedPreCS
743
			//
716
			//
744
			case 121:
717
			case 121:
745
 
718
  
746
			//
719
			//
747
			// Rule 122:  variableExpCS ::= keywordAsName1 isMarkedPreCS
720
			// Rule 122:  variableExpCS ::= keywordAsName1 isMarkedPreCS
748
			//
721
			//
749
			case 122: {
722
			case 122: {
750
				
751
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
723
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
752
				CSTNode result = createVariableExpCS(
724
				CSTNode result = createVariableExpCS(
753
						(SimpleNameCS)dtParser.getSym(1),
725
						(SimpleNameCS)dtParser.getSym(1),
Lines 762-778 Link Here
762
				dtParser.setSym1(result);
734
				dtParser.setSym1(result);
763
	  		  break;
735
	  		  break;
764
			}
736
			}
765
	 
737
	  
766
			//
738
			//
767
			// Rule 123:  variableExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
739
			// Rule 123:  variableExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
768
			//
740
			//
769
			case 123:
741
			case 123:
770
 
742
  
771
			//
743
			//
772
			// Rule 124:  variableExpCS ::= keywordAsName1 [ argumentsCS ] isMarkedPreCS
744
			// Rule 124:  variableExpCS ::= keywordAsName1 [ argumentsCS ] isMarkedPreCS
773
			//
745
			//
774
			case 124: {
746
			case 124: {
775
				
776
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
747
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
777
				CSTNode result = createVariableExpCS(
748
				CSTNode result = createVariableExpCS(
778
						(SimpleNameCS)dtParser.getSym(1),
749
						(SimpleNameCS)dtParser.getSym(1),
Lines 792-798 Link Here
792
			// Rule 126:  simpleNameCS ::= self
763
			// Rule 126:  simpleNameCS ::= self
793
			//
764
			//
794
			case 126: {
765
			case 126: {
795
				
796
				CSTNode result = createSimpleNameCS(
766
				CSTNode result = createSimpleNameCS(
797
						SimpleTypeEnum.SELF_LITERAL,
767
						SimpleTypeEnum.SELF_LITERAL,
798
						getTokenText(dtParser.getToken(1))
768
						getTokenText(dtParser.getToken(1))
Lines 806-812 Link Here
806
			// Rule 127:  simpleNameCS ::= IDENTIFIER
776
			// Rule 127:  simpleNameCS ::= IDENTIFIER
807
			//
777
			//
808
			case 127: {
778
			case 127: {
809
				
810
				CSTNode result = createSimpleNameCS(
779
				CSTNode result = createSimpleNameCS(
811
						SimpleTypeEnum.IDENTIFIER_LITERAL,
780
						SimpleTypeEnum.IDENTIFIER_LITERAL,
812
						getTokenText(dtParser.getToken(1))
781
						getTokenText(dtParser.getToken(1))
Lines 820-826 Link Here
820
			// Rule 128:  primitiveTypeCS ::= Integer
789
			// Rule 128:  primitiveTypeCS ::= Integer
821
			//
790
			//
822
			case 128: {
791
			case 128: {
823
				
824
				CSTNode result = createPrimitiveTypeCS(
792
				CSTNode result = createPrimitiveTypeCS(
825
						SimpleTypeEnum.INTEGER_LITERAL,
793
						SimpleTypeEnum.INTEGER_LITERAL,
826
						getTokenText(dtParser.getToken(1))
794
						getTokenText(dtParser.getToken(1))
Lines 834-840 Link Here
834
			// Rule 129:  primitiveTypeCS ::= UnlimitedNatural
802
			// Rule 129:  primitiveTypeCS ::= UnlimitedNatural
835
			//
803
			//
836
			case 129: {
804
			case 129: {
837
				
838
				CSTNode result = createPrimitiveTypeCS(
805
				CSTNode result = createPrimitiveTypeCS(
839
						SimpleTypeEnum.UNLIMITED_NATURAL_LITERAL,
806
						SimpleTypeEnum.UNLIMITED_NATURAL_LITERAL,
840
						getTokenText(dtParser.getToken(1))
807
						getTokenText(dtParser.getToken(1))
Lines 848-854 Link Here
848
			// Rule 130:  primitiveTypeCS ::= String
815
			// Rule 130:  primitiveTypeCS ::= String
849
			//
816
			//
850
			case 130: {
817
			case 130: {
851
				
852
				CSTNode result = createPrimitiveTypeCS(
818
				CSTNode result = createPrimitiveTypeCS(
853
						SimpleTypeEnum.STRING_LITERAL,
819
						SimpleTypeEnum.STRING_LITERAL,
854
						getTokenText(dtParser.getToken(1))
820
						getTokenText(dtParser.getToken(1))
Lines 862-868 Link Here
862
			// Rule 131:  primitiveTypeCS ::= Real
828
			// Rule 131:  primitiveTypeCS ::= Real
863
			//
829
			//
864
			case 131: {
830
			case 131: {
865
				
866
				CSTNode result = createPrimitiveTypeCS(
831
				CSTNode result = createPrimitiveTypeCS(
867
						SimpleTypeEnum.REAL_LITERAL,
832
						SimpleTypeEnum.REAL_LITERAL,
868
						getTokenText(dtParser.getToken(1))
833
						getTokenText(dtParser.getToken(1))
Lines 876-882 Link Here
876
			// Rule 132:  primitiveTypeCS ::= Boolean
841
			// Rule 132:  primitiveTypeCS ::= Boolean
877
			//
842
			//
878
			case 132: {
843
			case 132: {
879
				
880
				CSTNode result = createPrimitiveTypeCS(
844
				CSTNode result = createPrimitiveTypeCS(
881
						SimpleTypeEnum.BOOLEAN_LITERAL,
845
						SimpleTypeEnum.BOOLEAN_LITERAL,
882
						getTokenText(dtParser.getToken(1))
846
						getTokenText(dtParser.getToken(1))
Lines 890-896 Link Here
890
			// Rule 133:  primitiveTypeCS ::= OclAny
854
			// Rule 133:  primitiveTypeCS ::= OclAny
891
			//
855
			//
892
			case 133: {
856
			case 133: {
893
				
894
				CSTNode result = createPrimitiveTypeCS(
857
				CSTNode result = createPrimitiveTypeCS(
895
						SimpleTypeEnum.OCL_ANY_LITERAL,
858
						SimpleTypeEnum.OCL_ANY_LITERAL,
896
						getTokenText(dtParser.getToken(1))
859
						getTokenText(dtParser.getToken(1))
Lines 904-910 Link Here
904
			// Rule 134:  primitiveTypeCS ::= OclVoid
867
			// Rule 134:  primitiveTypeCS ::= OclVoid
905
			//
868
			//
906
			case 134: {
869
			case 134: {
907
				
908
				CSTNode result = createPrimitiveTypeCS(
870
				CSTNode result = createPrimitiveTypeCS(
909
						SimpleTypeEnum.OCL_VOID_LITERAL,
871
						SimpleTypeEnum.OCL_VOID_LITERAL,
910
						getTokenText(dtParser.getToken(1))
872
						getTokenText(dtParser.getToken(1))
Lines 918-924 Link Here
918
			// Rule 135:  primitiveTypeCS ::= Invalid
880
			// Rule 135:  primitiveTypeCS ::= Invalid
919
			//
881
			//
920
			case 135: {
882
			case 135: {
921
				
922
				CSTNode result = createPrimitiveTypeCS(
883
				CSTNode result = createPrimitiveTypeCS(
923
						SimpleTypeEnum.INVALID_LITERAL,
884
						SimpleTypeEnum.INVALID_LITERAL,
924
						getTokenText(dtParser.getToken(1))
885
						getTokenText(dtParser.getToken(1))
Lines 932-938 Link Here
932
			// Rule 136:  primitiveTypeCS ::= OclMessage
893
			// Rule 136:  primitiveTypeCS ::= OclMessage
933
			//
894
			//
934
			case 136: {
895
			case 136: {
935
				
936
				CSTNode result = createPrimitiveTypeCS(
896
				CSTNode result = createPrimitiveTypeCS(
937
						SimpleTypeEnum.OCL_MESSAGE_LITERAL,
897
						SimpleTypeEnum.OCL_MESSAGE_LITERAL,
938
						getTokenText(dtParser.getToken(1))
898
						getTokenText(dtParser.getToken(1))
Lines 946-952 Link Here
946
			// Rule 137:  pathNameCS ::= IDENTIFIER
906
			// Rule 137:  pathNameCS ::= IDENTIFIER
947
			//
907
			//
948
			case 137: {
908
			case 137: {
949
				
950
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
909
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
951
				setOffsets(result, getIToken(dtParser.getToken(1)));
910
				setOffsets(result, getIToken(dtParser.getToken(1)));
952
				dtParser.setSym1(result);
911
				dtParser.setSym1(result);
Lines 957-963 Link Here
957
			// Rule 138:  pathNameCS ::= pathNameCS :: simpleNameCS
916
			// Rule 138:  pathNameCS ::= pathNameCS :: simpleNameCS
958
			//
917
			//
959
			case 138: {
918
			case 138: {
960
				
961
				PathNameCS result = (PathNameCS)dtParser.getSym(1);
919
				PathNameCS result = (PathNameCS)dtParser.getSym(1);
962
				result = extendPathNameCS(result, getTokenText(dtParser.getToken(3)));
920
				result = extendPathNameCS(result, getTokenText(dtParser.getToken(3)));
963
				setOffsets(result, result, (CSTNode)dtParser.getSym(3));
921
				setOffsets(result, result, (CSTNode)dtParser.getSym(3));
Lines 969-990 Link Here
969
			// Rule 139:  pathNameCSOpt ::= $Empty
927
			// Rule 139:  pathNameCSOpt ::= $Empty
970
			//
928
			//
971
			case 139: {
929
			case 139: {
972
				
973
				CSTNode result = createPathNameCS();
930
				CSTNode result = createPathNameCS();
974
				dtParser.setSym1(result);
931
				dtParser.setSym1(result);
975
	  		  break;
932
	  		  break;
976
			}
933
			}
977
	 
934
	  
978
			//
935
			//
979
			// Rule 147:  enumLiteralExpCS ::= pathNameCS :: keywordAsName
936
			// Rule 147:  enumLiteralExpCS ::= pathNameCS :: keywordAsName
980
			//
937
			//
981
			case 147:
938
			case 147:
982
 
939
  
983
			//
940
			//
984
			// Rule 148:  enumLiteralExpCS ::= pathNameCS :: simpleNameCS
941
			// Rule 148:  enumLiteralExpCS ::= pathNameCS :: simpleNameCS
985
			//
942
			//
986
			case 148: {
943
			case 148: {
987
				
988
				CSTNode result = createEnumLiteralExpCS(
944
				CSTNode result = createEnumLiteralExpCS(
989
						(PathNameCS)dtParser.getSym(1),
945
						(PathNameCS)dtParser.getSym(1),
990
						(SimpleNameCS)dtParser.getSym(3)
946
						(SimpleNameCS)dtParser.getSym(3)
Lines 998-1004 Link Here
998
			// Rule 149:  collectionLiteralExpCS ::= collectionTypeIdentifierCS { collectionLiteralPartsCSopt }
954
			// Rule 149:  collectionLiteralExpCS ::= collectionTypeIdentifierCS { collectionLiteralPartsCSopt }
999
			//
955
			//
1000
			case 149: {
956
			case 149: {
1001
				
1002
				Object[] objs = (Object[])dtParser.getSym(1);
957
				Object[] objs = (Object[])dtParser.getSym(1);
1003
				CSTNode result = createCollectionLiteralExpCS(
958
				CSTNode result = createCollectionLiteralExpCS(
1004
						(CollectionTypeIdentifierEnum)objs[1],
959
						(CollectionTypeIdentifierEnum)objs[1],
Lines 1013-1019 Link Here
1013
			// Rule 150:  collectionTypeIdentifierCS ::= Set
968
			// Rule 150:  collectionTypeIdentifierCS ::= Set
1014
			//
969
			//
1015
			case 150: {
970
			case 150: {
1016
				
1017
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SET_LITERAL});
971
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SET_LITERAL});
1018
	  		  break;
972
	  		  break;
1019
			}
973
			}
Lines 1022-1028 Link Here
1022
			// Rule 151:  collectionTypeIdentifierCS ::= Bag
976
			// Rule 151:  collectionTypeIdentifierCS ::= Bag
1023
			//
977
			//
1024
			case 151: {
978
			case 151: {
1025
				
1026
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.BAG_LITERAL});
979
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.BAG_LITERAL});
1027
	  		  break;
980
	  		  break;
1028
			}
981
			}
Lines 1031-1037 Link Here
1031
			// Rule 152:  collectionTypeIdentifierCS ::= Sequence
984
			// Rule 152:  collectionTypeIdentifierCS ::= Sequence
1032
			//
985
			//
1033
			case 152: {
986
			case 152: {
1034
				
1035
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SEQUENCE_LITERAL});
987
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.SEQUENCE_LITERAL});
1036
	  		  break;
988
	  		  break;
1037
			}
989
			}
Lines 1040-1046 Link Here
1040
			// Rule 153:  collectionTypeIdentifierCS ::= Collection
992
			// Rule 153:  collectionTypeIdentifierCS ::= Collection
1041
			//
993
			//
1042
			case 153: {
994
			case 153: {
1043
				
1044
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.COLLECTION_LITERAL});
995
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.COLLECTION_LITERAL});
1045
	  		  break;
996
	  		  break;
1046
			}
997
			}
Lines 1049-1071 Link Here
1049
			// Rule 154:  collectionTypeIdentifierCS ::= OrderedSet
1000
			// Rule 154:  collectionTypeIdentifierCS ::= OrderedSet
1050
			//
1001
			//
1051
			case 154: {
1002
			case 154: {
1052
				
1053
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.ORDERED_SET_LITERAL});
1003
				dtParser.setSym1(new Object[]{getIToken(dtParser.getToken(1)), CollectionTypeIdentifierEnum.ORDERED_SET_LITERAL});
1054
	  		  break;
1004
	  		  break;
1055
			}
1005
			}
1056
	 
1006
	  
1057
			//
1007
			//
1058
			// Rule 155:  collectionLiteralPartsCSopt ::= $Empty
1008
			// Rule 155:  collectionLiteralPartsCSopt ::= $Empty
1059
			//
1009
			//
1060
			case 155:
1010
			case 155:
1061
				dtParser.setSym1(new BasicEList());
1011
				dtParser.setSym1(new BasicEList());
1062
				break;
1012
				break;
1063
 
1013
  
1064
			//
1014
			//
1065
			// Rule 157:  collectionLiteralPartsCS ::= collectionLiteralPartCS
1015
			// Rule 157:  collectionLiteralPartsCS ::= collectionLiteralPartCS
1066
			//
1016
			//
1067
			case 157: {
1017
			case 157: {
1068
				
1069
				EList result = new BasicEList();
1018
				EList result = new BasicEList();
1070
				result.add(dtParser.getSym(1));
1019
				result.add(dtParser.getSym(1));
1071
				dtParser.setSym1(result);
1020
				dtParser.setSym1(result);
Lines 1076-1082 Link Here
1076
			// Rule 158:  collectionLiteralPartsCS ::= collectionLiteralPartsCS , collectionLiteralPartCS
1025
			// Rule 158:  collectionLiteralPartsCS ::= collectionLiteralPartsCS , collectionLiteralPartCS
1077
			//
1026
			//
1078
			case 158: {
1027
			case 158: {
1079
				
1080
				EList result = (EList)dtParser.getSym(1);
1028
				EList result = (EList)dtParser.getSym(1);
1081
				result.add(dtParser.getSym(3));
1029
				result.add(dtParser.getSym(3));
1082
				dtParser.setSym1(result);
1030
				dtParser.setSym1(result);
Lines 1087-1093 Link Here
1087
			// Rule 160:  collectionLiteralPartCS ::= oclExpressionCS
1035
			// Rule 160:  collectionLiteralPartCS ::= oclExpressionCS
1088
			//
1036
			//
1089
			case 160: {
1037
			case 160: {
1090
				
1091
				CSTNode result = createCollectionLiteralPartCS(
1038
				CSTNode result = createCollectionLiteralPartCS(
1092
						(OCLExpressionCS)dtParser.getSym(1)
1039
						(OCLExpressionCS)dtParser.getSym(1)
1093
					);
1040
					);
Lines 1100-1106 Link Here
1100
			// Rule 161:  collectionRangeCS ::= - INTEGER_RANGE_START oclExpressionCS
1047
			// Rule 161:  collectionRangeCS ::= - INTEGER_RANGE_START oclExpressionCS
1101
			//
1048
			//
1102
			case 161: {
1049
			case 161: {
1103
				
1104
				OCLExpressionCS rangeStart = createRangeStart(
1050
				OCLExpressionCS rangeStart = createRangeStart(
1105
						getTokenText(dtParser.getToken(2)), true);
1051
						getTokenText(dtParser.getToken(2)), true);
1106
				CSTNode result = createCollectionRangeCS(
1052
				CSTNode result = createCollectionRangeCS(
Lines 1116-1122 Link Here
1116
			// Rule 162:  collectionRangeCS ::= INTEGER_RANGE_START oclExpressionCS
1062
			// Rule 162:  collectionRangeCS ::= INTEGER_RANGE_START oclExpressionCS
1117
			//
1063
			//
1118
			case 162: {
1064
			case 162: {
1119
				
1120
				OCLExpressionCS rangeStart = createRangeStart(
1065
				OCLExpressionCS rangeStart = createRangeStart(
1121
						getTokenText(dtParser.getToken(1)), false);
1066
						getTokenText(dtParser.getToken(1)), false);
1122
				CSTNode result = createCollectionRangeCS(
1067
				CSTNode result = createCollectionRangeCS(
Lines 1132-1138 Link Here
1132
			// Rule 163:  collectionRangeCS ::= oclExpressionCS .. oclExpressionCS
1077
			// Rule 163:  collectionRangeCS ::= oclExpressionCS .. oclExpressionCS
1133
			//
1078
			//
1134
			case 163: {
1079
			case 163: {
1135
				
1136
				CSTNode result = createCollectionRangeCS(
1080
				CSTNode result = createCollectionRangeCS(
1137
						(OCLExpressionCS)dtParser.getSym(1),
1081
						(OCLExpressionCS)dtParser.getSym(1),
1138
						(OCLExpressionCS)dtParser.getSym(3)
1082
						(OCLExpressionCS)dtParser.getSym(3)
Lines 1146-1152 Link Here
1146
			// Rule 169:  tupleLiteralExpCS ::= Tuple { variableListCS2 }
1090
			// Rule 169:  tupleLiteralExpCS ::= Tuple { variableListCS2 }
1147
			//
1091
			//
1148
			case 169: {
1092
			case 169: {
1149
				
1150
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
1093
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
1151
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1094
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1152
				dtParser.setSym1(result);
1095
				dtParser.setSym1(result);
Lines 1157-1163 Link Here
1157
			// Rule 170:  integerLiteralExpCS ::= INTEGER_LITERAL
1100
			// Rule 170:  integerLiteralExpCS ::= INTEGER_LITERAL
1158
			//
1101
			//
1159
			case 170: {
1102
			case 170: {
1160
				
1161
				CSTNode result = createIntegerLiteralExpCS(getTokenText(dtParser.getToken(1)));
1103
				CSTNode result = createIntegerLiteralExpCS(getTokenText(dtParser.getToken(1)));
1162
				setOffsets(result, getIToken(dtParser.getToken(1)));
1104
				setOffsets(result, getIToken(dtParser.getToken(1)));
1163
				dtParser.setSym1(result);
1105
				dtParser.setSym1(result);
Lines 1168-1174 Link Here
1168
			// Rule 171:  unlimitedNaturalLiteralExpCS ::= *
1110
			// Rule 171:  unlimitedNaturalLiteralExpCS ::= *
1169
			//
1111
			//
1170
			case 171: {
1112
			case 171: {
1171
				
1172
				CSTNode result = createUnlimitedNaturalLiteralExpCS(getTokenText(dtParser.getToken(1)));
1113
				CSTNode result = createUnlimitedNaturalLiteralExpCS(getTokenText(dtParser.getToken(1)));
1173
				setOffsets(result, getIToken(dtParser.getToken(1)));
1114
				setOffsets(result, getIToken(dtParser.getToken(1)));
1174
				dtParser.setSym1(result);
1115
				dtParser.setSym1(result);
Lines 1179-1185 Link Here
1179
			// Rule 172:  realLiteralExpCS ::= REAL_LITERAL
1120
			// Rule 172:  realLiteralExpCS ::= REAL_LITERAL
1180
			//
1121
			//
1181
			case 172: {
1122
			case 172: {
1182
				
1183
				CSTNode result = createRealLiteralExpCS(getTokenText(dtParser.getToken(1)));
1123
				CSTNode result = createRealLiteralExpCS(getTokenText(dtParser.getToken(1)));
1184
				setOffsets(result, getIToken(dtParser.getToken(1)));
1124
				setOffsets(result, getIToken(dtParser.getToken(1)));
1185
				dtParser.setSym1(result);
1125
				dtParser.setSym1(result);
Lines 1190-1196 Link Here
1190
			// Rule 173:  stringLiteralExpCS ::= STRING_LITERAL
1130
			// Rule 173:  stringLiteralExpCS ::= STRING_LITERAL
1191
			//
1131
			//
1192
			case 173: {
1132
			case 173: {
1193
				
1194
				IToken literalToken = getIToken(dtParser.getToken(1));
1133
				IToken literalToken = getIToken(dtParser.getToken(1));
1195
				StringLiteralExpCS result = createStringLiteralExpCS(literalToken.toString());
1134
				StringLiteralExpCS result = createStringLiteralExpCS(literalToken.toString());
1196
				result.setUnescapedStringSymbol(unescape(literalToken));
1135
				result.setUnescapedStringSymbol(unescape(literalToken));
Lines 1203-1209 Link Here
1203
			// Rule 174:  booleanLiteralExpCS ::= true
1142
			// Rule 174:  booleanLiteralExpCS ::= true
1204
			//
1143
			//
1205
			case 174: {
1144
			case 174: {
1206
				
1207
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1145
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1208
				setOffsets(result, getIToken(dtParser.getToken(1)));
1146
				setOffsets(result, getIToken(dtParser.getToken(1)));
1209
				dtParser.setSym1(result);
1147
				dtParser.setSym1(result);
Lines 1214-1220 Link Here
1214
			// Rule 175:  booleanLiteralExpCS ::= false
1152
			// Rule 175:  booleanLiteralExpCS ::= false
1215
			//
1153
			//
1216
			case 175: {
1154
			case 175: {
1217
				
1218
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1155
				CSTNode result = createBooleanLiteralExpCS(getTokenText(dtParser.getToken(1)));
1219
				setOffsets(result, getIToken(dtParser.getToken(1)));
1156
				setOffsets(result, getIToken(dtParser.getToken(1)));
1220
				dtParser.setSym1(result);
1157
				dtParser.setSym1(result);
Lines 1225-1231 Link Here
1225
			// Rule 176:  nullLiteralExpCS ::= null
1162
			// Rule 176:  nullLiteralExpCS ::= null
1226
			//
1163
			//
1227
			case 176: {
1164
			case 176: {
1228
				
1229
				CSTNode result = createNullLiteralExpCS(getTokenText(dtParser.getToken(1)));
1165
				CSTNode result = createNullLiteralExpCS(getTokenText(dtParser.getToken(1)));
1230
				setOffsets(result, getIToken(dtParser.getToken(1)));
1166
				setOffsets(result, getIToken(dtParser.getToken(1)));
1231
				dtParser.setSym1(result);
1167
				dtParser.setSym1(result);
Lines 1236-1274 Link Here
1236
			// Rule 177:  invalidLiteralExpCS ::= OclInvalid
1172
			// Rule 177:  invalidLiteralExpCS ::= OclInvalid
1237
			//
1173
			//
1238
			case 177: {
1174
			case 177: {
1239
				
1240
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
1175
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
1241
				setOffsets(result, getIToken(dtParser.getToken(1)));
1176
				setOffsets(result, getIToken(dtParser.getToken(1)));
1242
				dtParser.setSym1(result);
1177
				dtParser.setSym1(result);
1243
	  		  break;
1178
	  		  break;
1244
			}
1179
			}
1245
	 
1180
	  
1246
			//
1181
			//
1247
			// Rule 178:  callExpCS ::= -> featureCallExpCS
1182
			// Rule 178:  callExpCS ::= -> featureCallExpCS
1248
			//
1183
			//
1249
			case 178:
1184
			case 178:
1250
 
1185
  
1251
			//
1186
			//
1252
			// Rule 179:  callExpCS ::= -> loopExpCS
1187
			// Rule 179:  callExpCS ::= -> loopExpCS
1253
			//
1188
			//
1254
			case 179: {
1189
			case 179: {
1255
				
1256
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1190
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1257
				result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
1191
				result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
1258
				dtParser.setSym1(result);
1192
				dtParser.setSym1(result);
1259
	  		  break;
1193
	  		  break;
1260
			}
1194
			}
1261
	 
1195
	  
1262
			//
1196
			//
1263
			// Rule 180:  callExpCS ::= . keywordOperationCallExpCS
1197
			// Rule 180:  callExpCS ::= . keywordOperationCallExpCS
1264
			//
1198
			//
1265
			case 180:
1199
			case 180:
1266
 
1200
  
1267
			//
1201
			//
1268
			// Rule 181:  callExpCS ::= . featureCallExpCS
1202
			// Rule 181:  callExpCS ::= . featureCallExpCS
1269
			//
1203
			//
1270
			case 181: {
1204
			case 181: {
1271
				
1272
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1205
				CallExpCS result = (CallExpCS)dtParser.getSym(2);
1273
				result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
1206
				result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
1274
				dtParser.setSym1(result);
1207
				dtParser.setSym1(result);
Lines 1279-1285 Link Here
1279
			// Rule 184:  iteratorExpCS ::= iteratorName ( oclExpressionCS )
1212
			// Rule 184:  iteratorExpCS ::= iteratorName ( oclExpressionCS )
1280
			//
1213
			//
1281
			case 184: {
1214
			case 184: {
1282
				
1283
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1215
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1284
				CSTNode result = createIteratorExpCS(
1216
				CSTNode result = createIteratorExpCS(
1285
						simpleNameCS,
1217
						simpleNameCS,
Lines 1296-1302 Link Here
1296
			// Rule 185:  iteratorExpCS ::= iteratorName ( variableCS | oclExpressionCS )
1228
			// Rule 185:  iteratorExpCS ::= iteratorName ( variableCS | oclExpressionCS )
1297
			//
1229
			//
1298
			case 185: {
1230
			case 185: {
1299
				
1300
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1231
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1301
				CSTNode result = createIteratorExpCS(
1232
				CSTNode result = createIteratorExpCS(
1302
						simpleNameCS,
1233
						simpleNameCS,
Lines 1313-1319 Link Here
1313
			// Rule 186:  iteratorExpCS ::= iteratorName ( variableCS , variableCS | oclExpressionCS )
1244
			// Rule 186:  iteratorExpCS ::= iteratorName ( variableCS , variableCS | oclExpressionCS )
1314
			//
1245
			//
1315
			case 186: {
1246
			case 186: {
1316
				
1317
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1247
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1318
				CSTNode result = createIteratorExpCS(
1248
				CSTNode result = createIteratorExpCS(
1319
						simpleNameCS,
1249
						simpleNameCS,
Lines 1330-1336 Link Here
1330
			// Rule 187:  iterateExpCS ::= iterateName ( variableCS | oclExpressionCS )
1260
			// Rule 187:  iterateExpCS ::= iterateName ( variableCS | oclExpressionCS )
1331
			//
1261
			//
1332
			case 187: {
1262
			case 187: {
1333
				
1334
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1263
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1335
				CSTNode result = createIterateExpCS(
1264
				CSTNode result = createIterateExpCS(
1336
						simpleNameCS,
1265
						simpleNameCS,
Lines 1347-1353 Link Here
1347
			// Rule 188:  iterateExpCS ::= iterateName ( variableCS ; variableCS | oclExpressionCS )
1276
			// Rule 188:  iterateExpCS ::= iterateName ( variableCS ; variableCS | oclExpressionCS )
1348
			//
1277
			//
1349
			case 188: {
1278
			case 188: {
1350
				
1351
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1279
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1352
				CSTNode result = createIterateExpCS(
1280
				CSTNode result = createIterateExpCS(
1353
						simpleNameCS,
1281
						simpleNameCS,
Lines 1364-1370 Link Here
1364
			// Rule 189:  variableCS ::= IDENTIFIER
1292
			// Rule 189:  variableCS ::= IDENTIFIER
1365
			//
1293
			//
1366
			case 189: {
1294
			case 189: {
1367
				
1368
				CSTNode result = createVariableCS(
1295
				CSTNode result = createVariableCS(
1369
						getTokenText(dtParser.getToken(1)),
1296
						getTokenText(dtParser.getToken(1)),
1370
						null,
1297
						null,
Lines 1379-1385 Link Here
1379
			// Rule 190:  typedVariableCS ::= IDENTIFIER : typeCS
1306
			// Rule 190:  typedVariableCS ::= IDENTIFIER : typeCS
1380
			//
1307
			//
1381
			case 190: {
1308
			case 190: {
1382
				
1383
				CSTNode result = createVariableCS(
1309
				CSTNode result = createVariableCS(
1384
						getTokenText(dtParser.getToken(1)),
1310
						getTokenText(dtParser.getToken(1)),
1385
						(TypeCS)dtParser.getSym(3),
1311
						(TypeCS)dtParser.getSym(3),
Lines 1394-1400 Link Here
1394
			// Rule 192:  variableCS ::= IDENTIFIER : typeCS = oclExpressionCS
1320
			// Rule 192:  variableCS ::= IDENTIFIER : typeCS = oclExpressionCS
1395
			//
1321
			//
1396
			case 192: {
1322
			case 192: {
1397
				
1398
				CSTNode result = createVariableCS(
1323
				CSTNode result = createVariableCS(
1399
						getTokenText(dtParser.getToken(1)),
1324
						getTokenText(dtParser.getToken(1)),
1400
						(TypeCS)dtParser.getSym(3),
1325
						(TypeCS)dtParser.getSym(3),
Lines 1409-1415 Link Here
1409
			// Rule 193:  variableCS2 ::= IDENTIFIER = oclExpressionCS
1334
			// Rule 193:  variableCS2 ::= IDENTIFIER = oclExpressionCS
1410
			//
1335
			//
1411
			case 193: {
1336
			case 193: {
1412
				
1413
				CSTNode result = createVariableCS(
1337
				CSTNode result = createVariableCS(
1414
						getTokenText(dtParser.getToken(1)),
1338
						getTokenText(dtParser.getToken(1)),
1415
						null,
1339
						null,
Lines 1431-1437 Link Here
1431
			// Rule 200:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS )
1355
			// Rule 200:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS )
1432
			//
1356
			//
1433
			case 200: {
1357
			case 200: {
1434
				
1435
				Object[] objs = (Object[])dtParser.getSym(1);
1358
				Object[] objs = (Object[])dtParser.getSym(1);
1436
				CSTNode result = createCollectionTypeCS(
1359
				CSTNode result = createCollectionTypeCS(
1437
						(CollectionTypeIdentifierEnum)objs[1],
1360
						(CollectionTypeIdentifierEnum)objs[1],
Lines 1446-1470 Link Here
1446
			// Rule 201:  tupleTypeCS ::= Tuple ( variableListCSopt )
1369
			// Rule 201:  tupleTypeCS ::= Tuple ( variableListCSopt )
1447
			//
1370
			//
1448
			case 201: {
1371
			case 201: {
1449
				
1450
				CSTNode result = createTupleTypeCS((EList)dtParser.getSym(3));
1372
				CSTNode result = createTupleTypeCS((EList)dtParser.getSym(3));
1451
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1373
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
1452
				dtParser.setSym1(result);
1374
				dtParser.setSym1(result);
1453
	  		  break;
1375
	  		  break;
1454
			}
1376
			}
1455
	 
1377
	  
1456
			//
1378
			//
1457
			// Rule 202:  variableListCSopt ::= $Empty
1379
			// Rule 202:  variableListCSopt ::= $Empty
1458
			//
1380
			//
1459
			case 202:
1381
			case 202:
1460
				dtParser.setSym1(new BasicEList());
1382
				dtParser.setSym1(new BasicEList());
1461
				break;
1383
				break;
1462
 
1384
  
1463
			//
1385
			//
1464
			// Rule 204:  variableListCS ::= variableCS
1386
			// Rule 204:  variableListCS ::= variableCS
1465
			//
1387
			//
1466
			case 204: {
1388
			case 204: {
1467
				
1468
				EList result = new BasicEList();
1389
				EList result = new BasicEList();
1469
				result.add(dtParser.getSym(1));
1390
				result.add(dtParser.getSym(1));
1470
				dtParser.setSym1(result);
1391
				dtParser.setSym1(result);
Lines 1475-1534 Link Here
1475
			// Rule 205:  variableListCS ::= variableListCS , variableCS
1396
			// Rule 205:  variableListCS ::= variableListCS , variableCS
1476
			//
1397
			//
1477
			case 205: {
1398
			case 205: {
1478
				
1479
				EList result = (EList)dtParser.getSym(1);
1399
				EList result = (EList)dtParser.getSym(1);
1480
				result.add(dtParser.getSym(3));
1400
				result.add(dtParser.getSym(3));
1481
				dtParser.setSym1(result);
1401
				dtParser.setSym1(result);
1482
	  		  break;
1402
	  		  break;
1483
			}
1403
			}
1484
	 
1404
	  
1485
			//
1405
			//
1486
			// Rule 206:  variableListCS2 ::= variableCS2
1406
			// Rule 206:  variableListCS2 ::= variableCS2
1487
			//
1407
			//
1488
			case 206:
1408
			case 206:
1489
 
1409
  
1490
			//
1410
			//
1491
			// Rule 207:  variableListCS2 ::= variableCS
1411
			// Rule 207:  variableListCS2 ::= variableCS
1492
			//
1412
			//
1493
			case 207: {
1413
			case 207: {
1494
				
1495
				EList result = new BasicEList();
1414
				EList result = new BasicEList();
1496
				result.add(dtParser.getSym(1));
1415
				result.add(dtParser.getSym(1));
1497
				dtParser.setSym1(result);
1416
				dtParser.setSym1(result);
1498
	  		  break;
1417
	  		  break;
1499
			}
1418
			}
1500
	 
1419
	  
1501
			//
1420
			//
1502
			// Rule 208:  variableListCS2 ::= variableListCS2 , variableCS2
1421
			// Rule 208:  variableListCS2 ::= variableListCS2 , variableCS2
1503
			//
1422
			//
1504
			case 208:
1423
			case 208:
1505
 
1424
  
1506
			//
1425
			//
1507
			// Rule 209:  variableListCS2 ::= variableListCS2 , variableCS
1426
			// Rule 209:  variableListCS2 ::= variableListCS2 , variableCS
1508
			//
1427
			//
1509
			case 209: {
1428
			case 209: {
1510
				
1511
				EList result = (EList)dtParser.getSym(1);
1429
				EList result = (EList)dtParser.getSym(1);
1512
				result.add(dtParser.getSym(3));
1430
				result.add(dtParser.getSym(3));
1513
				dtParser.setSym1(result);
1431
				dtParser.setSym1(result);
1514
	  		  break;
1432
	  		  break;
1515
			}
1433
			}
1516
	 
1434
	  
1517
			//
1435
			//
1518
			// Rule 212:  featureCallExpCS ::= unaryName isMarkedPreCS ( argumentsCSopt )
1436
			// Rule 212:  featureCallExpCS ::= unaryName isMarkedPreCS ( argumentsCSopt )
1519
			//
1437
			//
1520
			case 212:
1438
			case 212:
1521
 
1439
   
1522
			//
1440
			//
1523
			// Rule 213:  operationCallExpCS ::= binaryName isMarkedPreCS ( argumentsCSopt )
1441
			// Rule 213:  operationCallExpCS ::= binaryName isMarkedPreCS ( argumentsCSopt )
1524
			//
1442
			//
1525
			case 213:
1443
			case 213:
1526
 
1444
  
1527
			//
1445
			//
1528
			// Rule 214:  keywordOperationCallExpCS ::= keywordAsName isMarkedPreCS ( argumentsCSopt )
1446
			// Rule 214:  keywordOperationCallExpCS ::= keywordAsName isMarkedPreCS ( argumentsCSopt )
1529
			//
1447
			//
1530
			case 214: {
1448
			case 214: {
1531
				
1532
				CSTNode result = createOperationCallExpCS(
1449
				CSTNode result = createOperationCallExpCS(
1533
						(SimpleNameCS)dtParser.getSym(1),
1450
						(SimpleNameCS)dtParser.getSym(1),
1534
						(IsMarkedPreCS)dtParser.getSym(2),
1451
						(IsMarkedPreCS)dtParser.getSym(2),
Lines 1543-1549 Link Here
1543
			// Rule 215:  stateExpCS ::= pathNameCSOpt
1460
			// Rule 215:  stateExpCS ::= pathNameCSOpt
1544
			//
1461
			//
1545
			case 215: {
1462
			case 215: {
1546
				
1547
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
1463
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
1548
				StateExpCS result = createStateExpCS(pathNameCS);
1464
				StateExpCS result = createStateExpCS(pathNameCS);
1549
				setOffsets(result, pathNameCS);
1465
				setOffsets(result, pathNameCS);
Lines 1555-1561 Link Here
1555
			// Rule 216:  operationCallExpCS ::= oclIsInStateName isMarkedPreCS ( stateExpCS )
1471
			// Rule 216:  operationCallExpCS ::= oclIsInStateName isMarkedPreCS ( stateExpCS )
1556
			//
1472
			//
1557
			case 216: {
1473
			case 216: {
1558
				
1559
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1474
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
1560
				CSTNode result = createOperationCallExpCS(
1475
				CSTNode result = createOperationCallExpCS(
1561
						simpleNameCS,
1476
						simpleNameCS,
Lines 1566-1582 Link Here
1566
				dtParser.setSym1(result);
1481
				dtParser.setSym1(result);
1567
	  		  break;
1482
	  		  break;
1568
			}
1483
			}
1569
	 
1484
	  
1570
			//
1485
			//
1571
			// Rule 217:  attrOrNavCallExpCS ::= simpleNameCS isMarkedPreCS
1486
			// Rule 217:  attrOrNavCallExpCS ::= simpleNameCS isMarkedPreCS
1572
			//
1487
			//
1573
			case 217:
1488
			case 217:
1574
 
1489
  
1575
			//
1490
			//
1576
			// Rule 218:  attrOrNavCallExpCS ::= keywordAsName isMarkedPreCS
1491
			// Rule 218:  attrOrNavCallExpCS ::= keywordAsName isMarkedPreCS
1577
			//
1492
			//
1578
			case 218: {
1493
			case 218: {
1579
				
1580
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
1494
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(2);
1581
				CSTNode result = createFeatureCallExpCS(
1495
				CSTNode result = createFeatureCallExpCS(
1582
						(SimpleNameCS)dtParser.getSym(1),
1496
						(SimpleNameCS)dtParser.getSym(1),
Lines 1596-1602 Link Here
1596
			// Rule 219:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
1510
			// Rule 219:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ] isMarkedPreCS
1597
			//
1511
			//
1598
			case 219: {
1512
			case 219: {
1599
				
1600
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
1513
				IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)dtParser.getSym(5);
1601
				CSTNode result = createFeatureCallExpCS(
1514
				CSTNode result = createFeatureCallExpCS(
1602
						(SimpleNameCS)dtParser.getSym(1),
1515
						(SimpleNameCS)dtParser.getSym(1),
Lines 1616-1622 Link Here
1616
			// Rule 220:  isMarkedPreCS ::= $Empty
1529
			// Rule 220:  isMarkedPreCS ::= $Empty
1617
			//
1530
			//
1618
			case 220: {
1531
			case 220: {
1619
				
1620
				CSTNode result = createIsMarkedPreCS(false);
1532
				CSTNode result = createIsMarkedPreCS(false);
1621
				setOffsets(result, getIToken(dtParser.getToken(1)));
1533
				setOffsets(result, getIToken(dtParser.getToken(1)));
1622
				dtParser.setSym1(result);
1534
				dtParser.setSym1(result);
Lines 1627-1651 Link Here
1627
			// Rule 221:  isMarkedPreCS ::= @pre
1539
			// Rule 221:  isMarkedPreCS ::= @pre
1628
			//
1540
			//
1629
			case 221: {
1541
			case 221: {
1630
				
1631
				CSTNode result = createIsMarkedPreCS(true);
1542
				CSTNode result = createIsMarkedPreCS(true);
1632
				setOffsets(result, getIToken(dtParser.getToken(1)));
1543
				setOffsets(result, getIToken(dtParser.getToken(1)));
1633
				dtParser.setSym1(result);
1544
				dtParser.setSym1(result);
1634
	  		  break;
1545
	  		  break;
1635
			}
1546
			}
1636
	 
1547
	  
1637
			//
1548
			//
1638
			// Rule 222:  argumentsCSopt ::= $Empty
1549
			// Rule 222:  argumentsCSopt ::= $Empty
1639
			//
1550
			//
1640
			case 222:
1551
			case 222:
1641
				dtParser.setSym1(new BasicEList());
1552
				dtParser.setSym1(new BasicEList());
1642
				break;
1553
				break;
1643
 
1554
  
1644
			//
1555
			//
1645
			// Rule 224:  argumentsCS ::= oclExpressionCS
1556
			// Rule 224:  argumentsCS ::= oclExpressionCS
1646
			//
1557
			//
1647
			case 224: {
1558
			case 224: {
1648
				
1649
				EList result = new BasicEList();
1559
				EList result = new BasicEList();
1650
				result.add(dtParser.getSym(1));
1560
				result.add(dtParser.getSym(1));
1651
				dtParser.setSym1(result);
1561
				dtParser.setSym1(result);
Lines 1656-1662 Link Here
1656
			// Rule 225:  argumentsCS ::= argumentsCS , oclExpressionCS
1566
			// Rule 225:  argumentsCS ::= argumentsCS , oclExpressionCS
1657
			//
1567
			//
1658
			case 225: {
1568
			case 225: {
1659
				
1660
				EList result = (EList)dtParser.getSym(1);
1569
				EList result = (EList)dtParser.getSym(1);
1661
				result.add(dtParser.getSym(3));
1570
				result.add(dtParser.getSym(3));
1662
				dtParser.setSym1(result);
1571
				dtParser.setSym1(result);
Lines 1667-1673 Link Here
1667
			// Rule 226:  letExpCS ::= let variableListCS in oclExpressionCS
1576
			// Rule 226:  letExpCS ::= let variableListCS in oclExpressionCS
1668
			//
1577
			//
1669
			case 226: {
1578
			case 226: {
1670
				
1671
				CSTNode result = createLetExpCS(
1579
				CSTNode result = createLetExpCS(
1672
						(EList)dtParser.getSym(2),
1580
						(EList)dtParser.getSym(2),
1673
						(OCLExpressionCS)dtParser.getSym(4)
1581
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1681-1687 Link Here
1681
			// Rule 227:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS endif
1589
			// Rule 227:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS endif
1682
			//
1590
			//
1683
			case 227: {
1591
			case 227: {
1684
				
1685
				CSTNode result = createIfExpCS(
1592
				CSTNode result = createIfExpCS(
1686
						(OCLExpressionCS)dtParser.getSym(2),
1593
						(OCLExpressionCS)dtParser.getSym(2),
1687
						(OCLExpressionCS)dtParser.getSym(4),
1594
						(OCLExpressionCS)dtParser.getSym(4),
Lines 1691-1707 Link Here
1691
				dtParser.setSym1(result);
1598
				dtParser.setSym1(result);
1692
	  		  break;
1599
	  		  break;
1693
			}
1600
			}
1694
	 
1601
	  
1695
			//
1602
			//
1696
			// Rule 228:  messageExpCS ::= ^ simpleNameCS ( oclMessageArgumentsCSopt )
1603
			// Rule 228:  messageExpCS ::= ^ simpleNameCS ( oclMessageArgumentsCSopt )
1697
			//
1604
			//
1698
			case 228:
1605
			case 228:
1699
 
1606
  
1700
			//
1607
			//
1701
			// Rule 229:  messageExpCS ::= ^^ simpleNameCS ( oclMessageArgumentsCSopt )
1608
			// Rule 229:  messageExpCS ::= ^^ simpleNameCS ( oclMessageArgumentsCSopt )
1702
			//
1609
			//
1703
			case 229: {
1610
			case 229: {
1704
				
1705
				CSTNode result = createMessageExpCS(
1611
				CSTNode result = createMessageExpCS(
1706
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
1612
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
1707
						(SimpleNameCS)dtParser.getSym(2),
1613
						(SimpleNameCS)dtParser.getSym(2),
Lines 1711-1729 Link Here
1711
				dtParser.setSym1(result);
1617
				dtParser.setSym1(result);
1712
	  		  break;
1618
	  		  break;
1713
			}
1619
			}
1714
	 
1620
	  
1715
			//
1621
			//
1716
			// Rule 230:  oclMessageArgumentsCSopt ::= $Empty
1622
			// Rule 230:  oclMessageArgumentsCSopt ::= $Empty
1717
			//
1623
			//
1718
			case 230:
1624
			case 230:
1719
				dtParser.setSym1(new BasicEList());
1625
				dtParser.setSym1(new BasicEList());
1720
				break;
1626
				break;
1721
 
1627
  
1722
			//
1628
			//
1723
			// Rule 232:  oclMessageArgumentsCS ::= oclMessageArgCS
1629
			// Rule 232:  oclMessageArgumentsCS ::= oclMessageArgCS
1724
			//
1630
			//
1725
			case 232: {
1631
			case 232: {
1726
				
1727
				EList result = new BasicEList();
1632
				EList result = new BasicEList();
1728
				result.add(dtParser.getSym(1));
1633
				result.add(dtParser.getSym(1));
1729
				dtParser.setSym1(result);
1634
				dtParser.setSym1(result);
Lines 1734-1740 Link Here
1734
			// Rule 233:  oclMessageArgumentsCS ::= oclMessageArgumentsCS , oclMessageArgCS
1639
			// Rule 233:  oclMessageArgumentsCS ::= oclMessageArgumentsCS , oclMessageArgCS
1735
			//
1640
			//
1736
			case 233: {
1641
			case 233: {
1737
				
1738
				EList result = (EList)dtParser.getSym(1);
1642
				EList result = (EList)dtParser.getSym(1);
1739
				result.add(dtParser.getSym(3));
1643
				result.add(dtParser.getSym(3));
1740
				dtParser.setSym1(result);
1644
				dtParser.setSym1(result);
Lines 1745-1751 Link Here
1745
			// Rule 234:  oclMessageArgCS ::= oclExpressionCS
1649
			// Rule 234:  oclMessageArgCS ::= oclExpressionCS
1746
			//
1650
			//
1747
			case 234: {
1651
			case 234: {
1748
				
1749
				CSTNode result = createOCLMessageArgCS(
1652
				CSTNode result = createOCLMessageArgCS(
1750
						null,
1653
						null,
1751
						(OCLExpressionCS)dtParser.getSym(1)
1654
						(OCLExpressionCS)dtParser.getSym(1)
Lines 1759-1765 Link Here
1759
			// Rule 235:  oclMessageArgCS ::= ?
1662
			// Rule 235:  oclMessageArgCS ::= ?
1760
			//
1663
			//
1761
			case 235: {
1664
			case 235: {
1762
				
1763
				CSTNode result = createOCLMessageArgCS(
1665
				CSTNode result = createOCLMessageArgCS(
1764
						null,
1666
						null,
1765
						null
1667
						null
Lines 1773-1779 Link Here
1773
			// Rule 236:  oclMessageArgCS ::= ? : typeCS
1675
			// Rule 236:  oclMessageArgCS ::= ? : typeCS
1774
			//
1676
			//
1775
			case 236: {
1677
			case 236: {
1776
				
1777
				CSTNode result = createOCLMessageArgCS(
1678
				CSTNode result = createOCLMessageArgCS(
1778
						(TypeCS)dtParser.getSym(3),
1679
						(TypeCS)dtParser.getSym(3),
1779
						null
1680
						null
Lines 1787-1793 Link Here
1787
			// Rule 245:  packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
1688
			// Rule 245:  packageDeclarationCSm ::= packageDeclarationCSm packageDeclarationCS
1788
			//
1689
			//
1789
			case 245: {
1690
			case 245: {
1790
				
1791
				PackageDeclarationCS result = (PackageDeclarationCS)dtParser.getSym(2);
1691
				PackageDeclarationCS result = (PackageDeclarationCS)dtParser.getSym(2);
1792
				result.setPackageDeclarationCS((PackageDeclarationCS) dtParser.getSym(1));
1692
				result.setPackageDeclarationCS((PackageDeclarationCS) dtParser.getSym(1));
1793
				dtParser.setSym1(result);
1693
				dtParser.setSym1(result);
Lines 1798-1804 Link Here
1798
			// Rule 246:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
1698
			// Rule 246:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt endpackage
1799
			//
1699
			//
1800
			case 246: {
1700
			case 246: {
1801
				
1802
				CSTNode result = createPackageDeclarationCS(
1701
				CSTNode result = createPackageDeclarationCS(
1803
						(PathNameCS)dtParser.getSym(2),
1702
						(PathNameCS)dtParser.getSym(2),
1804
						(EList)dtParser.getSym(3)
1703
						(EList)dtParser.getSym(3)
Lines 1812-1818 Link Here
1812
			// Rule 247:  packageDeclarationCS1 ::= contextDeclCSm
1711
			// Rule 247:  packageDeclarationCS1 ::= contextDeclCSm
1813
			//
1712
			//
1814
			case 247: {
1713
			case 247: {
1815
				
1816
				EList contextDecls = (EList)dtParser.getSym(1);
1714
				EList contextDecls = (EList)dtParser.getSym(1);
1817
				CSTNode result = createPackageDeclarationCS(null, contextDecls);
1715
				CSTNode result = createPackageDeclarationCS(null, contextDecls);
1818
				if (!contextDecls.isEmpty()) {
1716
				if (!contextDecls.isEmpty()) {
Lines 1821-1839 Link Here
1821
				dtParser.setSym1(result);
1719
				dtParser.setSym1(result);
1822
	  		  break;
1720
	  		  break;
1823
			}
1721
			}
1824
	 
1722
	  
1825
			//
1723
			//
1826
			// Rule 248:  contextDeclCSmopt ::= $Empty
1724
			// Rule 248:  contextDeclCSmopt ::= $Empty
1827
			//
1725
			//
1828
			case 248:
1726
			case 248:
1829
				dtParser.setSym1(new BasicEList());
1727
				dtParser.setSym1(new BasicEList());
1830
				break;
1728
				break;
1831
 
1729
  
1832
			//
1730
			//
1833
			// Rule 250:  contextDeclCSm ::= contextDeclCS
1731
			// Rule 250:  contextDeclCSm ::= contextDeclCS
1834
			//
1732
			//
1835
			case 250: {
1733
			case 250: {
1836
				
1837
				EList result = new BasicEList();
1734
				EList result = new BasicEList();
1838
				result.add(dtParser.getSym(1));
1735
				result.add(dtParser.getSym(1));
1839
				dtParser.setSym1(result);
1736
				dtParser.setSym1(result);
Lines 1844-1850 Link Here
1844
			// Rule 251:  contextDeclCSm ::= contextDeclCSm contextDeclCS
1741
			// Rule 251:  contextDeclCSm ::= contextDeclCSm contextDeclCS
1845
			//
1742
			//
1846
			case 251: {
1743
			case 251: {
1847
				
1848
				EList result = (EList)dtParser.getSym(1);
1744
				EList result = (EList)dtParser.getSym(1);
1849
				result.add(dtParser.getSym(2));
1745
				result.add(dtParser.getSym(2));
1850
				dtParser.setSym1(result);
1746
				dtParser.setSym1(result);
Lines 1855-1861 Link Here
1855
			// Rule 255:  propertyContextCS ::= context pathNameCS :: simpleNameCS : typeCS initOrDerValueCS
1751
			// Rule 255:  propertyContextCS ::= context pathNameCS :: simpleNameCS : typeCS initOrDerValueCS
1856
			//
1752
			//
1857
			case 255: {
1753
			case 255: {
1858
				
1859
				CSTNode result = createPropertyContextCS(
1754
				CSTNode result = createPropertyContextCS(
1860
						(PathNameCS)dtParser.getSym(2),
1755
						(PathNameCS)dtParser.getSym(2),
1861
						(SimpleNameCS)dtParser.getSym(4),
1756
						(SimpleNameCS)dtParser.getSym(4),
Lines 1871-1877 Link Here
1871
			// Rule 256:  initOrDerValueCS ::= initOrDerValueCSopt init : oclExpressionCS
1766
			// Rule 256:  initOrDerValueCS ::= initOrDerValueCSopt init : oclExpressionCS
1872
			//
1767
			//
1873
			case 256: {
1768
			case 256: {
1874
				
1875
				CSTNode result = createInitValueCS(
1769
				CSTNode result = createInitValueCS(
1876
						(InitOrDerValueCS)dtParser.getSym(1),
1770
						(InitOrDerValueCS)dtParser.getSym(1),
1877
						(OCLExpressionCS)dtParser.getSym(4)
1771
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1889-1895 Link Here
1889
			// Rule 257:  initOrDerValueCS ::= initOrDerValueCSopt derive : oclExpressionCS
1783
			// Rule 257:  initOrDerValueCS ::= initOrDerValueCSopt derive : oclExpressionCS
1890
			//
1784
			//
1891
			case 257: {
1785
			case 257: {
1892
				
1893
				CSTNode result = createDerValueCS(
1786
				CSTNode result = createDerValueCS(
1894
						(InitOrDerValueCS)dtParser.getSym(1),
1787
						(InitOrDerValueCS)dtParser.getSym(1),
1895
						(OCLExpressionCS)dtParser.getSym(4)
1788
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1914-1920 Link Here
1914
			// Rule 260:  classifierContextDeclCS ::= context pathNameCS invOrDefCSm
1807
			// Rule 260:  classifierContextDeclCS ::= context pathNameCS invOrDefCSm
1915
			//
1808
			//
1916
			case 260: {
1809
			case 260: {
1917
				
1918
				EList<InvOrDefCS> list = (EList<InvOrDefCS>)dtParser.getSym(3);
1810
				EList<InvOrDefCS> list = (EList<InvOrDefCS>)dtParser.getSym(3);
1919
				CSTNode result = createClassifierContextDeclCS(
1811
				CSTNode result = createClassifierContextDeclCS(
1920
						(PathNameCS)dtParser.getSym(2),
1812
						(PathNameCS)dtParser.getSym(2),
Lines 1929-1935 Link Here
1929
			// Rule 261:  invOrDefCSm ::= invOrDefCS
1821
			// Rule 261:  invOrDefCSm ::= invOrDefCS
1930
			//
1822
			//
1931
			case 261: {
1823
			case 261: {
1932
				
1933
				EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
1824
				EList<InvOrDefCS> result = new BasicEList<InvOrDefCS>();
1934
				result.add((InvOrDefCS)dtParser.getSym(1));
1825
				result.add((InvOrDefCS)dtParser.getSym(1));
1935
				dtParser.setSym1(result);
1826
				dtParser.setSym1(result);
Lines 1940-1946 Link Here
1940
			// Rule 262:  invOrDefCSm ::= invOrDefCSm invOrDefCS
1831
			// Rule 262:  invOrDefCSm ::= invOrDefCSm invOrDefCS
1941
			//
1832
			//
1942
			case 262: {
1833
			case 262: {
1943
				
1944
				EList<InvOrDefCS> result = (EList<InvOrDefCS>)dtParser.getSym(1);
1834
				EList<InvOrDefCS> result = (EList<InvOrDefCS>)dtParser.getSym(1);
1945
				result.add((InvOrDefCS)dtParser.getSym(2));
1835
				result.add((InvOrDefCS)dtParser.getSym(2));
1946
				dtParser.setSym1(result);
1836
				dtParser.setSym1(result);
Lines 1951-1957 Link Here
1951
			// Rule 263:  invOrDefCS ::= inv simpleNameCSopt : oclExpressionCS
1841
			// Rule 263:  invOrDefCS ::= inv simpleNameCSopt : oclExpressionCS
1952
			//
1842
			//
1953
			case 263: {
1843
			case 263: {
1954
				
1955
				CSTNode result = createInvCS(
1844
				CSTNode result = createInvCS(
1956
						(SimpleNameCS)dtParser.getSym(2),
1845
						(SimpleNameCS)dtParser.getSym(2),
1957
						(OCLExpressionCS)dtParser.getSym(4)
1846
						(OCLExpressionCS)dtParser.getSym(4)
Lines 1965-1971 Link Here
1965
			// Rule 264:  invOrDefCS ::= def simpleNameCSopt : defExpressionCS
1854
			// Rule 264:  invOrDefCS ::= def simpleNameCSopt : defExpressionCS
1966
			//
1855
			//
1967
			case 264: {
1856
			case 264: {
1968
				
1969
				CSTNode result = createDefCS(
1857
				CSTNode result = createDefCS(
1970
						(SimpleNameCS)dtParser.getSym(2),
1858
						(SimpleNameCS)dtParser.getSym(2),
1971
						(DefExpressionCS)dtParser.getSym(4)
1859
						(DefExpressionCS)dtParser.getSym(4)
Lines 1979-1985 Link Here
1979
			// Rule 265:  defExpressionCS ::= typedVariableCS = oclExpressionCS
1867
			// Rule 265:  defExpressionCS ::= typedVariableCS = oclExpressionCS
1980
			//
1868
			//
1981
			case 265: {
1869
			case 265: {
1982
				
1983
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
1870
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
1984
				OCLExpressionCS expressionCS = (OCLExpressionCS)dtParser.getSym(3);
1871
				OCLExpressionCS expressionCS = (OCLExpressionCS)dtParser.getSym(3);
1985
				CSTNode result = createDefExpressionCS(
1872
				CSTNode result = createDefExpressionCS(
Lines 1996-2002 Link Here
1996
			// Rule 266:  defExpressionCS ::= operationCS1 = oclExpressionCS
1883
			// Rule 266:  defExpressionCS ::= operationCS1 = oclExpressionCS
1997
			//
1884
			//
1998
			case 266: {
1885
			case 266: {
1999
				
2000
				CSTNode result = createDefExpressionCS(
1886
				CSTNode result = createDefExpressionCS(
2001
						null,
1887
						null,
2002
						(OperationCS)dtParser.getSym(1),
1888
						(OperationCS)dtParser.getSym(1),
Lines 2011-2017 Link Here
2011
			// Rule 267:  operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
1897
			// Rule 267:  operationContextDeclCS ::= context operationCS2 prePostOrBodyDeclCSm
2012
			//
1898
			//
2013
			case 267: {
1899
			case 267: {
2014
				
2015
				EList prePostOrBodyDecls = (EList)dtParser.getSym(3);
1900
				EList prePostOrBodyDecls = (EList)dtParser.getSym(3);
2016
				CSTNode result = createOperationContextDeclCS(
1901
				CSTNode result = createOperationContextDeclCS(
2017
						(OperationCS)dtParser.getSym(2),
1902
						(OperationCS)dtParser.getSym(2),
Lines 2026-2032 Link Here
2026
			// Rule 268:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
1911
			// Rule 268:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCS
2027
			//
1912
			//
2028
			case 268: {
1913
			case 268: {
2029
				
2030
				EList result = new BasicEList();
1914
				EList result = new BasicEList();
2031
				result.add(dtParser.getSym(1));
1915
				result.add(dtParser.getSym(1));
2032
				dtParser.setSym1(result);
1916
				dtParser.setSym1(result);
Lines 2037-2043 Link Here
2037
			// Rule 269:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
1921
			// Rule 269:  prePostOrBodyDeclCSm ::= prePostOrBodyDeclCSm prePostOrBodyDeclCS
2038
			//
1922
			//
2039
			case 269: {
1923
			case 269: {
2040
				
2041
				EList result = (EList)dtParser.getSym(1);
1924
				EList result = (EList)dtParser.getSym(1);
2042
				result.add(dtParser.getSym(2));
1925
				result.add(dtParser.getSym(2));
2043
				dtParser.setSym1(result);
1926
				dtParser.setSym1(result);
Lines 2048-2054 Link Here
2048
			// Rule 270:  prePostOrBodyDeclCS ::= pre simpleNameCSopt : oclExpressionCS
1931
			// Rule 270:  prePostOrBodyDeclCS ::= pre simpleNameCSopt : oclExpressionCS
2049
			//
1932
			//
2050
			case 270: {
1933
			case 270: {
2051
				
2052
				CSTNode result = createPrePostOrBodyDeclCS(
1934
				CSTNode result = createPrePostOrBodyDeclCS(
2053
						PrePostOrBodyEnum.PRE_LITERAL,
1935
						PrePostOrBodyEnum.PRE_LITERAL,
2054
						(SimpleNameCS)dtParser.getSym(2),
1936
						(SimpleNameCS)dtParser.getSym(2),
Lines 2063-2069 Link Here
2063
			// Rule 271:  prePostOrBodyDeclCS ::= post simpleNameCSopt : oclExpressionCS
1945
			// Rule 271:  prePostOrBodyDeclCS ::= post simpleNameCSopt : oclExpressionCS
2064
			//
1946
			//
2065
			case 271: {
1947
			case 271: {
2066
				
2067
				CSTNode result = createPrePostOrBodyDeclCS(
1948
				CSTNode result = createPrePostOrBodyDeclCS(
2068
						PrePostOrBodyEnum.POST_LITERAL,
1949
						PrePostOrBodyEnum.POST_LITERAL,
2069
						(SimpleNameCS)dtParser.getSym(2),
1950
						(SimpleNameCS)dtParser.getSym(2),
Lines 2078-2084 Link Here
2078
			// Rule 272:  prePostOrBodyDeclCS ::= body simpleNameCSopt : oclExpressionCS
1959
			// Rule 272:  prePostOrBodyDeclCS ::= body simpleNameCSopt : oclExpressionCS
2079
			//
1960
			//
2080
			case 272: {
1961
			case 272: {
2081
				
2082
				CSTNode result = createPrePostOrBodyDeclCS(
1962
				CSTNode result = createPrePostOrBodyDeclCS(
2083
						PrePostOrBodyEnum.BODY_LITERAL,
1963
						PrePostOrBodyEnum.BODY_LITERAL,
2084
						(SimpleNameCS)dtParser.getSym(2),
1964
						(SimpleNameCS)dtParser.getSym(2),
Lines 2093-2099 Link Here
2093
			// Rule 273:  ERROR_Colon ::= ERROR_TOKEN
1973
			// Rule 273:  ERROR_Colon ::= ERROR_TOKEN
2094
			//
1974
			//
2095
			case 273: {
1975
			case 273: {
2096
				
2097
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_COLON);
1976
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_COLON);
2098
	  		  break;
1977
	  		  break;
2099
			}
1978
			}
Lines 2102-2108 Link Here
2102
			// Rule 274:  ERROR_Empty ::= ERROR_TOKEN
1981
			// Rule 274:  ERROR_Empty ::= ERROR_TOKEN
2103
			//
1982
			//
2104
			case 274: {
1983
			case 274: {
2105
				
2106
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.EXTRA_TOKENS);
1984
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.EXTRA_TOKENS);
2107
	  		  break;
1985
	  		  break;
2108
			}
1986
			}
Lines 2111-2117 Link Here
2111
			// Rule 275:  ERROR_IsMarkedPreCS ::= ERROR_TOKEN
1989
			// Rule 275:  ERROR_IsMarkedPreCS ::= ERROR_TOKEN
2112
			//
1990
			//
2113
			case 275: {
1991
			case 275: {
2114
				
2115
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_AT_PRE);
1992
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_AT_PRE);
2116
				IsMarkedPreCS result = createIsMarkedPreCS(false);
1993
				IsMarkedPreCS result = createIsMarkedPreCS(false);
2117
				setOffsets(result, getIToken(dtParser.getToken(1)));
1994
				setOffsets(result, getIToken(dtParser.getToken(1)));
Lines 2123-2129 Link Here
2123
			// Rule 276:  ERROR_PathNameCS ::= ERROR_TOKEN
2000
			// Rule 276:  ERROR_PathNameCS ::= ERROR_TOKEN
2124
			//
2001
			//
2125
			case 276: {
2002
			case 276: {
2126
				
2127
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_PATH_NAME);
2003
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_PATH_NAME);
2128
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
2004
				CSTNode result = createPathNameCS(getTokenText(dtParser.getToken(1)));
2129
				setOffsets(result, getIToken(dtParser.getToken(1)));
2005
				setOffsets(result, getIToken(dtParser.getToken(1)));
Lines 2135-2141 Link Here
2135
			// Rule 277:  ERROR_SimpleNameCS ::= ERROR_TOKEN
2011
			// Rule 277:  ERROR_SimpleNameCS ::= ERROR_TOKEN
2136
			//
2012
			//
2137
			case 277: {
2013
			case 277: {
2138
				
2139
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_SIMPLE_NAME);
2014
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_SIMPLE_NAME);
2140
				SimpleNameCS result = createSimpleNameCS(
2015
				SimpleNameCS result = createSimpleNameCS(
2141
						SimpleTypeEnum.IDENTIFIER_LITERAL,
2016
						SimpleTypeEnum.IDENTIFIER_LITERAL,
Lines 2150-2156 Link Here
2150
			// Rule 278:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ERROR_TOKEN
2025
			// Rule 278:  attrOrNavCallExpCS ::= simpleNameCS [ argumentsCS ERROR_TOKEN
2151
			//
2026
			//
2152
			case 278: {
2027
			case 278: {
2153
				
2154
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RBRACK);
2028
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RBRACK);
2155
				CSTNode result = createFeatureCallExpCS(
2029
				CSTNode result = createFeatureCallExpCS(
2156
						(SimpleNameCS)dtParser.getSym(1),
2030
						(SimpleNameCS)dtParser.getSym(1),
Lines 2166-2172 Link Here
2166
			// Rule 279:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS ERROR_TOKEN
2040
			// Rule 279:  collectionTypeCS ::= collectionTypeIdentifierCS ( typeCS ERROR_TOKEN
2167
			//
2041
			//
2168
			case 279: {
2042
			case 279: {
2169
				
2170
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RPAREN);
2043
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RPAREN);
2171
				Object[] objs = (Object[])dtParser.getSym(1);
2044
				Object[] objs = (Object[])dtParser.getSym(1);
2172
				CSTNode result = createCollectionTypeCS(
2045
				CSTNode result = createCollectionTypeCS(
Lines 2182-2188 Link Here
2182
			// Rule 280:  collectionTypeCS ::= collectionTypeIdentifierCS ERROR_TOKEN
2055
			// Rule 280:  collectionTypeCS ::= collectionTypeIdentifierCS ERROR_TOKEN
2183
			//
2056
			//
2184
			case 280: {
2057
			case 280: {
2185
				
2186
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_LPAREN);
2058
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_LPAREN);
2187
				Object[] objs = (Object[])dtParser.getSym(1);
2059
				Object[] objs = (Object[])dtParser.getSym(1);
2188
				CSTNode result = createCollectionTypeCS(
2060
				CSTNode result = createCollectionTypeCS(
Lines 2198-2204 Link Here
2198
			// Rule 281:  dotArrowExpCS ::= pathNameCS :: ERROR_SimpleNameCS ( argumentsCSopt )
2070
			// Rule 281:  dotArrowExpCS ::= pathNameCS :: ERROR_SimpleNameCS ( argumentsCSopt )
2199
			//
2071
			//
2200
			case 281: {
2072
			case 281: {
2201
				
2202
				OperationCallExpCS result = createOperationCallExpCS(
2073
				OperationCallExpCS result = createOperationCallExpCS(
2203
						(PathNameCS)dtParser.getSym(1),
2074
						(PathNameCS)dtParser.getSym(1),
2204
						(SimpleNameCS)dtParser.getSym(3),
2075
						(SimpleNameCS)dtParser.getSym(3),
Lines 2214-2220 Link Here
2214
			// Rule 282:  enumLiteralExpCS ::= pathNameCS :: ERROR_SimpleNameCS
2085
			// Rule 282:  enumLiteralExpCS ::= pathNameCS :: ERROR_SimpleNameCS
2215
			//
2086
			//
2216
			case 282: {
2087
			case 282: {
2217
				
2218
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2088
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2219
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(3);
2089
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(3);
2220
				CSTNode result = createEnumLiteralExpCS(
2090
				CSTNode result = createEnumLiteralExpCS(
Lines 2225-2246 Link Here
2225
				dtParser.setSym1(result);
2095
				dtParser.setSym1(result);
2226
	  		  break;
2096
	  		  break;
2227
			}
2097
			}
2228
	 
2098
	  
2229
			//
2099
			//
2230
			// Rule 283:  featureCallExpCS ::= unaryName ERROR_IsMarkedPreCS ( argumentsCSopt )
2100
			// Rule 283:  featureCallExpCS ::= unaryName ERROR_IsMarkedPreCS ( argumentsCSopt )
2231
			//
2101
			//
2232
			case 283:
2102
			case 283:
2233
 
2103
   
2234
			//
2104
			//
2235
			// Rule 284:  keywordOperationCallExpCS ::= keywordAsName ERROR_IsMarkedPreCS ( argumentsCSopt )
2105
			// Rule 284:  keywordOperationCallExpCS ::= keywordAsName ERROR_IsMarkedPreCS ( argumentsCSopt )
2236
			//
2106
			//
2237
			case 284:
2107
			case 284:
2238
 
2108
  
2239
			//
2109
			//
2240
			// Rule 285:  operationCallExpCS ::= binaryName ERROR_IsMarkedPreCS ( argumentsCSopt )
2110
			// Rule 285:  operationCallExpCS ::= binaryName ERROR_IsMarkedPreCS ( argumentsCSopt )
2241
			//
2111
			//
2242
			case 285: {
2112
			case 285: {
2243
				
2244
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
2113
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
2245
				CSTNode result = createOperationCallExpCS(
2114
				CSTNode result = createOperationCallExpCS(
2246
						simpleNameCS,
2115
						simpleNameCS,
Lines 2256-2262 Link Here
2256
			// Rule 286:  operationCallExpCS ::= oclIsInStateName ERROR_IsMarkedPreCS ( stateExpCS )
2125
			// Rule 286:  operationCallExpCS ::= oclIsInStateName ERROR_IsMarkedPreCS ( stateExpCS )
2257
			//
2126
			//
2258
			case 286: {
2127
			case 286: {
2259
				
2260
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
2128
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(1);
2261
				CSTNode result = createOperationCallExpCS(
2129
				CSTNode result = createOperationCallExpCS(
2262
						simpleNameCS,
2130
						simpleNameCS,
Lines 2272-2278 Link Here
2272
			// Rule 287:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS ERROR_TOKEN
2140
			// Rule 287:  ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS ERROR_TOKEN
2273
			//
2141
			//
2274
			case 287: {
2142
			case 287: {
2275
				
2276
				reportErrorTokenMessage(dtParser.getToken(7), OCLParserErrors.MISSING_ENDIF);
2143
				reportErrorTokenMessage(dtParser.getToken(7), OCLParserErrors.MISSING_ENDIF);
2277
				CSTNode result = createIfExpCS(
2144
				CSTNode result = createIfExpCS(
2278
						(OCLExpressionCS)dtParser.getSym(2),
2145
						(OCLExpressionCS)dtParser.getSym(2),
Lines 2288-2294 Link Here
2288
			// Rule 288:  ifExpCS ::= if oclExpressionCS then oclExpressionCS ERROR_TOKEN
2155
			// Rule 288:  ifExpCS ::= if oclExpressionCS then oclExpressionCS ERROR_TOKEN
2289
			//
2156
			//
2290
			case 288: {
2157
			case 288: {
2291
				
2292
				reportErrorTokenMessage(dtParser.getToken(5), OCLParserErrors.MISSING_ELSE_ENDIF);
2158
				reportErrorTokenMessage(dtParser.getToken(5), OCLParserErrors.MISSING_ELSE_ENDIF);
2293
				CSTNode result = createIfExpCS(
2159
				CSTNode result = createIfExpCS(
2294
						(OCLExpressionCS)dtParser.getSym(2),
2160
						(OCLExpressionCS)dtParser.getSym(2),
Lines 2304-2310 Link Here
2304
			// Rule 289:  ifExpCS ::= if oclExpressionCS ERROR_TOKEN
2170
			// Rule 289:  ifExpCS ::= if oclExpressionCS ERROR_TOKEN
2305
			//
2171
			//
2306
			case 289: {
2172
			case 289: {
2307
				
2308
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_THEN_ELSE_ENDIF);
2173
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_THEN_ELSE_ENDIF);
2309
				CSTNode result = createIfExpCS(
2174
				CSTNode result = createIfExpCS(
2310
						(OCLExpressionCS)dtParser.getSym(2),
2175
						(OCLExpressionCS)dtParser.getSym(2),
Lines 2320-2326 Link Here
2320
			// Rule 290:  ifExpCS ::= if ERROR_TOKEN endif
2185
			// Rule 290:  ifExpCS ::= if ERROR_TOKEN endif
2321
			//
2186
			//
2322
			case 290: {
2187
			case 290: {
2323
				
2324
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_THEN_ELSE);
2188
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_THEN_ELSE);
2325
				CSTNode result = createIfExpCS(
2189
				CSTNode result = createIfExpCS(
2326
						createInvalidLiteralExpCS(getTokenText(dtParser.getToken(2))),
2190
						createInvalidLiteralExpCS(getTokenText(dtParser.getToken(2))),
Lines 2331-2347 Link Here
2331
				dtParser.setSym1(result);
2195
				dtParser.setSym1(result);
2332
	  		  break;
2196
	  		  break;
2333
			}
2197
			}
2334
	 
2198
	  
2335
			//
2199
			//
2336
			// Rule 291:  messageExpCS ::= ^ simpleNameCS ERROR_TOKEN
2200
			// Rule 291:  messageExpCS ::= ^ simpleNameCS ERROR_TOKEN
2337
			//
2201
			//
2338
			case 291:
2202
			case 291:
2339
 
2203
  
2340
			//
2204
			//
2341
			// Rule 292:  messageExpCS ::= ^^ simpleNameCS ERROR_TOKEN
2205
			// Rule 292:  messageExpCS ::= ^^ simpleNameCS ERROR_TOKEN
2342
			//
2206
			//
2343
			case 292: {
2207
			case 292: {
2344
				
2345
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_MESSAGE_ARGUMENTS);
2208
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_MESSAGE_ARGUMENTS);
2346
				CSTNode result = createMessageExpCS(
2209
				CSTNode result = createMessageExpCS(
2347
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
2210
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
Lines 2352-2368 Link Here
2352
				dtParser.setSym1(result);
2215
				dtParser.setSym1(result);
2353
	  		  break;
2216
	  		  break;
2354
			}
2217
			}
2355
	 
2218
	  
2356
			//
2219
			//
2357
			// Rule 293:  messageExpCS ::= ^ ERROR_SimpleNameCS
2220
			// Rule 293:  messageExpCS ::= ^ ERROR_SimpleNameCS
2358
			//
2221
			//
2359
			case 293:
2222
			case 293:
2360
 
2223
  
2361
			//
2224
			//
2362
			// Rule 294:  messageExpCS ::= ^^ ERROR_SimpleNameCS
2225
			// Rule 294:  messageExpCS ::= ^^ ERROR_SimpleNameCS
2363
			//
2226
			//
2364
			case 294: {
2227
			case 294: {
2365
				
2366
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(2);
2228
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(2);
2367
				CSTNode result = createMessageExpCS(
2229
				CSTNode result = createMessageExpCS(
2368
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
2230
						getIToken(dtParser.getToken(1)).getKind() == OCLBacktrackingParsersym.TK_CARET,
Lines 2378-2384 Link Here
2378
			// Rule 295:  oclExpCS ::= ERROR_TOKEN
2240
			// Rule 295:  oclExpCS ::= ERROR_TOKEN
2379
			//
2241
			//
2380
			case 295: {
2242
			case 295: {
2381
				
2382
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_EXPR);
2243
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_EXPR);
2383
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
2244
				CSTNode result = createInvalidLiteralExpCS(getTokenText(dtParser.getToken(1)));
2384
				setOffsets(result, getIToken(dtParser.getToken(1)));
2245
				setOffsets(result, getIToken(dtParser.getToken(1)));
Lines 2390-2396 Link Here
2390
			// Rule 296:  oclExpCS ::= ( oclExpressionCS ERROR_TOKEN
2251
			// Rule 296:  oclExpCS ::= ( oclExpressionCS ERROR_TOKEN
2391
			//
2252
			//
2392
			case 296: {
2253
			case 296: {
2393
				
2394
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_RPAREN);
2254
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_RPAREN);
2395
				CSTNode result = (CSTNode)dtParser.getSym(2);
2255
				CSTNode result = (CSTNode)dtParser.getSym(2);
2396
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
2256
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(3)));
Lines 2402-2408 Link Here
2402
			// Rule 297:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) ERROR_Colon
2262
			// Rule 297:  operationCS1 ::= IDENTIFIER ( parametersCSopt ) ERROR_Colon
2403
			//
2263
			//
2404
			case 297: {
2264
			case 297: {
2405
				
2406
				CSTNode result = createOperationCS(
2265
				CSTNode result = createOperationCS(
2407
						getTokenText(dtParser.getToken(1)),
2266
						getTokenText(dtParser.getToken(1)),
2408
						(EList)dtParser.getSym(3),
2267
						(EList)dtParser.getSym(3),
Lines 2417-2423 Link Here
2417
			// Rule 298:  operationCS1 ::= IDENTIFIER ( parametersCSopt ERROR_TOKEN
2276
			// Rule 298:  operationCS1 ::= IDENTIFIER ( parametersCSopt ERROR_TOKEN
2418
			//
2277
			//
2419
			case 298: {
2278
			case 298: {
2420
				
2421
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RPAREN);
2279
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RPAREN);
2422
				CSTNode result = createOperationCS(
2280
				CSTNode result = createOperationCS(
2423
						getTokenText(dtParser.getToken(1)),
2281
						getTokenText(dtParser.getToken(1)),
Lines 2433-2439 Link Here
2433
			// Rule 299:  operationCS1 ::= IDENTIFIER ERROR_TOKEN
2291
			// Rule 299:  operationCS1 ::= IDENTIFIER ERROR_TOKEN
2434
			//
2292
			//
2435
			case 299: {
2293
			case 299: {
2436
				
2437
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_LPAREN);
2294
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_LPAREN);
2438
				CSTNode result = createOperationCS(
2295
				CSTNode result = createOperationCS(
2439
						getTokenText(dtParser.getToken(1)),
2296
						getTokenText(dtParser.getToken(1)),
Lines 2449-2455 Link Here
2449
			// Rule 300:  operationCS1 ::= ERROR_TOKEN
2306
			// Rule 300:  operationCS1 ::= ERROR_TOKEN
2450
			//
2307
			//
2451
			case 300: {
2308
			case 300: {
2452
				
2453
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_IDENTIFIER);
2309
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_IDENTIFIER);
2454
				CSTNode result = createOperationCS(
2310
				CSTNode result = createOperationCS(
2455
						getTokenText(dtParser.getToken(1)),
2311
						getTokenText(dtParser.getToken(1)),
Lines 2465-2471 Link Here
2465
			// Rule 301:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) ERROR_Colon
2321
			// Rule 301:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ) ERROR_Colon
2466
			//
2322
			//
2467
			case 301: {
2323
			case 301: {
2468
				
2469
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2324
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2470
				CSTNode result = createOperationCS(
2325
				CSTNode result = createOperationCS(
2471
						pathNameCS,
2326
						pathNameCS,
Lines 2482-2488 Link Here
2482
			// Rule 302:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ERROR_TOKEN
2337
			// Rule 302:  operationCS2 ::= pathNameCS :: simpleNameCS ( parametersCSopt ERROR_TOKEN
2483
			//
2338
			//
2484
			case 302: {
2339
			case 302: {
2485
				
2486
				reportErrorTokenMessage(dtParser.getToken(6), OCLParserErrors.MISSING_RPAREN);
2340
				reportErrorTokenMessage(dtParser.getToken(6), OCLParserErrors.MISSING_RPAREN);
2487
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2341
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2488
				CSTNode result = createOperationCS(
2342
				CSTNode result = createOperationCS(
Lines 2500-2506 Link Here
2500
			// Rule 303:  operationCS2 ::= pathNameCS :: simpleNameCS ERROR_TOKEN
2354
			// Rule 303:  operationCS2 ::= pathNameCS :: simpleNameCS ERROR_TOKEN
2501
			//
2355
			//
2502
			case 303: {
2356
			case 303: {
2503
				
2504
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_LPAREN);
2357
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_LPAREN);
2505
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2358
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2506
				CSTNode result = createOperationCS(
2359
				CSTNode result = createOperationCS(
Lines 2518-2524 Link Here
2518
			// Rule 304:  operationCS2 ::= pathNameCS :: ERROR_SimpleNameCS
2371
			// Rule 304:  operationCS2 ::= pathNameCS :: ERROR_SimpleNameCS
2519
			//
2372
			//
2520
			case 304: {
2373
			case 304: {
2521
				
2522
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2374
				PathNameCS pathNameCS = (PathNameCS)dtParser.getSym(1);
2523
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(3);
2375
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(3);
2524
				CSTNode result = createOperationCS(
2376
				CSTNode result = createOperationCS(
Lines 2536-2542 Link Here
2536
			// Rule 305:  parametersCS ::= ERROR_TOKEN
2388
			// Rule 305:  parametersCS ::= ERROR_TOKEN
2537
			//
2389
			//
2538
			case 305: {
2390
			case 305: {
2539
				
2540
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_PARAMETERS);
2391
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_PARAMETERS);
2541
				EList result = new BasicEList();
2392
				EList result = new BasicEList();
2542
				dtParser.setSym1(result);
2393
				dtParser.setSym1(result);
Lines 2547-2553 Link Here
2547
			// Rule 306:  parametersCS ::= parametersCS , ERROR_TOKEN
2398
			// Rule 306:  parametersCS ::= parametersCS , ERROR_TOKEN
2548
			//
2399
			//
2549
			case 306: {
2400
			case 306: {
2550
				
2551
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_PARAMETER);
2401
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_PARAMETER);
2552
	  		  break;
2402
	  		  break;
2553
			}
2403
			}
Lines 2556-2562 Link Here
2556
			// Rule 309:  tupleLiteralExpCS ::= Tuple ERROR_TOKEN
2406
			// Rule 309:  tupleLiteralExpCS ::= Tuple ERROR_TOKEN
2557
			//
2407
			//
2558
			case 309: {
2408
			case 309: {
2559
				
2560
				reportErrorTokenMessage(dtParser.getToken(7), OCLParserErrors.MISSING_LBRACE);
2409
				reportErrorTokenMessage(dtParser.getToken(7), OCLParserErrors.MISSING_LBRACE);
2561
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
2410
				CSTNode result = createTupleLiteralExpCS((EList)dtParser.getSym(3));
2562
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
2411
				setOffsets(result, getIToken(dtParser.getToken(1)), getIToken(dtParser.getToken(4)));
Lines 2568-2574 Link Here
2568
			// Rule 310:  variableCS ::= IDENTIFIER ERROR_TOKEN
2417
			// Rule 310:  variableCS ::= IDENTIFIER ERROR_TOKEN
2569
			//
2418
			//
2570
			case 310: {
2419
			case 310: {
2571
				
2572
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_VARIABLE_TYPE);
2420
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_VARIABLE_TYPE);
2573
				CSTNode result = createVariableCS(
2421
				CSTNode result = createVariableCS(
2574
						getTokenText(dtParser.getToken(1)),
2422
						getTokenText(dtParser.getToken(1)),
Lines 2579-2595 Link Here
2579
				dtParser.setSym1(result);
2427
				dtParser.setSym1(result);
2580
	  		  break;
2428
	  		  break;
2581
			}
2429
			}
2582
	 
2430
	  
2583
			//
2431
			//
2584
			// Rule 311:  variableExpCS ::= simpleNameCS [ argumentsCS ERROR_TOKEN
2432
			// Rule 311:  variableExpCS ::= simpleNameCS [ argumentsCS ERROR_TOKEN
2585
			//
2433
			//
2586
			case 311:
2434
			case 311:
2587
 
2435
  
2588
			//
2436
			//
2589
			// Rule 312:  variableExpCS ::= keywordAsName1 [ argumentsCS ERROR_TOKEN
2437
			// Rule 312:  variableExpCS ::= keywordAsName1 [ argumentsCS ERROR_TOKEN
2590
			//
2438
			//
2591
			case 312: {
2439
			case 312: {
2592
				
2593
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RBRACK);
2440
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_RBRACK);
2594
				CSTNode result = createVariableExpCS(
2441
				CSTNode result = createVariableExpCS(
2595
						(SimpleNameCS)dtParser.getSym(1),
2442
						(SimpleNameCS)dtParser.getSym(1),
Lines 2600-2616 Link Here
2600
				dtParser.setSym1(result);
2447
				dtParser.setSym1(result);
2601
	  		  break;
2448
	  		  break;
2602
			}
2449
			}
2603
	 
2450
	  
2604
			//
2451
			//
2605
			// Rule 313:  variableListCS ::= ERROR_TOKEN
2452
			// Rule 313:  variableListCS ::= ERROR_TOKEN
2606
			//
2453
			//
2607
			case 313:
2454
			case 313:
2608
 
2455
  
2609
			//
2456
			//
2610
			// Rule 314:  variableListCS2 ::= ERROR_TOKEN
2457
			// Rule 314:  variableListCS2 ::= ERROR_TOKEN
2611
			//
2458
			//
2612
			case 314: {
2459
			case 314: {
2613
				
2614
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_VARIABLES);
2460
				reportErrorTokenMessage(dtParser.getToken(1), OCLParserErrors.MISSING_VARIABLES);
2615
				EList result = new BasicEList();
2461
				EList result = new BasicEList();
2616
				dtParser.setSym1(result);
2462
				dtParser.setSym1(result);
Lines 2621-2627 Link Here
2621
			// Rule 315:  classifierContextDeclCS ::= context pathNameCS ERROR_TOKEN
2467
			// Rule 315:  classifierContextDeclCS ::= context pathNameCS ERROR_TOKEN
2622
			//
2468
			//
2623
			case 315: {
2469
			case 315: {
2624
				
2625
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_INV_OR_DEF);
2470
				reportErrorTokenMessage(dtParser.getToken(3), OCLParserErrors.MISSING_INV_OR_DEF);
2626
				CSTNode result = createClassifierContextDeclCS(
2471
				CSTNode result = createClassifierContextDeclCS(
2627
						(PathNameCS)dtParser.getSym(2),
2472
						(PathNameCS)dtParser.getSym(2),
Lines 2636-2642 Link Here
2636
			// Rule 316:  defExpressionCS ::= typedVariableCS ERROR_TOKEN
2481
			// Rule 316:  defExpressionCS ::= typedVariableCS ERROR_TOKEN
2637
			//
2482
			//
2638
			case 316: {
2483
			case 316: {
2639
				
2640
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_EQUALS);
2484
				reportErrorTokenMessage(dtParser.getToken(2), OCLParserErrors.MISSING_EQUALS);
2641
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
2485
				VariableCS variableCS = (VariableCS)dtParser.getSym(1);
2642
				CSTNode result = createDefExpressionCS(
2486
				CSTNode result = createDefExpressionCS(
Lines 2653-2659 Link Here
2653
			// Rule 317:  defExpressionCS ::= IDENTIFIER ERROR_Colon
2497
			// Rule 317:  defExpressionCS ::= IDENTIFIER ERROR_Colon
2654
			//
2498
			//
2655
			case 317: {
2499
			case 317: {
2656
				
2657
				VariableCS variableCS = createVariableCS(
2500
				VariableCS variableCS = createVariableCS(
2658
							getTokenText(dtParser.getToken(1)),
2501
							getTokenText(dtParser.getToken(1)),
2659
							null,
2502
							null,
Lines 2674-2680 Link Here
2674
			// Rule 318:  initOrDerValueCS ::= initOrDerValueCSopt init ERROR_Colon
2517
			// Rule 318:  initOrDerValueCS ::= initOrDerValueCSopt init ERROR_Colon
2675
			//
2518
			//
2676
			case 318: {
2519
			case 318: {
2677
				
2678
				CSTNode result = createInitValueCS(
2520
				CSTNode result = createInitValueCS(
2679
						(InitOrDerValueCS)dtParser.getSym(1),
2521
						(InitOrDerValueCS)dtParser.getSym(1),
2680
						null
2522
						null
Lines 2692-2698 Link Here
2692
			// Rule 319:  initOrDerValueCS ::= initOrDerValueCSopt derive ERROR_Colon
2534
			// Rule 319:  initOrDerValueCS ::= initOrDerValueCSopt derive ERROR_Colon
2693
			//
2535
			//
2694
			case 319: {
2536
			case 319: {
2695
				
2696
				CSTNode result = createDerValueCS(
2537
				CSTNode result = createDerValueCS(
2697
						(InitOrDerValueCS)dtParser.getSym(1),
2538
						(InitOrDerValueCS)dtParser.getSym(1),
2698
						null
2539
						null
Lines 2710-2716 Link Here
2710
			// Rule 320:  invOrDefCS ::= inv simpleNameCS ERROR_Colon
2551
			// Rule 320:  invOrDefCS ::= inv simpleNameCS ERROR_Colon
2711
			//
2552
			//
2712
			case 320: {
2553
			case 320: {
2713
				
2714
				CSTNode result = createInvCS(
2554
				CSTNode result = createInvCS(
2715
						(SimpleNameCS)dtParser.getSym(2),
2555
						(SimpleNameCS)dtParser.getSym(2),
2716
						null
2556
						null
Lines 2724-2730 Link Here
2724
			// Rule 321:  invOrDefCS ::= def simpleNameCS ERROR_Colon
2564
			// Rule 321:  invOrDefCS ::= def simpleNameCS ERROR_Colon
2725
			//
2565
			//
2726
			case 321: {
2566
			case 321: {
2727
				
2728
				CSTNode result = createDefCS(
2567
				CSTNode result = createDefCS(
2729
						(SimpleNameCS)dtParser.getSym(2),
2568
						(SimpleNameCS)dtParser.getSym(2),
2730
						null
2569
						null
Lines 2738-2744 Link Here
2738
			// Rule 322:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_Empty endpackage
2577
			// Rule 322:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_Empty endpackage
2739
			//
2578
			//
2740
			case 322: {
2579
			case 322: {
2741
				
2742
				CSTNode result = createPackageDeclarationCS(
2580
				CSTNode result = createPackageDeclarationCS(
2743
						(PathNameCS)dtParser.getSym(2),
2581
						(PathNameCS)dtParser.getSym(2),
2744
						(EList)dtParser.getSym(3)
2582
						(EList)dtParser.getSym(3)
Lines 2752-2758 Link Here
2752
			// Rule 323:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_TOKEN
2590
			// Rule 323:  packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_TOKEN
2753
			//
2591
			//
2754
			case 323: {
2592
			case 323: {
2755
				
2756
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_ENDPACKAGE);
2593
				reportErrorTokenMessage(dtParser.getToken(4), OCLParserErrors.MISSING_ENDPACKAGE);
2757
				CSTNode result = createPackageDeclarationCS(
2594
				CSTNode result = createPackageDeclarationCS(
2758
						(PathNameCS)dtParser.getSym(2),
2595
						(PathNameCS)dtParser.getSym(2),
Lines 2767-2773 Link Here
2767
			// Rule 324:  packageDeclarationCS ::= package ERROR_PathNameCS
2604
			// Rule 324:  packageDeclarationCS ::= package ERROR_PathNameCS
2768
			//
2605
			//
2769
			case 324: {
2606
			case 324: {
2770
				
2771
				CSTNode result = createPackageDeclarationCS(
2607
				CSTNode result = createPackageDeclarationCS(
2772
						(PathNameCS)dtParser.getSym(2),
2608
						(PathNameCS)dtParser.getSym(2),
2773
						new BasicEList()
2609
						new BasicEList()
Lines 2781-2787 Link Here
2781
			// Rule 325:  prePostOrBodyDeclCS ::= pre simpleNameCS ERROR_Colon
2617
			// Rule 325:  prePostOrBodyDeclCS ::= pre simpleNameCS ERROR_Colon
2782
			//
2618
			//
2783
			case 325: {
2619
			case 325: {
2784
				
2785
				CSTNode result = createPrePostOrBodyDeclCS(
2620
				CSTNode result = createPrePostOrBodyDeclCS(
2786
						PrePostOrBodyEnum.PRE_LITERAL,
2621
						PrePostOrBodyEnum.PRE_LITERAL,
2787
						(SimpleNameCS)dtParser.getSym(2),
2622
						(SimpleNameCS)dtParser.getSym(2),
Lines 2796-2802 Link Here
2796
			// Rule 326:  prePostOrBodyDeclCS ::= post simpleNameCS ERROR_Colon
2631
			// Rule 326:  prePostOrBodyDeclCS ::= post simpleNameCS ERROR_Colon
2797
			//
2632
			//
2798
			case 326: {
2633
			case 326: {
2799
				
2800
				CSTNode result = createPrePostOrBodyDeclCS(
2634
				CSTNode result = createPrePostOrBodyDeclCS(
2801
						PrePostOrBodyEnum.POST_LITERAL,
2635
						PrePostOrBodyEnum.POST_LITERAL,
2802
						(SimpleNameCS)dtParser.getSym(2),
2636
						(SimpleNameCS)dtParser.getSym(2),
Lines 2811-2817 Link Here
2811
			// Rule 327:  prePostOrBodyDeclCS ::= body simpleNameCS ERROR_Colon
2645
			// Rule 327:  prePostOrBodyDeclCS ::= body simpleNameCS ERROR_Colon
2812
			//
2646
			//
2813
			case 327: {
2647
			case 327: {
2814
				
2815
				CSTNode result = createPrePostOrBodyDeclCS(
2648
				CSTNode result = createPrePostOrBodyDeclCS(
2816
						PrePostOrBodyEnum.BODY_LITERAL,
2649
						PrePostOrBodyEnum.BODY_LITERAL,
2817
						(SimpleNameCS)dtParser.getSym(2),
2650
						(SimpleNameCS)dtParser.getSym(2),
Lines 2826-2832 Link Here
2826
			// Rule 328:  propertyContextCS ::= context pathNameCS :: ERROR_SimpleNameCS
2659
			// Rule 328:  propertyContextCS ::= context pathNameCS :: ERROR_SimpleNameCS
2827
			//
2660
			//
2828
			case 328: {
2661
			case 328: {
2829
				
2830
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(4);
2662
				SimpleNameCS simpleNameCS = (SimpleNameCS)dtParser.getSym(4);
2831
				CSTNode result = createPropertyContextCS(
2663
				CSTNode result = createPropertyContextCS(
2832
						(PathNameCS)dtParser.getSym(2),
2664
						(PathNameCS)dtParser.getSym(2),
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingParser.g
Lines 1-7 Link Here
1
--/**
1
--/**
2
-- * <copyright>
2
-- * <copyright>
3
-- *
3
-- *
(-)* Copyright (c) 2008, 2009 Eclipse.org and others. (-10 / +12 lines)
Lines 9-14 Link Here
9
-- *
9
-- *
10
-- * Contributors:
10
-- * Contributors:
11
-- *   E.D. Willink - Initial API and implementation
11
-- *   E.D. Willink - Initial API and implementation
12
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
12
-- *
13
-- *
13
-- * </copyright>
14
-- * </copyright>
14
-- *
15
-- *
Lines 33-59 Link Here
33
%options backtrack
34
%options backtrack
34
%options noserialize
35
%options noserialize
35
%options package=org.eclipse.ocl.parser.backtracking
36
%options package=org.eclipse.ocl.parser.backtracking
36
%options import_terminals=OCLBacktrackingLexer.g
37
%options import_terminals=OCLBacktrackingLexer.gi
37
%options ast_type=CSTNode
38
%options ast_type=CSTNode
38
%options programming_language=java
39
%options programming_language=java
39
%options action=("*.java", "/.", "./")
40
%options action-block=("*.java", "/.", "./")
40
%options ParseTable=lpg.lpgjavaruntime.ParseTable
41
%options ParseTable=lpg.runtime.ParseTable
41
%options include_directory=".;..;../../lpg"
42
%options include_directory=".;..;../../lpg"
42
43
43
$Include
44
%Import
44
	OCLParserErrors.g
45
	OCLParserErrors.gi
45
$End
46
%End
46
47
47
$Globals
48
%Globals
48
	/.
49
	/.
49
		import org.eclipse.ocl.parser.AbstractOCLParser;
50
		import org.eclipse.ocl.parser.AbstractOCLParser;
50
	./
51
	./
51
$End
52
%End
52
53
53
$Define
54
%Define
54
	$lex_stream_class /.OCLBacktrackingLexer./
55
	$lex_stream_class /.OCLBacktrackingLexer./
55
	$prs_parser_class /.BacktrackingParser./
56
	$prs_parser_class /.BacktrackingParser./
56
	$prs_parser_exception /.NotBacktrackParseTableException./
57
	$prs_parser_exception /.NotBacktrackParseTableException./
57
	$prs_parser_throw /.throw new RuntimeException("****Error: Regenerate $prs_type.java with -BACKTRACK option")./
58
	$prs_parser_throw /.throw new RuntimeException("****Error: Regenerate $prs_type.java with -BACKTRACK option")./
58
	$prs_parse_args /.error_repair_count./
59
	$prs_parse_args /.error_repair_count./
59
$End
60
%End
61
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingLexersym.java (-13 / +6 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-33 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Borland - Bug 242880
14
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*
15
*
15
* </copyright>
16
* </copyright>
16
*
17
*
17
* $Id: OCLBacktrackingLexersym.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
18
* '$'Id''
18
*/
19
*/
19
20
20
package org.eclipse.ocl.parser.backtracking;
21
package org.eclipse.ocl.parser.backtracking;
21
22
22
/**
23
 * The backtracking variant of the OCL lexer symbol table.
24
 * 
25
 * @noimplement This interface is not intended to be implemented by clients.
26
 * @noextend This interface is not intended to be extended by clients.
27
 * 
28
 * @since 1.3
29
 */
30
@SuppressWarnings("nls")
31
public interface OCLBacktrackingLexersym {
23
public interface OCLBacktrackingLexersym {
32
    public final static int
24
    public final static int
33
      Char_CtlCharNotWS = 103,
25
      Char_CtlCharNotWS = 103,
Lines 134-140 Link Here
134
      Char_Equal = 15,
126
      Char_Equal = 15,
135
      Char_EOF = 99;
127
      Char_EOF = 99;
136
128
137
      public final static String orderedTerminalSymbols[] = {
129
    public final static String orderedTerminalSymbols[] = {
138
                 "",
130
                 "",
139
                 "0",
131
                 "0",
140
                 "1",
132
                 "1",
Lines 241-245 Link Here
241
                 "CtlCharNotWS"
233
                 "CtlCharNotWS"
242
             };
234
             };
243
235
236
    public final static int numTokenKinds = orderedTerminalSymbols.length;
244
    public final static boolean isValidForParser = true;
237
    public final static boolean isValidForParser = true;
245
}
238
}
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingKWLexerprs.java (-54 / +93 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-32 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*
14
*
15
* </copyright>
15
* </copyright>
16
*
16
*
17
* $Id: OCLBacktrackingKWLexerprs.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
17
* 
18
*/
18
*/
19
19
20
package org.eclipse.ocl.parser.backtracking;
20
package org.eclipse.ocl.parser.backtracking;
21
21
22
/**
22
public class OCLBacktrackingKWLexerprs implements lpg.runtime.ParseTable, OCLBacktrackingKWLexersym {
23
 * The backtracking variant of the OCL keyword lexer parse table.
23
    public final static int ERROR_SYMBOL = 0;
24
 * 
24
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
25
 * @noextend This class is not intended to be subclassed by clients.
25
26
 * 
26
    public final static int SCOPE_UBOUND = 0;
27
 * @since 1.3
27
    public final int getScopeUbound() { return SCOPE_UBOUND; }
28
 */
28
29
public class OCLBacktrackingKWLexerprs implements lpg.lpgjavaruntime.ParseTable, OCLBacktrackingKWLexersym {
29
    public final static int SCOPE_SIZE = 0;
30
    public final int getScopeSize() { return SCOPE_SIZE; }
31
32
    public final static int MAX_NAME_LENGTH = 0;
33
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
34
35
    public final static int NUM_STATES = 256;
36
    public final int getNumStates() { return NUM_STATES; }
37
38
    public final static int NT_OFFSET = 56;
39
    public final int getNtOffset() { return NT_OFFSET; }
40
41
    public final static int LA_STATE_OFFSET = 386;
42
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
43
44
    public final static int MAX_LA = 1;
45
    public final int getMaxLa() { return MAX_LA; }
46
47
    public final static int NUM_RULES = 63;
48
    public final int getNumRules() { return NUM_RULES; }
49
50
    public final static int NUM_NONTERMINALS = 2;
51
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
52
53
    public final static int NUM_SYMBOLS = 58;
54
    public final int getNumSymbols() { return NUM_SYMBOLS; }
55
56
    public final static int SEGMENT_SIZE = 8192;
57
    public final int getSegmentSize() { return SEGMENT_SIZE; }
58
59
    public final static int START_STATE = 64;
60
    public final int getStartState() { return START_STATE; }
61
62
    public final static int IDENTIFIER_SYMBOL = 0;
63
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
64
65
    public final static int EOFT_SYMBOL = 39;
66
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
67
68
    public final static int EOLT_SYMBOL = 57;
69
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
70
71
    public final static int ACCEPT_ACTION = 322;
72
    public final int getAcceptAction() { return ACCEPT_ACTION; }
73
74
    public final static int ERROR_ACTION = 323;
75
    public final int getErrorAction() { return ERROR_ACTION; }
76
77
    public final static boolean BACKTRACK = false;
78
    public final boolean getBacktrack() { return BACKTRACK; }
79
80
    public final int getStartSymbol() { return lhs(0); }
81
    public final boolean isValidForParser() { return OCLBacktrackingKWLexersym.isValidForParser; }
82
83
84
    public interface IsNullable {
85
        public final static byte isNullable[] = {0,
86
            0,0,0,0,0,0,0,0,0,0,
87
            0,0,0,0,0,0,0,0,0,0,
88
            0,0,0,0,0,0,0,0,0,0,
89
            0,0,0,0,0,0,0,0,0,0,
90
            0,0,0,0,0,0,0,0,0,0,
91
            0,0,0,0,0,0,0,0
92
        };
93
    };
94
    public final static byte isNullable[] = IsNullable.isNullable;
95
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
96
97
    public interface ProsthesesIndex {
98
        public final static byte prosthesesIndex[] = {0,
99
            2,1
100
        };
101
    };
102
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
103
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
30
104
31
    public interface IsKeyword {
105
    public interface IsKeyword {
32
        public final static byte isKeyword[] = {0,
106
        public final static byte isKeyword[] = {0,
Lines 35-41 Link Here
35
            0,0,0,0,0,0,0,0,0,0,
109
            0,0,0,0,0,0,0,0,0,0,
36
            0,0,0,0,0,0,0,0,0,0,
110
            0,0,0,0,0,0,0,0,0,0,
37
            0,0,0,0,0,0,0,0,0,0,
111
            0,0,0,0,0,0,0,0,0,0,
38
            0,0,0,0
112
            0,0,0,0,0,0
39
        };
113
        };
40
    };
114
    };
41
    public final static byte isKeyword[] = IsKeyword.isKeyword;
115
    public final static byte isKeyword[] = IsKeyword.isKeyword;
Lines 164-170 Link Here
164
            0,0,0,0,0,0,0,0,0,0,
238
            0,0,0,0,0,0,0,0,0,0,
165
            0,0,0,0,0,0,0,0,0,0,
239
            0,0,0,0,0,0,0,0,0,0,
166
            0,0,0,0,0,0,0,0,0,0,
240
            0,0,0,0,0,0,0,0,0,0,
167
            0,0,0,0,0
241
            0,0,0,0,0,0,0
168
        };
242
        };
169
    };
243
    };
170
    public final static byte termCheck[] = TermCheck.termCheck;
244
    public final static byte termCheck[] = TermCheck.termCheck;
Lines 250-305 Link Here
250
    public final int scopeState(int index) { return 0;}
324
    public final int scopeState(int index) { return 0;}
251
    public final int inSymb(int index) { return 0;}
325
    public final int inSymb(int index) { return 0;}
252
    public final String name(int index) { return null; }
326
    public final String name(int index) { return null; }
253
    public final int getErrorSymbol() { return 0; }
254
    public final int getScopeUbound() { return 0; }
255
    public final int getScopeSize() { return 0; }
256
    public final int getMaxNameLength() { return 0; }
257
258
    public final static int
259
           NUM_STATES        = 256,
260
           NT_OFFSET         = 54,
261
           LA_STATE_OFFSET   = 386,
262
           MAX_LA            = 1,
263
           NUM_RULES         = 63,
264
           NUM_NONTERMINALS  = 2,
265
           NUM_SYMBOLS       = 56,
266
           SEGMENT_SIZE      = 8192,
267
           START_STATE       = 64,
268
           IDENTIFIER_SYMBOL = 0,
269
           EOFT_SYMBOL       = 39,
270
           EOLT_SYMBOL       = 55,
271
           ACCEPT_ACTION     = 322,
272
           ERROR_ACTION      = 323;
273
274
    public final static boolean BACKTRACK = false;
275
276
    public final int getNumStates() { return NUM_STATES; }
277
    public final int getNtOffset() { return NT_OFFSET; }
278
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
279
    public final int getMaxLa() { return MAX_LA; }
280
    public final int getNumRules() { return NUM_RULES; }
281
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
282
    public final int getNumSymbols() { return NUM_SYMBOLS; }
283
    public final int getSegmentSize() { return SEGMENT_SIZE; }
284
    public final int getStartState() { return START_STATE; }
285
    public final int getStartSymbol() { return lhs[0]; }
286
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
287
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
288
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
289
    public final int getAcceptAction() { return ACCEPT_ACTION; }
290
    public final int getErrorAction() { return ERROR_ACTION; }
291
    public final boolean isValidForParser() { return isValidForParser; }
292
    public final boolean getBacktrack() { return BACKTRACK; }
293
294
    public final int originalState(int state) { return 0; }
327
    public final int originalState(int state) { return 0; }
295
    public final int asi(int state) { return 0; }
328
    public final int asi(int state) { return 0; }
296
    public final int nasi(int state) { return 0; }
329
    public final int nasi(int state) { return 0; }
297
    public final int inSymbol(int state) { return 0; }
330
    public final int inSymbol(int state) { return 0; }
298
331
332
    /**
333
     * assert(! goto_default);
334
     */
299
    public final int ntAction(int state, int sym) {
335
    public final int ntAction(int state, int sym) {
300
        return baseAction[state + sym];
336
        return baseAction[state + sym];
301
    }
337
    }
302
338
339
    /**
340
     * assert(! shift_default);
341
     */
303
    public final int tAction(int state, int sym) {
342
    public final int tAction(int state, int sym) {
304
        int i = baseAction[state],
343
        int i = baseAction[state],
305
            k = i + sym;
344
            k = i + sym;
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingKWLexer.java (-133 / +189 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-33 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*   
14
*
15
* </copyright>
15
* </copyright>
16
*
16
*
17
* $Id: OCLBacktrackingKWLexer.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
17
* 
18
*/
18
*/
19
19
20
package org.eclipse.ocl.parser.backtracking;
20
package org.eclipse.ocl.parser.backtracking;
21
21
22
22
23
24
/**
25
 * The backtracking variant of the OCL keyword lexer.
26
 * 
27
 * @noextend This class is not intended to be subclassed by clients.
28
 * 
29
 * @since 1.3
30
 */
31
public class OCLBacktrackingKWLexer extends OCLBacktrackingKWLexerprs implements OCLBacktrackingParsersym
23
public class OCLBacktrackingKWLexer extends OCLBacktrackingKWLexerprs implements OCLBacktrackingParsersym
32
{
24
{
33
    private char[] inputChars;
25
    private char[] inputChars;
Lines 65-130 Link Here
65
    final static int tokenKind[] = new int[128];
57
    final static int tokenKind[] = new int[128];
66
    static
58
    static
67
    {
59
    {
68
        tokenKind['$'] = Char_DollarSign;
60
        tokenKind['$'] = OCLBacktrackingKWLexersym.Char_DollarSign;
69
61
        tokenKind['%'] = OCLBacktrackingKWLexersym.Char_Percent;
70
        tokenKind['a'] = Char_a;
62
        tokenKind['_'] = OCLBacktrackingKWLexersym.Char__;
71
        tokenKind['b'] = Char_b;
63
72
        tokenKind['c'] = Char_c;
64
        tokenKind['a'] = OCLBacktrackingKWLexersym.Char_a;
73
        tokenKind['d'] = Char_d;
65
        tokenKind['b'] = OCLBacktrackingKWLexersym.Char_b;
74
        tokenKind['e'] = Char_e;
66
        tokenKind['c'] = OCLBacktrackingKWLexersym.Char_c;
75
        tokenKind['f'] = Char_f;
67
        tokenKind['d'] = OCLBacktrackingKWLexersym.Char_d;
76
        tokenKind['g'] = Char_g;
68
        tokenKind['e'] = OCLBacktrackingKWLexersym.Char_e;
77
        tokenKind['h'] = Char_h;
69
        tokenKind['f'] = OCLBacktrackingKWLexersym.Char_f;
78
        tokenKind['i'] = Char_i;
70
        tokenKind['g'] = OCLBacktrackingKWLexersym.Char_g;
79
        tokenKind['j'] = Char_j;
71
        tokenKind['h'] = OCLBacktrackingKWLexersym.Char_h;
80
        tokenKind['k'] = Char_k;
72
        tokenKind['i'] = OCLBacktrackingKWLexersym.Char_i;
81
        tokenKind['l'] = Char_l;
73
        tokenKind['j'] = OCLBacktrackingKWLexersym.Char_j;
82
        tokenKind['m'] = Char_m;
74
        tokenKind['k'] = OCLBacktrackingKWLexersym.Char_k;
83
        tokenKind['n'] = Char_n;
75
        tokenKind['l'] = OCLBacktrackingKWLexersym.Char_l;
84
        tokenKind['o'] = Char_o;
76
        tokenKind['m'] = OCLBacktrackingKWLexersym.Char_m;
85
        tokenKind['p'] = Char_p;
77
        tokenKind['n'] = OCLBacktrackingKWLexersym.Char_n;
86
        tokenKind['q'] = Char_q;
78
        tokenKind['o'] = OCLBacktrackingKWLexersym.Char_o;
87
        tokenKind['r'] = Char_r;
79
        tokenKind['p'] = OCLBacktrackingKWLexersym.Char_p;
88
        tokenKind['s'] = Char_s;
80
        tokenKind['q'] = OCLBacktrackingKWLexersym.Char_q;
89
        tokenKind['t'] = Char_t;
81
        tokenKind['r'] = OCLBacktrackingKWLexersym.Char_r;
90
        tokenKind['u'] = Char_u;
82
        tokenKind['s'] = OCLBacktrackingKWLexersym.Char_s;
91
        tokenKind['v'] = Char_v;
83
        tokenKind['t'] = OCLBacktrackingKWLexersym.Char_t;
92
        tokenKind['w'] = Char_w;
84
        tokenKind['u'] = OCLBacktrackingKWLexersym.Char_u;
93
        tokenKind['x'] = Char_x;
85
        tokenKind['v'] = OCLBacktrackingKWLexersym.Char_v;
94
        tokenKind['y'] = Char_y;
86
        tokenKind['w'] = OCLBacktrackingKWLexersym.Char_w;
95
        tokenKind['z'] = Char_z;
87
        tokenKind['x'] = OCLBacktrackingKWLexersym.Char_x;
96
88
        tokenKind['y'] = OCLBacktrackingKWLexersym.Char_y;
97
        tokenKind['A'] = Char_A;
89
        tokenKind['z'] = OCLBacktrackingKWLexersym.Char_z;
98
        tokenKind['B'] = Char_B;
90
99
        tokenKind['C'] = Char_C;
91
        tokenKind['A'] = OCLBacktrackingKWLexersym.Char_A;
100
        tokenKind['D'] = Char_D;
92
        tokenKind['B'] = OCLBacktrackingKWLexersym.Char_B;
101
        tokenKind['E'] = Char_E;
93
        tokenKind['C'] = OCLBacktrackingKWLexersym.Char_C;
102
        tokenKind['F'] = Char_F;
94
        tokenKind['D'] = OCLBacktrackingKWLexersym.Char_D;
103
        tokenKind['G'] = Char_G;
95
        tokenKind['E'] = OCLBacktrackingKWLexersym.Char_E;
104
        tokenKind['H'] = Char_H;
96
        tokenKind['F'] = OCLBacktrackingKWLexersym.Char_F;
105
        tokenKind['I'] = Char_I;
97
        tokenKind['G'] = OCLBacktrackingKWLexersym.Char_G;
106
        tokenKind['J'] = Char_J;
98
        tokenKind['H'] = OCLBacktrackingKWLexersym.Char_H;
107
        tokenKind['K'] = Char_K;
99
        tokenKind['I'] = OCLBacktrackingKWLexersym.Char_I;
108
        tokenKind['L'] = Char_L;
100
        tokenKind['J'] = OCLBacktrackingKWLexersym.Char_J;
109
        tokenKind['M'] = Char_M;
101
        tokenKind['K'] = OCLBacktrackingKWLexersym.Char_K;
110
        tokenKind['N'] = Char_N;
102
        tokenKind['L'] = OCLBacktrackingKWLexersym.Char_L;
111
        tokenKind['O'] = Char_O;
103
        tokenKind['M'] = OCLBacktrackingKWLexersym.Char_M;
112
        tokenKind['P'] = Char_P;
104
        tokenKind['N'] = OCLBacktrackingKWLexersym.Char_N;
113
        tokenKind['Q'] = Char_Q;
105
        tokenKind['O'] = OCLBacktrackingKWLexersym.Char_O;
114
        tokenKind['R'] = Char_R;
106
        tokenKind['P'] = OCLBacktrackingKWLexersym.Char_P;
115
        tokenKind['S'] = Char_S;
107
        tokenKind['Q'] = OCLBacktrackingKWLexersym.Char_Q;
116
        tokenKind['T'] = Char_T;
108
        tokenKind['R'] = OCLBacktrackingKWLexersym.Char_R;
117
        tokenKind['U'] = Char_U;
109
        tokenKind['S'] = OCLBacktrackingKWLexersym.Char_S;
118
        tokenKind['V'] = Char_V;
110
        tokenKind['T'] = OCLBacktrackingKWLexersym.Char_T;
119
        tokenKind['W'] = Char_W;
111
        tokenKind['U'] = OCLBacktrackingKWLexersym.Char_U;
120
        tokenKind['X'] = Char_X;
112
        tokenKind['V'] = OCLBacktrackingKWLexersym.Char_V;
121
        tokenKind['Y'] = Char_Y;
113
        tokenKind['W'] = OCLBacktrackingKWLexersym.Char_W;
122
        tokenKind['Z'] = Char_Z;
114
        tokenKind['X'] = OCLBacktrackingKWLexersym.Char_X;
115
        tokenKind['Y'] = OCLBacktrackingKWLexersym.Char_Y;
116
        tokenKind['Z'] = OCLBacktrackingKWLexersym.Char_Z;
123
    };
117
    };
124
118
125
    final int getKind(char c)
119
    final int getKind(int c)
126
    {
120
    {
127
        return (c < 128 ? tokenKind[c] : 0);
121
        return (((c & 0xFFFFFF80) == 0) /* 0 <= c < 128? */ ? tokenKind[c] : 0);
128
    }
122
    }
129
123
130
124
Lines 136-517 Link Here
136
        //
130
        //
137
        // Rule 1:  KeyWord ::= s e l f
131
        // Rule 1:  KeyWord ::= s e l f
138
        //
132
        //
139
		keywordKind[1] = (TK_self);
133
        
134
		keywordKind[1] = (OCLBacktrackingParsersym.TK_self);
140
	  
135
	  
141
	
136
	
142
        //
137
        //
143
        // Rule 2:  KeyWord ::= i n v
138
        // Rule 2:  KeyWord ::= i n v
144
        //
139
        //
145
		keywordKind[2] = (TK_inv);
140
        
141
		keywordKind[2] = (OCLBacktrackingParsersym.TK_inv);
146
	  
142
	  
147
	
143
	
148
        //
144
        //
149
        // Rule 3:  KeyWord ::= p r e
145
        // Rule 3:  KeyWord ::= p r e
150
        //
146
        //
151
		keywordKind[3] = (TK_pre);
147
        
148
		keywordKind[3] = (OCLBacktrackingParsersym.TK_pre);
152
	  
149
	  
153
	
150
	
154
        //
151
        //
155
        // Rule 4:  KeyWord ::= p o s t
152
        // Rule 4:  KeyWord ::= p o s t
156
        //
153
        //
157
		keywordKind[4] = (TK_post);
154
        
155
		keywordKind[4] = (OCLBacktrackingParsersym.TK_post);
158
	  
156
	  
159
	
157
	
160
        //
158
        //
161
        // Rule 5:  KeyWord ::= b o d y
159
        // Rule 5:  KeyWord ::= b o d y
162
        //
160
        //
163
		keywordKind[5] = (TK_body);
161
        
162
		keywordKind[5] = (OCLBacktrackingParsersym.TK_body);
164
	  
163
	  
165
	
164
	
166
        //
165
        //
167
        // Rule 6:  KeyWord ::= c o n t e x t
166
        // Rule 6:  KeyWord ::= c o n t e x t
168
        //
167
        //
169
		keywordKind[6] = (TK_context);
168
        
169
		keywordKind[6] = (OCLBacktrackingParsersym.TK_context);
170
	  
170
	  
171
	
171
	
172
        //
172
        //
173
        // Rule 7:  KeyWord ::= p a c k a g e
173
        // Rule 7:  KeyWord ::= p a c k a g e
174
        //
174
        //
175
		keywordKind[7] = (TK_package);
175
        
176
		keywordKind[7] = (OCLBacktrackingParsersym.TK_package);
176
	  
177
	  
177
	
178
	
178
        //
179
        //
179
        // Rule 8:  KeyWord ::= e n d p a c k a g e
180
        // Rule 8:  KeyWord ::= e n d p a c k a g e
180
        //
181
        //
181
		keywordKind[8] = (TK_endpackage);
182
        
183
		keywordKind[8] = (OCLBacktrackingParsersym.TK_endpackage);
182
	  
184
	  
183
	
185
	
184
        //
186
        //
185
        // Rule 9:  KeyWord ::= d e f
187
        // Rule 9:  KeyWord ::= d e f
186
        //
188
        //
187
		keywordKind[9] = (TK_def);
189
        
190
		keywordKind[9] = (OCLBacktrackingParsersym.TK_def);
188
	  
191
	  
189
	
192
	
190
        //
193
        //
191
        // Rule 10:  KeyWord ::= d e r i v e
194
        // Rule 10:  KeyWord ::= d e r i v e
192
        //
195
        //
193
		keywordKind[10] = (TK_derive);
196
        
197
		keywordKind[10] = (OCLBacktrackingParsersym.TK_derive);
194
	  
198
	  
195
	
199
	
196
        //
200
        //
197
        // Rule 11:  KeyWord ::= i n i t
201
        // Rule 11:  KeyWord ::= i n i t
198
        //
202
        //
199
		keywordKind[11] = (TK_init);
203
        
204
		keywordKind[11] = (OCLBacktrackingParsersym.TK_init);
200
	  
205
	  
201
	
206
	
202
        //
207
        //
203
        // Rule 12:  KeyWord ::= i f
208
        // Rule 12:  KeyWord ::= i f
204
        //
209
        //
205
		keywordKind[12] = (TK_if);
210
        
211
		keywordKind[12] = (OCLBacktrackingParsersym.TK_if);
206
	  
212
	  
207
	
213
	
208
        //
214
        //
209
        // Rule 13:  KeyWord ::= t h e n
215
        // Rule 13:  KeyWord ::= t h e n
210
        //
216
        //
211
		keywordKind[13] = (TK_then);
217
        
218
		keywordKind[13] = (OCLBacktrackingParsersym.TK_then);
212
	  
219
	  
213
	
220
	
214
        //
221
        //
215
        // Rule 14:  KeyWord ::= e l s e
222
        // Rule 14:  KeyWord ::= e l s e
216
        //
223
        //
217
		keywordKind[14] = (TK_else);
224
        
225
		keywordKind[14] = (OCLBacktrackingParsersym.TK_else);
218
	  
226
	  
219
	
227
	
220
        //
228
        //
221
        // Rule 15:  KeyWord ::= e n d i f
229
        // Rule 15:  KeyWord ::= e n d i f
222
        //
230
        //
223
		keywordKind[15] = (TK_endif);
231
        
232
		keywordKind[15] = (OCLBacktrackingParsersym.TK_endif);
224
	  
233
	  
225
	
234
	
226
        //
235
        //
227
        // Rule 16:  KeyWord ::= a n d
236
        // Rule 16:  KeyWord ::= a n d
228
        //
237
        //
229
		keywordKind[16] = (TK_and);
238
        
239
		keywordKind[16] = (OCLBacktrackingParsersym.TK_and);
230
	  
240
	  
231
	
241
	
232
        //
242
        //
233
        // Rule 17:  KeyWord ::= o r
243
        // Rule 17:  KeyWord ::= o r
234
        //
244
        //
235
		keywordKind[17] = (TK_or);
245
        
246
		keywordKind[17] = (OCLBacktrackingParsersym.TK_or);
236
	  
247
	  
237
	
248
	
238
        //
249
        //
239
        // Rule 18:  KeyWord ::= x o r
250
        // Rule 18:  KeyWord ::= x o r
240
        //
251
        //
241
		keywordKind[18] = (TK_xor);
252
        
253
		keywordKind[18] = (OCLBacktrackingParsersym.TK_xor);
242
	  
254
	  
243
	
255
	
244
        //
256
        //
245
        // Rule 19:  KeyWord ::= n o t
257
        // Rule 19:  KeyWord ::= n o t
246
        //
258
        //
247
		keywordKind[19] = (TK_not);
259
        
260
		keywordKind[19] = (OCLBacktrackingParsersym.TK_not);
248
	  
261
	  
249
	
262
	
250
        //
263
        //
251
        // Rule 20:  KeyWord ::= i m p l i e s
264
        // Rule 20:  KeyWord ::= i m p l i e s
252
        //
265
        //
253
		keywordKind[20] = (TK_implies);
266
        
267
		keywordKind[20] = (OCLBacktrackingParsersym.TK_implies);
254
	  
268
	  
255
	
269
	
256
        //
270
        //
257
        // Rule 21:  KeyWord ::= l e t
271
        // Rule 21:  KeyWord ::= l e t
258
        //
272
        //
259
		keywordKind[21] = (TK_let);
273
        
274
		keywordKind[21] = (OCLBacktrackingParsersym.TK_let);
260
	  
275
	  
261
	
276
	
262
        //
277
        //
263
        // Rule 22:  KeyWord ::= i n
278
        // Rule 22:  KeyWord ::= i n
264
        //
279
        //
265
		keywordKind[22] = (TK_in);
280
        
281
		keywordKind[22] = (OCLBacktrackingParsersym.TK_in);
266
	  
282
	  
267
	
283
	
268
        //
284
        //
269
        // Rule 23:  KeyWord ::= t r u e
285
        // Rule 23:  KeyWord ::= t r u e
270
        //
286
        //
271
		keywordKind[23] = (TK_true);
287
        
288
		keywordKind[23] = (OCLBacktrackingParsersym.TK_true);
272
	  
289
	  
273
	
290
	
274
        //
291
        //
275
        // Rule 24:  KeyWord ::= f a l s e
292
        // Rule 24:  KeyWord ::= f a l s e
276
        //
293
        //
277
		keywordKind[24] = (TK_false);
294
        
295
		keywordKind[24] = (OCLBacktrackingParsersym.TK_false);
278
	  
296
	  
279
	
297
	
280
        //
298
        //
281
        // Rule 25:  KeyWord ::= S e t
299
        // Rule 25:  KeyWord ::= S e t
282
        //
300
        //
283
		keywordKind[25] = (TK_Set);
301
        
302
		keywordKind[25] = (OCLBacktrackingParsersym.TK_Set);
284
	  
303
	  
285
	
304
	
286
        //
305
        //
287
        // Rule 26:  KeyWord ::= B a g
306
        // Rule 26:  KeyWord ::= B a g
288
        //
307
        //
289
		keywordKind[26] = (TK_Bag);
308
        
309
		keywordKind[26] = (OCLBacktrackingParsersym.TK_Bag);
290
	  
310
	  
291
	
311
	
292
        //
312
        //
293
        // Rule 27:  KeyWord ::= S e q u e n c e
313
        // Rule 27:  KeyWord ::= S e q u e n c e
294
        //
314
        //
295
		keywordKind[27] = (TK_Sequence);
315
        
316
		keywordKind[27] = (OCLBacktrackingParsersym.TK_Sequence);
296
	  
317
	  
297
	
318
	
298
        //
319
        //
299
        // Rule 28:  KeyWord ::= C o l l e c t i o n
320
        // Rule 28:  KeyWord ::= C o l l e c t i o n
300
        //
321
        //
301
		keywordKind[28] = (TK_Collection);
322
        
323
		keywordKind[28] = (OCLBacktrackingParsersym.TK_Collection);
302
	  
324
	  
303
	
325
	
304
        //
326
        //
305
        // Rule 29:  KeyWord ::= O r d e r e d S e t
327
        // Rule 29:  KeyWord ::= O r d e r e d S e t
306
        //
328
        //
307
		keywordKind[29] = (TK_OrderedSet);
329
        
330
		keywordKind[29] = (OCLBacktrackingParsersym.TK_OrderedSet);
308
	  
331
	  
309
	
332
	
310
        //
333
        //
311
        // Rule 30:  KeyWord ::= i t e r a t e
334
        // Rule 30:  KeyWord ::= i t e r a t e
312
        //
335
        //
313
		keywordKind[30] = (TK_iterate);
336
        
337
		keywordKind[30] = (OCLBacktrackingParsersym.TK_iterate);
314
	  
338
	  
315
	
339
	
316
        //
340
        //
317
        // Rule 31:  KeyWord ::= f o r A l l
341
        // Rule 31:  KeyWord ::= f o r A l l
318
        //
342
        //
319
		keywordKind[31] = (TK_forAll);
343
        
344
		keywordKind[31] = (OCLBacktrackingParsersym.TK_forAll);
320
	  
345
	  
321
	
346
	
322
        //
347
        //
323
        // Rule 32:  KeyWord ::= e x i s t s
348
        // Rule 32:  KeyWord ::= e x i s t s
324
        //
349
        //
325
		keywordKind[32] = (TK_exists);
350
        
351
		keywordKind[32] = (OCLBacktrackingParsersym.TK_exists);
326
	  
352
	  
327
	
353
	
328
        //
354
        //
329
        // Rule 33:  KeyWord ::= i s U n i q u e
355
        // Rule 33:  KeyWord ::= i s U n i q u e
330
        //
356
        //
331
		keywordKind[33] = (TK_isUnique);
357
        
358
		keywordKind[33] = (OCLBacktrackingParsersym.TK_isUnique);
332
	  
359
	  
333
	
360
	
334
        //
361
        //
335
        // Rule 34:  KeyWord ::= a n y
362
        // Rule 34:  KeyWord ::= a n y
336
        //
363
        //
337
		keywordKind[34] = (TK_any);
364
        
365
		keywordKind[34] = (OCLBacktrackingParsersym.TK_any);
338
	  
366
	  
339
	
367
	
340
        //
368
        //
341
        // Rule 35:  KeyWord ::= o n e
369
        // Rule 35:  KeyWord ::= o n e
342
        //
370
        //
343
		keywordKind[35] = (TK_one);
371
        
372
		keywordKind[35] = (OCLBacktrackingParsersym.TK_one);
344
	  
373
	  
345
	
374
	
346
        //
375
        //
347
        // Rule 36:  KeyWord ::= c o l l e c t
376
        // Rule 36:  KeyWord ::= c o l l e c t
348
        //
377
        //
349
		keywordKind[36] = (TK_collect);
378
        
379
		keywordKind[36] = (OCLBacktrackingParsersym.TK_collect);
350
	  
380
	  
351
	
381
	
352
        //
382
        //
353
        // Rule 37:  KeyWord ::= s e l e c t
383
        // Rule 37:  KeyWord ::= s e l e c t
354
        //
384
        //
355
		keywordKind[37] = (TK_select);
385
        
386
		keywordKind[37] = (OCLBacktrackingParsersym.TK_select);
356
	  
387
	  
357
	
388
	
358
        //
389
        //
359
        // Rule 38:  KeyWord ::= r e j e c t
390
        // Rule 38:  KeyWord ::= r e j e c t
360
        //
391
        //
361
		keywordKind[38] = (TK_reject);
392
        
393
		keywordKind[38] = (OCLBacktrackingParsersym.TK_reject);
362
	  
394
	  
363
	
395
	
364
        //
396
        //
365
        // Rule 39:  KeyWord ::= c o l l e c t N e s t e d
397
        // Rule 39:  KeyWord ::= c o l l e c t N e s t e d
366
        //
398
        //
367
		keywordKind[39] = (TK_collectNested);
399
        
400
		keywordKind[39] = (OCLBacktrackingParsersym.TK_collectNested);
368
	  
401
	  
369
	
402
	
370
        //
403
        //
371
        // Rule 40:  KeyWord ::= s o r t e d B y
404
        // Rule 40:  KeyWord ::= s o r t e d B y
372
        //
405
        //
373
		keywordKind[40] = (TK_sortedBy);
406
        
407
		keywordKind[40] = (OCLBacktrackingParsersym.TK_sortedBy);
374
	  
408
	  
375
	
409
	
376
        //
410
        //
377
        // Rule 41:  KeyWord ::= c l o s u r e
411
        // Rule 41:  KeyWord ::= c l o s u r e
378
        //
412
        //
379
		keywordKind[41] = (TK_closure);
413
        
414
		keywordKind[41] = (OCLBacktrackingParsersym.TK_closure);
380
	  
415
	  
381
	
416
	
382
        //
417
        //
383
        // Rule 42:  KeyWord ::= o c l I s K i n d O f
418
        // Rule 42:  KeyWord ::= o c l I s K i n d O f
384
        //
419
        //
385
		keywordKind[42] = (TK_oclIsKindOf);
420
        
421
		keywordKind[42] = (OCLBacktrackingParsersym.TK_oclIsKindOf);
386
	  
422
	  
387
	
423
	
388
        //
424
        //
389
        // Rule 43:  KeyWord ::= o c l I s T y p e O f
425
        // Rule 43:  KeyWord ::= o c l I s T y p e O f
390
        //
426
        //
391
		keywordKind[43] = (TK_oclIsTypeOf);
427
        
428
		keywordKind[43] = (OCLBacktrackingParsersym.TK_oclIsTypeOf);
392
	  
429
	  
393
	
430
	
394
        //
431
        //
395
        // Rule 44:  KeyWord ::= o c l A s T y p e
432
        // Rule 44:  KeyWord ::= o c l A s T y p e
396
        //
433
        //
397
		keywordKind[44] = (TK_oclAsType);
434
        
435
		keywordKind[44] = (OCLBacktrackingParsersym.TK_oclAsType);
398
	  
436
	  
399
	
437
	
400
        //
438
        //
401
        // Rule 45:  KeyWord ::= o c l I s N e w
439
        // Rule 45:  KeyWord ::= o c l I s N e w
402
        //
440
        //
403
		keywordKind[45] = (TK_oclIsNew);
441
        
442
		keywordKind[45] = (OCLBacktrackingParsersym.TK_oclIsNew);
404
	  
443
	  
405
	
444
	
406
        //
445
        //
407
        // Rule 46:  KeyWord ::= o c l I s U n d e f i n e d
446
        // Rule 46:  KeyWord ::= o c l I s U n d e f i n e d
408
        //
447
        //
409
		keywordKind[46] = (TK_oclIsUndefined);
448
        
449
		keywordKind[46] = (OCLBacktrackingParsersym.TK_oclIsUndefined);
410
	  
450
	  
411
	
451
	
412
        //
452
        //
413
        // Rule 47:  KeyWord ::= o c l I s I n v a l i d
453
        // Rule 47:  KeyWord ::= o c l I s I n v a l i d
414
        //
454
        //
415
		keywordKind[47] = (TK_oclIsInvalid);
455
        
456
		keywordKind[47] = (OCLBacktrackingParsersym.TK_oclIsInvalid);
416
	  
457
	  
417
	
458
	
418
        //
459
        //
419
        // Rule 48:  KeyWord ::= o c l I s I n S t a t e
460
        // Rule 48:  KeyWord ::= o c l I s I n S t a t e
420
        //
461
        //
421
		keywordKind[48] = (TK_oclIsInState);
462
        
463
		keywordKind[48] = (OCLBacktrackingParsersym.TK_oclIsInState);
422
	  
464
	  
423
	
465
	
424
        //
466
        //
425
        // Rule 49:  KeyWord ::= a l l I n s t a n c e s
467
        // Rule 49:  KeyWord ::= a l l I n s t a n c e s
426
        //
468
        //
427
		keywordKind[49] = (TK_allInstances);
469
        
470
		keywordKind[49] = (OCLBacktrackingParsersym.TK_allInstances);
428
	  
471
	  
429
	
472
	
430
        //
473
        //
431
        // Rule 50:  KeyWord ::= S t r i n g
474
        // Rule 50:  KeyWord ::= S t r i n g
432
        //
475
        //
433
		keywordKind[50] = (TK_String);
476
        
477
		keywordKind[50] = (OCLBacktrackingParsersym.TK_String);
434
	  
478
	  
435
	
479
	
436
        //
480
        //
437
        // Rule 51:  KeyWord ::= I n t e g e r
481
        // Rule 51:  KeyWord ::= I n t e g e r
438
        //
482
        //
439
		keywordKind[51] = (TK_Integer);
483
        
484
		keywordKind[51] = (OCLBacktrackingParsersym.TK_Integer);
440
	  
485
	  
441
	
486
	
442
        //
487
        //
443
        // Rule 52:  KeyWord ::= U n l i m i t e d N a t u r a l
488
        // Rule 52:  KeyWord ::= U n l i m i t e d N a t u r a l
444
        //
489
        //
445
		keywordKind[52] = (TK_UnlimitedNatural);
490
        
491
		keywordKind[52] = (OCLBacktrackingParsersym.TK_UnlimitedNatural);
446
	  
492
	  
447
	
493
	
448
        //
494
        //
449
        // Rule 53:  KeyWord ::= R e a l
495
        // Rule 53:  KeyWord ::= R e a l
450
        //
496
        //
451
		keywordKind[53] = (TK_Real);
497
        
498
		keywordKind[53] = (OCLBacktrackingParsersym.TK_Real);
452
	  
499
	  
453
	
500
	
454
        //
501
        //
455
        // Rule 54:  KeyWord ::= B o o l e a n
502
        // Rule 54:  KeyWord ::= B o o l e a n
456
        //
503
        //
457
		keywordKind[54] = (TK_Boolean);
504
        
505
		keywordKind[54] = (OCLBacktrackingParsersym.TK_Boolean);
458
	  
506
	  
459
	
507
	
460
        //
508
        //
461
        // Rule 55:  KeyWord ::= T u p l e
509
        // Rule 55:  KeyWord ::= T u p l e
462
        //
510
        //
463
		keywordKind[55] = (TK_Tuple);
511
        
512
		keywordKind[55] = (OCLBacktrackingParsersym.TK_Tuple);
464
	  
513
	  
465
	
514
	
466
        //
515
        //
467
        // Rule 56:  KeyWord ::= O c l A n y
516
        // Rule 56:  KeyWord ::= O c l A n y
468
        //
517
        //
469
		keywordKind[56] = (TK_OclAny);
518
        
519
		keywordKind[56] = (OCLBacktrackingParsersym.TK_OclAny);
470
	  
520
	  
471
	
521
	
472
        //
522
        //
473
        // Rule 57:  KeyWord ::= O c l V o i d
523
        // Rule 57:  KeyWord ::= O c l V o i d
474
        //
524
        //
475
		keywordKind[57] = (TK_OclVoid);
525
        
526
		keywordKind[57] = (OCLBacktrackingParsersym.TK_OclVoid);
476
	  
527
	  
477
	
528
	
478
        //
529
        //
479
        // Rule 58:  KeyWord ::= I n v a l i d
530
        // Rule 58:  KeyWord ::= I n v a l i d
480
        //
531
        //
481
		keywordKind[58] = (TK_Invalid);
532
        
533
		keywordKind[58] = (OCLBacktrackingParsersym.TK_Invalid);
482
	  
534
	  
483
	
535
	
484
        //
536
        //
485
        // Rule 59:  KeyWord ::= O c l M e s s a g e
537
        // Rule 59:  KeyWord ::= O c l M e s s a g e
486
        //
538
        //
487
		keywordKind[59] = (TK_OclMessage);
539
        
540
		keywordKind[59] = (OCLBacktrackingParsersym.TK_OclMessage);
488
	  
541
	  
489
	
542
	
490
        //
543
        //
491
        // Rule 60:  KeyWord ::= n u l l
544
        // Rule 60:  KeyWord ::= n u l l
492
        //
545
        //
493
		keywordKind[60] = (TK_null);
546
        
547
		keywordKind[60] = (OCLBacktrackingParsersym.TK_null);
494
	  
548
	  
495
	
549
	
496
        //
550
        //
497
        // Rule 61:  KeyWord ::= O c l I n v a l i d
551
        // Rule 61:  KeyWord ::= O c l I n v a l i d
498
        //
552
        //
499
		keywordKind[61] = (TK_OclInvalid);
553
        
554
		keywordKind[61] = (OCLBacktrackingParsersym.TK_OclInvalid);
500
	  
555
	  
501
	
556
	
502
        //
557
        //
503
        // Rule 62:  KeyWord ::= a t t r
558
        // Rule 62:  KeyWord ::= a t t r
504
        //
559
        //
505
		keywordKind[62] = (TK_attr);
560
        
561
		keywordKind[62] = (OCLBacktrackingParsersym.TK_attr);
506
	  
562
	  
507
	
563
	
508
        //
564
        //
509
        // Rule 63:  KeyWord ::= o p e r
565
        // Rule 63:  KeyWord ::= o p e r
510
        //
566
        //
511
		keywordKind[63] = (TK_oper);
567
        
568
		keywordKind[63] = (OCLBacktrackingParsersym.TK_oper);
512
	  
569
	  
513
	
570
	
514
515
        for (int i = 0; i < keywordKind.length; i++)
571
        for (int i = 0; i < keywordKind.length; i++)
516
        {
572
        {
517
            if (keywordKind[i] == 0)
573
            if (keywordKind[i] == 0)
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingParserprs.java (-77 / +137 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 13-35 Link Here
13
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
16
*
19
*
17
* </copyright>
20
* </copyright>
18
*
21
*
19
* $Id: OCLBacktrackingParserprs.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
20
*/
23
*/
21
24
22
package org.eclipse.ocl.parser.backtracking;
25
package org.eclipse.ocl.parser.backtracking;
23
26
24
/**
27
public class OCLBacktrackingParserprs implements lpg.runtime.ParseTable, OCLBacktrackingParsersym {
25
 * The backtracking variant of the OCL parser parse table.
28
    public final static int ERROR_SYMBOL = 1;
26
 * 
29
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
27
 * @noextend This class is not intended to be subclassed by clients.
30
28
 * 
31
    public final static int SCOPE_UBOUND = 58;
29
 * @since 1.3
32
    public final int getScopeUbound() { return SCOPE_UBOUND; }
30
 */
33
31
@SuppressWarnings("nls")
34
    public final static int SCOPE_SIZE = 59;
32
public class OCLBacktrackingParserprs implements lpg.lpgjavaruntime.ParseTable, OCLBacktrackingParsersym {
35
    public final int getScopeSize() { return SCOPE_SIZE; }
36
37
    public final static int MAX_NAME_LENGTH = 26;
38
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
39
40
    public final static int NUM_STATES = 241;
41
    public final int getNumStates() { return NUM_STATES; }
42
43
    public final static int NT_OFFSET = 99;
44
    public final int getNtOffset() { return NT_OFFSET; }
45
46
    public final static int LA_STATE_OFFSET = 3795;
47
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
48
49
    public final static int MAX_LA = 2;
50
    public final int getMaxLa() { return MAX_LA; }
51
52
    public final static int NUM_RULES = 328;
53
    public final int getNumRules() { return NUM_RULES; }
54
55
    public final static int NUM_NONTERMINALS = 109;
56
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
57
58
    public final static int NUM_SYMBOLS = 208;
59
    public final int getNumSymbols() { return NUM_SYMBOLS; }
60
61
    public final static int SEGMENT_SIZE = 8192;
62
    public final int getSegmentSize() { return SEGMENT_SIZE; }
63
64
    public final static int START_STATE = 3223;
65
    public final int getStartState() { return START_STATE; }
66
67
    public final static int IDENTIFIER_SYMBOL = 4;
68
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
69
70
    public final static int EOFT_SYMBOL = 73;
71
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
72
73
    public final static int EOLT_SYMBOL = 73;
74
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
75
76
    public final static int ACCEPT_ACTION = 3466;
77
    public final int getAcceptAction() { return ACCEPT_ACTION; }
78
79
    public final static int ERROR_ACTION = 3467;
80
    public final int getErrorAction() { return ERROR_ACTION; }
81
82
    public final static boolean BACKTRACK = true;
83
    public final boolean getBacktrack() { return BACKTRACK; }
84
85
    public final int getStartSymbol() { return lhs(0); }
86
    public final boolean isValidForParser() { return OCLBacktrackingParsersym.isValidForParser; }
87
88
89
    public interface IsNullable {
90
        public final static byte isNullable[] = {0,
91
            0,0,0,0,0,0,0,0,0,0,
92
            0,0,0,0,0,0,0,0,0,0,
93
            0,0,0,0,0,0,0,0,0,0,
94
            0,0,0,0,0,0,0,0,0,0,
95
            0,0,0,0,0,0,0,0,0,0,
96
            0,0,0,0,0,0,0,0,0,0,
97
            0,0,0,0,0,0,0,0,0,0,
98
            0,0,0,0,0,0,0,0,0,0,
99
            0,0,0,0,0,0,0,0,0,0,
100
            0,0,0,0,0,0,0,0,0,0,
101
            0,0,0,0,0,0,0,0,0,0,
102
            0,0,0,0,0,0,0,0,0,0,
103
            0,0,0,0,0,0,0,0,0,0,
104
            0,0,0,0,0,0,0,0,0,0,
105
            0,0,0,0,0,0,0,0,0,1,
106
            0,0,1,0,0,0,0,1,0,0,
107
            0,0,0,0,0,0,0,0,1,1,
108
            0,1,0,0,0,0,0,0,1,1,
109
            0,0,0,0,1,1,0,0,0,0,
110
            0,0,1,0,0,0,0,0,1,0,
111
            0,1,0,0,0,0,0,0
112
        };
113
    };
114
    public final static byte isNullable[] = IsNullable.isNullable;
115
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
116
117
    public interface ProsthesesIndex {
118
        public final static byte prosthesesIndex[] = {0,
119
            54,9,21,108,62,5,6,7,10,3,
120
            8,15,50,51,11,40,42,44,48,49,
121
            56,57,58,59,60,61,67,68,69,70,
122
            71,41,43,38,39,34,35,36,37,32,
123
            33,30,31,28,29,25,26,27,77,23,
124
            52,53,105,47,109,78,80,81,24,107,
125
            97,98,99,100,88,91,92,4,12,19,
126
            20,22,55,65,66,73,79,83,84,85,
127
            86,87,93,94,96,101,2,13,14,17,
128
            18,45,46,63,64,72,74,75,76,82,
129
            89,90,95,102,103,104,106,1,16
130
        };
131
    };
132
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
133
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
33
134
34
    public interface IsKeyword {
135
    public interface IsKeyword {
35
        public final static byte isKeyword[] = {0,
136
        public final static byte isKeyword[] = {0,
Lines 1541-1573 Link Here
1541
1642
1542
    public interface ScopeRhs {
1643
    public interface ScopeRhs {
1543
        public final static char scopeRhs[] = {0,
1644
        public final static char scopeRhs[] = {0,
1544
            151,94,114,0,100,0,151,94,101,0,
1645
            151,94,114,0,1,0,151,94,101,0,
1545
            145,2,0,145,69,0,145,90,145,69,
1646
            145,2,0,145,69,0,145,90,145,69,
1546
            0,43,116,100,0,145,91,145,90,145,
1647
            0,90,145,1,0,145,91,145,90,145,
1547
            69,0,44,116,100,0,43,116,44,116,
1648
            69,0,91,145,1,0,90,145,91,145,
1548
            100,0,153,2,159,110,0,12,0,153,
1649
            1,0,153,2,159,110,0,3,0,153,
1549
            2,159,108,0,153,2,159,168,0,153,
1650
            2,159,108,0,153,2,159,168,0,153,
1550
            2,154,80,102,0,155,2,104,0,180,
1651
            2,154,80,102,0,155,2,104,0,180,
1551
            2,101,89,0,180,2,101,88,0,45,
1652
            2,101,89,0,180,2,101,88,0,84,
1552
            0,44,116,45,0,43,116,44,116,45,
1653
            0,91,145,84,0,90,145,91,145,84,
1553
            0,177,68,0,52,116,0,16,0,0,
1654
            0,177,68,0,83,145,0,79,150,0,
1554
            153,2,150,108,0,153,2,150,110,0,
1655
            153,2,150,108,0,153,2,150,110,0,
1555
            153,2,150,168,0,199,2,52,0,155,
1656
            153,2,150,168,0,199,2,52,0,155,
1556
            37,4,0,7,116,0,145,70,149,81,
1657
            37,4,0,5,145,0,145,70,149,81,
1557
            149,2,187,0,149,81,149,2,187,0,
1658
            149,2,187,0,149,81,149,2,187,0,
1558
            18,116,12,0,149,2,187,0,22,115,
1659
            70,145,3,0,149,2,187,0,81,149,
1559
            18,116,12,0,145,70,149,2,187,0,
1660
            70,145,3,0,145,70,149,2,187,0,
1560
            145,70,149,31,149,2,188,0,149,31,
1661
            145,70,149,31,149,2,188,0,149,31,
1561
            149,2,188,0,149,2,188,0,19,115,
1662
            149,2,188,0,149,2,188,0,31,149,
1562
            18,116,12,0,145,70,149,2,188,0,
1663
            70,145,3,0,145,70,149,2,188,0,
1563
            145,2,188,0,195,93,52,0,14,0,
1664
            145,2,188,0,195,93,52,0,74,0,
1564
            193,93,104,0,153,2,101,80,102,0,
1665
            193,93,104,0,153,2,101,80,102,0,
1565
            153,2,61,0,133,0,4,130,0,3,
1666
            153,2,61,0,133,0,9,131,0,8,
1566
            130,0,137,0,2,128,0,1,128,0,
1667
            131,0,137,0,29,134,0,28,134,0,
1567
            139,0,9,125,0,8,125,0,6,125,
1668
            139,0,13,136,0,12,136,0,11,136,
1568
            0,5,125,0,141,0,10,123,0,7,
1669
            0,10,136,0,141,0,7,140,0,5,
1569
            123,0,143,0,48,121,0,47,121,0,
1670
            140,0,143,0,27,142,0,26,142,0,
1570
            46,121,0
1671
            25,142,0
1571
        };
1672
        };
1572
    };
1673
    };
1573
    public final static char scopeRhs[] = ScopeRhs.scopeRhs;
1674
    public final static char scopeRhs[] = ScopeRhs.scopeRhs;
Lines 1791-1843 Link Here
1791
    public final static String name[] = Name.name;
1892
    public final static String name[] = Name.name;
1792
    public final String name(int index) { return name[index]; }
1893
    public final String name(int index) { return name[index]; }
1793
1894
1794
    public final static int
1795
           ERROR_SYMBOL      = 1,
1796
           SCOPE_UBOUND      = 58,
1797
           SCOPE_SIZE        = 59,
1798
           MAX_NAME_LENGTH   = 26;
1799
1800
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
1801
    public final int getScopeUbound() { return SCOPE_UBOUND; }
1802
    public final int getScopeSize() { return SCOPE_SIZE; }
1803
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
1804
1805
    public final static int
1806
           NUM_STATES        = 241,
1807
           NT_OFFSET         = 99,
1808
           LA_STATE_OFFSET   = 3795,
1809
           MAX_LA            = 2,
1810
           NUM_RULES         = 328,
1811
           NUM_NONTERMINALS  = 109,
1812
           NUM_SYMBOLS       = 208,
1813
           SEGMENT_SIZE      = 8192,
1814
           START_STATE       = 3223,
1815
           IDENTIFIER_SYMBOL = 4,
1816
           EOFT_SYMBOL       = 73,
1817
           EOLT_SYMBOL       = 73,
1818
           ACCEPT_ACTION     = 3466,
1819
           ERROR_ACTION      = 3467;
1820
1821
    public final static boolean BACKTRACK = true;
1822
1823
    public final int getNumStates() { return NUM_STATES; }
1824
    public final int getNtOffset() { return NT_OFFSET; }
1825
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
1826
    public final int getMaxLa() { return MAX_LA; }
1827
    public final int getNumRules() { return NUM_RULES; }
1828
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
1829
    public final int getNumSymbols() { return NUM_SYMBOLS; }
1830
    public final int getSegmentSize() { return SEGMENT_SIZE; }
1831
    public final int getStartState() { return START_STATE; }
1832
    public final int getStartSymbol() { return lhs[0]; }
1833
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
1834
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
1835
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
1836
    public final int getAcceptAction() { return ACCEPT_ACTION; }
1837
    public final int getErrorAction() { return ERROR_ACTION; }
1838
    public final boolean isValidForParser() { return isValidForParser; }
1839
    public final boolean getBacktrack() { return BACKTRACK; }
1840
1841
    public final int originalState(int state) {
1895
    public final int originalState(int state) {
1842
        return -baseCheck[state];
1896
        return -baseCheck[state];
1843
    }
1897
    }
Lines 1851-1860 Link Here
1851
        return inSymb[originalState(state)];
1905
        return inSymb[originalState(state)];
1852
    }
1906
    }
1853
1907
1908
    /**
1909
     * assert(! goto_default);
1910
     */
1854
    public final int ntAction(int state, int sym) {
1911
    public final int ntAction(int state, int sym) {
1855
        return baseAction[state + sym];
1912
        return baseAction[state + sym];
1856
    }
1913
    }
1857
1914
1915
    /**
1916
     * assert(! shift_default);
1917
     */
1858
    public final int tAction(int state, int sym) {
1918
    public final int tAction(int state, int sym) {
1859
        int i = baseAction[state],
1919
        int i = baseAction[state],
1860
            k = i + sym;
1920
            k = i + sym;
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingParsersym.java (-12 / +7 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
* Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
6
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
7
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
8
* which accompanies this distribution, and is available at
Lines 13-35 Link Here
13
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Remove unnecessary warning suppression
14
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   E.D.Willink - Bugs 225493, 243976, 259818
15
*   Zeligsoft - Bug 243976
16
*   Zeligsoft - Bug 243976
17
*   Borland - Bug 242880
18
*   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
16
*
19
*
17
* </copyright>
20
* </copyright>
18
*
21
*
19
* $Id: OCLBacktrackingParsersym.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
22
* $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
20
*/
23
*/
21
24
22
package org.eclipse.ocl.parser.backtracking;
25
package org.eclipse.ocl.parser.backtracking;
23
26
24
/**
25
 * The backtracking variant of the OCL parser symbol table.
26
 * 
27
 * @noimplement This interface is not intended to be implemented by clients.
28
 * @noextend This interface is not intended to be extended by clients.
29
 * 
30
 * @since 1.3
31
 */
32
@SuppressWarnings("nls")
33
public interface OCLBacktrackingParsersym {
27
public interface OCLBacktrackingParsersym {
34
    public final static int
28
    public final static int
35
      TK_NUMERIC_OPERATION = 61,
29
      TK_NUMERIC_OPERATION = 61,
Lines 132-138 Link Here
132
      TK_INTEGER_RANGE_START = 97,
126
      TK_INTEGER_RANGE_START = 97,
133
      TK_ERROR_TOKEN = 1;
127
      TK_ERROR_TOKEN = 1;
134
128
135
      public final static String orderedTerminalSymbols[] = {
129
    public final static String orderedTerminalSymbols[] = {
136
                 "",
130
                 "",
137
                 "ERROR_TOKEN",
131
                 "ERROR_TOKEN",
138
                 "LPAREN",
132
                 "LPAREN",
Lines 235-239 Link Here
235
                 "oper"
229
                 "oper"
236
             };
230
             };
237
231
232
    public final static int numTokenKinds = orderedTerminalSymbols.length;
238
    public final static boolean isValidForParser = true;
233
    public final static boolean isValidForParser = true;
239
}
234
}
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingLexerprs.java (-283 / +355 lines)
Lines 1-7 Link Here
1
/**
1
/**
2
* <copyright>
2
* <copyright>
3
*
3
*
4
* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., and others.
4
* Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
* All rights reserved.   This program and the accompanying materials
5
* All rights reserved.   This program and the accompanying materials
6
* are made available under the terms of the Eclipse Public License v1.0
6
* are made available under the terms of the Eclipse Public License v1.0
7
* which accompanies this distribution, and is available at
7
* which accompanies this distribution, and is available at
Lines 10-32 Link Here
10
* Contributors:
10
* Contributors:
11
*   IBM - Initial API and implementation
11
*   IBM - Initial API and implementation
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
12
*   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
*      - Bug 259818
13
*   Borland - Bug 242880
14
*   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
*
15
*
15
* </copyright>
16
* </copyright>
16
*
17
*
17
* $Id: OCLBacktrackingLexerprs.java,v 1.1 2009/01/13 20:31:30 cdamus Exp $
18
* '$'Id''
18
*/
19
*/
19
20
20
package org.eclipse.ocl.parser.backtracking;
21
package org.eclipse.ocl.parser.backtracking;
21
22
22
/**
23
public class OCLBacktrackingLexerprs implements lpg.runtime.ParseTable, OCLBacktrackingLexersym {
23
 * The backtracking variant of the OCL lexer parse table.
24
    public final static int ERROR_SYMBOL = 0;
24
 * 
25
    public final int getErrorSymbol() { return ERROR_SYMBOL; }
25
 * @noextend This class is not intended to be subclassed by clients.
26
26
 * 
27
    public final static int SCOPE_UBOUND = 0;
27
 * @since 1.3
28
    public final int getScopeUbound() { return SCOPE_UBOUND; }
28
 */
29
29
public class OCLBacktrackingLexerprs implements lpg.lpgjavaruntime.ParseTable, OCLBacktrackingLexersym {
30
    public final static int SCOPE_SIZE = 0;
31
    public final int getScopeSize() { return SCOPE_SIZE; }
32
33
    public final static int MAX_NAME_LENGTH = 0;
34
    public final int getMaxNameLength() { return MAX_NAME_LENGTH; }
35
36
    public final static int NUM_STATES = 50;
37
    public final int getNumStates() { return NUM_STATES; }
38
39
    public final static int NT_OFFSET = 103;
40
    public final int getNtOffset() { return NT_OFFSET; }
41
42
    public final static int LA_STATE_OFFSET = 824;
43
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
44
45
    public final static int MAX_LA = 1;
46
    public final int getMaxLa() { return MAX_LA; }
47
48
    public final static int NUM_RULES = 309;
49
    public final int getNumRules() { return NUM_RULES; }
50
51
    public final static int NUM_NONTERMINALS = 44;
52
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
53
54
    public final static int NUM_SYMBOLS = 147;
55
    public final int getNumSymbols() { return NUM_SYMBOLS; }
56
57
    public final static int SEGMENT_SIZE = 8192;
58
    public final int getSegmentSize() { return SEGMENT_SIZE; }
59
60
    public final static int START_STATE = 310;
61
    public final int getStartState() { return START_STATE; }
62
63
    public final static int IDENTIFIER_SYMBOL = 0;
64
    public final int getIdentifier_SYMBOL() { return IDENTIFIER_SYMBOL; }
65
66
    public final static int EOFT_SYMBOL = 99;
67
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
68
69
    public final static int EOLT_SYMBOL = 104;
70
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
71
72
    public final static int ACCEPT_ACTION = 514;
73
    public final int getAcceptAction() { return ACCEPT_ACTION; }
74
75
    public final static int ERROR_ACTION = 515;
76
    public final int getErrorAction() { return ERROR_ACTION; }
77
78
    public final static boolean BACKTRACK = false;
79
    public final boolean getBacktrack() { return BACKTRACK; }
80
81
    public final int getStartSymbol() { return lhs(0); }
82
    public final boolean isValidForParser() { return OCLBacktrackingLexersym.isValidForParser; }
83
84
85
    public interface IsNullable {
86
        public final static byte isNullable[] = {0,
87
            0,0,0,0,0,0,0,0,0,0,
88
            0,0,0,0,0,0,0,0,0,0,
89
            0,0,0,0,0,0,0,0,0,0,
90
            0,0,0,0,0,0,0,0,0,0,
91
            0,0,0,0,0,0,0,0,0,0,
92
            0,0,0,0,0,0,0,0,0,0,
93
            0,0,0,0,0,0,0,0,0,0,
94
            0,0,0,0,0,0,0,0,0,0,
95
            0,0,0,0,0,0,0,0,0,0,
96
            0,0,0,0,0,0,0,0,0,0,
97
            0,0,0,0,0,0,0,0,0,0,
98
            0,0,0,0,0,0,1,0,0,0,
99
            0,0,0,0,0,0,0,0,0,0,
100
            0,1,0,0,0,0,0,0,0,0,
101
            0,0,0,0,0,0,0
102
        };
103
    };
104
    public final static byte isNullable[] = IsNullable.isNullable;
105
    public final boolean isNullable(int index) { return isNullable[index] != 0; }
106
107
    public interface ProsthesesIndex {
108
        public final static byte prosthesesIndex[] = {0,
109
            20,25,26,27,35,4,15,37,40,43,
110
            24,5,3,6,17,18,23,32,34,36,
111
            41,42,2,7,8,9,10,11,12,13,
112
            14,16,19,33,38,39,44,1,21,22,
113
            28,29,30,31
114
        };
115
    };
116
    public final static byte prosthesesIndex[] = ProsthesesIndex.prosthesesIndex;
117
    public final int prosthesesIndex(int index) { return prosthesesIndex[index]; }
30
118
31
    public interface IsKeyword {
119
    public interface IsKeyword {
32
        public final static byte isKeyword[] = {0,
120
        public final static byte isKeyword[] = {0,
Lines 74-86 Link Here
74
            1,1,1,1,1,1,1,1,1,1,
162
            1,1,1,1,1,1,1,1,1,1,
75
            1,1,1,1,1,1,1,1,1,1,
163
            1,1,1,1,1,1,1,1,1,1,
76
            1,1,1,1,1,1,1,1,1,1,
164
            1,1,1,1,1,1,1,1,1,1,
165
            1,1,2,1,1,1,1,1,1,1,
77
            1,1,1,1,1,1,1,1,1,1,
166
            1,1,1,1,1,1,1,1,1,1,
78
            1,1,1,1,1,1,1,1,1,1,
167
            1,1,1,1,1,1,1,1,1,1,
79
            1,1,1,1,1,1,1,1,1,1,
168
            2,2,1,2,1,2,0,1,3,3,
80
            1,1,1,1,1,1,1,1,1,1,
169
            3,3,3,3,3,4,4,3,3
81
            1,1,1,1,1,1,1,2,2,1,
82
            2,1,2,0,1,3,3,3,3,3,
83
            3,3,4,4,3,3
84
        };
170
        };
85
    };
171
    };
86
    public final static byte baseCheck[] = BaseCheck.baseCheck;
172
    public final static byte baseCheck[] = BaseCheck.baseCheck;
Lines 90-146 Link Here
90
176
91
    public interface BaseAction {
177
    public interface BaseAction {
92
        public final static char baseAction[] = {
178
        public final static char baseAction[] = {
93
            21,21,21,21,21,21,21,21,21,21,
179
            23,23,23,23,23,23,23,23,23,23,
94
            21,21,21,21,21,21,21,21,21,21,
180
            23,23,23,23,23,23,23,23,23,23,
95
            21,21,21,21,21,21,21,21,21,21,
181
            23,23,23,23,23,23,23,23,23,23,
96
            21,21,21,21,21,21,21,21,21,21,
182
            23,23,23,23,23,23,23,23,23,23,
97
            21,22,23,23,23,27,27,27,27,28,
183
            23,24,25,25,25,29,29,29,29,30,
98
            28,26,26,6,6,35,35,30,13,13,
184
            30,28,28,7,7,39,39,32,15,15,
99
            13,9,9,9,9,9,2,2,2,2,
185
            15,11,11,11,11,11,2,2,2,2,
100
            3,3,3,3,3,3,3,3,3,3,
186
            3,3,3,3,3,3,3,3,3,3,
101
            3,3,3,3,3,3,3,3,3,3,
187
            3,3,3,3,3,3,3,3,3,3,
102
            3,3,3,3,3,3,4,4,4,4,
188
            3,3,3,3,3,3,4,4,4,4,
103
            4,4,4,4,4,4,4,4,4,4,
189
            4,4,4,4,4,4,4,4,4,4,
104
            4,4,4,4,4,4,4,4,4,4,
190
            4,4,4,4,4,4,4,4,4,4,
105
            4,4,1,1,1,1,1,1,1,1,
191
            4,4,1,1,1,1,1,1,1,1,
106
            1,1,37,37,37,37,37,37,37,37,
192
            1,1,41,41,41,41,41,41,41,41,
107
            38,38,38,38,38,38,38,38,38,38,
193
            42,42,42,42,42,42,42,42,42,42,
108
            38,38,36,36,39,39,39,15,15,40,
194
            42,42,40,40,43,43,43,17,17,44,
109
            40,29,29,11,11,11,11,11,32,32,
195
            44,31,31,13,13,13,13,13,34,34,
110
            32,32,32,32,32,32,32,32,32,32,
196
            34,34,34,34,34,34,34,34,34,34,
111
            32,32,32,32,32,32,32,32,32,32,
197
            34,34,34,34,34,34,34,34,34,34,
112
            32,32,32,32,32,32,32,32,17,17,
198
            34,34,34,34,34,34,34,34,19,19,
113
            17,17,17,17,17,17,17,17,17,17,
199
            19,19,19,19,19,19,19,19,19,19,
114
            17,17,17,17,17,17,17,17,17,17,
200
            19,19,19,19,19,19,19,19,19,19,
115
            17,17,17,17,17,17,17,18,18,18,
201
            19,19,19,19,19,19,19,5,5,5,
116
            18,18,18,18,18,18,18,18,18,18,
202
            5,5,5,5,5,5,5,5,5,5,
117
            18,18,18,18,18,18,18,18,18,18,
203
            5,5,5,5,5,5,5,5,5,5,
118
            18,18,18,18,18,18,7,7,7,7,
204
            5,5,5,5,5,20,20,8,8,35,
119
            7,7,7,7,7,7,7,7,7,7,
205
            35,35,35,9,16,16,16,16,33,33,
120
            7,7,7,7,7,7,7,7,7,7,
206
            33,33,33,33,33,33,36,36,36,36,
121
            7,7,7,7,7,7,14,14,14,14,
207
            21,21,21,21,21,10,10,10,10,10,
122
            31,31,31,31,31,31,31,31,19,19,
208
            10,6,22,37,37,12,12,14,14,18,
123
            19,19,19,8,8,8,8,8,5,20,
209
            26,26,26,26,26,26,26,26,26,27,
124
            33,33,10,10,12,12,16,24,24,24,
210
            988,486,485,485,485,1426,2,339,1333,326,
125
            24,24,24,24,24,24,25,891,478,472,
211
            1377,487,1380,493,1082,326,1366,54,488,1427,
126
            472,472,2,354,1236,344,479,1280,491,1283,
212
            43,162,318,322,6,7,8,9,478,1320,
127
            344,1247,408,480,1269,54,162,408,339,6,
213
            54,320,315,309,490,490,490,490,490,490,
128
            7,8,9,421,1223,54,337,488,309,481,
214
            1314,490,490,490,44,392,318,405,309,490,
129
            481,481,481,481,985,481,481,44,431,334,
215
            490,490,490,490,490,1087,490,490,490,1384,
130
            427,309,481,481,481,481,481,1330,481,481,
216
            392,1385,430,406,409,409,409,409,409,409,
131
            304,431,1217,437,406,457,457,457,457,457,
217
            1165,409,409,409,1243,409,891,424,424,424,
132
            990,457,457,1287,457,794,466,466,466,466,
218
            424,424,600,296,296,296,296,296,296,1428,
133
            1291,54,1,47,47,47,47,402,1307,54,
219
            296,296,296,1388,54,100,424,424,424,697,
134
            1288,47,1068,466,466,466,47,1318,54,47,
220
            296,296,296,296,296,296,1313,296,296,296,
135
            1146,205,52,52,52,52,1331,100,466,1216,
221
            304,1404,54,424,794,294,294,294,294,294,
136
            473,503,313,313,313,313,313,986,313,313,
222
            1083,1,47,47,47,47,503,263,263,263,
137
            994,400,496,496,496,1219,400,1069,1258,417,
223
            263,263,47,1316,294,294,294,47,1166,431,
138
            1333,496,52,52,417,1289,496,600,313,313,
224
            47,1091,403,498,498,498,1344,421,403,1355,
139
            313,313,313,1332,313,313,697,311,311,311,
225
            467,473,1430,421,498,1386,467,1415,54,498,
140
            311,1220,1334,103,45,45,45,45,1335,1336,
226
            1429,263,263,103,45,45,45,45,205,52,
141
            1337,1281,45,506,311,311,311,45,1329,506,
227
            52,52,52,1317,45,1431,1432,1433,1434,45,
142
            45,1073,165,164,164,164,1148,165,164,164,
228
            1378,515,45,1170,165,164,164,164,1245,165,
143
            164,43,506,334,506,506
229
            164,164,164,515,515,515,515,515,515,515,
230
            515,52,52,515,515
144
        };
231
        };
145
    };
232
    };
146
    public final static char baseAction[] = BaseAction.baseAction;
233
    public final static char baseAction[] = BaseAction.baseAction;
Lines 236-242 Link Here
236
            37,38,39,40,41,42,43,44,45,46,
323
            37,38,39,40,41,42,43,44,45,46,
237
            47,48,49,50,51,52,53,54,55,56,
324
            47,48,49,50,51,52,53,54,55,56,
238
            57,58,59,60,61,62,63,64,65,66,
325
            57,58,59,60,61,62,63,64,65,66,
239
            67,68,69,70,71,72,0,74,75,76,
326
            67,68,69,70,71,72,73,74,75,76,
240
            77,78,79,80,81,82,83,84,85,86,
327
            77,78,79,80,81,82,83,84,85,86,
241
            87,88,89,90,91,92,93,94,95,96,
328
            87,88,89,90,91,92,93,94,95,96,
242
            0,1,2,3,4,5,6,7,8,9,
329
            0,1,2,3,4,5,6,7,8,9,
Lines 246-299 Link Here
246
            40,41,42,43,44,45,46,47,48,49,
333
            40,41,42,43,44,45,46,47,48,49,
247
            50,51,52,53,54,55,56,57,58,59,
334
            50,51,52,53,54,55,56,57,58,59,
248
            60,61,62,63,64,65,66,67,68,69,
335
            60,61,62,63,64,65,66,67,68,69,
249
            70,71,72,73,0,75,76,77,78,79,
336
            70,71,72,0,74,75,76,77,78,79,
250
            80,81,82,83,84,85,86,87,88,89,
337
            80,81,82,83,84,85,86,87,88,89,
251
            90,0,0,0,0,0,0,97,98,0,
338
            90,91,92,93,94,95,96,0,1,2,
252
            100,101,102,0,1,2,3,4,5,6,
253
            7,8,9,10,11,12,13,14,0,16,
254
            17,18,19,20,21,22,23,24,25,26,
255
            27,28,29,30,31,32,33,34,35,36,
256
            37,38,39,40,41,42,43,44,45,46,
257
            47,48,49,50,51,52,53,54,55,56,
258
            57,58,59,60,61,62,63,64,65,75,
259
            67,68,69,70,71,76,73,0,0,0,
260
            77,78,0,1,2,3,4,5,6,7,
261
            8,9,10,11,12,13,14,102,16,17,
262
            18,19,20,21,22,23,24,25,26,27,
263
            28,29,30,31,32,33,34,35,36,37,
264
            38,39,40,41,42,43,44,45,46,47,
265
            48,49,50,51,52,53,54,55,56,57,
266
            58,59,60,61,62,63,64,65,71,0,
267
            0,73,0,0,0,0,74,0,1,2,
268
            3,4,5,6,7,8,9,10,11,12,
339
            3,4,5,6,7,8,9,10,11,12,
269
            13,14,0,16,17,18,19,20,21,22,
340
            13,14,15,16,17,18,19,20,21,22,
270
            23,24,25,26,27,28,29,30,31,32,
341
            23,24,25,26,27,28,29,30,31,32,
271
            33,34,35,36,37,38,39,40,41,42,
342
            33,34,35,36,37,38,39,40,41,42,
272
            43,44,45,46,47,48,49,50,51,52,
343
            43,44,45,46,47,48,49,50,51,52,
273
            53,54,55,56,57,58,59,60,61,62,
344
            53,54,55,56,57,58,59,60,61,62,
274
            63,64,65,68,69,0,0,0,0,0,
345
            63,64,65,66,67,68,69,70,71,72,
275
            0,74,0,1,2,3,4,5,6,7,
346
            73,0,75,76,77,78,79,80,81,82,
276
            8,9,10,11,12,0,1,2,3,4,
347
            83,84,85,86,87,88,89,90,0,0,
277
            5,6,7,8,9,10,0,1,2,3,
348
            0,0,0,0,97,98,0,100,101,102,
278
            4,5,6,7,8,9,10,0,1,2,
279
            3,4,5,6,7,8,9,10,0,1,
280
            2,3,4,5,6,7,8,9,10,0,
281
            0,66,0,67,66,66,0,0,0,67,
282
            0,1,2,3,4,5,6,7,8,9,
349
            0,1,2,3,4,5,6,7,8,9,
283
            10,15,15,15,69,70,0,1,2,3,
350
            10,11,12,13,14,0,16,17,18,19,
284
            4,5,6,7,8,9,10,0,1,2,
351
            20,21,22,23,24,25,26,27,28,29,
285
            3,4,5,6,7,8,9,10,0,0,
352
            30,31,32,33,34,35,36,37,38,39,
286
            0,0,0,0,0,0,0,0,0,11,
353
            40,41,42,43,44,45,46,47,48,49,
287
            12,0,13,11,14,0,15,0,0,0,
354
            50,51,52,53,54,55,56,57,58,59,
288
            0,72,0,0,68,0,0,0,0,0,
355
            60,61,62,63,64,65,75,67,68,69,
356
            70,71,76,73,0,0,0,77,78,0,
357
            1,2,3,4,5,6,7,8,9,10,
358
            11,12,13,14,102,16,17,18,19,20,
359
            21,22,23,24,25,26,27,28,29,30,
360
            31,32,33,34,35,36,37,38,39,40,
361
            41,42,43,44,45,46,47,48,49,50,
362
            51,52,53,54,55,56,57,58,59,60,
363
            61,62,63,64,65,71,0,0,73,0,
364
            0,0,0,74,0,1,2,3,4,5,
365
            6,7,8,9,10,11,12,13,14,0,
366
            16,17,18,19,20,21,22,23,24,25,
367
            26,27,28,29,30,31,32,33,34,35,
368
            36,37,38,39,40,41,42,43,44,45,
369
            46,47,48,49,50,51,52,53,54,55,
370
            56,57,58,59,60,61,62,63,64,65,
371
            68,69,0,0,0,0,0,0,74,0,
372
            1,2,3,4,5,6,7,8,9,10,
373
            11,12,0,1,2,3,4,5,6,7,
374
            8,9,10,0,1,2,3,4,5,6,
375
            7,8,9,10,0,1,2,3,4,5,
376
            6,7,8,9,10,0,1,2,3,4,
377
            5,6,7,8,9,10,0,0,66,0,
378
            67,66,66,0,0,0,67,0,1,2,
379
            3,4,5,6,7,8,9,10,15,15,
380
            15,69,70,0,1,2,3,4,5,6,
381
            7,8,9,10,0,1,2,3,4,5,
382
            6,7,8,9,10,0,0,0,0,0,
383
            0,0,0,0,0,0,11,12,0,13,
384
            11,14,0,15,0,0,0,0,72,0,
385
            0,68,0,0,0,0,0,0,0,0,
289
            0,0,0,0,0,0,0,0,0,0,
386
            0,0,0,0,0,0,0,0,0,0,
290
            0,0,0,0,0,0,97,98,0,100,
387
            0,0,0,97,98,0,100,101,99,102,
291
            101,99,102,0,0,0,0,0,0,0,
292
            0,0,0,0,0,0,0,0,0,0,
388
            0,0,0,0,0,0,0,0,0,0,
293
            0,0,0,0,0,0,0,0,0,0,
389
            0,0,0,0,0,0,0,0,0,0,
294
            0,0,0,0,0,0,0,0,0,0,
390
            0,0,0,0,0,0,0,0,0,0,
295
            0,0,0,0,0,0,0,0,0,0,
391
            0,0,0,0,0,0,0,0,0,0,
296
            0,0,99,99,99,99,0,0,0,0
392
            0,0,0,0,0,0,0,0,0,99,
393
            99,99,99,0,0,0,0
297
        };
394
        };
298
    };
395
    };
299
    public final static byte termCheck[] = TermCheck.termCheck;
396
    public final static byte termCheck[] = TermCheck.termCheck;
Lines 301-450 Link Here
301
398
302
    public interface TermAction {
399
    public interface TermAction {
303
        public final static char termAction[] = {0,
400
        public final static char termAction[] = {0,
304
            506,553,553,553,553,553,553,553,553,553,
401
            515,562,562,562,562,562,562,562,562,562,
305
            553,553,553,553,553,553,553,553,553,553,
402
            562,562,562,562,562,562,562,562,562,562,
306
            553,553,553,553,553,553,553,553,553,553,
403
            562,562,562,562,562,562,562,562,562,562,
307
            553,553,553,553,553,553,553,553,553,553,
404
            562,562,562,562,562,562,562,562,562,562,
308
            553,553,553,553,553,553,553,553,553,553,
405
            562,562,562,562,562,562,562,562,562,562,
309
            553,553,553,553,553,553,553,553,553,553,
406
            562,562,562,562,562,562,562,562,562,562,
310
            553,553,553,553,553,553,553,553,553,553,
407
            562,562,562,562,562,562,562,562,562,562,
311
            553,473,553,553,553,553,553,553,552,553,
408
            562,473,562,562,562,562,562,562,561,562,
312
            553,553,553,553,553,553,553,553,553,553,
409
            562,562,562,562,562,562,562,562,562,562,
313
            553,553,553,553,553,553,553,553,553,506,
410
            562,562,562,562,562,562,562,562,562,515,
314
            553,553,506,551,551,551,551,551,551,551,
411
            562,562,515,560,560,560,560,560,560,560,
315
            551,551,551,551,551,551,551,551,551,551,
412
            560,560,560,560,560,560,560,560,560,560,
316
            551,551,551,551,551,551,551,551,551,551,
413
            560,560,560,560,560,560,560,560,560,560,
317
            551,551,551,551,551,551,551,551,551,551,
414
            560,560,560,560,560,560,560,560,560,560,
318
            551,551,551,551,551,551,551,551,551,551,
415
            560,560,560,560,560,560,560,560,560,560,
319
            551,551,551,551,551,551,551,551,551,551,
416
            560,560,560,560,560,560,560,560,560,560,
320
            551,551,551,551,551,551,551,551,551,551,
417
            560,560,560,560,560,560,560,560,560,560,
321
            551,551,551,556,551,551,551,551,551,551,
418
            560,560,560,565,560,560,560,560,560,560,
322
            517,551,551,551,551,551,551,551,551,551,
419
            526,560,560,560,560,560,560,560,560,560,
323
            551,551,551,551,551,551,551,551,551,551,
420
            560,560,560,560,560,560,560,560,560,560,
324
            551,511,551,551,10,558,558,558,558,558,
421
            560,520,560,560,10,567,567,567,567,567,
325
            558,558,558,558,558,558,558,558,558,558,
422
            567,567,567,567,567,567,567,567,567,567,
326
            558,558,558,558,558,558,558,558,558,558,
423
            567,567,567,567,567,567,567,567,567,567,
327
            558,558,558,558,558,558,558,558,558,558,
424
            567,567,567,567,567,567,567,567,567,567,
328
            558,558,558,558,558,558,558,558,558,558,
425
            567,567,567,567,567,567,567,567,567,567,
329
            558,558,558,558,558,558,558,558,558,558,
426
            567,567,567,567,567,567,567,567,567,567,
330
            558,558,558,558,558,558,558,558,558,558,
427
            567,567,567,567,567,567,567,567,567,567,
331
            558,558,558,558,558,558,558,558,558,558,
428
            567,567,567,567,567,567,567,567,567,567,
332
            558,558,558,558,558,558,558,558,558,558,
429
            567,567,567,567,567,567,567,567,567,567,
333
            558,558,558,558,558,558,558,558,558,558,
430
            567,567,567,567,567,567,567,567,567,567,
334
            558,558,558,48,506,506,506,558,314,481,
431
            567,567,567,48,515,515,515,567,297,490,
335
            481,481,481,481,481,481,481,481,481,481,
432
            490,490,490,490,490,490,490,490,490,490,
336
            481,481,481,481,481,481,481,481,481,481,
433
            490,490,490,490,490,490,490,490,490,490,
337
            481,481,481,481,481,481,481,481,481,481,
434
            490,490,490,490,490,490,490,490,490,490,
338
            481,481,481,481,481,481,481,481,481,481,
435
            490,490,490,490,490,490,490,490,490,490,
339
            481,481,481,481,481,481,481,481,481,481,
436
            490,490,490,490,490,490,490,490,490,490,
340
            481,481,481,481,481,481,481,481,481,481,
437
            490,490,490,490,490,490,490,490,490,490,
341
            481,481,481,481,429,481,481,481,481,481,
438
            490,490,490,490,416,490,490,490,490,490,
342
            481,481,481,481,481,481,481,481,481,481,
439
            490,490,490,490,490,490,490,490,490,490,
343
            481,481,481,481,481,481,481,481,481,481,
440
            490,490,490,490,490,490,490,490,490,490,
344
            481,481,481,481,481,506,457,457,457,457,
441
            490,490,490,490,436,515,409,409,409,409,
345
            457,457,457,457,457,457,457,457,457,457,
442
            409,409,409,409,409,409,409,409,409,409,
346
            457,457,457,457,457,457,457,457,457,457,
443
            409,409,409,409,409,409,409,409,409,409,
347
            457,457,457,457,457,457,457,457,457,457,
444
            409,409,409,409,409,409,409,409,409,409,
348
            457,457,457,457,457,457,457,457,457,457,
445
            409,409,409,409,409,409,409,409,409,409,
349
            457,457,457,457,457,457,457,457,457,457,
446
            409,409,409,409,409,409,409,409,409,409,
350
            457,457,457,457,457,457,457,457,457,457,
447
            409,409,409,409,409,409,409,409,409,409,
351
            457,445,457,457,457,457,457,457,457,457,
448
            409,443,409,409,409,409,409,409,409,409,
352
            457,457,457,457,457,457,457,457,457,457,
449
            409,409,409,409,409,409,409,409,409,409,
353
            457,457,457,457,457,457,457,457,457,457,
450
            409,409,409,409,409,409,409,409,409,409,
354
            457,457,315,819,819,819,819,819,819,819,
451
            409,436,515,778,778,778,778,778,778,778,
355
            819,819,819,819,819,819,819,819,819,819,
452
            778,778,778,778,778,778,778,778,778,778,
356
            819,819,819,819,819,819,819,819,819,819,
453
            778,778,778,778,778,778,778,778,778,778,
357
            819,819,819,819,819,819,819,819,819,819,
454
            778,778,778,778,778,778,778,778,778,778,
358
            819,819,819,819,819,819,819,819,819,819,
455
            778,778,778,778,778,778,778,778,778,778,
359
            819,819,819,819,819,819,819,819,819,819,
456
            778,778,778,778,778,778,778,778,778,778,
360
            819,819,819,819,819,819,819,819,429,819,
457
            778,778,778,778,778,778,778,778,778,778,
361
            819,819,819,819,819,819,819,819,819,819,
458
            778,778,778,778,778,778,778,778,778,778,
362
            819,819,819,819,819,819,819,819,819,819,
459
            778,778,778,778,778,778,778,778,778,778,
363
            819,819,819,819,819,819,819,819,819,506,
460
            778,778,778,778,778,778,778,778,778,298,
364
            819,819,819,819,819,819,819,819,819,819,
461
            811,811,811,811,811,811,811,811,811,811,
365
            819,819,819,819,819,819,819,819,819,819,
462
            811,811,811,811,811,811,811,811,811,811,
366
            819,819,819,819,819,819,819,819,819,819,
463
            811,811,811,811,811,811,811,811,811,811,
367
            819,819,819,819,819,819,819,819,819,819,
464
            811,811,811,811,811,811,811,811,811,811,
368
            819,819,819,819,819,819,819,819,819,819,
465
            811,811,811,811,811,811,811,811,811,811,
369
            819,819,819,819,819,819,819,819,819,819,
466
            811,811,811,811,811,811,811,811,811,811,
370
            819,819,819,819,819,471,819,819,819,819,
467
            811,811,811,811,811,416,811,811,811,811,
371
            819,819,819,819,819,819,819,819,819,819,
468
            811,811,811,811,811,811,811,811,811,811,
372
            819,819,819,819,819,819,819,819,819,819,
469
            811,811,811,811,811,811,811,811,811,811,
373
            819,819,819,819,819,819,506,817,817,817,
470
            811,811,811,811,811,436,515,811,811,811,
374
            817,817,817,817,817,817,817,817,817,817,
471
            811,811,811,811,811,811,811,811,811,811,
375
            817,817,817,817,817,817,817,817,817,817,
472
            811,811,811,811,811,811,811,811,811,811,
376
            817,817,817,817,817,817,817,817,817,817,
473
            811,811,811,811,811,811,811,811,811,811,
377
            817,817,817,817,817,817,817,817,817,817,
474
            811,811,811,811,811,811,811,811,811,811,
378
            817,817,817,817,817,817,817,817,817,817,
475
            811,811,811,811,811,811,811,811,811,811,
379
            817,817,817,817,817,817,817,817,817,817,
476
            811,811,811,811,811,811,811,811,811,811,
380
            817,817,817,817,817,817,817,817,817,822,
477
            811,811,483,811,811,811,811,811,811,811,
381
            817,817,817,817,817,817,817,817,817,817,
478
            811,811,811,811,811,811,811,811,811,811,
382
            817,817,817,817,817,817,817,817,817,817,
479
            811,811,811,811,811,811,811,811,811,811,
383
            817,817,447,506,466,466,466,466,466,466,
480
            811,811,436,515,809,809,809,809,809,809,
384
            466,466,466,466,466,466,466,466,466,466,
481
            809,809,809,809,809,809,809,809,809,809,
385
            466,466,466,466,466,466,466,466,466,466,
482
            809,809,809,809,809,809,809,809,809,809,
386
            466,466,466,466,466,466,466,466,466,466,
483
            809,809,809,809,809,809,809,809,809,809,
387
            466,466,466,466,466,466,466,466,466,466,
484
            809,809,809,809,809,809,809,809,809,809,
388
            466,466,466,466,466,466,466,466,466,466,
485
            809,809,809,809,809,809,809,809,809,809,
389
            466,466,466,466,466,466,466,466,466,466,
486
            809,809,809,809,809,809,809,809,809,809,
390
            466,466,466,466,466,466,506,466,466,466,
487
            809,809,809,809,809,809,814,809,809,809,
391
            466,466,466,466,466,466,466,466,466,466,
488
            809,809,809,809,809,809,809,809,809,809,
392
            466,466,466,466,466,466,466,466,466,447,
489
            809,809,809,809,809,809,809,809,809,448,
393
            506,478,478,478,478,478,478,478,478,478,
490
            515,424,424,424,424,424,424,424,424,424,
394
            478,472,472,472,472,527,472,472,472,472,
491
            424,424,424,424,424,424,424,424,424,424,
395
            472,472,472,472,472,472,472,472,472,472,
492
            424,424,424,424,424,424,424,424,424,424,
396
            472,472,472,472,472,472,472,472,472,472,
493
            424,424,424,424,424,424,424,424,424,424,
397
            472,472,472,472,472,472,472,472,472,472,
494
            424,424,424,424,424,424,424,424,424,424,
398
            472,472,472,472,472,472,472,472,472,472,
495
            424,424,424,424,424,424,424,424,424,424,
399
            472,472,472,472,472,472,384,382,410,420,
496
            424,424,424,424,424,424,424,424,424,424,
400
            519,521,479,395,506,364,390,393,412,536,
497
            424,424,424,515,424,424,424,424,424,424,
401
            377,358,540,533,534,531,532,546,537,523,
498
            424,424,424,424,424,424,424,424,424,424,
402
            524,506,506,506,38,506,506,479,479,32,
499
            424,424,424,424,424,424,448,515,486,486,
403
            479,479,371,506,400,400,400,400,400,400,
500
            486,486,486,486,486,486,486,486,485,485,
404
            400,400,400,400,496,496,496,496,506,496,
501
            485,485,536,485,485,485,485,485,485,485,
405
            496,496,496,496,496,496,496,496,496,496,
502
            485,485,485,485,485,485,485,485,485,485,
406
            496,496,496,496,496,496,496,496,496,496,
503
            485,485,485,485,485,485,485,485,485,485,
407
            496,496,496,496,496,496,496,496,496,496,
504
            485,485,485,485,485,485,485,485,485,485,
408
            496,496,496,496,496,496,496,496,496,496,
505
            485,485,485,485,485,485,485,485,485,485,
409
            496,496,496,496,496,496,496,496,496,545,
506
            485,485,485,373,350,371,384,528,530,487,
410
            832,455,825,824,826,539,395,16,506,506,
507
            386,515,324,365,369,380,545,329,343,549,
411
            463,827,1,671,671,671,671,671,671,671,
508
            542,543,540,541,555,546,532,533,515,515,
412
            671,671,671,670,670,670,670,510,670,670,
509
            515,38,515,515,487,487,32,487,487,358,
413
            670,670,670,670,670,670,670,670,670,670,
510
            515,403,403,403,403,403,403,403,403,403,
414
            670,670,670,670,670,670,670,670,670,670,
511
            403,498,498,498,498,515,498,498,498,498,
415
            670,670,670,670,670,670,670,670,670,670,
512
            498,498,498,498,498,498,498,498,498,498,
416
            670,670,670,670,670,670,670,670,670,670,
513
            498,498,498,498,498,498,498,498,498,498,
417
            670,670,670,670,670,670,670,670,380,506,
514
            498,498,498,498,498,498,498,498,498,498,
418
            506,815,506,506,506,14,672,317,671,671,
515
            498,498,498,498,498,498,498,498,498,498,
419
            671,671,671,671,671,671,671,671,670,670,
516
            498,498,498,498,498,498,554,824,465,817,
420
            670,670,506,670,670,670,670,670,670,670,
517
            816,818,548,386,16,515,515,470,819,1,
421
            670,670,670,670,670,670,670,670,670,670,
518
            680,680,680,680,680,680,680,680,680,680,
422
            670,670,670,670,670,670,670,670,670,670,
519
            679,679,679,679,519,679,679,679,679,679,
423
            670,670,670,670,670,670,670,670,670,670,
520
            679,679,679,679,679,679,679,679,679,679,
424
            670,670,670,670,670,670,670,670,670,670,
521
            679,679,679,679,679,679,679,679,679,679,
425
            670,670,670,535,557,506,35,506,308,3,
522
            679,679,679,679,679,679,679,679,679,679,
426
            506,672,6,560,560,560,560,560,560,560,
523
            679,679,679,679,679,679,679,679,679,679,
427
            560,560,560,334,334,506,344,344,344,344,
524
            679,679,679,679,679,420,515,515,807,515,
428
            344,344,344,344,344,344,506,408,408,408,
525
            515,515,14,681,300,680,680,680,680,680,
429
            408,408,408,408,408,408,408,506,417,417,
526
            680,680,680,680,680,679,679,679,679,515,
430
            417,417,417,417,417,417,417,417,58,560,
527
            679,679,679,679,679,679,679,679,679,679,
431
            560,560,560,560,560,560,560,560,560,12,
528
            679,679,679,679,679,679,679,679,679,679,
432
            312,814,506,542,814,814,20,19,325,440,
529
            679,679,679,679,679,679,679,679,679,679,
433
            57,560,560,560,560,560,560,560,560,560,
530
            679,679,679,679,679,679,679,679,679,679,
434
            560,529,528,830,448,341,60,560,560,560,
531
            679,679,679,679,679,679,679,679,679,679,
435
            560,560,560,560,560,560,560,59,560,560,
532
            544,566,515,35,515,291,3,515,681,6,
436
            560,560,560,560,560,560,560,560,7,506,
533
            569,569,569,569,569,569,569,569,569,569,
437
            506,322,506,163,53,161,167,506,506,334,
534
            318,318,515,326,326,326,326,326,326,326,
438
            334,506,426,543,450,506,829,506,506,506,
535
            326,326,326,515,421,421,421,421,421,421,
439
            506,668,506,506,530,506,506,506,506,506,
536
            421,421,421,421,515,467,467,467,467,467,
440
            506,506,506,506,506,506,506,506,506,506,
537
            467,467,467,467,467,58,569,569,569,569,
441
            506,506,506,506,506,506,668,668,506,668,
538
            569,569,569,569,569,569,12,295,806,515,
442
            668,505,315,506,506,506,506,506,506,506,
539
            551,806,806,20,19,308,451,57,569,569,
443
            506,506,506,506,506,506,506,506,506,506,
540
            569,569,569,569,569,569,569,569,538,537,
444
            506,506,506,506,506,506,506,506,506,506,
541
            822,459,456,60,569,569,569,569,569,569,
445
            506,506,506,506,506,506,506,506,506,506,
542
            569,569,569,569,59,569,569,569,569,569,
446
            506,506,506,506,506,506,506,506,506,506,
543
            569,569,569,569,569,7,515,515,305,515,
447
            506,506,1,6,12,1
544
            163,53,161,167,515,515,318,318,515,399,
545
            552,462,515,821,515,515,515,515,677,515,
546
            515,539,515,515,515,515,515,515,515,515,
547
            515,515,515,515,515,515,515,515,515,515,
548
            515,515,515,677,677,515,677,677,514,298,
549
            515,515,515,515,515,515,515,515,515,515,
550
            515,515,515,515,515,515,515,515,515,515,
551
            515,515,515,515,515,515,515,515,515,515,
552
            515,515,515,515,515,515,515,515,515,515,
553
            515,515,515,515,515,515,515,515,515,1,
554
            6,12,1
448
        };
555
        };
449
    };
556
    };
450
    public final static char termAction[] = TermAction.termAction;
557
    public final static char termAction[] = TermAction.termAction;
Lines 464-519 Link Here
464
    public final int scopeState(int index) { return 0;}
571
    public final int scopeState(int index) { return 0;}
465
    public final int inSymb(int index) { return 0;}
572
    public final int inSymb(int index) { return 0;}
466
    public final String name(int index) { return null; }
573
    public final String name(int index) { return null; }
467
    public final int getErrorSymbol() { return 0; }
468
    public final int getScopeUbound() { return 0; }
469
    public final int getScopeSize() { return 0; }
470
    public final int getMaxNameLength() { return 0; }
471
472
    public final static int
473
           NUM_STATES        = 49,
474
           NT_OFFSET         = 103,
475
           LA_STATE_OFFSET   = 832,
476
           MAX_LA            = 1,
477
           NUM_RULES         = 326,
478
           NUM_NONTERMINALS  = 40,
479
           NUM_SYMBOLS       = 143,
480
           SEGMENT_SIZE      = 8192,
481
           START_STATE       = 327,
482
           IDENTIFIER_SYMBOL = 0,
483
           EOFT_SYMBOL       = 99,
484
           EOLT_SYMBOL       = 104,
485
           ACCEPT_ACTION     = 505,
486
           ERROR_ACTION      = 506;
487
488
    public final static boolean BACKTRACK = false;
489
490
    public final int getNumStates() { return NUM_STATES; }
491
    public final int getNtOffset() { return NT_OFFSET; }
492
    public final int getLaStateOffset() { return LA_STATE_OFFSET; }
493
    public final int getMaxLa() { return MAX_LA; }
494
    public final int getNumRules() { return NUM_RULES; }
495
    public final int getNumNonterminals() { return NUM_NONTERMINALS; }
496
    public final int getNumSymbols() { return NUM_SYMBOLS; }
497
    public final int getSegmentSize() { return SEGMENT_SIZE; }
498
    public final int getStartState() { return START_STATE; }
499
    public final int getStartSymbol() { return lhs[0]; }
500
    public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
501
    public final int getEoftSymbol() { return EOFT_SYMBOL; }
502
    public final int getEoltSymbol() { return EOLT_SYMBOL; }
503
    public final int getAcceptAction() { return ACCEPT_ACTION; }
504
    public final int getErrorAction() { return ERROR_ACTION; }
505
    public final boolean isValidForParser() { return isValidForParser; }
506
    public final boolean getBacktrack() { return BACKTRACK; }
507
508
    public final int originalState(int state) { return 0; }
574
    public final int originalState(int state) { return 0; }
509
    public final int asi(int state) { return 0; }
575
    public final int asi(int state) { return 0; }
510
    public final int nasi(int state) { return 0; }
576
    public final int nasi(int state) { return 0; }
511
    public final int inSymbol(int state) { return 0; }
577
    public final int inSymbol(int state) { return 0; }
512
578
579
    /**
580
     * assert(! goto_default);
581
     */
513
    public final int ntAction(int state, int sym) {
582
    public final int ntAction(int state, int sym) {
514
        return baseAction[state + sym];
583
        return baseAction[state + sym];
515
    }
584
    }
516
585
586
    /**
587
     * assert(! shift_default);
588
     */
517
    public final int tAction(int state, int sym) {
589
    public final int tAction(int state, int sym) {
518
        int i = baseAction[state],
590
        int i = baseAction[state],
519
            k = i + sym;
591
            k = i + sym;
(-)src/org/eclipse/ocl/cst/CSTNode.java (-1 / +1 lines)
Lines 17-23 Link Here
17
 */
17
 */
18
package org.eclipse.ocl.cst;
18
package org.eclipse.ocl.cst;
19
19
20
import lpg.lpgjavaruntime.IToken;
20
import lpg.runtime.IToken;
21
import org.eclipse.emf.ecore.EObject;
21
import org.eclipse.emf.ecore.EObject;
22
22
23
/**
23
/**
(-)src/org/eclipse/ocl/cst/CSTPackage.java (-5 / +5 lines)
Lines 4937-4943 Link Here
4937
	 * The meta object id for the '<em>IToken</em>' data type.
4937
	 * The meta object id for the '<em>IToken</em>' data type.
4938
	 * <!-- begin-user-doc -->
4938
	 * <!-- begin-user-doc -->
4939
	 * <!-- end-user-doc -->
4939
	 * <!-- end-user-doc -->
4940
	 * @see lpg.lpgjavaruntime.IToken
4940
	 * @see lpg.runtime.IToken
4941
	 * @see org.eclipse.ocl.cst.impl.CSTPackageImpl#getIToken()
4941
	 * @see org.eclipse.ocl.cst.impl.CSTPackageImpl#getIToken()
4942
	 * @generated
4942
	 * @generated
4943
	 * @noreference This field is not intended to be referenced by clients.
4943
	 * @noreference This field is not intended to be referenced by clients.
Lines 6425-6437 Link Here
6425
	EEnum getDotOrArrowEnum();
6425
	EEnum getDotOrArrowEnum();
6426
6426
6427
	/**
6427
	/**
6428
	 * Returns the meta object for data type '{@link lpg.lpgjavaruntime.IToken <em>IToken</em>}'.
6428
	 * Returns the meta object for data type '{@link lpg.runtime.IToken <em>IToken</em>}'.
6429
	 * <!-- begin-user-doc -->
6429
	 * <!-- begin-user-doc -->
6430
	 * @since 1.3
6430
	 * @since 1.3
6431
	 * <!-- end-user-doc -->
6431
	 * <!-- end-user-doc -->
6432
	 * @return the meta object for data type '<em>IToken</em>'.
6432
	 * @return the meta object for data type '<em>IToken</em>'.
6433
	 * @see lpg.lpgjavaruntime.IToken
6433
	 * @see lpg.runtime.IToken
6434
	 * @model instanceClass="lpg.lpgjavaruntime.IToken"
6434
	 * @model instanceClass="lpg.runtime.IToken"
6435
	 * @generated
6435
	 * @generated
6436
	 */
6436
	 */
6437
	EDataType getIToken();
6437
	EDataType getIToken();
Lines 7765-7771 Link Here
7765
		 * <!-- begin-user-doc -->
7765
		 * <!-- begin-user-doc -->
7766
		 * @since 1.3
7766
		 * @since 1.3
7767
		 * <!-- end-user-doc -->
7767
		 * <!-- end-user-doc -->
7768
		 * @see lpg.lpgjavaruntime.IToken
7768
		 * @see lpg.runtime.IToken
7769
		 * @see org.eclipse.ocl.cst.impl.CSTPackageImpl#getIToken()
7769
		 * @see org.eclipse.ocl.cst.impl.CSTPackageImpl#getIToken()
7770
		 * @generated
7770
		 * @generated
7771
		 */
7771
		 */
(-)src/org/eclipse/ocl/cst/impl/CSTPackageImpl.java (-1 / +1 lines)
Lines 18-24 Link Here
18
 */
18
 */
19
package org.eclipse.ocl.cst.impl;
19
package org.eclipse.ocl.cst.impl;
20
20
21
import lpg.lpgjavaruntime.IToken;
21
import lpg.runtime.IToken;
22
import org.eclipse.emf.ecore.EAttribute;
22
import org.eclipse.emf.ecore.EAttribute;
23
import org.eclipse.emf.ecore.EClass;
23
import org.eclipse.emf.ecore.EClass;
24
import org.eclipse.emf.ecore.EDataType;
24
import org.eclipse.emf.ecore.EDataType;
(-)src/org/eclipse/ocl/cst/impl/CSTFactoryImpl.java (-1 / +1 lines)
Lines 17-23 Link Here
17
 */
17
 */
18
package org.eclipse.ocl.cst.impl;
18
package org.eclipse.ocl.cst.impl;
19
19
20
import lpg.lpgjavaruntime.IToken;
20
import lpg.runtime.IToken;
21
import org.eclipse.emf.ecore.EClass;
21
import org.eclipse.emf.ecore.EClass;
22
import org.eclipse.emf.ecore.EDataType;
22
import org.eclipse.emf.ecore.EDataType;
23
import org.eclipse.emf.ecore.EObject;
23
import org.eclipse.emf.ecore.EObject;
(-)src/org/eclipse/ocl/cst/impl/CSTNodeImpl.java (-1 / +1 lines)
Lines 17-23 Link Here
17
 */
17
 */
18
package org.eclipse.ocl.cst.impl;
18
package org.eclipse.ocl.cst.impl;
19
19
20
import lpg.lpgjavaruntime.IToken;
20
import lpg.runtime.IToken;
21
import org.eclipse.emf.common.notify.Notification;
21
import org.eclipse.emf.common.notify.Notification;
22
import org.eclipse.emf.ecore.EClass;
22
import org.eclipse.emf.ecore.EClass;
23
import org.eclipse.emf.ecore.impl.ENotificationImpl;
23
import org.eclipse.emf.ecore.impl.ENotificationImpl;
(-)model/OCLCST.ecore (-1 / +1 lines)
Lines 15-21 Link Here
15
          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
15
          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
16
          transient="true"/>
16
          transient="true"/>
17
    </eClassifiers>
17
    </eClassifiers>
18
    <eClassifiers xsi:type="ecore:EDataType" name="IToken" instanceClassName="lpg.lpgjavaruntime.IToken"/>
18
    <eClassifiers xsi:type="ecore:EDataType" name="IToken" instanceClassName="lpg.runtime.IToken"/>
19
    <eClassifiers xsi:type="ecore:EClass" name="PackageDeclarationCS" eSuperTypes="#//cst/CSTNode">
19
    <eClassifiers xsi:type="ecore:EClass" name="PackageDeclarationCS" eSuperTypes="#//cst/CSTNode">
20
      <eStructuralFeatures xsi:type="ecore:EReference" name="pathNameCS" eType="#//cst/PathNameCS"
20
      <eStructuralFeatures xsi:type="ecore:EReference" name="pathNameCS" eType="#//cst/PathNameCS"
21
          containment="true"/>
21
          containment="true"/>
(-)model/OCLCST.uml (-1 / +1 lines)
Lines 874-880 Link Here
874
  <Ecore:EClass xmi:id="_qf-8J_8fEduhWtVvKtiQ7w" base_Class="_qdx-Vf8fEduhWtVvKtiQ7w"/>
874
  <Ecore:EClass xmi:id="_qf-8J_8fEduhWtVvKtiQ7w" base_Class="_qdx-Vf8fEduhWtVvKtiQ7w"/>
875
  <Ecore:EClass xmi:id="_qf-8KP8fEduhWtVvKtiQ7w" base_Class="_qdx-V_8fEduhWtVvKtiQ7w"/>
875
  <Ecore:EClass xmi:id="_qf-8KP8fEduhWtVvKtiQ7w" base_Class="_qdx-V_8fEduhWtVvKtiQ7w"/>
876
  <Ecore:EAttribute xmi:id="_qf-8Kf8fEduhWtVvKtiQ7w" base_Property="_qdx-Wf8fEduhWtVvKtiQ7w"/>
876
  <Ecore:EAttribute xmi:id="_qf-8Kf8fEduhWtVvKtiQ7w" base_Property="_qdx-Wf8fEduhWtVvKtiQ7w"/>
877
  <Ecore:EDataType xmi:id="_wn-44I2FEd2mlKUM3HGxZg" instanceClassName="lpg.lpgjavaruntime.IToken" base_PrimitiveType="_tvVQwI2FEd2mlKUM3HGxZg"/>
877
  <Ecore:EDataType xmi:id="_wn-44I2FEd2mlKUM3HGxZg" instanceClassName="lpg.runtime.IToken" base_PrimitiveType="_tvVQwI2FEd2mlKUM3HGxZg"/>
878
  <Ecore:EAttribute xmi:id="_qkehgI2JEd2mlKUM3HGxZg" isTransient="true" base_Property="_PkTnII2GEd2mlKUM3HGxZg"/>
878
  <Ecore:EAttribute xmi:id="_qkehgI2JEd2mlKUM3HGxZg" isTransient="true" base_Property="_PkTnII2GEd2mlKUM3HGxZg"/>
879
  <Ecore:EAttribute xmi:id="_na5BwI2GEd2mlKUM3HGxZg" isTransient="true" base_Property="_kTt1cI2GEd2mlKUM3HGxZg"/>
879
  <Ecore:EAttribute xmi:id="_na5BwI2GEd2mlKUM3HGxZg" isTransient="true" base_Property="_kTt1cI2GEd2mlKUM3HGxZg"/>
880
  <Ecore:EAttribute xmi:id="_CoEkwI2HEd2mlKUM3HGxZg" isTransient="true" base_Property="_xJpmEI2GEd2mlKUM3HGxZg"/>
880
  <Ecore:EAttribute xmi:id="_CoEkwI2HEd2mlKUM3HGxZg" isTransient="true" base_Property="_xJpmEI2GEd2mlKUM3HGxZg"/>
(-)META-INF/MANIFEST.MF (-1 / +1 lines)
Lines 36-42 Link Here
36
Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
36
Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
37
 org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)";visibility:=reexport,
37
 org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)";visibility:=reexport,
38
 org.eclipse.emf.ecore.xmi;bundle-version="[2.4.0,3.0.0)",
38
 org.eclipse.emf.ecore.xmi;bundle-version="[2.4.0,3.0.0)",
39
 net.sourceforge.lpg.lpgjavaruntime;version="[1.0.0,1.2.0)";visibility:=reexport
39
 lpg.runtime;bundle-version="2.0.17";visibility:=reexport
40
Bundle-Activator: org.eclipse.ocl.internal.OCLPlugin$Implementation
40
Bundle-Activator: org.eclipse.ocl.internal.OCLPlugin$Implementation
41
Eclipse-LazyStart: true
41
Eclipse-LazyStart: true
42
Bundle-ActivationPolicy: lazy
42
Bundle-ActivationPolicy: lazy
(-)src/org/eclipse/ocl/internal/helper/OCLSyntaxHelper.java (-1 / +1 lines)
Lines 28-34 Link Here
28
import java.util.ListIterator;
28
import java.util.ListIterator;
29
import java.util.Set;
29
import java.util.Set;
30
30
31
import lpg.lpgjavaruntime.IToken;
31
import lpg.runtime.IToken;
32
32
33
import org.eclipse.emf.ecore.EObject;
33
import org.eclipse.emf.ecore.EObject;
34
import org.eclipse.emf.ecore.util.EcoreUtil;
34
import org.eclipse.emf.ecore.util.EcoreUtil;
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingKWLexer.gi (+35 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2008, 2009 IBM Corporation, Open Canarias S.L. and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   IBM - Initial API and implementation
12
-- *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
-- *
15
-- * </copyright>
16
-- *
17
-- * $Id: OCLBacktrackingKWLexer.g,v 1.1 2009/01/13 20:31:30 cdamus Exp $
18
-- */
19
--
20
-- The OCL Backtracking KeyWord Lexer, which is nominally identical to the
21
-- normal KeyWord Lexer, however the extra ERROR_TOKEN symbol makes it difficult
22
-- to share reliably.
23
--
24
25
%options slr
26
%options fp=OCLBacktrackingKWLexer,prefix=Char_
27
%options noserialize
28
%options package=org.eclipse.ocl.parser.backtracking
29
%options template=../../lpg/KeywordTemplateD.gi
30
%options export_terminals=("OCLBacktrackingParsersym.java", "TK_")
31
%options include_directory="..;../../lpg"
32
33
%Import
34
	OCLKWLexer.gi
35
%End
(-)src/org/eclipse/ocl/parser/backtracking/OCLParserErrors.gi (+205 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2008 Eclipse.org, Open Canarias S.L. and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   E.D. Willink - Initial API and implementation
12
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
-- *
14
-- * </copyright>
15
-- *
16
-- * $Id: OCLParserErrors.g,v 1.1 2009/01/13 20:31:30 cdamus Exp $
17
-- */
18
--
19
-- Additional ERROR_TOKEN rules for The OCL Parser
20
--
21
22
%Import
23
	OCLParser.g
24
%End
25
26
%Import
27
	EssentialOCLErrors.gi
28
%End
29
30
%Rules
31
32
	classifierContextDeclCS ::= context pathNameCS ERROR_TOKEN
33
		/.$BeginAction
34
					reportErrorTokenMessage($getToken(3), OCLParserErrors.MISSING_INV_OR_DEF);
35
					CSTNode result = createClassifierContextDeclCS(
36
							(PathNameCS)$getSym(2),
37
							new BasicEList<InvOrDefCS>()
38
						);
39
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
40
					$setResult(result);
41
		  $EndAction
42
		./
43
		
44
	defExpressionCS ::= typedVariableCS ERROR_TOKEN
45
		/.$BeginAction
46
					reportErrorTokenMessage($getToken(2), OCLParserErrors.MISSING_EQUALS);
47
					VariableCS variableCS = (VariableCS)$getSym(1);
48
					CSTNode result = createDefExpressionCS(
49
							variableCS,
50
							null,
51
							null
52
						);
53
					setOffsets(result, variableCS, getIToken($getToken(2)));
54
					$setResult(result);
55
		  $EndAction
56
		./
57
	defExpressionCS ::= IDENTIFIER ERROR_Colon
58
		/.$BeginAction
59
					VariableCS variableCS = createVariableCS(
60
								getTokenText($getToken(1)),
61
								null,
62
								null
63
							);
64
					setOffsets(variableCS, getIToken($getToken(1)), getIToken($getToken(2)));
65
					CSTNode result = createDefExpressionCS(
66
							variableCS,
67
							null,
68
							null
69
						);
70
					setOffsets(result, variableCS, getIToken($getToken(2)));
71
					$setResult(result);
72
		  $EndAction
73
		./
74
75
	initOrDerValueCS ::= initOrDerValueCSopt init ERROR_Colon
76
		/.$BeginAction
77
					CSTNode result = createInitValueCS(
78
							(InitOrDerValueCS)$getSym(1),
79
							null
80
						);
81
					if ($getSym(1) != null) {
82
						setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(3)));
83
					} else {
84
						setOffsets(result, getIToken($getToken(2)), getIToken($getToken(3)));
85
					}
86
					$setResult(result);
87
		  $EndAction
88
		./
89
	initOrDerValueCS ::= initOrDerValueCSopt derive ERROR_Colon
90
		/.$BeginAction
91
					CSTNode result = createDerValueCS(
92
							(InitOrDerValueCS)$getSym(1),
93
							null
94
						);
95
					if ($getSym(1) != null) {
96
						setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(3)));
97
					} else {
98
						setOffsets(result, getIToken($getToken(2)), getIToken($getToken(3)));
99
					}
100
					$setResult(result);
101
		  $EndAction
102
		./
103
		
104
	invOrDefCS ::= inv simpleNameCS ERROR_Colon
105
		/.$BeginAction
106
					CSTNode result = createInvCS(
107
							(SimpleNameCS)$getSym(2),
108
							null
109
						);
110
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
111
					$setResult(result);
112
		  $EndAction
113
		./	
114
	invOrDefCS ::= def simpleNameCS ERROR_Colon
115
		/.$BeginAction
116
					CSTNode result = createDefCS(
117
							(SimpleNameCS)$getSym(2),
118
							null
119
						);
120
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
121
					$setResult(result);
122
		  $EndAction
123
		./
124
125
	packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_Empty endpackage
126
		/.$BeginAction
127
					CSTNode result = createPackageDeclarationCS(
128
							(PathNameCS)$getSym(2),
129
							(EList)$getSym(3)
130
						);
131
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
132
					$setResult(result);
133
		  $EndAction
134
		./
135
	packageDeclarationCS ::= package pathNameCS contextDeclCSmopt ERROR_TOKEN
136
		/.$BeginAction
137
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_ENDPACKAGE);
138
					CSTNode result = createPackageDeclarationCS(
139
							(PathNameCS)$getSym(2),
140
							(EList)$getSym(3)
141
						);
142
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
143
					$setResult(result);
144
		  $EndAction
145
		./
146
	packageDeclarationCS ::= package ERROR_PathNameCS
147
		/.$BeginAction
148
					CSTNode result = createPackageDeclarationCS(
149
							(PathNameCS)$getSym(2),
150
							new BasicEList()
151
						);
152
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(2)));
153
					$setResult(result);
154
		  $EndAction
155
		./
156
		
157
	prePostOrBodyDeclCS ::= pre simpleNameCS ERROR_Colon
158
		/.$BeginAction
159
					CSTNode result = createPrePostOrBodyDeclCS(
160
							PrePostOrBodyEnum.PRE_LITERAL,
161
							(SimpleNameCS)$getSym(2),
162
							createInvalidLiteralExpCS(getTokenText($getToken(3)))
163
						);
164
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
165
					$setResult(result);
166
		  $EndAction
167
		./
168
	prePostOrBodyDeclCS ::= post simpleNameCS ERROR_Colon
169
		/.$BeginAction
170
					CSTNode result = createPrePostOrBodyDeclCS(
171
							PrePostOrBodyEnum.POST_LITERAL,
172
							(SimpleNameCS)$getSym(2),
173
							createInvalidLiteralExpCS(getTokenText($getToken(3)))
174
						);
175
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
176
					$setResult(result);
177
		  $EndAction
178
		./
179
	prePostOrBodyDeclCS ::= body simpleNameCS ERROR_Colon
180
		/.$BeginAction
181
					CSTNode result = createPrePostOrBodyDeclCS(
182
							PrePostOrBodyEnum.BODY_LITERAL,
183
							(SimpleNameCS)$getSym(2),
184
							createInvalidLiteralExpCS(getTokenText($getToken(3)))
185
						);
186
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
187
					$setResult(result);
188
		  $EndAction
189
		./
190
		
191
	propertyContextCS ::= context pathNameCS '::' ERROR_SimpleNameCS
192
		/.$BeginAction
193
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(4);
194
					CSTNode result = createPropertyContextCS(
195
							(PathNameCS)$getSym(2),
196
							simpleNameCS,
197
							null,
198
							null
199
						);
200
					setOffsets(result, getIToken($getToken(1)), simpleNameCS);
201
					$setResult(result);
202
		  $EndAction
203
		./
204
		
205
%End
(-)src/org/eclipse/ocl/parser/OCLKWLexer.gi (+549 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2005, 2009 IBM Corporation  Zeligsoft Inc, Open Canarias S.L., and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   IBM - Initial API and implementation
12
-- *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
-- *
15
-- * </copyright>
16
-- *
17
-- * $Id: OCLKWLexer.g,v 1.1 2007/10/11 23:05:00 cdamus Exp $
18
-- */
19
--
20
-- The OCL KeyWord Lexer
21
--
22
23
%options slr
24
%options fp=OCLKWLexer,prefix=Char_
25
%options noserialize
26
%options package=org.eclipse.ocl.parser
27
%options template=../lpg/KeywordTemplateD.gi
28
%options export_terminals=("OCLParsersym.java", "TK_")
29
%options include_directory="../lpg"
30
31
%Define
32
33
	--
34
	-- Definition of macros used in the template
35
	--
36
	$action_class /.$file_prefix./
37
	$eof_char /.Char_EOF./
38
	$copyright_contributions /.*./
39
	
40
%End
41
42
%Notice
43
	/./**
44
 * <copyright>
45
 *
46
 * Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc, Open Canarias S.L., and others.
47
 * All rights reserved.   This program and the accompanying materials
48
 * are made available under the terms of the Eclipse Public License v1.0
49
 * which accompanies this distribution, and is available at
50
 * http://www.eclipse.org/legal/epl-v10.html
51
 *
52
 * Contributors:
53
 *   IBM - Initial API and implementation
54
 *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
55
 *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
56
$copyright_contributions
57
 * </copyright>
58
 *
59
 * 
60
 */
61
	./
62
%End
63
64
%Include
65
	KWLexerMap.gi
66
%End
67
68
%Export
69
	self
70
	inv
71
	pre
72
	post
73
	context
74
	package
75
	endpackage
76
	def
77
	if
78
	then
79
	else
80
	endif
81
	and
82
	or
83
	xor
84
	not
85
	implies
86
	let
87
	in
88
	true
89
	false
90
91
	--
92
	-- the following appear to have been omitted from the list of
93
	-- OCL reserved words in Section 7.4.9.  They will be treated 
94
	-- as unreserved for compliance
95
	--
96
	body
97
	derive
98
	init
99
	null
100
--  return  -- don't need a keyword for LPG purposes
101
	
102
	--
103
	-- the following are not used in the OCL concrete syntax, but
104
	-- are defined as reserved words in the Spec 7.4.9
105
	--
106
	attr
107
	oper
108
109
	--
110
	-- the remainder of the LPG keywords are defined as such for the
111
	-- purpose of constructing the CST grammar.  They are not OCL
112
	-- reserved words
113
	--		
114
	Set
115
	Bag
116
	Sequence
117
	Collection
118
	OrderedSet
119
120
	iterate
121
	forAll
122
	exists
123
	isUnique
124
	any
125
	one
126
127
	collect
128
	select
129
	reject
130
	collectNested
131
	sortedBy
132
133
	closure
134
135
	oclIsKindOf
136
	oclIsTypeOf
137
	oclAsType
138
	oclIsNew
139
	oclIsUndefined
140
	oclIsInvalid
141
	oclIsInState
142
	allInstances
143
144
	String
145
	Integer
146
	UnlimitedNatural
147
	Real
148
	Boolean
149
	Tuple
150
	OclAny
151
	OclVoid
152
	Invalid
153
	OclMessage
154
155
	OclInvalid
156
%End
157
158
%Terminals
159
	a b c d e f g h i j k l m n o p q r s t u v w x y z
160
	A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
161
%End
162
163
%Start
164
	KeyWord
165
%End
166
167
%Rules
168
169
-- The Goal for the parser is a single Keyword
170
171
	KeyWord ::=
172
		s e l f
173
		/.$BeginAction
174
			$setResult($_self);
175
		  $EndAction
176
		./
177
178
		| i n v
179
		/.$BeginAction
180
			$setResult($_inv);
181
		  $EndAction
182
		./
183
184
		| p r e
185
		/.$BeginAction
186
			$setResult($_pre);
187
		  $EndAction
188
		./
189
190
		| p o s t
191
		/.$BeginAction
192
			$setResult($_post);
193
		  $EndAction
194
		./
195
		
196
		| b o d y
197
		/.$BeginAction
198
			$setResult($_body);
199
		  $EndAction
200
		./
201
		
202
		| c o n t e x t
203
		/.$BeginAction
204
			$setResult($_context);
205
		  $EndAction
206
		./
207
		
208
		| p a c k a g e
209
		/.$BeginAction
210
			$setResult($_package);
211
		  $EndAction
212
		./
213
		
214
		| e n d p a c k a g e
215
		/.$BeginAction
216
			$setResult($_endpackage);
217
		  $EndAction
218
		./
219
		
220
		| d e f
221
		/.$BeginAction
222
			$setResult($_def);
223
		  $EndAction
224
		./
225
		
226
		| d e r i v e
227
		/.$BeginAction
228
			$setResult($_derive);
229
		  $EndAction
230
		./
231
		
232
		| i n i t
233
		/.$BeginAction
234
			$setResult($_init);
235
		  $EndAction
236
		./
237
		
238
		| i f
239
		/.$BeginAction
240
			$setResult($_if);
241
		  $EndAction
242
		./
243
		
244
		| t h e n
245
		/.$BeginAction
246
			$setResult($_then);
247
		  $EndAction
248
		./
249
		
250
		| e l s e
251
		/.$BeginAction
252
			$setResult($_else);
253
		  $EndAction
254
		./
255
		
256
		| e n d i f
257
		/.$BeginAction
258
			$setResult($_endif);
259
		  $EndAction
260
		./
261
		
262
		| a n d
263
		/.$BeginAction
264
			$setResult($_and);
265
		  $EndAction
266
		./
267
		
268
		| o r
269
		/.$BeginAction
270
			$setResult($_or);
271
		  $EndAction
272
		./
273
		
274
		| x o r
275
		/.$BeginAction
276
			$setResult($_xor);
277
		  $EndAction
278
		./
279
		
280
		| n o t
281
		/.$BeginAction
282
			$setResult($_not);
283
		  $EndAction
284
		./
285
		
286
		| i m p l i e s
287
		/.$BeginAction
288
			$setResult($_implies);
289
		  $EndAction
290
		./
291
		
292
		| l e t
293
		/.$BeginAction
294
			$setResult($_let);
295
		  $EndAction
296
		./
297
		
298
		| i n
299
		/.$BeginAction
300
			$setResult($_in);
301
		  $EndAction
302
		./
303
		
304
		| t r u e
305
		/.$BeginAction
306
			$setResult($_true);
307
		  $EndAction
308
		./
309
		
310
		| f a l s e
311
		/.$BeginAction
312
			$setResult($_false);
313
		  $EndAction
314
		./
315
		
316
		| S e t
317
		/.$BeginAction
318
			$setResult($_Set);
319
		  $EndAction
320
		./
321
		
322
		| B a g
323
		/.$BeginAction
324
			$setResult($_Bag);
325
		  $EndAction
326
		./
327
		
328
		| S e q u e n c e
329
		/.$BeginAction
330
			$setResult($_Sequence);
331
		  $EndAction
332
		./
333
		
334
		| C o l l e c t i o n
335
		/.$BeginAction
336
			$setResult($_Collection);
337
		  $EndAction
338
		./
339
340
		| O r d e r e d S e t
341
		/.$BeginAction
342
			$setResult($_OrderedSet);
343
		  $EndAction
344
		./
345
346
		| i t e r a t e
347
		/.$BeginAction
348
			$setResult($_iterate);
349
		  $EndAction
350
		./
351
		
352
		| f o r A l l
353
		/.$BeginAction
354
			$setResult($_forAll);
355
		  $EndAction
356
		./
357
		
358
		| e x i s t s
359
		/.$BeginAction
360
			$setResult($_exists);
361
		  $EndAction
362
		./
363
		
364
		| i s U n i q u e
365
		/.$BeginAction
366
			$setResult($_isUnique);
367
		  $EndAction
368
		./
369
		
370
		| a n y
371
		/.$BeginAction
372
			$setResult($_any);
373
		  $EndAction
374
		./
375
		
376
		| o n e
377
		/.$BeginAction
378
			$setResult($_one);
379
		  $EndAction
380
		./
381
382
		| c o l l e c t
383
		/.$BeginAction
384
			$setResult($_collect);
385
		  $EndAction
386
		./
387
		
388
		| s e l e c t
389
		/.$BeginAction
390
			$setResult($_select);
391
		  $EndAction
392
		./
393
		
394
		| r e j e c t
395
		/.$BeginAction
396
			$setResult($_reject);
397
		  $EndAction
398
		./
399
		
400
		| c o l l e c t N e s t e d
401
		/.$BeginAction
402
			$setResult($_collectNested);
403
		  $EndAction
404
		./
405
		
406
		| s o r t e d B y
407
		/.$BeginAction
408
			$setResult($_sortedBy);
409
		  $EndAction
410
		./
411
412
		| c l o s u r e
413
		/.$BeginAction
414
			$setResult($_closure);
415
		  $EndAction
416
		./
417
		
418
		| o c l I s K i n d O f
419
		/.$BeginAction
420
			$setResult($_oclIsKindOf);
421
		  $EndAction
422
		./
423
424
		| o c l I s T y p e O f
425
		/.$BeginAction
426
			$setResult($_oclIsTypeOf);
427
		  $EndAction
428
		./
429
		
430
		| o c l A s T y p e
431
		/.$BeginAction
432
			$setResult($_oclAsType);
433
		  $EndAction
434
		./
435
		
436
		| o c l I s N e w
437
		/.$BeginAction
438
			$setResult($_oclIsNew);
439
		  $EndAction
440
		./
441
		
442
		| o c l I s U n d e f i n e d
443
		/.$BeginAction
444
			$setResult($_oclIsUndefined);
445
		  $EndAction
446
		./
447
		
448
		| o c l I s I n v a l i d
449
		/.$BeginAction
450
			$setResult($_oclIsInvalid);
451
		  $EndAction
452
		./
453
		
454
		| o c l I s I n S t a t e
455
		/.$BeginAction
456
			$setResult($_oclIsInState);
457
		  $EndAction
458
		./
459
		
460
		| a l l I n s t a n c e s
461
		/.$BeginAction
462
			$setResult($_allInstances);
463
		  $EndAction
464
		./
465
466
		| S t r i n g
467
		/.$BeginAction
468
			$setResult($_String);
469
		  $EndAction
470
		./
471
472
		| I n t e g e r
473
		/.$BeginAction
474
			$setResult($_Integer);
475
		  $EndAction
476
		./
477
		
478
		| U n l i m i t e d N a t u r a l
479
		/.$BeginAction
480
			$setResult($_UnlimitedNatural);
481
		  $EndAction
482
		./
483
		
484
		| R e a l
485
		/.$BeginAction
486
			$setResult($_Real);
487
		  $EndAction
488
		./
489
		
490
		| B o o l e a n
491
		/.$BeginAction
492
			$setResult($_Boolean);
493
		  $EndAction
494
		./
495
496
		| T u p l e
497
		/.$BeginAction
498
			$setResult($_Tuple);
499
		  $EndAction
500
		./
501
502
		| O c l A n y
503
		/.$BeginAction
504
			$setResult($_OclAny);
505
		  $EndAction
506
		./
507
508
		| O c l V o i d
509
		/.$BeginAction
510
			$setResult($_OclVoid);
511
		  $EndAction
512
		./
513
514
		| I n v a l i d
515
		/.$BeginAction
516
			$setResult($_Invalid);
517
		  $EndAction
518
		./
519
520
		| O c l M e s s a g e
521
		/.$BeginAction
522
			$setResult($_OclMessage);
523
		  $EndAction
524
		./
525
526
		| n u l l
527
		/.$BeginAction
528
			$setResult($_null);
529
		  $EndAction
530
		./
531
532
		| O c l I n v a l i d
533
		/.$BeginAction
534
			$setResult($_OclInvalid);
535
		  $EndAction
536
		./
537
538
		| a t t r
539
		/.$BeginAction
540
			$setResult($_attr);
541
		  $EndAction
542
		./
543
544
		| o p e r
545
		/.$BeginAction
546
			$setResult($_oper);
547
		  $EndAction
548
		./
549
%End
(-)src/org/eclipse/ocl/lpg/LexerTemplateD.gi (+236 lines)
Added Link Here
1
--
2
-- An instance of this template must have a $Export section and the export_terminals option
3
--
4
-- Macros that may be redefined in an instance of this template
5
--
6
--     $eof_token
7
--     $additional_interfaces
8
--     $super_stream_class -- subclass com.ibm.lpg.LpgLexStream for getKind
9
--     $prs_stream_class -- use /.PrsStream./ if not subclassing
10
--
11
-- B E G I N N I N G   O F   T E M P L A T E   LexerTemplateD
12
--
13
%options programming_language=java,margin=4
14
%options table
15
%options action=("*.java", "/.", "./")
16
%options ParseTable=lpg.runtime.ParseTable
17
%options prefix=Char_
18
19
--
20
-- This template requires that the name of the EOF token be set
21
-- to EOF and that the prefix be "Char_" to be consistent with
22
-- KeywordTemplateD.
23
--
24
%Eof
25
    EOF
26
%End
27
28
--
29
-- This template also requires that the name of the parser EOF
30
-- Token to be exported be set to EOF_TOKEN
31
--
32
%Export
33
    EOF_TOKEN
34
%End
35
36
%Define
37
    --
38
    -- Macros that are be needed in an instance of this template
39
    --
40
    $eof_token /.$_EOF_TOKEN./
41
    
42
    $additional_interfaces /../
43
    $super_stream_class /.AbstractLexer./
44
    $prs_stream_class /.AbstractParser./
45
    $environment_class /.BasicEnvironment./
46
    $adapt_environment /.environment./
47
    
48
49
    $prs_stream /. // macro prs_stream is deprecated. Use function getPrsStream
50
                  getPrsStream()./
51
    $setSym1 /. // macro setSym1 is deprecated. Use function setResult
52
               lexParser.setSym1./
53
    $setResult /. // macro setResult is deprecated. Use function setResult
54
                 lexParser.setSym1./
55
    $getSym /. // macro getSym is deprecated. Use function getLastToken
56
              lexParser.getSym./
57
    $getToken /. // macro getToken is deprecated. Use function getToken
58
                lexParser.getToken./
59
    $getLeftSpan /. // macro getLeftSpan is deprecated. Use function getLeftSpan
60
                   lexParser.getFirstToken./
61
    $getRightSpan /. // macro getRightSpan is deprecated. Use function getRightSpan
62
                    lexParser.getLastToken./
63
64
    --
65
    -- Macros useful for specifying actions
66
    --
67
    $Header
68
    /.
69
                //
70
                // Rule $rule_number:  $rule_text
71
                //./
72
73
    $DefaultAction
74
    /. $Header
75
                case $rule_number: { ./
76
77
    $BeginAction /.$DefaultAction./
78
79
    $EndAction
80
    /.          break;
81
                }./
82
83
    $BeginJava
84
    /.$BeginAction
85
                $symbol_declarations./
86
87
    $EndJava /.$EndAction./
88
89
    $NoAction
90
    /. $Header
91
                case $rule_number:
92
                    break; ./
93
94
    $BeginActions
95
    /.
96
        public void ruleAction( int ruleNumber)
97
        {
98
            switch(ruleNumber)
99
            {./
100
101
    $SplitActions
102
    /.
103
	            default:
104
	                ruleAction$rule_number(ruleNumber);
105
	                break;
106
	        }
107
	        return;
108
	    }
109
	
110
	    public void ruleAction$rule_number(int ruleNumber)
111
	    {
112
	        switch (ruleNumber)
113
	        {./
114
115
    $EndActions
116
    /.
117
                default:
118
                    break;
119
            }
120
            return;
121
        }./
122
%End
123
124
%Globals
125
    /.import lpg.runtime.*;
126
    import org.eclipse.ocl.lpg.AbstractLexer;
127
    import org.eclipse.ocl.lpg.AbstractParser;
128
    ./
129
%End
130
131
%Headers
132
    /.
133
    @SuppressWarnings("nls")
134
    public class $action_type extends $super_stream_class implements $exp_type, $sym_type, RuleAction$additional_interfaces
135
    {
136
        private static ParseTable prs = new $prs_type();
137
        //
138
        // The Lexer contains an array of characters as the input stream to be parsed.
139
        // There are methods to retrieve and classify characters.
140
        // The lexparser "token" is implemented simply as the index of the next character in the array.
141
        // The Lexer extends the abstract class LpgLexStream with an implementation of the abstract
142
        // method getKind.  The template defines the Lexer class and the lexer() method.
143
        // A driver creates the action class, "Lexer", passing an Option object to the constructor.
144
        //
145
        protected $kw_lexer_class kwLexer;
146
        protected boolean printTokens;
147
        private $prs_stream_class parser;
148
        private LexParser lexParser = new LexParser(this, prs, this);
149
        
150
        private final $environment_class oclEnvironment;
151
152
        public $action_type($environment_class environment) {
153
            super($adapt_environment);
154
            oclEnvironment = environment;
155
        }
156
        
157
		public $action_class($environment_class environment, char[] chars) {
158
			this(environment, chars, "OCL", ECLIPSE_TAB_VALUE);
159
			kwLexer = new $kw_lexer_class(getInputChars(), $_IDENTIFIER);
160
		}
161
162
        public $action_type($environment_class environment, char[] input_chars, String filename, int tab)  {
163
            super($adapt_environment, input_chars, filename, tab);
164
            oclEnvironment = environment;
165
        }
166
        
167
		public $environment_class getOCLEnvironment() {
168
        	return oclEnvironment;
169
        }
170
171
        @Override
172
        public int [] getKeywordKinds() { return kwLexer.getKeywordKinds(); }
173
174
        public int getLeftSpan() { return lexParser.getFirstToken(); }
175
        public $prs_stream_class getParser() { return parser; }
176
        public int getRhsFirstTokenIndex(int i) { return lexParser.getFirstToken(i); }
177
        public int getRhsLastTokenIndex(int i) { return lexParser.getLastToken(i); }
178
        public int getRightSpan() { return lexParser.getLastToken(); }
179
180
        @Override
181
        public int getToken(int i) { return lexParser.getToken(i); }
182
183
        @Override
184
        public void initialize(char [] content, String filename)
185
        {
186
            super.initialize(content, filename);
187
            if (kwLexer == null)
188
                 kwLexer = new $kw_lexer_class(getInputChars(), $_IDENTIFIER);
189
            else
190
                 kwLexer.setInputChars(getInputChars());
191
        }
192
193
        @Override
194
        public String[] orderedExportedSymbols() { return $exp_type.orderedTerminalSymbols; }
195
        
196
	    @Override
197
	    public void setInputChars(char[] inputChars) {
198
			super.setInputChars(inputChars);
199
			kwLexer = new $kw_lexer_class(getInputChars(), $_IDENTIFIER);
200
		}
201
        
202
        @Override
203
        public void lexToTokens(Monitor monitor, $prs_stream_class parser)
204
        {
205
            if (getInputChars() == null)
206
                throw new NullPointerException("LexStream was not initialized");
207
208
            this.parser = parser;
209
210
            parser.makeToken(0, 0, 0); // Token list must start with a bad token
211
                
212
            lexParser.parseCharacters(monitor);  // Lex the input characters
213
                
214
            int i = getStreamIndex();
215
            parser.makeToken(i, i, $eof_token); // and end with the end of file token
216
            parser.setStreamLength(parser.getSize());
217
                
218
            return;
219
        }
220
    ./
221
%End
222
223
%Rules
224
    /.$BeginActions./
225
%End
226
227
%Trailers
228
    /.
229
        $EndActions
230
    }
231
    ./
232
%End
233
234
--
235
-- E N D   O F   T E M P L A T E
236
--
(-)src/org/eclipse/ocl/lpg/LexerBasicMap.gi (+196 lines)
Added Link Here
1
%Headers
2
    --
3
    -- Additional methods for the action class not provided in the template
4
    --
5
    
6
	-- [cwd] Template provided by LPG defines a constructor that uses an Option
7
	--       class that does not exist in LPG Runtime.  Deleted this constructor
8
	
9
    /.        
10
        final void makeToken(int kind)
11
        {
12
            int startOffset = getLeftSpan(),
13
                endOffset = getRightSpan();
14
            makeToken(startOffset, endOffset, kind);
15
            if (printTokens) printValue(startOffset, endOffset);
16
        }
17
18
        final void makeComment(int kind)
19
        {
20
            int startOffset = getLeftSpan(),
21
                endOffset = getRightSpan();
22
            super.getPrsStream().makeAdjunct(startOffset, endOffset, kind);
23
        }
24
25
        final void skipToken()
26
        {
27
            if (printTokens) printValue(getLeftSpan(), getRightSpan());
28
        }
29
        
30
        final void checkForKeyWord()
31
        {
32
            int startOffset = getLeftSpan(),
33
                endOffset = getRightSpan(),
34
            kwKind = kwLexer.lexer(startOffset, endOffset);
35
            makeToken(startOffset, endOffset, kwKind);
36
            if (printTokens) printValue(startOffset, endOffset);
37
        }
38
        
39
        final void printValue(int startOffset, int endOffset)
40
        {
41
            String s = new String(getInputChars(), startOffset, endOffset - startOffset + 1);
42
            System.out.print(s);
43
        }
44
45
        //
46
        //
47
        //
48
        public final static int tokenKind[] =
49
        {
50
            Char_CtlCharNotWS,    // 000    0x00
51
            Char_CtlCharNotWS,    // 001    0x01
52
            Char_CtlCharNotWS,    // 002    0x02
53
            Char_CtlCharNotWS,    // 003    0x03
54
            Char_CtlCharNotWS,    // 004    0x04
55
            Char_CtlCharNotWS,    // 005    0x05
56
            Char_CtlCharNotWS,    // 006    0x06
57
            Char_CtlCharNotWS,    // 007    0x07
58
            Char_CtlCharNotWS,    // 008    0x08
59
            Char_HT,              // 009    0x09
60
            Char_LF,              // 010    0x0A
61
            Char_CtlCharNotWS,    // 011    0x0B
62
            Char_FF,              // 012    0x0C
63
            Char_CR,              // 013    0x0D
64
            Char_CtlCharNotWS,    // 014    0x0E
65
            Char_CtlCharNotWS,    // 015    0x0F
66
            Char_CtlCharNotWS,    // 016    0x10
67
            Char_CtlCharNotWS,    // 017    0x11
68
            Char_CtlCharNotWS,    // 018    0x12
69
            Char_CtlCharNotWS,    // 019    0x13
70
            Char_CtlCharNotWS,    // 020    0x14
71
            Char_CtlCharNotWS,    // 021    0x15
72
            Char_CtlCharNotWS,    // 022    0x16
73
            Char_CtlCharNotWS,    // 023    0x17
74
            Char_CtlCharNotWS,    // 024    0x18
75
            Char_CtlCharNotWS,    // 025    0x19
76
            Char_CtlCharNotWS,    // 026    0x1A
77
            Char_CtlCharNotWS,    // 027    0x1B
78
            Char_CtlCharNotWS,    // 028    0x1C
79
            Char_CtlCharNotWS,    // 029    0x1D
80
            Char_CtlCharNotWS,    // 030    0x1E
81
            Char_CtlCharNotWS,    // 031    0x1F
82
            Char_Space,           // 032    0x20
83
            Char_Exclamation,     // 033    0x21
84
            Char_DoubleQuote,     // 034    0x22
85
            Char_Sharp,           // 035    0x23
86
            Char_DollarSign,      // 036    0x24
87
            Char_Percent,         // 037    0x25
88
            Char_Ampersand,       // 038    0x26
89
            Char_SingleQuote,     // 039    0x27
90
            Char_LeftParen,       // 040    0x28
91
            Char_RightParen,      // 041    0x29
92
            Char_Star,            // 042    0x2A
93
            Char_Plus,            // 043    0x2B
94
            Char_Comma,           // 044    0x2C
95
            Char_Minus,           // 045    0x2D
96
            Char_Dot,             // 046    0x2E
97
            Char_Slash,           // 047    0x2F
98
            Char_0,               // 048    0x30
99
            Char_1,               // 049    0x31
100
            Char_2,               // 050    0x32
101
            Char_3,               // 051    0x33
102
            Char_4,               // 052    0x34
103
            Char_5,               // 053    0x35
104
            Char_6,               // 054    0x36
105
            Char_7,               // 055    0x37
106
            Char_8,               // 056    0x38
107
            Char_9,               // 057    0x39
108
            Char_Colon,           // 058    0x3A
109
            Char_SemiColon,       // 059    0x3B
110
            Char_LessThan,        // 060    0x3C
111
            Char_Equal,           // 061    0x3D
112
            Char_GreaterThan,     // 062    0x3E
113
            Char_QuestionMark,    // 063    0x3F
114
            Char_AtSign,          // 064    0x40
115
            Char_A,               // 065    0x41
116
            Char_B,               // 066    0x42
117
            Char_C,               // 067    0x43
118
            Char_D,               // 068    0x44
119
            Char_E,               // 069    0x45
120
            Char_F,               // 070    0x46
121
            Char_G,               // 071    0x47
122
            Char_H,               // 072    0x48
123
            Char_I,               // 073    0x49
124
            Char_J,               // 074    0x4A
125
            Char_K,               // 075    0x4B
126
            Char_L,               // 076    0x4C
127
            Char_M,               // 077    0x4D
128
            Char_N,               // 078    0x4E
129
            Char_O,               // 079    0x4F
130
            Char_P,               // 080    0x50
131
            Char_Q,               // 081    0x51
132
            Char_R,               // 082    0x52
133
            Char_S,               // 083    0x53
134
            Char_T,               // 084    0x54
135
            Char_U,               // 085    0x55
136
            Char_V,               // 086    0x56
137
            Char_W,               // 087    0x57
138
            Char_X,               // 088    0x58
139
            Char_Y,               // 089    0x59
140
            Char_Z,               // 090    0x5A
141
            Char_LeftBracket,     // 091    0x5B
142
            Char_BackSlash,       // 092    0x5C
143
            Char_RightBracket,    // 093    0x5D
144
            Char_Caret,           // 094    0x5E
145
            Char__,               // 095    0x5F
146
            Char_BackQuote,       // 096    0x60
147
            Char_a,               // 097    0x61
148
            Char_b,               // 098    0x62
149
            Char_c,               // 099    0x63
150
            Char_d,               // 100    0x64
151
            Char_e,               // 101    0x65
152
            Char_f,               // 102    0x66
153
            Char_g,               // 103    0x67
154
            Char_h,               // 104    0x68
155
            Char_i,               // 105    0x69
156
            Char_j,               // 106    0x6A
157
            Char_k,               // 107    0x6B
158
            Char_l,               // 108    0x6C
159
            Char_m,               // 109    0x6D
160
            Char_n,               // 110    0x6E
161
            Char_o,               // 111    0x6F
162
            Char_p,               // 112    0x70
163
            Char_q,               // 113    0x71
164
            Char_r,               // 114    0x72
165
            Char_s,               // 115    0x73
166
            Char_t,               // 116    0x74
167
            Char_u,               // 117    0x75
168
            Char_v,               // 118    0x76
169
            Char_w,               // 119    0x77
170
            Char_x,               // 120    0x78
171
            Char_y,               // 121    0x79
172
            Char_z,               // 122    0x7A
173
            Char_LeftBrace,       // 123    0x7B
174
            Char_VerticalBar,     // 124    0x7C
175
            Char_RightBrace,      // 125    0x7D
176
            Char_Tilde,           // 126    0x7E
177
            Char_CtlCharNotWS,    // 127    0x7F
178
179
            Char_Acute,           // for the acute accent 0xb4
180
            Char_AfterASCIINotAcute,  // for all chars in range 0x80..0xfffe excluding the acute accent
181
            Char_EOF              // for '\uffff' or 65535 
182
        };
183
                
184
        @Override public final int getKind(int i)  // Classify character at ith location
185
        {
186
            char c = (i >= getStreamLength() ? '\uffff' : getCharValue(i));
187
            return (c < 128)? // ASCII Character
188
                      tokenKind[c] :
189
                      (c == '\uffff')?
190
                           Char_EOF :
191
                           (c == '\u00b4')?
192
                           Char_Acute :
193
                               Char_AfterASCIINotAcute;
194
        }
195
    ./
196
%End
(-)src/org/eclipse/ocl/parser/EssentialOCL.gi (+1728 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
5
-- * Open Canarias S.L and others.
6
-- * All rights reserved.   This program and the accompanying materials
7
-- * are made available under the terms of the Eclipse Public License v1.0
8
-- * which accompanies this distribution, and is available at
9
-- * http://www.eclipse.org/legal/epl-v10.html
10
-- *
11
-- * Contributors:
12
-- *   IBM - Initial API and implementation
13
-- *   E.D.Willink - Elimination of some shift-reduce conflicts
14
-- *   E.D.Willink - Remove unnecessary warning suppression
15
-- *   E.D.Willink - Bugs 225493, 243976, 259818
16
-- *   Zeligsoft - Bug 243976
17
-- *   Borland - Bug 242880
18
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v 2.0.17 adoption
19
-- *
20
-- * </copyright>
21
-- *
22
-- * $Id: EssentialOCL.gi,v 1.7 2009/03/05 14:12:14 cdamus Exp $
23
-- */
24
--
25
-- The EssentialOCL Parser
26
--
27
28
29
%Define
30
31
	-- Definition of macros used in the parser template
32
	--
33
	$prs_stream_class /.AbstractOCLParser./
34
	$prs_parser_class /.DeterministicParser./
35
	$prs_parser_exception /.NotDeterministicParseTableException./
36
	$prs_parser_throw /.throw new RuntimeException("****Error: Regenerate $prs_type.java with -NOBACKTRACK option")./
37
	$prs_parse_args /../
38
	$lex_stream_class /.AbstractLexer./
39
	$action_class /.$file_prefix./
40
	$copyright_contributions /.*./
41
42
	-- package namespace of the LPG Runtime API
43
	$lpg_ns /.lpg.runtime./
44
45
	$NewCase
46
	/. $Header
47
				case $rule_number:./
48
49
	-- From bt/dtParserTemplateD.g
50
	------------------------------------------------------
51
	$Header
52
	/.
53
				//
54
				// Rule $rule_number:  $rule_text
55
				//./
56
57
	$BeginAction
58
	/. $Header
59
				case $rule_number: {./
60
61
	$EndAction
62
	/.		  break;
63
				}./
64
65
	$BeginJava
66
		/. ./
67
68
	$EndJava 
69
		/. ./
70
71
	$NoAction
72
	/. $Header
73
				case $rule_number:
74
					break;./
75
76
	$NullAction
77
	/. $Header
78
				case $rule_number:
79
					$setResult(null);
80
					break;./
81
82
	$EmptyListAction
83
	/. $Header
84
				case $rule_number:
85
					$setResult(new BasicEList());
86
					break;./
87
	
88
	$BeginActions
89
	/.
90
		@SuppressWarnings("unchecked")
91
		public void ruleAction(int ruleNumber)
92
		{
93
			switch (ruleNumber) {
94
			./
95
96
	$EndActions
97
	/.
98
				default:
99
					break;
100
			}
101
			return;
102
		}./
103
104
	$additional_interfaces /../
105
	$action_class /.$file_prefix./
106
	$setSym1 /.dtParser.setSym1./
107
	$setResult /.dtParser.setSym1./
108
	$getSym /.dtParser.getSym./
109
	$getToken /.dtParser.getToken./
110
	$getIToken /.getIToken./
111
	$getLeftSpan /.dtParser.getFirstToken./
112
	$getRightSpan /.dtParser.getLastToken./
113
	$prs_stream /.prsStream./
114
	
115
	-- modified to include throwing exceptions
116
	$parserCore
117
	/.
118
	public class $action_class extends $prs_stream_class implements RuleAction$additional_interfaces
119
	{
120
		protected static ParseTable prs = new $prs_type();
121
		private $prs_parser_class dtParser;
122
123
		public $action_class($lex_stream_class lexer) {
124
			super(lexer);
125
		}
126
127
		public int getEOFTokenKind() { return $prs_type.EOFT_SYMBOL; }
128
	
129
		public $environment_class getOCLEnvironment() {
130
			return getLexer().getOCLEnvironment();
131
		}
132
		
133
		@Override 
134
		public $lex_stream_class getLexer() {
135
			return ($lex_stream_class)super.getLexer();
136
		}
137
138
		public String getTokenKindName(int kind) { return $sym_type.orderedTerminalSymbols[kind]; }			
139
140
		@Override
141
		public String[] orderedTerminalSymbols() { return $sym_type.orderedTerminalSymbols; }
142
			
143
		@SuppressWarnings("nls")
144
		@Override
145
		public $ast_type parseTokensToCST(Monitor monitor, int error_repair_count) {
146
			ParseTable prsTable = new $prs_type();
147
148
			try {
149
				dtParser = new $prs_parser_class(monitor, this, prsTable, this);
150
			}
151
			catch ($prs_parser_exception e) {
152
                $prs_parser_throw;
153
			}
154
			catch (BadParseSymFileException e) {
155
				throw new RuntimeException("****Error: Bad Parser Symbol File -- $sym_type.java. Regenerate $prs_type.java");
156
			}
157
158
			try {
159
				return ($ast_type) dtParser.parse($prs_parse_args);
160
			}
161
			catch (BadParseException e) {
162
				reset(e.error_token); // point to error token
163
164
				DiagnoseParser diagnoseParser = new DiagnoseParser(this, prsTable);
165
				diagnoseParser.diagnose(e.error_token);
166
			}
167
168
			return null;
169
		}
170
	
171
        /**
172
         * Initializes a concrete-syntax node's start and end offsets from the
173
         * current token in the parser stream.
174
         * 
175
         * @param cstNode a concrete-syntax node
176
         * 
177
         * @since 1.2
178
         */
179
		protected void setOffsets(CSTNode cstNode) {
180
			IToken firstToken = getIToken($getToken(1));
181
			cstNode.setStartToken(firstToken);
182
			cstNode.setEndToken(firstToken);
183
			cstNode.setStartOffset(firstToken.getStartOffset());
184
			cstNode.setEndOffset(firstToken.getEndOffset()-1);
185
		}
186
	./
187
%End
188
189
%Notice
190
	/./**
191
 * <copyright>
192
 *
193
 * Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., Borland Software Corp., 
194
 * Open Canarias S.L. and others.
195
 * All rights reserved.   This program and the accompanying materials
196
 * are made available under the terms of the Eclipse Public License v1.0
197
 * which accompanies this distribution, and is available at
198
 * http://www.eclipse.org/legal/epl-v10.html
199
 *
200
 * Contributors:
201
 *   IBM - Initial API and implementation
202
 *   E.D.Willink - Elimination of some shift-reduce conflicts
203
 *   E.D.Willink - Remove unnecessary warning suppression
204
 *   E.D.Willink - Bugs 225493, 243976, 259818
205
 *   Zeligsoft - Bug 243976
206
 *   Borland - Bug 242880
207
 *   Adolfo Sanchez- Barbudo Herrera - LPG v 2.0.17 adoption
208
$copyright_contributions
209
 * </copyright>
210
 *
211
 * $Id: EssentialOCL.g,v 1.7 2009/03/05 14:12:14 cdamus Exp $
212
 */
213
	./
214
%End
215
216
%Globals
217
	/.import org.eclipse.emf.common.util.BasicEList;
218
	import org.eclipse.emf.common.util.EList;
219
	import org.eclipse.ocl.cst.CSTNode;
220
	import org.eclipse.ocl.cst.CallExpCS;
221
	import org.eclipse.ocl.cst.CollectionTypeIdentifierEnum;
222
	import org.eclipse.ocl.cst.DotOrArrowEnum;
223
	import org.eclipse.ocl.cst.IntegerLiteralExpCS;
224
	import org.eclipse.ocl.cst.IsMarkedPreCS;
225
	import org.eclipse.ocl.cst.MessageExpCS;
226
	import org.eclipse.ocl.cst.OCLExpressionCS;
227
	import org.eclipse.ocl.cst.OCLMessageArgCS;
228
	import org.eclipse.ocl.cst.OperationCallExpCS;
229
	import org.eclipse.ocl.cst.PathNameCS;
230
	import org.eclipse.ocl.cst.SimpleNameCS;
231
	import org.eclipse.ocl.cst.SimpleTypeEnum;
232
	import org.eclipse.ocl.cst.StateExpCS;
233
	import org.eclipse.ocl.cst.StringLiteralExpCS;
234
	import org.eclipse.ocl.cst.TypeCS;
235
	import org.eclipse.ocl.cst.VariableCS;
236
	import org.eclipse.ocl.util.OCLStandardLibraryUtil;
237
	import org.eclipse.ocl.utilities.PredefinedType;
238
	
239
	import $lpg_ns.BadParseException;
240
	import $lpg_ns.BadParseSymFileException;
241
	import $lpg_ns.$prs_parser_class;
242
	import $lpg_ns.DiagnoseParser;
243
	import $lpg_ns.IToken;
244
	import $lpg_ns.Monitor;
245
	import $lpg_ns.$prs_parser_exception;
246
	import $lpg_ns.ParseTable;
247
	import $lpg_ns.RuleAction;
248
	./
249
%End
250
251
%KeyWords
252
	self
253
	inv
254
	pre
255
	post
256
	endpackage
257
	def
258
	if
259
	then
260
	else
261
	endif
262
	and
263
	or
264
	xor
265
	not
266
	implies
267
	let
268
	in
269
	true
270
	false
271
272
	--
273
	-- the following appear to have been omitted from the list of
274
	-- OCL reserved words in Section 7.4.9.  They will be treated 
275
	-- as unreserved for compliance
276
	--
277
	body
278
	derive
279
	init
280
	null
281
--  return  -- don't need a keyword for LPG purposes
282
283
	--
284
	-- the remainder of the LPG keywords are defined as such for the
285
	-- purpose of constructing the CST grammar.  They are not OCL
286
	-- reserved words
287
	--		
288
	Set
289
	Bag
290
	Sequence
291
	Collection
292
	OrderedSet
293
294
	iterate
295
	forAll
296
	exists
297
	isUnique
298
	any
299
	one
300
301
	collect
302
	select
303
	reject
304
	collectNested
305
	sortedBy
306
307
	closure
308
309
	oclIsKindOf
310
	oclIsTypeOf
311
	oclAsType
312
	oclIsNew
313
	oclIsUndefined
314
	oclIsInvalid
315
	oclIsInState
316
	allInstances
317
318
	String
319
	Integer
320
	UnlimitedNatural
321
	Real
322
	Boolean
323
	Tuple
324
	OclAny
325
	OclVoid
326
	Invalid
327
	OclMessage
328
	
329
	OclInvalid
330
%End
331
332
%Identifier
333
	IDENTIFIER
334
%End
335
336
%Terminals
337
	
338
	NUMERIC_OPERATION
339
340
	STRING_LITERAL
341
	INTEGER_LITERAL
342
	REAL_LITERAL
343
	
344
	PLUS     ::= '+'
345
	MINUS    ::= '-'
346
	MULTIPLY ::= '*'
347
	DIVIDE   ::= '/'
348
349
	GREATER       ::= '>'
350
	LESS          ::= '<'
351
	EQUAL         ::= '='
352
	GREATER_EQUAL ::= '>='
353
	LESS_EQUAL    ::= '<='
354
	NOT_EQUAL     ::= '<>'
355
356
	LPAREN   ::= '('
357
	RPAREN   ::= ')'
358
	LBRACE   ::= '{'
359
	RBRACE   ::= '}'
360
	LBRACKET ::= '['
361
	RBRACKET ::= ']'
362
363
	ARROW      ::= '->'
364
	BAR        ::= '|'
365
	COMMA      ::= ','
366
	COLON      ::= ':'
367
	COLONCOLON ::= '::'
368
	SEMICOLON  ::= ';'
369
	DOT        ::= '.'
370
	DOTDOT     ::= '..'
371
	ATPRE      ::= '@pre'
372
373
	CARET        ::= '^'
374
	CARETCARET   ::= '^^'
375
	QUESTIONMARK ::= '?'
376
377
%End
378
379
%EOF
380
    EOF_TOKEN
381
%End
382
383
%ERROR
384
    ERROR_TOKEN
385
%End
386
387
--$EOL
388
--	SEMICOLON
389
--$End
390
391
--$Start
392
--    goal
393
--$End
394
395
%Headers
396
	/.$parserCore
397
398
	./
399
%End
400
401
%Rules
402
	/.$BeginActions./
403
404
	-- opt = optional
405
	-- m = multiple
406
407
	--
408
	-- Define a group of names that we define as keywords for the purpose
409
	-- of constructing an LPG grammar, but that are not reserved by OCL
410
	-- and are commonly used in models such as the UML metamodel, itself
411
	--
412
	
413
	binaryIdentifier -> oclIsUndefined
414
	binaryIdentifier -> oclIsInvalid
415
	binaryIdentifier -> oclIsNew
416
	binaryIdentifier -> oclAsType
417
	binaryIdentifier -> oclIsKindOf
418
	binaryIdentifier -> oclIsTypeOf
419
	binaryIdentifier -> EQUAL
420
	binaryIdentifier -> NOT_EQUAL
421
	binaryIdentifier -> PLUS
422
	binaryIdentifier -> MULTIPLY
423
	binaryIdentifier -> DIVIDE
424
	binaryIdentifier -> GREATER
425
	binaryIdentifier -> LESS
426
	binaryIdentifier -> GREATER_EQUAL
427
	binaryIdentifier -> LESS_EQUAL
428
	binaryIdentifier -> and
429
	binaryIdentifier -> or
430
	binaryIdentifier -> xor
431
432
	unaryIdentifier -> MINUS
433
	unaryIdentifier -> not
434
435
	iteratorIdentifier -> forAll
436
	iteratorIdentifier -> exists
437
	iteratorIdentifier -> isUnique
438
	iteratorIdentifier -> any
439
	iteratorIdentifier -> one
440
	iteratorIdentifier -> collect
441
	iteratorIdentifier -> select
442
	iteratorIdentifier -> reject
443
	iteratorIdentifier -> collectNested
444
	iteratorIdentifier -> sortedBy
445
	iteratorIdentifier -> closure
446
447
	keywordAsIdentifier1 -> iterate
448
	keywordAsIdentifier1 -> iteratorIdentifier
449
	keywordAsIdentifier1 -> allInstances
450
	keywordAsIdentifier1 -> body
451
	keywordAsIdentifier1 -> derive
452
	keywordAsIdentifier1 -> init
453
	keywordAsIdentifier1 -> Set
454
	keywordAsIdentifier1 -> Bag
455
	keywordAsIdentifier1 -> Sequence
456
	keywordAsIdentifier1 -> Collection
457
	keywordAsIdentifier1 -> OrderedSet
458
	--------
459
	keywordAsIdentifier -> keywordAsIdentifier1
460
	keywordAsIdentifier -> null
461
462
	binaryName -> simpleNameCS
463
	binaryName ::= binaryIdentifier
464
		/.$NewCase./
465
	keywordAsName ::= keywordAsIdentifier
466
		/.$NewCase./
467
	keywordAsName1 ::= keywordAsIdentifier1
468
		/.$NewCase./
469
	unaryName ::= unaryIdentifier
470
		/.$BeginAction
471
					SimpleNameCS result = createSimpleNameCS(
472
								SimpleTypeEnum.IDENTIFIER_LITERAL,
473
								getTokenText($getToken(1))
474
							);
475
					setOffsets(result, getIToken($getToken(1)));
476
					$setResult(result);
477
		  $EndAction
478
		./
479
		
480
	iterateName ::= iterate
481
		/.$NewCase./
482
	iteratorName ::= iteratorIdentifier
483
		/.$NewCase./
484
	oclIsInStateName ::= oclIsInState
485
		/.$BeginAction
486
					SimpleNameCS result = createSimpleNameCS(
487
								SimpleTypeEnum.KEYWORD_LITERAL,
488
								getTokenText($getToken(1))
489
							);
490
					setOffsets(result, getIToken($getToken(1)));
491
					$setResult(result);
492
		  $EndAction
493
		./
494
495
	--
496
	-- the 'operationCS' non-terminal is not referenced in this grammar
497
	--
498
	operationCS -> operationCS1
499
	operationCS -> operationCS2
500
	operationCS1 ::= IDENTIFIER '(' parametersCSopt ')' ':' typeCSopt
501
		/.$BeginAction
502
					CSTNode result = createOperationCS(
503
							getTokenText($getToken(1)),
504
							(EList)$getSym(3),
505
							(TypeCS)$getSym(6)
506
						);
507
					if ($getSym(6) != null) {
508
						setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(6));
509
					} else {
510
						setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
511
					}
512
					$setResult(result);
513
		  $EndAction
514
		./
515
	operationCS2 ::= pathNameCS '::' simpleNameCS '(' parametersCSopt ')' ':' typeCSopt
516
		/.$BeginAction
517
					CSTNode result = createOperationCS(
518
							(PathNameCS)$getSym(1),
519
							(SimpleNameCS)$getSym(3),
520
							(EList)$getSym(5),
521
							(TypeCS)$getSym(8)
522
						);
523
					if ($getSym(8) != null) {
524
						setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(8));
525
					} else {
526
						setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(7)));
527
					}
528
					$setResult(result);
529
		  $EndAction
530
		./
531
532
533
	parametersCSopt ::= %empty
534
		/.$EmptyListAction./
535
	parametersCSopt -> parametersCS
536
	parametersCS ::= variableCS
537
		/.$BeginAction
538
					EList result = new BasicEList();
539
					result.add($getSym(1));
540
					$setResult(result);
541
		  $EndAction
542
		./
543
	parametersCS ::= parametersCS ',' variableCS
544
		/.$BeginAction
545
					EList result = (EList)$getSym(1);
546
					result.add($getSym(3));
547
					$setResult(result);
548
		  $EndAction
549
		./
550
551
	simpleNameCSopt ::= %empty
552
		/.$NullAction./
553
	simpleNameCSopt -> simpleNameCS	
554
555
	oclExpressionCS -> impliesExpCS
556
	oclExpressionCS -> impliesWithLet
557
	
558
	impliesExpCS -> andOrXorExpCS
559
	impliesWithLet -> andOrXorWithLet
560
	impliesExpCS ::= impliesExpCS implies andOrXorExpCS
561
		/.$NewCase./
562
	impliesWithLet ::= impliesExpCS implies andOrXorWithLet
563
		/.$NewCase./
564
565
	andOrXorExpCS -> equalityExpCS
566
	andOrXorWithLet -> equalityWithLet
567
	andOrXorExpCS ::= andOrXorExpCS and equalityExpCS
568
		/.$NewCase./
569
	andOrXorExpCS ::= andOrXorExpCS or equalityExpCS
570
		/.$NewCase./
571
	andOrXorExpCS ::= andOrXorExpCS xor equalityExpCS
572
		/.$NewCase./
573
	andOrXorWithLet ::= andOrXorExpCS and equalityWithLet
574
		/.$NewCase./
575
	andOrXorWithLet ::= andOrXorExpCS or equalityWithLet
576
		/.$NewCase./
577
	andOrXorWithLet ::= andOrXorExpCS xor equalityWithLet
578
		/.$BeginAction
579
					SimpleNameCS simpleNameCS = createSimpleNameCS(
580
								SimpleTypeEnum.STRING_LITERAL,
581
								getTokenText($getToken(2))
582
							);
583
					setOffsets(simpleNameCS, getIToken($getToken(2)));
584
					EList args = new BasicEList();
585
					args.add($getSym(3));
586
					CSTNode result = createOperationCallExpCS(
587
							(OCLExpressionCS)$getSym(1),
588
							simpleNameCS,
589
							args
590
						);
591
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
592
					$setResult(result);
593
		  $EndAction
594
		./
595
596
	equalityExpCS -> relationalExpCS
597
	equalityWithLet -> relationalWithLet
598
	equalityExpCS ::= equalityExpCS '=' relationalExpCS
599
		/.$NewCase./
600
	equalityWithLet ::= equalityExpCS '=' relationalWithLet
601
		/.$BeginAction
602
					SimpleNameCS simpleNameCS = createSimpleNameCS(
603
								SimpleTypeEnum.STRING_LITERAL,
604
								OCLStandardLibraryUtil.getOperationName(PredefinedType.EQUAL)
605
							);
606
					setOffsets(simpleNameCS, getIToken($getToken(2)));
607
					EList args = new BasicEList();
608
					args.add($getSym(3));
609
					CSTNode result = createOperationCallExpCS(
610
							(OCLExpressionCS)$getSym(1),
611
							simpleNameCS,
612
							args
613
						);
614
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
615
					$setResult(result);
616
		  $EndAction
617
		./
618
	equalityExpCS ::= equalityExpCS '<>' relationalExpCS
619
		/.$NewCase./
620
	equalityWithLet ::= equalityExpCS '<>' relationalWithLet
621
		/.$BeginAction
622
					SimpleNameCS simpleNameCS = createSimpleNameCS(
623
								SimpleTypeEnum.STRING_LITERAL,
624
								OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
625
							);
626
					setOffsets(simpleNameCS, getIToken($getToken(2)));
627
					EList args = new BasicEList();
628
					args.add($getSym(3));
629
					CSTNode result = createOperationCallExpCS(
630
							(OCLExpressionCS)$getSym(1),
631
							simpleNameCS,
632
							args
633
						);
634
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
635
					$setResult(result);
636
		  $EndAction
637
		./
638
	
639
	relationalExpCS -> ifExpCSPrec
640
	-- Note that ifExp already embeds let, so we needn't deal with it here
641
	relationalWithLet -> additiveWithLet
642
	relationalExpCS ::= relationalExpCS '>' ifExpCSPrec
643
		/.$NewCase./
644
	relationalWithLet ::= relationalExpCS '>' additiveWithLet
645
		/.$BeginAction
646
					SimpleNameCS simpleNameCS = createSimpleNameCS(
647
								SimpleTypeEnum.STRING_LITERAL,
648
								OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN)
649
							);
650
					setOffsets(simpleNameCS, getIToken($getToken(2)));
651
					EList args = new BasicEList();
652
					args.add($getSym(3));
653
					CSTNode result = createOperationCallExpCS(
654
							(OCLExpressionCS)$getSym(1),
655
							simpleNameCS,
656
							args
657
						);
658
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
659
					$setResult(result);
660
		  $EndAction
661
		./
662
	relationalExpCS ::= relationalExpCS '<' ifExpCSPrec
663
		/.$NewCase./
664
	relationalWithLet ::= relationalExpCS '<' additiveWithLet
665
		/.$BeginAction
666
					SimpleNameCS simpleNameCS = createSimpleNameCS(
667
								SimpleTypeEnum.STRING_LITERAL,
668
								OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN)
669
							);
670
					setOffsets(simpleNameCS, getIToken($getToken(2)));
671
					EList args = new BasicEList();
672
					args.add($getSym(3));
673
					CSTNode result = createOperationCallExpCS(
674
							(OCLExpressionCS)$getSym(1),
675
							simpleNameCS,
676
							args
677
						);
678
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
679
					$setResult(result);
680
		  $EndAction
681
		./
682
	relationalExpCS ::= relationalExpCS '>=' ifExpCSPrec
683
		/.$NewCase./
684
	relationalWithLet ::= relationalExpCS '>=' additiveWithLet
685
		/.$BeginAction
686
					SimpleNameCS simpleNameCS = createSimpleNameCS(
687
								SimpleTypeEnum.STRING_LITERAL,
688
								OCLStandardLibraryUtil.getOperationName(PredefinedType.GREATER_THAN_EQUAL)
689
							);
690
					setOffsets(simpleNameCS, getIToken($getToken(2)));
691
					EList args = new BasicEList();
692
					args.add($getSym(3));
693
					CSTNode result = createOperationCallExpCS(
694
							(OCLExpressionCS)$getSym(1),
695
							simpleNameCS,
696
							args
697
						);
698
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
699
					$setResult(result);
700
		  $EndAction
701
		./
702
	relationalExpCS ::= relationalExpCS '<=' ifExpCSPrec
703
		/.$NewCase./
704
	relationalWithLet ::= relationalExpCS '<=' additiveWithLet
705
		/.$BeginAction
706
					SimpleNameCS simpleNameCS = createSimpleNameCS(
707
								SimpleTypeEnum.STRING_LITERAL,
708
								OCLStandardLibraryUtil.getOperationName(PredefinedType.LESS_THAN_EQUAL)
709
							);
710
					setOffsets(simpleNameCS, getIToken($getToken(2)));
711
					EList args = new BasicEList();
712
					args.add($getSym(3));
713
					CSTNode result = createOperationCallExpCS(
714
							(OCLExpressionCS)$getSym(1),
715
							simpleNameCS,
716
							args
717
						);
718
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
719
					$setResult(result);
720
		  $EndAction
721
		./
722
	
723
	ifExpCSPrec -> additiveExpCS
724
	ifExpCSPrec -> ifExpCS
725
726
	additiveExpCS -> multiplicativeExpCS
727
	additiveWithLet -> multiplicativeWithLet
728
	additiveExpCS ::= additiveExpCS '+' multiplicativeExpCS
729
		/.$NewCase./
730
	additiveWithLet ::= additiveExpCS '+' multiplicativeWithLet
731
		/.$BeginAction
732
					SimpleNameCS simpleNameCS = createSimpleNameCS(
733
								SimpleTypeEnum.STRING_LITERAL,
734
								OCLStandardLibraryUtil.getOperationName(PredefinedType.PLUS)
735
							);
736
					setOffsets(simpleNameCS, getIToken($getToken(2)));
737
					EList args = new BasicEList();
738
					args.add($getSym(3));
739
					CSTNode result = createOperationCallExpCS(
740
							(OCLExpressionCS)$getSym(1),
741
							simpleNameCS,
742
							args
743
						);
744
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
745
					$setResult(result);
746
		  $EndAction
747
		./
748
	additiveExpCS ::= additiveExpCS '-' multiplicativeExpCS
749
		/.$NewCase./
750
	additiveWithLet ::= additiveExpCS '-' multiplicativeWithLet
751
		/.$BeginAction
752
					SimpleNameCS simpleNameCS = createSimpleNameCS(
753
								SimpleTypeEnum.STRING_LITERAL,
754
								OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
755
							);
756
					setOffsets(simpleNameCS, getIToken($getToken(2)));
757
					EList args = new BasicEList();
758
					args.add($getSym(3));
759
					CSTNode result = createOperationCallExpCS(
760
							(OCLExpressionCS)$getSym(1),
761
							simpleNameCS,
762
							args
763
						);
764
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
765
					$setResult(result);
766
		  $EndAction
767
		./
768
	
769
	multiplicativeExpCS -> unaryExpCS
770
	multiplicativeWithLet -> unaryWithLet
771
	multiplicativeExpCS ::= multiplicativeExpCS '*' unaryExpCS
772
		/.$NewCase./
773
	multiplicativeWithLet ::= multiplicativeExpCS '*' unaryWithLet
774
		/.$BeginAction
775
					SimpleNameCS simpleNameCS = createSimpleNameCS(
776
								SimpleTypeEnum.STRING_LITERAL,
777
								OCLStandardLibraryUtil.getOperationName(PredefinedType.TIMES)
778
							);
779
					setOffsets(simpleNameCS, getIToken($getToken(2)));
780
					EList args = new BasicEList();
781
					args.add($getSym(3));
782
					CSTNode result = createOperationCallExpCS(
783
							(OCLExpressionCS)$getSym(1),
784
							simpleNameCS,
785
							args
786
						);
787
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
788
					$setResult(result);
789
		  $EndAction
790
		./
791
	multiplicativeExpCS ::= multiplicativeExpCS '/' unaryExpCS
792
		/.$NewCase./
793
	multiplicativeWithLet ::= multiplicativeExpCS '/' unaryWithLet
794
		/.$BeginAction
795
					SimpleNameCS simpleNameCS = createSimpleNameCS(
796
								SimpleTypeEnum.STRING_LITERAL,
797
								OCLStandardLibraryUtil.getOperationName(PredefinedType.DIVIDE)
798
							);
799
					setOffsets(simpleNameCS, getIToken($getToken(2)));
800
					EList args = new BasicEList();
801
					args.add($getSym(3));
802
					CSTNode result = createOperationCallExpCS(
803
							(OCLExpressionCS)$getSym(1),
804
							simpleNameCS,
805
							args
806
						);
807
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
808
					$setResult(result);
809
		  $EndAction
810
		./
811
	
812
	unaryExpCS -> dotArrowExpCS
813
	unaryWithLet -> letExpCS
814
	unaryExpCS ::= '-' unaryExpCS
815
		/.$BeginAction
816
					SimpleNameCS simpleNameCS = createSimpleNameCS(
817
								SimpleTypeEnum.STRING_LITERAL,
818
								OCLStandardLibraryUtil.getOperationName(PredefinedType.MINUS)
819
							);
820
					setOffsets(simpleNameCS, getIToken($getToken(1)));
821
					CSTNode result = createOperationCallExpCS(
822
							(OCLExpressionCS)$getSym(2),
823
							simpleNameCS,
824
							new BasicEList()
825
						);
826
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(2));
827
					$setResult(result);
828
		  $EndAction
829
		./
830
	unaryExpCS ::= not unaryExpCS
831
		/.$BeginAction
832
					SimpleNameCS simpleNameCS = createSimpleNameCS(
833
								SimpleTypeEnum.STRING_LITERAL,
834
								getTokenText($getToken(1))
835
							);
836
					setOffsets(simpleNameCS, getIToken($getToken(1)));
837
					CSTNode result = createOperationCallExpCS(
838
							(OCLExpressionCS)$getSym(2),
839
							simpleNameCS,
840
							new BasicEList()
841
						);
842
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(2));
843
					$setResult(result);
844
		  $EndAction
845
		./
846
847
	dotArrowExpCS -> oclExpCS
848
	dotArrowExpCS ::= dotArrowExpCS callExpCS
849
		/.$BeginAction
850
					CallExpCS result = (CallExpCS)$getSym(2);
851
					result.setSource((OCLExpressionCS)$getSym(1));
852
					setOffsets(result, (CSTNode)$getSym(1), result);
853
					$setResult(result);
854
		  $EndAction
855
		./
856
	dotArrowExpCS ::= dotArrowExpCS messageExpCS
857
		/.$BeginAction
858
					MessageExpCS result = (MessageExpCS)$getSym(2);
859
					result.setTarget((OCLExpressionCS)$getSym(1));
860
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(2));
861
					$setResult(result);
862
		  $EndAction
863
		./
864
	dotArrowExpCS ::= NUMERIC_OPERATION '(' argumentsCSopt ')'
865
		/.$BeginAction
866
					// NUMERIC_OPERATION -> Integer '.' Identifier
867
					String text = getTokenText(dtParser.getToken(1));
868
					int index = text.indexOf('.');
869
					String integer = text.substring(0, index);
870
					String simpleName = text.substring(index + 1);
871
872
					// create the IntegerLiteralExpCS
873
					IToken numericToken = getIToken($getToken(1));
874
					int startOffset = numericToken.getStartOffset();
875
					int endOffset = startOffset + integer.length() - 1; // inclusive
876
877
					IntegerLiteralExpCS integerLiteralExpCS = createIntegerLiteralExpCS(integer);
878
					integerLiteralExpCS.setStartOffset(startOffset);
879
					integerLiteralExpCS.setEndOffset(endOffset);
880
					integerLiteralExpCS.setStartToken(numericToken);
881
					integerLiteralExpCS.setEndToken(numericToken);
882
883
					startOffset = endOffset + 2; // end of integerLiteral + 1('.') + 1(start of simpleName)
884
					endOffset = getIToken($getToken(1)).getEndOffset();
885
886
					// create the SimpleNameCS
887
					SimpleNameCS simpleNameCS = createSimpleNameCS(
888
								SimpleTypeEnum.IDENTIFIER_LITERAL,
889
								simpleName
890
							);
891
					simpleNameCS.setStartOffset(startOffset);
892
					simpleNameCS.setEndOffset(endOffset);
893
					simpleNameCS.setStartToken(numericToken);
894
					simpleNameCS.setEndToken(numericToken);
895
896
					// create the OperationCallExpCS
897
					CSTNode result = createOperationCallExpCS(
898
							integerLiteralExpCS,
899
							simpleNameCS,
900
							(EList)$getSym(3)
901
						);
902
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
903
					$setResult(result);
904
		  $EndAction
905
		./
906
907
    -- static operation call (@pre is not permitted in this context)
908
	dotArrowExpCS ::=  pathNameCS '::' simpleNameCS '(' argumentsCSopt ')'
909
		/.$BeginAction
910
					OperationCallExpCS result = createOperationCallExpCS(
911
							(PathNameCS)$getSym(1),
912
							(SimpleNameCS)$getSym(3),
913
							(EList)$getSym(5)
914
						);
915
					setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(6)));
916
					result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
917
					$setResult(result);
918
		  $EndAction
919
		./
920
921
922
	oclExpCS -> variableExpCS
923
	oclExpCS -> literalExpCS
924
	oclExpCS -> operationCallExpCS
925
	oclExpCS -> keywordOperationCallExpCS
926
927
	oclExpCS ::= '(' oclExpressionCS ')'
928
		/.$BeginAction
929
					CSTNode result = (CSTNode)$getSym(2);
930
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
931
					$setResult(result);
932
		  $EndAction
933
		./
934
935
	variableExpCS ::= simpleNameCS isMarkedPreCS
936
		/.$NewCase./
937
	variableExpCS ::= keywordAsName1 isMarkedPreCS
938
		/.$BeginAction
939
					IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)$getSym(2);
940
					CSTNode result = createVariableExpCS(
941
							(SimpleNameCS)$getSym(1),
942
							new BasicEList(),
943
							isMarkedPreCS
944
						);
945
					if (isMarkedPreCS.isPre()) {
946
						setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(2));
947
					} else {
948
						setOffsets(result, (CSTNode)$getSym(1));
949
					}
950
					$setResult(result);
951
		  $EndAction
952
		./
953
	variableExpCS ::= simpleNameCS '[' argumentsCS ']' isMarkedPreCS
954
		/.$NewCase./
955
	variableExpCS ::= keywordAsName1 '[' argumentsCS ']' isMarkedPreCS
956
		/.$BeginAction
957
					IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)$getSym(5);
958
					CSTNode result = createVariableExpCS(
959
							(SimpleNameCS)$getSym(1),
960
							(EList)$getSym(3),
961
							isMarkedPreCS
962
						);
963
					if (isMarkedPreCS.isPre()) {
964
						setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(5));
965
					} else {
966
						setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(4)));
967
					}
968
					$setResult(result);
969
		  $EndAction
970
		./
971
972
973
	simpleNameCS -> primitiveTypeCS
974
	simpleNameCS ::= self
975
		/.$BeginAction
976
					CSTNode result = createSimpleNameCS(
977
							SimpleTypeEnum.SELF_LITERAL,
978
							getTokenText($getToken(1))
979
						);
980
					setOffsets(result, getIToken($getToken(1)));
981
					$setResult(result);
982
		  $EndAction
983
		./
984
	simpleNameCS ::= IDENTIFIER
985
		/.$BeginAction
986
					CSTNode result = createSimpleNameCS(
987
							SimpleTypeEnum.IDENTIFIER_LITERAL,
988
							getTokenText($getToken(1))
989
						);
990
					setOffsets(result, getIToken($getToken(1)));
991
					$setResult(result);
992
		  $EndAction
993
		./
994
995
	primitiveTypeCS ::= Integer
996
		/.$BeginAction
997
					CSTNode result = createPrimitiveTypeCS(
998
							SimpleTypeEnum.INTEGER_LITERAL,
999
							getTokenText($getToken(1))
1000
						);
1001
					setOffsets(result, getIToken($getToken(1)));
1002
					$setResult(result);
1003
		  $EndAction
1004
		./
1005
	primitiveTypeCS ::= UnlimitedNatural
1006
		/.$BeginAction
1007
					CSTNode result = createPrimitiveTypeCS(
1008
							SimpleTypeEnum.UNLIMITED_NATURAL_LITERAL,
1009
							getTokenText($getToken(1))
1010
						);
1011
					setOffsets(result, getIToken($getToken(1)));
1012
					$setResult(result);
1013
		  $EndAction
1014
		./
1015
	primitiveTypeCS ::= String
1016
		/.$BeginAction
1017
					CSTNode result = createPrimitiveTypeCS(
1018
							SimpleTypeEnum.STRING_LITERAL,
1019
							getTokenText($getToken(1))
1020
						);
1021
					setOffsets(result, getIToken($getToken(1)));
1022
					$setResult(result);
1023
		  $EndAction
1024
		./
1025
	primitiveTypeCS ::= Real
1026
		/.$BeginAction
1027
					CSTNode result = createPrimitiveTypeCS(
1028
							SimpleTypeEnum.REAL_LITERAL,
1029
							getTokenText($getToken(1))
1030
						);
1031
					setOffsets(result, getIToken($getToken(1)));
1032
					$setResult(result);
1033
		  $EndAction
1034
		./
1035
	primitiveTypeCS ::= Boolean
1036
		/.$BeginAction
1037
					CSTNode result = createPrimitiveTypeCS(
1038
							SimpleTypeEnum.BOOLEAN_LITERAL,
1039
							getTokenText($getToken(1))
1040
						);
1041
					setOffsets(result, getIToken($getToken(1)));
1042
					$setResult(result);
1043
		  $EndAction
1044
		./
1045
	primitiveTypeCS ::= OclAny
1046
		/.$BeginAction
1047
					CSTNode result = createPrimitiveTypeCS(
1048
							SimpleTypeEnum.OCL_ANY_LITERAL,
1049
							getTokenText($getToken(1))
1050
						);
1051
					setOffsets(result, getIToken($getToken(1)));
1052
					$setResult(result);
1053
		  $EndAction
1054
		./
1055
	primitiveTypeCS ::= OclVoid
1056
		/.$BeginAction
1057
					CSTNode result = createPrimitiveTypeCS(
1058
							SimpleTypeEnum.OCL_VOID_LITERAL,
1059
							getTokenText($getToken(1))
1060
						);
1061
					setOffsets(result, getIToken($getToken(1)));
1062
					$setResult(result);
1063
		  $EndAction
1064
		./
1065
	primitiveTypeCS ::= Invalid
1066
		/.$BeginAction
1067
					CSTNode result = createPrimitiveTypeCS(
1068
							SimpleTypeEnum.INVALID_LITERAL,
1069
							getTokenText($getToken(1))
1070
						);
1071
					setOffsets(result, getIToken($getToken(1)));
1072
					$setResult(result);
1073
		  $EndAction
1074
		./
1075
	primitiveTypeCS ::= OclMessage
1076
		/.$BeginAction
1077
					CSTNode result = createPrimitiveTypeCS(
1078
							SimpleTypeEnum.OCL_MESSAGE_LITERAL,
1079
							getTokenText($getToken(1))
1080
						);
1081
					setOffsets(result, getIToken($getToken(1)));
1082
					$setResult(result);
1083
		  $EndAction
1084
		./
1085
1086
	pathNameCS ::= IDENTIFIER
1087
		/.$BeginAction
1088
					CSTNode result = createPathNameCS(getTokenText($getToken(1)));
1089
					setOffsets(result, getIToken($getToken(1)));
1090
					$setResult(result);
1091
		  $EndAction
1092
		./
1093
	pathNameCS ::= pathNameCS '::' simpleNameCS
1094
		/.$BeginAction
1095
					PathNameCS result = (PathNameCS)$getSym(1);
1096
					result = extendPathNameCS(result, getTokenText(dtParser.getToken(3)));
1097
					setOffsets(result, result, (CSTNode)$getSym(3));
1098
					$setResult(result);
1099
		  $EndAction
1100
		./
1101
1102
	pathNameCSOpt ::= %empty
1103
		/.$BeginAction
1104
					CSTNode result = createPathNameCS();
1105
					$setResult(result);
1106
		  $EndAction
1107
		./
1108
	pathNameCSOpt -> pathNameCS
1109
1110
	literalExpCS -> enumLiteralExpCS
1111
	literalExpCS -> collectionLiteralExpCS
1112
	literalExpCS -> tupleLiteralExpCS
1113
	literalExpCS -> primitiveLiteralExpCS
1114
	literalExpCS -> nullLiteralExpCS
1115
	literalExpCS -> invalidLiteralExpCS
1116
1117
    -- also covers the case of static attribute call, in which
1118
    --    case @pre is not allowed anyway
1119
	enumLiteralExpCS ::= pathNameCS '::' keywordAsName
1120
		/.$NewCase./
1121
	enumLiteralExpCS ::= pathNameCS '::' simpleNameCS
1122
		/.$BeginAction
1123
					CSTNode result = createEnumLiteralExpCS(
1124
							(PathNameCS)$getSym(1),
1125
							(SimpleNameCS)$getSym(3)
1126
						);
1127
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
1128
					$setResult(result);
1129
		  $EndAction
1130
		./
1131
1132
	collectionLiteralExpCS ::= collectionTypeIdentifierCS '{' collectionLiteralPartsCSopt '}'
1133
		/.$BeginAction
1134
					Object[] objs = (Object[])$getSym(1);
1135
					CSTNode result = createCollectionLiteralExpCS(
1136
							(CollectionTypeIdentifierEnum)objs[1],
1137
							(EList)$getSym(3)
1138
						);
1139
					setOffsets(result, (IToken)objs[0], getIToken($getToken(4)));
1140
					$setResult(result);
1141
		  $EndAction
1142
		./
1143
1144
	collectionTypeIdentifierCS ::= Set
1145
		/.$BeginAction
1146
					$setResult(new Object[]{getIToken($getToken(1)), CollectionTypeIdentifierEnum.SET_LITERAL});
1147
		  $EndAction
1148
		./
1149
	collectionTypeIdentifierCS ::= Bag
1150
		/.$BeginAction
1151
					$setResult(new Object[]{getIToken($getToken(1)), CollectionTypeIdentifierEnum.BAG_LITERAL});
1152
		  $EndAction
1153
		./
1154
	collectionTypeIdentifierCS ::= Sequence
1155
		/.$BeginAction
1156
					$setResult(new Object[]{getIToken($getToken(1)), CollectionTypeIdentifierEnum.SEQUENCE_LITERAL});
1157
		  $EndAction
1158
		./
1159
	collectionTypeIdentifierCS ::= Collection
1160
		/.$BeginAction
1161
					$setResult(new Object[]{getIToken($getToken(1)), CollectionTypeIdentifierEnum.COLLECTION_LITERAL});
1162
		  $EndAction
1163
		./
1164
	collectionTypeIdentifierCS ::= OrderedSet
1165
		/.$BeginAction
1166
					$setResult(new Object[]{getIToken($getToken(1)), CollectionTypeIdentifierEnum.ORDERED_SET_LITERAL});
1167
		  $EndAction
1168
		./
1169
1170
	collectionLiteralPartsCSopt ::= %empty
1171
		/.$EmptyListAction./
1172
	collectionLiteralPartsCSopt -> collectionLiteralPartsCS
1173
1174
	collectionLiteralPartsCS ::= collectionLiteralPartCS
1175
		/.$BeginAction
1176
					EList result = new BasicEList();
1177
					result.add($getSym(1));
1178
					$setResult(result);
1179
		  $EndAction
1180
		./
1181
	collectionLiteralPartsCS ::= collectionLiteralPartsCS ',' collectionLiteralPartCS
1182
		/.$BeginAction
1183
					EList result = (EList)$getSym(1);
1184
					result.add($getSym(3));
1185
					$setResult(result);
1186
		  $EndAction
1187
		./
1188
1189
	collectionLiteralPartCS -> collectionRangeCS
1190
	collectionLiteralPartCS ::= oclExpressionCS
1191
		/.$BeginAction
1192
					CSTNode result = createCollectionLiteralPartCS(
1193
							(OCLExpressionCS)$getSym(1)
1194
						);
1195
					setOffsets(result, (CSTNode)$getSym(1));
1196
					$setResult(result);
1197
		  $EndAction
1198
		./
1199
1200
	collectionRangeCS ::= '-' INTEGER_RANGE_START oclExpressionCS
1201
		/.$BeginAction
1202
					OCLExpressionCS rangeStart = createRangeStart(
1203
							getTokenText($getToken(2)), true);
1204
					CSTNode result = createCollectionRangeCS(
1205
							rangeStart,
1206
							(OCLExpressionCS)$getSym(3)
1207
						);
1208
					setOffsets(result, rangeStart, (CSTNode)$getSym(3));
1209
					$setResult(result);
1210
		  $EndAction
1211
		./
1212
	collectionRangeCS ::= INTEGER_RANGE_START oclExpressionCS
1213
		/.$BeginAction
1214
					OCLExpressionCS rangeStart = createRangeStart(
1215
							getTokenText($getToken(1)), false);
1216
					CSTNode result = createCollectionRangeCS(
1217
							rangeStart,
1218
							(OCLExpressionCS)$getSym(2)
1219
						);
1220
					setOffsets(result, rangeStart, (CSTNode)$getSym(2));
1221
					$setResult(result);
1222
		  $EndAction
1223
		./
1224
	collectionRangeCS ::= oclExpressionCS '..' oclExpressionCS
1225
		/.$BeginAction
1226
					CSTNode result = createCollectionRangeCS(
1227
							(OCLExpressionCS)$getSym(1),
1228
							(OCLExpressionCS)$getSym(3)
1229
						);
1230
					setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(3));
1231
					$setResult(result);
1232
		  $EndAction
1233
		./
1234
1235
	primitiveLiteralExpCS -> integerLiteralExpCS
1236
	primitiveLiteralExpCS -> unlimitedNaturalLiteralExpCS
1237
	primitiveLiteralExpCS -> realLiteralExpCS
1238
	primitiveLiteralExpCS -> stringLiteralExpCS
1239
	primitiveLiteralExpCS -> booleanLiteralExpCS
1240
1241
	tupleLiteralExpCS ::= Tuple '{' variableListCS2 '}'
1242
		/.$BeginAction
1243
					CSTNode result = createTupleLiteralExpCS((EList)$getSym(3));
1244
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
1245
					$setResult(result);
1246
		  $EndAction
1247
		./
1248
	integerLiteralExpCS ::= INTEGER_LITERAL
1249
		/.$BeginAction
1250
					CSTNode result = createIntegerLiteralExpCS(getTokenText($getToken(1)));
1251
					setOffsets(result, getIToken($getToken(1)));
1252
					$setResult(result);
1253
		  $EndAction
1254
		./
1255
	unlimitedNaturalLiteralExpCS ::= '*'
1256
		/.$BeginAction
1257
					CSTNode result = createUnlimitedNaturalLiteralExpCS(getTokenText($getToken(1)));
1258
					setOffsets(result, getIToken($getToken(1)));
1259
					$setResult(result);
1260
		  $EndAction
1261
		./
1262
	realLiteralExpCS ::= REAL_LITERAL
1263
		/.$BeginAction
1264
					CSTNode result = createRealLiteralExpCS(getTokenText($getToken(1)));
1265
					setOffsets(result, getIToken($getToken(1)));
1266
					$setResult(result);
1267
		  $EndAction
1268
		./
1269
	stringLiteralExpCS ::= STRING_LITERAL
1270
		/.$BeginAction
1271
					IToken literalToken = getIToken($getToken(1));
1272
					StringLiteralExpCS result = createStringLiteralExpCS(literalToken.toString());
1273
					result.setUnescapedStringSymbol(unescape(literalToken));
1274
					setOffsets(result, literalToken);
1275
					$setResult(result);
1276
		  $EndAction
1277
		./
1278
	booleanLiteralExpCS ::= true
1279
		/.$BeginAction
1280
					CSTNode result = createBooleanLiteralExpCS(getTokenText($getToken(1)));
1281
					setOffsets(result, getIToken($getToken(1)));
1282
					$setResult(result);
1283
		  $EndAction
1284
		./
1285
	booleanLiteralExpCS ::= false
1286
		/.$BeginAction
1287
					CSTNode result = createBooleanLiteralExpCS(getTokenText($getToken(1)));
1288
					setOffsets(result, getIToken($getToken(1)));
1289
					$setResult(result);
1290
		  $EndAction
1291
		./
1292
1293
	nullLiteralExpCS ::= null
1294
		/.$BeginAction
1295
					CSTNode result = createNullLiteralExpCS(getTokenText($getToken(1)));
1296
					setOffsets(result, getIToken($getToken(1)));
1297
					$setResult(result);
1298
		  $EndAction
1299
		./
1300
1301
	invalidLiteralExpCS ::= OclInvalid
1302
		/.$BeginAction
1303
					CSTNode result = createInvalidLiteralExpCS(getTokenText($getToken(1)));
1304
					setOffsets(result, getIToken($getToken(1)));
1305
					$setResult(result);
1306
		  $EndAction
1307
		./
1308
1309
1310
	callExpCS ::= '->' featureCallExpCS
1311
		/.$NewCase./
1312
	callExpCS ::= '->' loopExpCS
1313
		/.$BeginAction
1314
					CallExpCS result = (CallExpCS)$getSym(2);
1315
					result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
1316
					$setResult(result);
1317
		  $EndAction
1318
		./
1319
	callExpCS ::= '.' keywordOperationCallExpCS
1320
		/.$NewCase./
1321
	callExpCS ::= '.' featureCallExpCS
1322
		/.$BeginAction
1323
					CallExpCS result = (CallExpCS)$getSym(2);
1324
					result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
1325
					$setResult(result);
1326
		  $EndAction
1327
		./
1328
1329
	loopExpCS -> iteratorExpCS
1330
	loopExpCS -> iterateExpCS
1331
1332
	iteratorExpCS ::= iteratorName '(' oclExpressionCS ')'
1333
		/.$BeginAction
1334
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1335
					CSTNode result = createIteratorExpCS(
1336
							simpleNameCS,
1337
							null,
1338
							null,
1339
							(OCLExpressionCS)$getSym(3)
1340
						);
1341
					setOffsets(result, simpleNameCS, getIToken($getToken(4)));
1342
					$setResult(result);
1343
		  $EndAction
1344
		./
1345
	iteratorExpCS ::= iteratorName '(' variableCS '|' oclExpressionCS ')'
1346
		/.$BeginAction
1347
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1348
					CSTNode result = createIteratorExpCS(
1349
							simpleNameCS,
1350
							(VariableCS)$getSym(3),
1351
							null,
1352
							(OCLExpressionCS)$getSym(5)
1353
						);
1354
					setOffsets(result, simpleNameCS, getIToken($getToken(6)));
1355
					$setResult(result);
1356
		  $EndAction
1357
		./
1358
	iteratorExpCS ::= iteratorName '(' variableCS ',' variableCS '|' oclExpressionCS ')'
1359
		/.$BeginAction
1360
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1361
					CSTNode result = createIteratorExpCS(
1362
							simpleNameCS,
1363
							(VariableCS)$getSym(3),
1364
							(VariableCS)$getSym(5),
1365
							(OCLExpressionCS)$getSym(7)
1366
						);
1367
					setOffsets(result, simpleNameCS, getIToken($getToken(8)));
1368
					$setResult(result);
1369
		  $EndAction
1370
		./
1371
1372
	iterateExpCS ::= iterateName '(' variableCS '|' oclExpressionCS ')'
1373
		/.$BeginAction
1374
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1375
					CSTNode result = createIterateExpCS(
1376
							simpleNameCS,
1377
							(VariableCS)$getSym(3),
1378
							null,
1379
							(OCLExpressionCS)$getSym(5)
1380
						);
1381
					setOffsets(result, simpleNameCS, getIToken($getToken(6)));
1382
					$setResult(result);
1383
		  $EndAction
1384
		./
1385
	iterateExpCS ::= iterateName '(' variableCS ';' variableCS '|' oclExpressionCS ')'
1386
		/.$BeginAction
1387
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1388
					CSTNode result = createIterateExpCS(
1389
							simpleNameCS,
1390
							(VariableCS)$getSym(3),
1391
							(VariableCS)$getSym(5),
1392
							(OCLExpressionCS)$getSym(7)
1393
						);
1394
					setOffsets(result, simpleNameCS, getIToken($getToken(8)));
1395
					$setResult(result);
1396
		  $EndAction
1397
		./
1398
1399
	variableCS ::= IDENTIFIER
1400
		/.$BeginAction
1401
					CSTNode result = createVariableCS(
1402
							getTokenText($getToken(1)),
1403
							null,
1404
							null
1405
						);
1406
					setOffsets(result, getIToken($getToken(1)));
1407
					$setResult(result);
1408
		  $EndAction
1409
		./
1410
	typedVariableCS ::= IDENTIFIER ':' typeCS
1411
		/.$BeginAction
1412
					CSTNode result = createVariableCS(
1413
							getTokenText($getToken(1)),
1414
							(TypeCS)$getSym(3),
1415
							null
1416
						);
1417
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(3));
1418
					$setResult(result);
1419
		  $EndAction
1420
		./
1421
	variableCS -> typedVariableCS
1422
	variableCS ::= IDENTIFIER ':' typeCS '=' oclExpressionCS
1423
		/.$BeginAction
1424
					CSTNode result = createVariableCS(
1425
							getTokenText($getToken(1)),
1426
							(TypeCS)$getSym(3),
1427
							(OCLExpressionCS)$getSym(5)
1428
						);
1429
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(5));
1430
					$setResult(result);
1431
		  $EndAction
1432
		./
1433
1434
	-- this form of variable declaration is only used in tuple literals
1435
	variableCS2 ::= IDENTIFIER '=' oclExpressionCS
1436
		/.$BeginAction
1437
					CSTNode result = createVariableCS(
1438
							getTokenText($getToken(1)),
1439
							null,
1440
							(OCLExpressionCS)$getSym(3)
1441
						);
1442
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(3));
1443
					$setResult(result);
1444
		  $EndAction
1445
		./
1446
1447
	typeCSopt ::= %empty
1448
		/.$NullAction./
1449
	typeCSopt -> typeCS
1450
1451
	-- the order of these rules is important!  Try to match primitives
1452
	--   first, then tuples (more complex), and finally collections.
1453
	--   Looking for type names in the Ecore model is a last resort
1454
	typeCS -> primitiveTypeCS
1455
	typeCS -> tupleTypeCS
1456
	typeCS -> collectionTypeCS
1457
	typeCS -> pathNameCS
1458
1459
	collectionTypeCS ::= collectionTypeIdentifierCS '(' typeCS ')'
1460
		/.$BeginAction
1461
					Object[] objs = (Object[])$getSym(1);
1462
					CSTNode result = createCollectionTypeCS(
1463
							(CollectionTypeIdentifierEnum)objs[1],
1464
							(TypeCS)$getSym(3)
1465
						);
1466
					setOffsets(result, (IToken)objs[0], getIToken($getToken(4)));
1467
					$setResult(result);
1468
		  $EndAction
1469
		./
1470
1471
	tupleTypeCS ::= Tuple '(' variableListCSopt ')'
1472
		/.$BeginAction
1473
					CSTNode result = createTupleTypeCS((EList)$getSym(3));
1474
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
1475
					$setResult(result);
1476
		  $EndAction
1477
		./
1478
1479
	
1480
	variableListCSopt ::= %empty
1481
		/.$EmptyListAction./
1482
	variableListCSopt -> variableListCS
1483
	variableListCS ::= variableCS 
1484
		/.$BeginAction
1485
					EList result = new BasicEList();
1486
					result.add($getSym(1));
1487
					$setResult(result);
1488
		  $EndAction
1489
		./
1490
	variableListCS ::= variableListCS ',' variableCS
1491
		/.$BeginAction
1492
					EList result = (EList)$getSym(1);
1493
					result.add($getSym(3));
1494
					$setResult(result);
1495
		  $EndAction
1496
		./
1497
	
1498
	-- this form of variable declaration list is only used in tuple literals
1499
	variableListCS2 ::= variableCS2
1500
		/.$NewCase./
1501
	variableListCS2 ::= variableCS
1502
		/.$BeginAction
1503
					EList result = new BasicEList();
1504
					result.add($getSym(1));
1505
					$setResult(result);
1506
		  $EndAction
1507
		./
1508
	variableListCS2 ::= variableListCS2 ',' variableCS2
1509
		/.$NewCase./
1510
	variableListCS2 ::= variableListCS2 ',' variableCS
1511
		/.$BeginAction
1512
					EList result = (EList)$getSym(1);
1513
					result.add($getSym(3));
1514
					$setResult(result);
1515
		  $EndAction
1516
		./
1517
	
1518
	-- covers attributeCallExpCS and navigationCallExpCS
1519
	featureCallExpCS -> attrOrNavCallExpCS
1520
1521
	featureCallExpCS -> operationCallExpCS
1522
	featureCallExpCS ::= unaryName isMarkedPreCS '(' argumentsCSopt ')'
1523
		/.$NewCase./
1524
	-- even though these operations do not use @pre or do not accept multiple arguments
1525
	-- in order to get better error reporting, the rule signature must comply with
1526
	-- the full rule of an operationCallExpCS
1527
	-- the alternative would be to remove these as keywords, but then the parser
1528
	-- would accept variable declarations where the var can be named "oclIsNew" for example
1529
	operationCallExpCS ::= binaryName isMarkedPreCS '(' argumentsCSopt ')'
1530
		/.$NewCase./
1531
	keywordOperationCallExpCS ::= keywordAsName isMarkedPreCS '(' argumentsCSopt ')'
1532
		/.$BeginAction
1533
					CSTNode result = createOperationCallExpCS(
1534
							(SimpleNameCS)$getSym(1),
1535
							(IsMarkedPreCS)$getSym(2),
1536
							(EList)$getSym(4)
1537
						);
1538
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
1539
					$setResult(result);
1540
		  $EndAction
1541
		./
1542
1543
	stateExpCS ::= pathNameCSOpt
1544
		/.$BeginAction
1545
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
1546
					StateExpCS result = createStateExpCS(pathNameCS);
1547
					setOffsets(result, pathNameCS);
1548
					$setResult(result);
1549
		  $EndAction
1550
		./
1551
	-- FIXME StateExpCS creates a needless irregularity; unwrap its content as an argument list
1552
	operationCallExpCS ::= oclIsInStateName isMarkedPreCS '(' stateExpCS ')'
1553
		/.$BeginAction
1554
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
1555
					CSTNode result = createOperationCallExpCS(
1556
							simpleNameCS,
1557
							(IsMarkedPreCS)$getSym(2),
1558
							(StateExpCS)$getSym(4)
1559
						);
1560
					setOffsets(result, simpleNameCS, getIToken($getToken(5)));
1561
					$setResult(result);
1562
		  $EndAction
1563
		./
1564
1565
	attrOrNavCallExpCS ::= simpleNameCS isMarkedPreCS
1566
		/.$NewCase./
1567
	attrOrNavCallExpCS ::= keywordAsName isMarkedPreCS
1568
		/.$BeginAction
1569
					IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)$getSym(2);
1570
					CSTNode result = createFeatureCallExpCS(
1571
							(SimpleNameCS)$getSym(1),
1572
							new BasicEList(),
1573
							isMarkedPreCS
1574
						);
1575
					if (isMarkedPreCS.isPre()) {
1576
						setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(2));
1577
					} else {
1578
						setOffsets(result, (CSTNode)$getSym(1));
1579
					}
1580
					$setResult(result);
1581
		  $EndAction
1582
		./
1583
	attrOrNavCallExpCS ::= simpleNameCS '[' argumentsCS ']' isMarkedPreCS
1584
		/.$BeginAction
1585
					IsMarkedPreCS isMarkedPreCS = (IsMarkedPreCS)$getSym(5);
1586
					CSTNode result = createFeatureCallExpCS(
1587
							(SimpleNameCS)$getSym(1),
1588
							(EList)$getSym(3),
1589
							isMarkedPreCS
1590
						);
1591
					if (isMarkedPreCS.isPre()) {
1592
						setOffsets(result, (CSTNode)$getSym(1), (CSTNode)$getSym(5));
1593
					} else {
1594
						setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(4)));
1595
					}
1596
					$setResult(result);
1597
		  $EndAction
1598
		./
1599
1600
	isMarkedPreCS ::= %empty
1601
		/.$BeginAction
1602
					CSTNode result = createIsMarkedPreCS(false);
1603
					setOffsets(result, getIToken($getToken(1)));
1604
					$setResult(result);
1605
		  $EndAction
1606
		./
1607
	isMarkedPreCS ::= '@pre'
1608
		/.$BeginAction
1609
					CSTNode result = createIsMarkedPreCS(true);
1610
					setOffsets(result, getIToken($getToken(1)));
1611
					$setResult(result);
1612
		  $EndAction
1613
		./
1614
1615
	argumentsCSopt ::= %empty
1616
		/.$EmptyListAction./
1617
	argumentsCSopt -> argumentsCS
1618
1619
	argumentsCS ::= oclExpressionCS
1620
		/.$BeginAction
1621
					EList result = new BasicEList();
1622
					result.add($getSym(1));
1623
					$setResult(result);
1624
		  $EndAction
1625
		./
1626
	argumentsCS ::= argumentsCS ',' oclExpressionCS
1627
		/.$BeginAction
1628
					EList result = (EList)$getSym(1);
1629
					result.add($getSym(3));
1630
					$setResult(result);
1631
		  $EndAction
1632
		./
1633
1634
	letExpCS ::= let variableListCS in oclExpressionCS
1635
		/.$BeginAction
1636
					CSTNode result = createLetExpCS(
1637
							(EList)$getSym(2),
1638
							(OCLExpressionCS)$getSym(4)
1639
						);
1640
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(4));
1641
					$setResult(result);
1642
		  $EndAction
1643
		./
1644
1645
	ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS endif
1646
		/.$BeginAction
1647
					CSTNode result = createIfExpCS(
1648
							(OCLExpressionCS)$getSym(2),
1649
							(OCLExpressionCS)$getSym(4),
1650
							(OCLExpressionCS)$getSym(6)
1651
						);
1652
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(7)));
1653
					$setResult(result);
1654
		  $EndAction
1655
		./
1656
1657
	messageExpCS ::= '^' simpleNameCS '(' oclMessageArgumentsCSopt ')'
1658
		/.$NewCase./
1659
	messageExpCS ::= '^^' simpleNameCS '(' oclMessageArgumentsCSopt ')'
1660
		/.$BeginAction
1661
					CSTNode result = createMessageExpCS(
1662
							getIToken($getToken(1)).getKind() == $sym_type.TK_CARET,
1663
							(SimpleNameCS)$getSym(2),
1664
							(EList<OCLMessageArgCS>)$getSym(4)
1665
						);
1666
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
1667
					$setResult(result);
1668
		  $EndAction
1669
		./
1670
1671
	oclMessageArgumentsCSopt ::= %empty
1672
		/.$EmptyListAction./
1673
	oclMessageArgumentsCSopt -> oclMessageArgumentsCS
1674
1675
	oclMessageArgumentsCS ::= oclMessageArgCS
1676
		/.$BeginAction
1677
					EList result = new BasicEList();
1678
					result.add($getSym(1));
1679
					$setResult(result);
1680
		  $EndAction
1681
		./
1682
	oclMessageArgumentsCS ::= oclMessageArgumentsCS ',' oclMessageArgCS
1683
		/.$BeginAction
1684
					EList result = (EList)$getSym(1);
1685
					result.add($getSym(3));
1686
					$setResult(result);
1687
		  $EndAction
1688
		./
1689
1690
	oclMessageArgCS ::= oclExpressionCS
1691
		/.$BeginAction
1692
					CSTNode result = createOCLMessageArgCS(
1693
							null,
1694
							(OCLExpressionCS)$getSym(1)
1695
						);
1696
					setOffsets(result, (CSTNode)$getSym(1));
1697
					$setResult(result);
1698
		  $EndAction
1699
		./
1700
	oclMessageArgCS ::= '?'
1701
		/.$BeginAction
1702
					CSTNode result = createOCLMessageArgCS(
1703
							null,
1704
							null
1705
						);
1706
					setOffsets(result, getIToken($getToken(1)));
1707
					$setResult(result);
1708
		  $EndAction
1709
		./
1710
	oclMessageArgCS ::= '?' ':' typeCS
1711
		/.$BeginAction
1712
					CSTNode result = createOCLMessageArgCS(
1713
							(TypeCS)$getSym(3),
1714
							null
1715
						);
1716
					setOffsets(result, getIToken($getToken(1)), (CSTNode)$getSym(3));
1717
					$setResult(result);
1718
		  $EndAction
1719
		./
1720
1721
%End
1722
1723
%Trailers
1724
	/.
1725
		$EndActions
1726
	}
1727
	./
1728
%End
(-)src/org/eclipse/ocl/parser/backtracking/OCLBacktrackingLexer.gi (+42 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2008, 2009 Eclipse.org, Open Canarias S.L., and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   IBM - Initial API and implementation
12
-- *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
14
-- *
15
-- * </copyright>
16
-- *
17
-- * $Id: OCLBacktrackingLexer.g,v 1.1 2009/01/13 20:31:30 cdamus Exp $
18
-- */
19
--
20
-- The OCL Backtracking Lexer, which is nominally identical to the
21
-- normal Lexer, however the extra ERROR_TOKEN symbol makes it difficult
22
-- to share reliably.
23
--
24
25
%options escape=$
26
%options la=2
27
%options fp=OCLBacktrackingLexer,prefix=Char_
28
%options single-productions
29
%options noserialize
30
%options package=org.eclipse.ocl.parser.backtracking
31
%options template=../../lpg/LexerTemplateD.gi
32
%options filter=OCLBacktrackingKWLexer.gi
33
%options export_terminals=("OCLBacktrackingParsersym.java", "TK_")
34
%options include_directory="..;../../lpg"
35
36
%Import
37
	OCLLexer.gi
38
%End
39
40
%Define
41
	$kw_lexer_class /.OCLBacktrackingKWLexer./
42
%End
(-)src/org/eclipse/ocl/parser/backtracking/EssentialOCLErrors.gi (+419 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2008, 2009 Eclipse.org, Open Canarias S.L, and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   E.D.Willink - Initial API and implementation
12
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
13
-- *
14
-- * </copyright>
15
-- *
16
-- * $Id: EssentialOCLErrors.g,v 1.1 2009/01/13 20:31:30 cdamus Exp $
17
-- */
18
--
19
-- Additional ERROR_TOKEN rules for The EssentialOCL Backtracking Parser
20
--
21
22
%Rules
23
	ERROR_Colon ::= ERROR_TOKEN
24
		/.$BeginAction
25
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_COLON);
26
		  $EndAction
27
		./
28
	ERROR_Empty ::= ERROR_TOKEN
29
		/.$BeginAction
30
					reportErrorTokenMessage($getToken(1), OCLParserErrors.EXTRA_TOKENS);
31
		  $EndAction
32
		./
33
	ERROR_IsMarkedPreCS ::= ERROR_TOKEN
34
		/.$BeginAction
35
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_AT_PRE);
36
					IsMarkedPreCS result = createIsMarkedPreCS(false);
37
					setOffsets(result, getIToken($getToken(1)));
38
					$setResult(result);
39
		  $EndAction
40
		./
41
42
	ERROR_PathNameCS ::= ERROR_TOKEN
43
		/.$BeginAction
44
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_PATH_NAME);
45
					CSTNode result = createPathNameCS(getTokenText($getToken(1)));
46
					setOffsets(result, getIToken($getToken(1)));
47
					$setResult(result);
48
		  $EndAction
49
		./
50
		
51
	ERROR_SimpleNameCS ::= ERROR_TOKEN
52
		/.$BeginAction
53
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_SIMPLE_NAME);
54
					SimpleNameCS result = createSimpleNameCS(
55
							SimpleTypeEnum.IDENTIFIER_LITERAL,
56
							getTokenText($getToken(1))
57
						);
58
					setOffsets(result, getIToken($getToken(1)));
59
					$setResult(result);
60
		  $EndAction
61
		./
62
63
	attrOrNavCallExpCS ::= simpleNameCS '[' argumentsCS ERROR_TOKEN
64
		/.$BeginAction
65
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_RBRACK);
66
					CSTNode result = createFeatureCallExpCS(
67
							(SimpleNameCS)$getSym(1),
68
							(EList)$getSym(3),
69
							createIsMarkedPreCS(false)
70
						);
71
					setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(4)));
72
					$setResult(result);
73
		  $EndAction
74
		./
75
		
76
	collectionTypeCS ::= collectionTypeIdentifierCS '(' typeCS ERROR_TOKEN
77
		/.$BeginAction
78
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_RPAREN);
79
					Object[] objs = (Object[])$getSym(1);
80
					CSTNode result = createCollectionTypeCS(
81
							(CollectionTypeIdentifierEnum)objs[1],
82
							(TypeCS)$getSym(3)
83
						);
84
					setOffsets(result, (IToken)objs[0], getIToken($getToken(4)));
85
					$setResult(result);
86
		  $EndAction
87
		./
88
	collectionTypeCS ::= collectionTypeIdentifierCS ERROR_TOKEN
89
		/.$BeginAction
90
					reportErrorTokenMessage($getToken(2), OCLParserErrors.MISSING_LPAREN);
91
					Object[] objs = (Object[])$getSym(1);
92
					CSTNode result = createCollectionTypeCS(
93
							(CollectionTypeIdentifierEnum)objs[1],
94
							null
95
						);
96
					setOffsets(result, (IToken)objs[0], getIToken($getToken(2)));
97
					$setResult(result);
98
		  $EndAction
99
		./
100
101
	dotArrowExpCS ::=  pathNameCS '::' ERROR_SimpleNameCS '(' argumentsCSopt ')'
102
		/.$BeginAction
103
					OperationCallExpCS result = createOperationCallExpCS(
104
							(PathNameCS)$getSym(1),
105
							(SimpleNameCS)$getSym(3),
106
							(EList)$getSym(5)
107
						);
108
					setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(6)));
109
					result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
110
					$setResult(result);
111
		  $EndAction
112
		./
113
-- FIXME	dotArrowExpCS ::= NUMERIC_OPERATION ERROR_SimpleNameCS
114
115
	enumLiteralExpCS ::= pathNameCS '::' ERROR_SimpleNameCS
116
		/.$BeginAction
117
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
118
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(3);
119
					CSTNode result = createEnumLiteralExpCS(
120
							pathNameCS,
121
							simpleNameCS
122
						);
123
					setOffsets(result, pathNameCS, simpleNameCS);
124
					$setResult(result);
125
		  $EndAction
126
		./
127
		
128
	featureCallExpCS ::= unaryName ERROR_IsMarkedPreCS '(' argumentsCSopt ')'
129
		/.$NewCase./
130
	keywordOperationCallExpCS ::= keywordAsName ERROR_IsMarkedPreCS '(' argumentsCSopt ')'
131
		/.$NewCase./
132
	operationCallExpCS ::= binaryName ERROR_IsMarkedPreCS '(' argumentsCSopt ')'
133
		/.$BeginAction
134
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
135
					CSTNode result = createOperationCallExpCS(
136
							simpleNameCS,
137
							(IsMarkedPreCS)$getSym(2),
138
							(EList)$getSym(4)
139
						);
140
					setOffsets(result, simpleNameCS, getIToken($getToken(5)));
141
					$setResult(result);
142
		  $EndAction
143
		./
144
	operationCallExpCS ::= oclIsInStateName ERROR_IsMarkedPreCS '(' stateExpCS ')'
145
		/.$BeginAction
146
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(1);
147
					CSTNode result = createOperationCallExpCS(
148
							simpleNameCS,
149
							(IsMarkedPreCS)$getSym(2),
150
							(StateExpCS)$getSym(4)
151
						);
152
					setOffsets(result, simpleNameCS, getIToken($getToken(5)));
153
					$setResult(result);
154
		  $EndAction
155
		./
156
157
	ifExpCS ::= if oclExpressionCS then oclExpressionCS else oclExpressionCS ERROR_TOKEN
158
		/.$BeginAction
159
					reportErrorTokenMessage($getToken(7), OCLParserErrors.MISSING_ENDIF);
160
					CSTNode result = createIfExpCS(
161
							(OCLExpressionCS)$getSym(2),
162
							(OCLExpressionCS)$getSym(4),
163
							(OCLExpressionCS)$getSym(6)
164
						);
165
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(7)));
166
					$setResult(result);
167
		  $EndAction
168
		./
169
	ifExpCS ::= if oclExpressionCS then oclExpressionCS ERROR_TOKEN
170
		/.$BeginAction
171
					reportErrorTokenMessage($getToken(5), OCLParserErrors.MISSING_ELSE_ENDIF);
172
					CSTNode result = createIfExpCS(
173
							(OCLExpressionCS)$getSym(2),
174
							(OCLExpressionCS)$getSym(4),
175
							createInvalidLiteralExpCS(getTokenText($getToken(5)))
176
						);
177
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
178
					$setResult(result);
179
		  $EndAction
180
		./
181
	ifExpCS ::= if oclExpressionCS ERROR_TOKEN
182
		/.$BeginAction
183
					reportErrorTokenMessage($getToken(3), OCLParserErrors.MISSING_THEN_ELSE_ENDIF);
184
					CSTNode result = createIfExpCS(
185
							(OCLExpressionCS)$getSym(2),
186
							createInvalidLiteralExpCS(getTokenText($getToken(3))),
187
							createInvalidLiteralExpCS(getTokenText($getToken(3)))
188
						);
189
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
190
					$setResult(result);
191
		  $EndAction
192
		./
193
	ifExpCS ::= if ERROR_TOKEN endif
194
		/.$BeginAction
195
					reportErrorTokenMessage($getToken(3), OCLParserErrors.MISSING_THEN_ELSE);
196
					CSTNode result = createIfExpCS(
197
							createInvalidLiteralExpCS(getTokenText($getToken(2))),
198
							createInvalidLiteralExpCS(getTokenText($getToken(2))),
199
							createInvalidLiteralExpCS(getTokenText($getToken(2)))
200
						);
201
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
202
					$setResult(result);
203
		  $EndAction
204
		./
205
		
206
	messageExpCS ::= '^' simpleNameCS ERROR_TOKEN
207
		/.$NewCase./
208
	messageExpCS ::= '^^' simpleNameCS ERROR_TOKEN
209
		/.$BeginAction
210
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_MESSAGE_ARGUMENTS);
211
					CSTNode result = createMessageExpCS(
212
							getIToken($getToken(1)).getKind() == $sym_type.TK_CARET,
213
							(SimpleNameCS)$getSym(2),
214
							new BasicEList<OCLMessageArgCS>()
215
						);
216
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
217
					$setResult(result);
218
		  $EndAction
219
		./
220
	messageExpCS ::= '^' ERROR_SimpleNameCS
221
		/.$NewCase./
222
	messageExpCS ::= '^^' ERROR_SimpleNameCS
223
		/.$BeginAction
224
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(2);
225
					CSTNode result = createMessageExpCS(
226
							getIToken($getToken(1)).getKind() == $sym_type.TK_CARET,
227
							simpleNameCS,
228
							new BasicEList<OCLMessageArgCS>()
229
						);
230
					setOffsets(result, getIToken($getToken(1)), simpleNameCS);
231
					$setResult(result);
232
		  $EndAction
233
		./
234
235
	oclExpCS ::= ERROR_TOKEN
236
		/.$BeginAction
237
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_EXPR);
238
					CSTNode result = createInvalidLiteralExpCS(getTokenText($getToken(1)));
239
					setOffsets(result, getIToken($getToken(1)));
240
					$setResult(result);
241
		  $EndAction
242
		./
243
	oclExpCS ::= '(' oclExpressionCS ERROR_TOKEN
244
		/.$BeginAction
245
					reportErrorTokenMessage($getToken(3), OCLParserErrors.MISSING_RPAREN);
246
					CSTNode result = (CSTNode)$getSym(2);
247
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
248
					$setResult(result);
249
		  $EndAction
250
		./
251
252
	operationCS1 ::= IDENTIFIER '(' parametersCSopt ')' ERROR_Colon
253
		/.$BeginAction
254
					CSTNode result = createOperationCS(
255
							getTokenText($getToken(1)),
256
							(EList)$getSym(3),
257
							null
258
						);
259
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(5)));
260
					$setResult(result);
261
		  $EndAction
262
		./
263
	operationCS1 ::= IDENTIFIER '(' parametersCSopt ERROR_TOKEN
264
		/.$BeginAction
265
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_RPAREN);
266
					CSTNode result = createOperationCS(
267
							getTokenText($getToken(1)),
268
							(EList)$getSym(3),
269
							null
270
						);
271
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
272
					$setResult(result);
273
		  $EndAction
274
		./
275
	operationCS1 ::= IDENTIFIER ERROR_TOKEN
276
		/.$BeginAction
277
					reportErrorTokenMessage($getToken(2), OCLParserErrors.MISSING_LPAREN);
278
					CSTNode result = createOperationCS(
279
							getTokenText($getToken(1)),
280
							new BasicEList(),
281
							null
282
						);
283
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(2)));
284
					$setResult(result);
285
		  $EndAction
286
		./
287
	operationCS1 ::= ERROR_TOKEN
288
		/.$BeginAction
289
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_IDENTIFIER);
290
					CSTNode result = createOperationCS(
291
							getTokenText($getToken(1)),
292
							new BasicEList(),
293
							null
294
						);
295
					setOffsets(result, getIToken($getToken(1)));
296
					$setResult(result);
297
		  $EndAction
298
		./
299
	operationCS2 ::= pathNameCS '::' simpleNameCS '(' parametersCSopt ')' ERROR_Colon
300
		/.$BeginAction
301
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
302
					CSTNode result = createOperationCS(
303
							pathNameCS,
304
							(SimpleNameCS)$getSym(3),
305
							(EList)$getSym(5),
306
							(TypeCS)$getSym(8)
307
						);
308
					setOffsets(result, pathNameCS, getIToken($getToken(7)));
309
					$setResult(result);
310
		  $EndAction
311
		./
312
	operationCS2 ::= pathNameCS '::' simpleNameCS '(' parametersCSopt ERROR_TOKEN
313
		/.$BeginAction
314
					reportErrorTokenMessage($getToken(6), OCLParserErrors.MISSING_RPAREN);
315
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
316
					CSTNode result = createOperationCS(
317
							pathNameCS,
318
							(SimpleNameCS)$getSym(3),
319
							(EList)$getSym(5),
320
							null
321
						);
322
					setOffsets(result, pathNameCS, getIToken($getToken(7)));
323
					$setResult(result);
324
		  $EndAction
325
		./
326
	operationCS2 ::= pathNameCS '::' simpleNameCS ERROR_TOKEN
327
		/.$BeginAction
328
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_LPAREN);
329
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
330
					CSTNode result = createOperationCS(
331
							pathNameCS,
332
							(SimpleNameCS)$getSym(3),
333
							new BasicEList(),
334
							null
335
						);
336
					setOffsets(result, pathNameCS, getIToken($getToken(4)));
337
					$setResult(result);
338
		  $EndAction
339
		./
340
	operationCS2 ::= pathNameCS '::' ERROR_SimpleNameCS
341
		/.$BeginAction
342
					PathNameCS pathNameCS = (PathNameCS)$getSym(1);
343
					SimpleNameCS simpleNameCS = (SimpleNameCS)$getSym(3);
344
					CSTNode result = createOperationCS(
345
							pathNameCS,
346
							simpleNameCS,
347
							new BasicEList(),
348
							null
349
						);
350
					setOffsets(result, pathNameCS, simpleNameCS);
351
					$setResult(result);
352
		  $EndAction
353
		./
354
355
	parametersCS ::= ERROR_TOKEN
356
		/.$BeginAction
357
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_PARAMETERS);
358
					EList result = new BasicEList();
359
					$setResult(result);
360
		  $EndAction
361
		./
362
	parametersCS ::= parametersCS ',' ERROR_TOKEN
363
		/.$BeginAction
364
					reportErrorTokenMessage($getToken(3), OCLParserErrors.MISSING_PARAMETER);
365
		  $EndAction
366
		./
367
368
	pathNameCS -> ERROR_PathNameCS
369
		
370
	simpleNameCSopt -> ERROR_SimpleNameCS
371
372
	tupleLiteralExpCS ::= Tuple ERROR_TOKEN
373
		/.$BeginAction
374
					reportErrorTokenMessage($getToken(7), OCLParserErrors.MISSING_LBRACE);
375
					CSTNode result = createTupleLiteralExpCS((EList)$getSym(3));
376
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(4)));
377
					$setResult(result);
378
		  $EndAction
379
		./
380
381
	variableCS ::= IDENTIFIER ERROR_TOKEN
382
		/.$BeginAction
383
					reportErrorTokenMessage($getToken(2), OCLParserErrors.MISSING_VARIABLE_TYPE);
384
					CSTNode result = createVariableCS(
385
							getTokenText($getToken(1)),
386
							null,
387
							null
388
						);
389
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(2)));
390
					$setResult(result);
391
		  $EndAction
392
		./
393
394
	variableExpCS ::= simpleNameCS '[' argumentsCS ERROR_TOKEN
395
		/.$NewCase./
396
	variableExpCS ::= keywordAsName1 '[' argumentsCS ERROR_TOKEN
397
		/.$BeginAction
398
					reportErrorTokenMessage($getToken(4), OCLParserErrors.MISSING_RBRACK);
399
					CSTNode result = createVariableExpCS(
400
							(SimpleNameCS)$getSym(1),
401
							(EList)$getSym(3),
402
							createIsMarkedPreCS(false)
403
						);
404
					setOffsets(result, (CSTNode)$getSym(1), getIToken($getToken(4)));
405
					$setResult(result);
406
		  $EndAction
407
		./
408
409
	variableListCS ::= ERROR_TOKEN
410
		/.$NewCase./
411
	variableListCS2 ::= ERROR_TOKEN
412
		/.$BeginAction
413
					reportErrorTokenMessage($getToken(1), OCLParserErrors.MISSING_VARIABLES);
414
					EList result = new BasicEList();
415
					$setResult(result);
416
		  $EndAction
417
		./
418
419
%End
(-)src/org/eclipse/ocl/lpg/KeywordTemplateD.gi (+119 lines)
Added Link Here
1
--
2
-- An LPG Lexer Template Using lpg.jar
3
--
4
-- An instance of this template must have a $Export section and the export_terminals option
5
-- There must be only one non-terminal, the start symbol, for the keywords
6
-- The action for each keyword should be a call to $setResult(terminal_symbol)
7
--
8
-- Macro that may be redefined in an instance of this template
9
--
10
--     $eof_char
11
--
12
-- B E G I N N I N G   O F   T E M P L A T E   KeywordTemplateD
13
--
14
%options Programming_Language=java,margin=4
15
%options table
16
%options action-block=("*.java", "/.", "./")
17
%options ParseTable=lpg.runtime.ParseTable
18
%options prefix=Char_
19
%options single-productions
20
21
--
22
-- This template requires that the name of the EOF token be set
23
-- to EOF and that the prefix be "Char_" to be consistent with
24
-- LexerTemplateD.
25
--
26
%Eof
27
    EOF
28
%End
29
30
%Define
31
    --
32
    -- Macro that may be respecified in an instance of this template
33
    --
34
    $eof_char /.Char_EOF./
35
36
    --
37
    -- Macros useful for specifying actions
38
    --
39
    $setResult /.keywordKind[$rule_number] = ./
40
41
    $Header
42
    /.
43
            //
44
            // Rule $rule_number:  $rule_text
45
            //
46
            ./
47
48
    $BeginAction /.$Header./
49
50
    $EndAction /../
51
52
    $BeginJava /.$BeginAction./
53
54
    $EndJava /.$EndAction./
55
%End
56
57
%Headers
58
    /.
59
    public class $action_type extends $prs_type implements $exp_type
60
    {
61
        private char[] inputChars;
62
        private final int keywordKind[] = new int[$num_rules + 1];
63
64
        public int[] getKeywordKinds() { return keywordKind; }
65
66
        public int lexer(int curtok, int lasttok)
67
        {
68
            int current_kind = getKind(inputChars[curtok]),
69
                act;
70
71
            for (act = tAction(START_STATE, current_kind);
72
                 act > NUM_RULES && act < ACCEPT_ACTION;
73
                 act = tAction(act, current_kind))
74
            {
75
                curtok++;
76
                current_kind = (curtok > lasttok
77
                                       ? $eof_char
78
                                       : getKind(inputChars[curtok]));
79
            }
80
81
            if (act > ERROR_ACTION)
82
            {
83
                curtok++;
84
                act -= ERROR_ACTION;
85
            }
86
87
            return keywordKind[act == ERROR_ACTION  || curtok <= lasttok ? 0 : act];
88
        }
89
90
        public void setInputChars(char[] inputChars) { this.inputChars = inputChars; }
91
92
    ./
93
%End
94
95
%Rules
96
    /.
97
98
        public $action_type(char[] inputChars, int identifierKind)
99
        {
100
            this.inputChars = inputChars;
101
            keywordKind[0] = identifierKind;
102
    ./
103
%End
104
105
%Trailers
106
    /.
107
            for (int i = 0; i < keywordKind.length; i++)
108
            {
109
                if (keywordKind[i] == 0)
110
                    keywordKind[i] = identifierKind;
111
            }
112
        }
113
    }
114
    ./
115
%End
116
117
--
118
-- E N D   O F   T E M P L A T E
119
--
(-)src/org/eclipse/ocl/parser/OCLLexer.gi (+614 lines)
Added Link Here
1
--/**
2
-- * <copyright>
3
-- *
4
-- * Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
5
-- * All rights reserved.   This program and the accompanying materials
6
-- * are made available under the terms of the Eclipse Public License v1.0
7
-- * which accompanies this distribution, and is available at
8
-- * http://www.eclipse.org/legal/epl-v10.html
9
-- *
10
-- * Contributors:
11
-- *   IBM - Initial API and implementation
12
-- *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
13
-- *               - Bug 259818
14
-- *   Borland - Bug 242880
15
-- *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
16
-- *   
17
-- * </copyright>
18
-- *
19
-- * $Id: OCLLexer.g,v 1.2 2009/02/12 00:04:09 cdamus Exp $
20
-- */
21
--
22
-- The OCL Lexer
23
--
24
25
%options escape=$
26
%options la=2
27
%options fp=OCLLexer,prefix=Char_
28
%options single-productions
29
%options noserialize
30
%options package=org.eclipse.ocl.parser
31
%options template=../lpg/LexerTemplateD.gi
32
%options filter=OCLKWLexer.gi
33
%options export_terminals=("OCLParsersym.java", "TK_")
34
%options include_directory="../lpg"
35
36
%Define
37
38
	--
39
	-- Definition of macros used in the template
40
	--
41
	$action_class /.$file_prefix./
42
	$eof_token /.$_EOF_TOKEN./
43
    $environment_class /.Environment<?,?,?,?,?,?,?,?,?,?,?,?>./
44
    $adapt_environment /.OCLUtil.getAdapter(environment, BasicEnvironment.class)./
45
    $environment_import /.org.eclipse.ocl.Environment./
46
 
47
	--
48
	-- Definition of macro used in the included file LexerBasicMap.g
49
	--
50
	$kw_lexer_class /.OCLKWLexer./
51
	$copyright_contributions /.*./
52
53
%End
54
55
%Notice
56
	/./**
57
 * <copyright>
58
 *
59
 * Copyright (c) 2005, 2009 IBM Corporation, Borland Software Corp., Open Canarias S.L. and others.
60
 * All rights reserved.   This program and the accompanying materials
61
 * are made available under the terms of the Eclipse Public License v1.0
62
 * which accompanies this distribution, and is available at
63
 * http://www.eclipse.org/legal/epl-v10.html
64
 *
65
 * Contributors:
66
 *   IBM - Initial API and implementation
67
 *   E.D.Willink - Lexer and Parser refactoring to support extensibility and flexible error handling
68
 *               - Bug 259818
69
 *   Borland - Bug 242880
70
 *   Adolfo Sanchez-Barbudo Herrera - LPG v2.0.17 adoption
71
 $copyright_contributions
72
 * </copyright>
73
 *
74
 * '$'Id'$'
75
 */
76
	./
77
%End
78
79
%Include
80
	LexerBasicMap.gi
81
%End
82
83
%Globals
84
    /.import $environment_import;
85
    import org.eclipse.ocl.lpg.BasicEnvironment;
86
    import org.eclipse.ocl.util.OCLUtil;
87
    ./
88
%End
89
90
%Export
91
92
	IDENTIFIER
93
	STRING_LITERAL
94
	INTEGER_LITERAL
95
	REAL_LITERAL
96
	NUMERIC_OPERATION
97
	INTEGER_RANGE_START
98
	
99
	PLUS
100
	MINUS
101
	MULTIPLY
102
	DIVIDE
103
104
	GREATER
105
	LESS
106
	EQUAL
107
	GREATER_EQUAL
108
	LESS_EQUAL
109
	NOT_EQUAL
110
111
	LPAREN
112
	RPAREN
113
	LBRACE
114
	RBRACE
115
	LBRACKET
116
	RBRACKET
117
118
	ARROW
119
	BAR
120
	COMMA
121
	COLON
122
	COLONCOLON
123
	SEMICOLON
124
	DOT
125
	DOTDOT
126
	ATPRE
127
	
128
	CARET
129
	CARETCARET
130
	QUESTIONMARK
131
132
%End
133
134
%Terminals
135
	CtlCharNotWS
136
137
	LF   CR   HT   FF
138
139
	a b c d e f g h i j k l m n o p q r s t u v w x y z
140
	_
141
142
	A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
143
144
	0 1 2 3 4 5 6 7 8 9
145
146
	AfterASCIINotAcute
147
	Space        ::= ' '
148
	LF           ::= NewLine
149
	CR           ::= Return
150
	HT           ::= HorizontalTab
151
	FF           ::= FormFeed
152
	DoubleQuote  ::= '"'
153
	SingleQuote  ::= "'"
154
	Percent      ::= '%'
155
	VerticalBar  ::= '|'
156
	Exclamation  ::= '!'
157
	AtSign       ::= '@'
158
	BackQuote    ::= '`'
159
	Acute        ::= '�'
160
	Tilde        ::= '~'
161
	Sharp        ::= '#'
162
	DollarSign   ::= '$'
163
	Ampersand    ::= '&'
164
	Caret        ::= '^'
165
	Colon        ::= ':'
166
	SemiColon    ::= ';'
167
	BackSlash    ::= '\'
168
	LeftBrace    ::= '{'
169
	RightBrace   ::= '}'
170
	LeftBracket  ::= '['
171
	RightBracket ::= ']'
172
	QuestionMark ::= '?'
173
	Comma        ::= ','
174
	Dot          ::= '.'
175
	LessThan     ::= '<'
176
	GreaterThan  ::= '>'
177
	Plus         ::= '+'
178
	Minus        ::= '-'
179
	Slash        ::= '/'
180
	Star         ::= '*'
181
	LeftParen    ::= '('
182
	RightParen   ::= ')'
183
	Equal        ::= '='
184
185
%End
186
187
%Start
188
	Token
189
%End
190
191
%Rules
192
193
	---------------------  Rules for Scanned Tokens --------------------------------
194
	-- The lexer creates an array list of tokens which is defined in the PrsStream class.
195
	-- A token has three attributes: a start offset, an end offset and a kind.
196
	-- 
197
	-- Only rules that produce complete tokens have actions to create token objects.
198
	-- When making a token, calls to the methods, $getToken(1) and $getRightSpan(), 
199
	-- provide the offsets (i.e. the span) of a rule's right hand side (rhs) and thus of the token.
200
	-- For a rule of the form A ::= A1 A2 ... An, the start offset of the rhs of A is given by
201
	-- $getToken(1) or by $getLeftSpan() and the end offset by $getRightSpan().
202
	--  
203
	-- Regarding rules for parsing in general, note that for a rhs symbol Ai, the 
204
	-- method $getToken(i) returns the location of the leftmost character derived from Ai.  
205
	-- The method $getLeftSpan(i) returns the same location unless Ai produces %empty in which case
206
	-- it returns the location of the last character derived before reducing Ai to %empty. 
207
	-- The method $getRightSpan(i) returns the location of the rightmost character derived from Ai 
208
	-- unless Ai produces %empty in which case it returns the location of the last character 
209
	-- derived before reducing Ai to %empty.
210
	--------------------------------------------------------------------------------
211
	Token ::= Identifier
212
		/.$BeginAction
213
					checkForKeyWord();
214
		  $EndAction
215
		./
216
217
	-- an empty String literal looks just like an escaped single-quote
218
	Token ::= EscapedSQ
219
		/.$BeginAction
220
					makeToken($_STRING_LITERAL);
221
		  $EndAction
222
		./
223
224
	Token ::= SingleQuote SLNotSQ SingleQuote
225
		/.$BeginAction
226
					makeToken($_STRING_LITERAL);
227
		  $EndAction
228
		./
229
230
	Token ::= Acute SLNotSQOpt Acute
231
		/.$BeginAction
232
					makeToken($_STRING_LITERAL);
233
		  $EndAction
234
		./
235
236
	Token ::= BackQuote SLNotSQOpt Acute
237
		/.$BeginAction
238
					makeToken($_STRING_LITERAL);
239
		  $EndAction
240
		./
241
242
	Token ::= IntegerLiteral
243
		/.$BeginAction
244
					makeToken($_INTEGER_LITERAL);
245
		  $EndAction
246
		./
247
248
	Token ::= RealLiteral
249
		/.$BeginAction
250
					makeToken($_REAL_LITERAL);
251
		  $EndAction
252
		./
253
254
	Token ::= NumericOperation
255
		/.$BeginAction
256
					makeToken($_NUMERIC_OPERATION);
257
		  $EndAction
258
		./
259
260
	Token ::= IntegerRangeStart
261
		/.$BeginAction
262
					makeToken($_INTEGER_RANGE_START);
263
		  $EndAction
264
		./
265
266
	Token ::= SLC
267
		/.$BeginAction
268
					skipToken();
269
		  $EndAction
270
		./
271
272
    Token ::= '/' '*' Inside Stars '/'
273
        /.$BeginAction
274
                    skipToken();
275
          $EndAction
276
        ./
277
278
	Token ::= WS -- White Space is scanned but not added to output vector
279
		/.$BeginAction
280
					skipToken();
281
		  $EndAction
282
		./
283
284
	Token ::= '+'
285
		/.$BeginAction
286
					makeToken($_PLUS);
287
		  $EndAction
288
		./
289
290
	Token ::= '-'
291
		/.$BeginAction
292
					makeToken($_MINUS);
293
		  $EndAction
294
		./
295
296
	Token ::= '*'
297
		/.$BeginAction
298
					makeToken($_MULTIPLY);
299
		  $EndAction
300
		./
301
302
	Token ::= '/'
303
		/.$BeginAction
304
					makeToken($_DIVIDE);
305
		  $EndAction
306
		./
307
308
	Token ::= '('
309
		/.$BeginAction
310
					makeToken($_LPAREN);
311
		  $EndAction
312
		./
313
314
	Token ::= ')'
315
		/.$BeginAction
316
					makeToken($_RPAREN);
317
		  $EndAction
318
		./
319
320
	Token ::= '>'
321
		/.$BeginAction
322
					makeToken($_GREATER);
323
		  $EndAction
324
		./
325
		
326
	Token ::= '<'
327
		/.$BeginAction
328
					makeToken($_LESS);
329
		  $EndAction
330
		./
331
332
	Token ::= '='
333
		/.$BeginAction
334
					makeToken($_EQUAL);
335
		  $EndAction
336
		./
337
338
	Token ::= '>' '='
339
		/.$BeginAction
340
					makeToken($_GREATER_EQUAL);
341
		  $EndAction
342
		./
343
344
	Token ::= '<' '='
345
		/.$BeginAction
346
					makeToken($_LESS_EQUAL);
347
		  $EndAction
348
		./
349
350
	Token ::= '<' '>'
351
		/.$BeginAction
352
					makeToken($_NOT_EQUAL);
353
		  $EndAction
354
		./
355
356
	Token ::= '['
357
		/.$BeginAction
358
					makeToken($_LBRACKET);
359
		  $EndAction
360
		./
361
362
	Token ::= ']'
363
		/.$BeginAction
364
					makeToken($_RBRACKET);
365
		  $EndAction
366
		./
367
368
	Token ::= '{'
369
		/.$BeginAction
370
					makeToken($_LBRACE);
371
		  $EndAction
372
		./
373
374
	Token ::= '}'
375
		/.$BeginAction
376
					makeToken($_RBRACE);
377
		  $EndAction
378
		./
379
380
	Token ::= '-' '>'
381
		/.$BeginAction
382
					makeToken($_ARROW);
383
		  $EndAction
384
		./
385
386
	Token ::= '|'
387
		/.$BeginAction
388
					makeToken($_BAR);
389
		  $EndAction
390
		./
391
392
	Token ::= ','
393
		/.$BeginAction
394
					makeToken($_COMMA);
395
		  $EndAction
396
		./
397
398
	Token ::= ':'
399
		/.$BeginAction
400
					makeToken($_COLON);
401
		  $EndAction
402
		./
403
404
	Token ::= ':' ':'
405
		/.$BeginAction
406
					makeToken($_COLONCOLON);
407
		  $EndAction
408
		./
409
410
	Token ::= ';'
411
		/.$BeginAction
412
					makeToken($_SEMICOLON);
413
		  $EndAction
414
		./
415
416
	Token ::= '.'
417
		/.$BeginAction
418
					makeToken($_DOT);
419
		  $EndAction
420
		./
421
422
	Token ::= '.' '.'
423
		/.$BeginAction
424
					makeToken($_DOTDOT);
425
		  $EndAction
426
		./
427
428
	Token ::= '@' p r e
429
		/.$BeginAction
430
					makeToken($_ATPRE);
431
		  $EndAction
432
		./
433
434
435
	Token ::= '^'
436
		/.$BeginAction
437
					makeToken($_CARET);
438
		  $EndAction
439
		./
440
441
	Token ::= '^' '^'
442
		/.$BeginAction
443
					makeToken($_CARETCARET);
444
		  $EndAction
445
		./
446
		
447
	Token ::= '?'
448
		/.$BeginAction
449
					makeToken($_QUESTIONMARK);
450
		  $EndAction
451
		./
452
453
454
    IntegerLiteral -> Integer
455
    --                | '0' LetterXx HexDigits
456
457
    RealLiteral -> Decimal
458
                 | Decimal Exponent
459
                 | Integer Exponent
460
461
    Inside ::= Inside Stars NotSlashOrStar
462
             | Inside '/'
463
             | Inside NotSlashOrStar
464
             | %empty
465
466
    Stars -> '*'
467
           | Stars '*'
468
469
    SLC -> '-' '-'
470
         | SLC NotEol
471
472
    Integer -> Digit
473
             | Integer Digit
474
475
    HexDigits -> HexDigit
476
               | HexDigits HexDigit
477
478
    Decimal -> Integer '.' Integer
479
480
    Exponent -> LetterEe Integer
481
              | LetterEe '-' Integer
482
              | LetterEe '+' Integer
483
484
    WSChar -> Space
485
            | LF
486
            | CR
487
            | HT
488
            | FF
489
490
    Letter -> LowerCaseLetter
491
            | UpperCaseLetter
492
            | _
493
            | AfterASCIINotAcute
494
495
    LowerCaseLetter -> a | b | c | d | e | f | g | h | i | j | k | l | m |
496
                       n | o | p | q | r | s | t | u | v | w | x | y | z
497
498
    UpperCaseLetter -> A | B | C | D | E | F | G | H | I | J | K | L | M |
499
                       N | O | P | Q | R | S | T | U | V | W | X | Y | Z
500
501
    Digit -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
502
503
    OctalDigit -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
504
505
    a..fA..F -> a | b | c | d | e | f | A | B | C | D | E | F
506
507
    HexDigit -> Digit
508
              | a..fA..F
509
510
    OctalDigits3 -> OctalDigit
511
                  | OctalDigit OctalDigit
512
                  | OctalDigit OctalDigit OctalDigit
513
514
    LetterEe -> 'E'
515
              | 'e'
516
517
    LetterXx -> 'X'
518
              | 'x'
519
520
    WS -> WSChar
521
        | WS WSChar
522
523
    Identifier -> Letter
524
                | Identifier Letter
525
                | Identifier Digit
526
                | Identifier DollarSign
527
                | QuotedName
528
529
    SpecialNotStar -> '+' | '-' | '/' | '(' | ')' | '"' | '!' | '@' | '`' | '~' |
530
                      '%' | '&' | '^' | ':' | ';' | "'" | '\' | '|' | '{' | '}' |
531
                      '[' | ']' | '?' | ',' | '.' | '<' | '>' | '=' | '#' | DollarSign
532
533
    SpecialNotSlash -> '+' | '-' | -- exclude the star as well
534
                       '(' | ')' | '"' | '!' | '@' | '`' | '~' |
535
                       '%' | '&' | '^' | ':' | ';' | "'" | '\' | '|' | '{' | '}' |
536
                       '[' | ']' | '?' | ',' | '.' | '<' | '>' | '=' | '#' | DollarSign
537
538
    SpecialNotSQNotDQ -> '+' | '-' | '/' | '(' | ')' | '*' | '!' | '@' | '`' | '~' |
539
                         '%' | '&' | '^' | ':' | ';' | '|' | '{' | '}' |
540
                         '[' | ']' | '?' | ',' | '.' | '<' | '>' | '=' | '#' | DollarSign
541
542
    
543
    SpecialNotDQ -> SpecialNotSQNotDQ | "'"
544
    SpecialNotSQ -> SpecialNotSQNotDQ | '"'
545
546
    EscapedSymbols -> NotSQNotDQ | '"' | "'" | '\'
547
    BackslashEscapedSymbol -> '\' EscapedSymbols
548
549
    NotSlashOrStar -> Letter
550
                    | Digit
551
                    | SpecialNotSlash
552
                    | WSChar
553
554
    NotEol -> Letter
555
            | Digit
556
            | Space
557
            | '*'
558
            | SpecialNotStar
559
            | HT
560
            | FF
561
            | CtlCharNotWS
562
563
    NotSQNotDQ -> Letter
564
           | Digit
565
           | SpecialNotSQNotDQ
566
           | Space
567
568
    NotDQ -> Letter
569
           | Digit
570
           | SpecialNotDQ
571
           | Space
572
           | EscapedDQ
573
           --| '\' u HexDigit HexDigit HexDigit HexDigit
574
           --| '\' OctalDigit
575
576
    NotSQ -> Letter
577
           | Digit
578
           | SpecialNotSQ
579
           | Space
580
           | EscapedSQ
581
           | BackslashEscapedSymbol
582
           --| '\' u HexDigit HexDigit HexDigit HexDigit
583
           --| '\' OctalDigit
584
585
	EscapedSQ -> SingleQuote SingleQuote
586
587
	-- maintain this for compatibility with the "...\"..." escapes in an
588
	-- escape mechanism (double-quotes) that isn't compliant, anyway
589
	EscapedDQ -> '\' DoubleQuote
590
591
	SLNotDQ -> NotDQ
592
	         | SLNotDQ NotDQ
593
594
	SLNotSQ -> NotSQ
595
	         | SLNotSQ NotSQ
596
597
	SLNotSQOpt -> %empty
598
	            | SLNotSQ
599
600
	QuotedName -> '"' SLNotDQ '"'
601
602
	NumericOperation -> Integer '.' Identifier
603
	NumericOperation -> Integer '.' '+'
604
	NumericOperation -> Integer '.' '-'
605
	NumericOperation -> Integer '.' '*'
606
	NumericOperation -> Integer '.' '/'
607
	NumericOperation -> Integer '.' '<'
608
	NumericOperation -> Integer '.' '<' '='
609
	NumericOperation -> Integer '.' '>' '='
610
	NumericOperation -> Integer '.' '>'
611
612
	IntegerRangeStart -> Integer '.' '.'
613
614
%End
(-)src/org/eclipse/ocl/lpg/KWLexerMap.gi (+80 lines)
Added Link Here
1
%Terminals
2
    DollarSign ::= '$'
3
    Percent ::= '%'
4
    _
5
    a b c d e f g h i j k l m n o p q r s t u v w x y z
6
    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
7
%End
8
9
%Headers
10
    /.
11
        final static int tokenKind[] = new int[128];
12
        static
13
        {
14
            tokenKind['$'] = $sym_type.$prefix$DollarSign$suffix$;
15
            tokenKind['%'] = $sym_type.$prefix$Percent$suffix$;
16
            tokenKind['_'] = $sym_type.$prefix$_$suffix$;
17
18
            tokenKind['a'] = $sym_type.$prefix$a$suffix$;
19
            tokenKind['b'] = $sym_type.$prefix$b$suffix$;
20
            tokenKind['c'] = $sym_type.$prefix$c$suffix$;
21
            tokenKind['d'] = $sym_type.$prefix$d$suffix$;
22
            tokenKind['e'] = $sym_type.$prefix$e$suffix$;
23
            tokenKind['f'] = $sym_type.$prefix$f$suffix$;
24
            tokenKind['g'] = $sym_type.$prefix$g$suffix$;
25
            tokenKind['h'] = $sym_type.$prefix$h$suffix$;
26
            tokenKind['i'] = $sym_type.$prefix$i$suffix$;
27
            tokenKind['j'] = $sym_type.$prefix$j$suffix$;
28
            tokenKind['k'] = $sym_type.$prefix$k$suffix$;
29
            tokenKind['l'] = $sym_type.$prefix$l$suffix$;
30
            tokenKind['m'] = $sym_type.$prefix$m$suffix$;
31
            tokenKind['n'] = $sym_type.$prefix$n$suffix$;
32
            tokenKind['o'] = $sym_type.$prefix$o$suffix$;
33
            tokenKind['p'] = $sym_type.$prefix$p$suffix$;
34
            tokenKind['q'] = $sym_type.$prefix$q$suffix$;
35
            tokenKind['r'] = $sym_type.$prefix$r$suffix$;
36
            tokenKind['s'] = $sym_type.$prefix$s$suffix$;
37
            tokenKind['t'] = $sym_type.$prefix$t$suffix$;
38
            tokenKind['u'] = $sym_type.$prefix$u$suffix$;
39
            tokenKind['v'] = $sym_type.$prefix$v$suffix$;
40
            tokenKind['w'] = $sym_type.$prefix$w$suffix$;
41
            tokenKind['x'] = $sym_type.$prefix$x$suffix$;
42
            tokenKind['y'] = $sym_type.$prefix$y$suffix$;
43
            tokenKind['z'] = $sym_type.$prefix$z$suffix$;
44
45
            tokenKind['A'] = $sym_type.$prefix$A$suffix$;
46
            tokenKind['B'] = $sym_type.$prefix$B$suffix$;
47
            tokenKind['C'] = $sym_type.$prefix$C$suffix$;
48
            tokenKind['D'] = $sym_type.$prefix$D$suffix$;
49
            tokenKind['E'] = $sym_type.$prefix$E$suffix$;
50
            tokenKind['F'] = $sym_type.$prefix$F$suffix$;
51
            tokenKind['G'] = $sym_type.$prefix$G$suffix$;
52
            tokenKind['H'] = $sym_type.$prefix$H$suffix$;
53
            tokenKind['I'] = $sym_type.$prefix$I$suffix$;
54
            tokenKind['J'] = $sym_type.$prefix$J$suffix$;
55
            tokenKind['K'] = $sym_type.$prefix$K$suffix$;
56
            tokenKind['L'] = $sym_type.$prefix$L$suffix$;
57
            tokenKind['M'] = $sym_type.$prefix$M$suffix$;
58
            tokenKind['N'] = $sym_type.$prefix$N$suffix$;
59
            tokenKind['O'] = $sym_type.$prefix$O$suffix$;
60
            tokenKind['P'] = $sym_type.$prefix$P$suffix$;
61
            tokenKind['Q'] = $sym_type.$prefix$Q$suffix$;
62
            tokenKind['R'] = $sym_type.$prefix$R$suffix$;
63
            tokenKind['S'] = $sym_type.$prefix$S$suffix$;
64
            tokenKind['T'] = $sym_type.$prefix$T$suffix$;
65
            tokenKind['U'] = $sym_type.$prefix$U$suffix$;
66
            tokenKind['V'] = $sym_type.$prefix$V$suffix$;
67
            tokenKind['W'] = $sym_type.$prefix$W$suffix$;
68
            tokenKind['X'] = $sym_type.$prefix$X$suffix$;
69
            tokenKind['Y'] = $sym_type.$prefix$Y$suffix$;
70
            tokenKind['Z'] = $sym_type.$prefix$Z$suffix$;
71
        };
72
    
73
        final int getKind(int c)
74
        {
75
            return (((c & 0xFFFFFF80) == 0) /* 0 <= c < 128? */ ? tokenKind[c] : 0);
76
        }
77
    ./
78
%End
79
80

Return to bug 242153