1 /* VhdlParserTokenManager.cc */
2 #include "VhdlParserTokenManager.h"
3 #include "TokenMgrError.h"
4 namespace vhdl {
5 namespace parser {
6 static const unsigned long long jjbitVec0[] = {
7    0xfffffffffffffffeULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
8 };
9 static const unsigned long long jjbitVec2[] = {
10    0x0ULL, 0x0ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
11 };
12 static const unsigned long long jjbitVec3[] = {
13    0x0ULL, 0x0ULL, 0xffffffff00000000ULL, 0xffffffffffffffffULL
14 };
15 static const int jjnextStates[] = {
16    56, 57, 58, 59, 60, 63, 67, 68, 69, 78, 18, 19, 79, 81, 83, 48,
17    49, 2, 35, 36, 0, 3, 4, 5, 7, 12, 13, 15, 16, 22, 21, 23,
18    31, 32, 34, 37, 38, 40, 44, 45, 47, 51, 52, 54, 58, 59, 60, 63,
19    62, 61, 63, 67, 68, 69, 70, 71, 73, 78, 18, 19, 78, 18, 19, 79,
20    9, 10, 26, 27, 25, 28,
21 };
22 static JJChar jjstrLiteralChars_0[] = {0};
23 static JJChar jjstrLiteralChars_1[] = {0};
24 static JJChar jjstrLiteralChars_2[] = {0};
25 static JJChar jjstrLiteralChars_3[] = {0};
26 static JJChar jjstrLiteralChars_4[] = {0};
27 static JJChar jjstrLiteralChars_5[] = {0};
28 static JJChar jjstrLiteralChars_6[] = {0};
29 
30 static JJChar jjstrLiteralChars_7[] = {0};
31 static JJChar jjstrLiteralChars_8[] = {0};
32 static JJChar jjstrLiteralChars_9[] = {0};
33 static JJChar jjstrLiteralChars_10[] = {0};
34 static JJChar jjstrLiteralChars_11[] = {0};
35 static JJChar jjstrLiteralChars_12[] = {0};
36 static JJChar jjstrLiteralChars_13[] = {0};
37 static JJChar jjstrLiteralChars_14[] = {0};
38 static JJChar jjstrLiteralChars_15[] = {0};
39 static JJChar jjstrLiteralChars_16[] = {0};
40 static JJChar jjstrLiteralChars_17[] = {0};
41 static JJChar jjstrLiteralChars_18[] = {0};
42 static JJChar jjstrLiteralChars_19[] = {0};
43 static JJChar jjstrLiteralChars_20[] = {0};
44 
45 static JJChar jjstrLiteralChars_21[] = {0};
46 static JJChar jjstrLiteralChars_22[] = {0};
47 static JJChar jjstrLiteralChars_23[] = {0};
48 static JJChar jjstrLiteralChars_24[] = {0};
49 static JJChar jjstrLiteralChars_25[] = {0};
50 static JJChar jjstrLiteralChars_26[] = {0};
51 static JJChar jjstrLiteralChars_27[] = {0};
52 static JJChar jjstrLiteralChars_28[] = {0};
53 static JJChar jjstrLiteralChars_29[] = {0};
54 static JJChar jjstrLiteralChars_30[] = {0};
55 static JJChar jjstrLiteralChars_31[] = {0};
56 static JJChar jjstrLiteralChars_32[] = {0};
57 static JJChar jjstrLiteralChars_33[] = {0};
58 static JJChar jjstrLiteralChars_34[] = {0};
59 
60 static JJChar jjstrLiteralChars_35[] = {0};
61 static JJChar jjstrLiteralChars_36[] = {0};
62 static JJChar jjstrLiteralChars_37[] = {0};
63 static JJChar jjstrLiteralChars_38[] = {0};
64 static JJChar jjstrLiteralChars_39[] = {0};
65 static JJChar jjstrLiteralChars_40[] = {0};
66 static JJChar jjstrLiteralChars_41[] = {0};
67 static JJChar jjstrLiteralChars_42[] = {0};
68 static JJChar jjstrLiteralChars_43[] = {0};
69 static JJChar jjstrLiteralChars_44[] = {0};
70 static JJChar jjstrLiteralChars_45[] = {0};
71 static JJChar jjstrLiteralChars_46[] = {0};
72 static JJChar jjstrLiteralChars_47[] = {0};
73 static JJChar jjstrLiteralChars_48[] = {0};
74 
75 static JJChar jjstrLiteralChars_49[] = {0};
76 static JJChar jjstrLiteralChars_50[] = {0};
77 static JJChar jjstrLiteralChars_51[] = {0};
78 static JJChar jjstrLiteralChars_52[] = {0};
79 static JJChar jjstrLiteralChars_53[] = {0};
80 static JJChar jjstrLiteralChars_54[] = {0};
81 static JJChar jjstrLiteralChars_55[] = {0};
82 static JJChar jjstrLiteralChars_56[] = {0};
83 static JJChar jjstrLiteralChars_57[] = {0};
84 static JJChar jjstrLiteralChars_58[] = {0};
85 static JJChar jjstrLiteralChars_59[] = {0};
86 static JJChar jjstrLiteralChars_60[] = {0};
87 static JJChar jjstrLiteralChars_61[] = {0};
88 static JJChar jjstrLiteralChars_62[] = {0};
89 
90 static JJChar jjstrLiteralChars_63[] = {0};
91 static JJChar jjstrLiteralChars_64[] = {0};
92 static JJChar jjstrLiteralChars_65[] = {0};
93 static JJChar jjstrLiteralChars_66[] = {0};
94 static JJChar jjstrLiteralChars_67[] = {0};
95 static JJChar jjstrLiteralChars_68[] = {0};
96 static JJChar jjstrLiteralChars_69[] = {0};
97 static JJChar jjstrLiteralChars_70[] = {0};
98 static JJChar jjstrLiteralChars_71[] = {0};
99 static JJChar jjstrLiteralChars_72[] = {0};
100 static JJChar jjstrLiteralChars_73[] = {0};
101 static JJChar jjstrLiteralChars_74[] = {0};
102 static JJChar jjstrLiteralChars_75[] = {0};
103 static JJChar jjstrLiteralChars_76[] = {0};
104 
105 static JJChar jjstrLiteralChars_77[] = {0};
106 static JJChar jjstrLiteralChars_78[] = {0};
107 static JJChar jjstrLiteralChars_79[] = {0};
108 static JJChar jjstrLiteralChars_80[] = {0};
109 static JJChar jjstrLiteralChars_81[] = {0};
110 static JJChar jjstrLiteralChars_82[] = {0};
111 static JJChar jjstrLiteralChars_83[] = {0};
112 static JJChar jjstrLiteralChars_84[] = {0};
113 static JJChar jjstrLiteralChars_85[] = {0};
114 static JJChar jjstrLiteralChars_86[] = {0};
115 static JJChar jjstrLiteralChars_87[] = {0};
116 static JJChar jjstrLiteralChars_88[] = {0};
117 static JJChar jjstrLiteralChars_89[] = {0};
118 static JJChar jjstrLiteralChars_90[] = {0};
119 
120 static JJChar jjstrLiteralChars_91[] = {0};
121 static JJChar jjstrLiteralChars_92[] = {0};
122 static JJChar jjstrLiteralChars_93[] = {0};
123 static JJChar jjstrLiteralChars_94[] = {0};
124 static JJChar jjstrLiteralChars_95[] = {0};
125 static JJChar jjstrLiteralChars_96[] = {0};
126 static JJChar jjstrLiteralChars_97[] = {0};
127 static JJChar jjstrLiteralChars_98[] = {0};
128 static JJChar jjstrLiteralChars_99[] = {0};
129 static JJChar jjstrLiteralChars_100[] = {0};
130 static JJChar jjstrLiteralChars_101[] = {0};
131 static JJChar jjstrLiteralChars_102[] = {0};
132 static JJChar jjstrLiteralChars_103[] = {0};
133 static JJChar jjstrLiteralChars_104[] = {0};
134 
135 static JJChar jjstrLiteralChars_105[] = {0};
136 static JJChar jjstrLiteralChars_106[] = {0};
137 static JJChar jjstrLiteralChars_107[] = {0};
138 static JJChar jjstrLiteralChars_108[] = {0};
139 static JJChar jjstrLiteralChars_109[] = {0};
140 static JJChar jjstrLiteralChars_110[] = {0};
141 static JJChar jjstrLiteralChars_111[] = {0};
142 static JJChar jjstrLiteralChars_112[] = {0};
143 static JJChar jjstrLiteralChars_113[] = {0};
144 static JJChar jjstrLiteralChars_114[] = {0};
145 static JJChar jjstrLiteralChars_115[] = {0};
146 static JJChar jjstrLiteralChars_116[] = {0};
147 static JJChar jjstrLiteralChars_117[] = {0};
148 static JJChar jjstrLiteralChars_118[] = {0};
149 
150 static JJChar jjstrLiteralChars_119[] = {0};
151 static JJChar jjstrLiteralChars_120[] = {0};
152 static JJChar jjstrLiteralChars_121[] = {0};
153 static JJChar jjstrLiteralChars_122[] = {0};
154 static JJChar jjstrLiteralChars_123[] = {0};
155 static JJChar jjstrLiteralChars_124[] = {0};
156 static JJChar jjstrLiteralChars_125[] = {0};
157 
158 static JJChar jjstrLiteralChars_126[] = {0x26, 0};
159 static JJChar jjstrLiteralChars_127[] = {0x27, 0};
160 
161 static JJChar jjstrLiteralChars_128[] = {0x28, 0};
162 static JJChar jjstrLiteralChars_129[] = {0x29, 0};
163 
164 static JJChar jjstrLiteralChars_130[] = {0x2a, 0x2a, 0};
165 static JJChar jjstrLiteralChars_131[] = {0x2a, 0};
166 
167 static JJChar jjstrLiteralChars_132[] = {0x2b, 0};
168 static JJChar jjstrLiteralChars_133[] = {0x2d, 0};
169 
170 static JJChar jjstrLiteralChars_134[] = {0x2c, 0};
171 static JJChar jjstrLiteralChars_135[] = {0x3a, 0x3d, 0};
172 
173 static JJChar jjstrLiteralChars_136[] = {0x3a, 0};
174 static JJChar jjstrLiteralChars_137[] = {0x3b, 0};
175 
176 static JJChar jjstrLiteralChars_138[] = {0x3c, 0x3d, 0};
177 static JJChar jjstrLiteralChars_139[] = {0x3e, 0x3d, 0};
178 
179 static JJChar jjstrLiteralChars_140[] = {0x3c, 0};
180 static JJChar jjstrLiteralChars_141[] = {0x3e, 0};
181 
182 static JJChar jjstrLiteralChars_142[] = {0x3d, 0};
183 static JJChar jjstrLiteralChars_143[] = {0x2f, 0x3d, 0};
184 
185 static JJChar jjstrLiteralChars_144[] = {0x3d, 0x3e, 0};
186 static JJChar jjstrLiteralChars_145[] = {0x3c, 0x3e, 0};
187 
188 static JJChar jjstrLiteralChars_146[] = {0x3c, 0x3c, 0};
189 static JJChar jjstrLiteralChars_147[] = {0x3e, 0x3e, 0};
190 
191 static JJChar jjstrLiteralChars_148[] = {0x3f, 0x3f, 0};
192 static JJChar jjstrLiteralChars_149[] = {0x3f, 0x3e, 0x3d, 0};
193 
194 static JJChar jjstrLiteralChars_150[] = {0x3f, 0x3c, 0x3d, 0};
195 static JJChar jjstrLiteralChars_151[] = {0x3f, 0x3e, 0};
196 
197 static JJChar jjstrLiteralChars_152[] = {0x3f, 0x3c, 0};
198 static JJChar jjstrLiteralChars_153[] = {0x3f, 0x3d, 0};
199 
200 static JJChar jjstrLiteralChars_154[] = {0x3f, 0x2f, 0x3d, 0};
201 static JJChar jjstrLiteralChars_155[] = {0x3f, 0};
202 
203 static JJChar jjstrLiteralChars_156[] = {0x7c, 0};
204 static JJChar jjstrLiteralChars_157[] = {0x2e, 0};
205 
206 static JJChar jjstrLiteralChars_158[] = {0x2f, 0};
207 static JJChar jjstrLiteralChars_159[] = {0x40, 0};
208 
209 static JJChar jjstrLiteralChars_160[] = {0x5e, 0};
210 static JJChar jjstrLiteralChars_161[] = {0x5b, 0};
211 
212 static JJChar jjstrLiteralChars_162[] = {0x5d, 0};
213 static JJChar jjstrLiteralChars_163[] = {0x7b, 0};
214 
215 static JJChar jjstrLiteralChars_164[] = {0x7d, 0};
216 static JJChar jjstrLiteralChars_165[] = {0};
217 static JJChar jjstrLiteralChars_166[] = {0};
218 static JJChar jjstrLiteralChars_167[] = {0};
219 static JJChar jjstrLiteralChars_168[] = {0};
220 static JJChar jjstrLiteralChars_169[] = {0};
221 static JJChar jjstrLiteralChars_170[] = {0};
222 static JJChar jjstrLiteralChars_171[] = {0};
223 static JJChar jjstrLiteralChars_172[] = {0};
224 static JJChar jjstrLiteralChars_173[] = {0};
225 static JJChar jjstrLiteralChars_174[] = {0};
226 static JJChar jjstrLiteralChars_175[] = {0};
227 static JJChar jjstrLiteralChars_176[] = {0};
228 static JJChar jjstrLiteralChars_177[] = {0};
229 
230 static JJChar jjstrLiteralChars_178[] = {0};
231 static JJChar jjstrLiteralChars_179[] = {0};
232 static JJChar jjstrLiteralChars_180[] = {0};
233 static JJChar jjstrLiteralChars_181[] = {0};
234 static JJChar jjstrLiteralChars_182[] = {0};
235 static JJChar jjstrLiteralChars_183[] = {0};
236 static JJChar jjstrLiteralChars_184[] = {0};
237 static JJChar jjstrLiteralChars_185[] = {0};
238 static JJChar jjstrLiteralChars_186[] = {0};
239 static JJChar jjstrLiteralChars_187[] = {0};
240 static JJChar jjstrLiteralChars_188[] = {0};
241 static JJChar jjstrLiteralChars_189[] = {0};
242 static JJChar jjstrLiteralChars_190[] = {0};
243 static const JJString jjstrLiteralImages[] = {
244 jjstrLiteralChars_0,
245 jjstrLiteralChars_1,
246 jjstrLiteralChars_2,
247 jjstrLiteralChars_3,
248 jjstrLiteralChars_4,
249 jjstrLiteralChars_5,
250 jjstrLiteralChars_6,
251 jjstrLiteralChars_7,
252 jjstrLiteralChars_8,
253 jjstrLiteralChars_9,
254 jjstrLiteralChars_10,
255 jjstrLiteralChars_11,
256 jjstrLiteralChars_12,
257 jjstrLiteralChars_13,
258 jjstrLiteralChars_14,
259 jjstrLiteralChars_15,
260 jjstrLiteralChars_16,
261 jjstrLiteralChars_17,
262 jjstrLiteralChars_18,
263 jjstrLiteralChars_19,
264 jjstrLiteralChars_20,
265 jjstrLiteralChars_21,
266 jjstrLiteralChars_22,
267 jjstrLiteralChars_23,
268 jjstrLiteralChars_24,
269 jjstrLiteralChars_25,
270 jjstrLiteralChars_26,
271 jjstrLiteralChars_27,
272 jjstrLiteralChars_28,
273 jjstrLiteralChars_29,
274 jjstrLiteralChars_30,
275 jjstrLiteralChars_31,
276 jjstrLiteralChars_32,
277 jjstrLiteralChars_33,
278 jjstrLiteralChars_34,
279 jjstrLiteralChars_35,
280 jjstrLiteralChars_36,
281 jjstrLiteralChars_37,
282 jjstrLiteralChars_38,
283 jjstrLiteralChars_39,
284 jjstrLiteralChars_40,
285 jjstrLiteralChars_41,
286 jjstrLiteralChars_42,
287 jjstrLiteralChars_43,
288 jjstrLiteralChars_44,
289 jjstrLiteralChars_45,
290 jjstrLiteralChars_46,
291 jjstrLiteralChars_47,
292 jjstrLiteralChars_48,
293 jjstrLiteralChars_49,
294 jjstrLiteralChars_50,
295 jjstrLiteralChars_51,
296 jjstrLiteralChars_52,
297 jjstrLiteralChars_53,
298 jjstrLiteralChars_54,
299 jjstrLiteralChars_55,
300 jjstrLiteralChars_56,
301 jjstrLiteralChars_57,
302 jjstrLiteralChars_58,
303 jjstrLiteralChars_59,
304 jjstrLiteralChars_60,
305 jjstrLiteralChars_61,
306 jjstrLiteralChars_62,
307 jjstrLiteralChars_63,
308 jjstrLiteralChars_64,
309 jjstrLiteralChars_65,
310 jjstrLiteralChars_66,
311 jjstrLiteralChars_67,
312 jjstrLiteralChars_68,
313 jjstrLiteralChars_69,
314 jjstrLiteralChars_70,
315 jjstrLiteralChars_71,
316 jjstrLiteralChars_72,
317 jjstrLiteralChars_73,
318 jjstrLiteralChars_74,
319 jjstrLiteralChars_75,
320 jjstrLiteralChars_76,
321 jjstrLiteralChars_77,
322 jjstrLiteralChars_78,
323 jjstrLiteralChars_79,
324 jjstrLiteralChars_80,
325 jjstrLiteralChars_81,
326 jjstrLiteralChars_82,
327 jjstrLiteralChars_83,
328 jjstrLiteralChars_84,
329 jjstrLiteralChars_85,
330 jjstrLiteralChars_86,
331 jjstrLiteralChars_87,
332 jjstrLiteralChars_88,
333 jjstrLiteralChars_89,
334 jjstrLiteralChars_90,
335 jjstrLiteralChars_91,
336 jjstrLiteralChars_92,
337 jjstrLiteralChars_93,
338 jjstrLiteralChars_94,
339 jjstrLiteralChars_95,
340 jjstrLiteralChars_96,
341 jjstrLiteralChars_97,
342 jjstrLiteralChars_98,
343 jjstrLiteralChars_99,
344 jjstrLiteralChars_100,
345 jjstrLiteralChars_101,
346 jjstrLiteralChars_102,
347 jjstrLiteralChars_103,
348 jjstrLiteralChars_104,
349 jjstrLiteralChars_105,
350 jjstrLiteralChars_106,
351 jjstrLiteralChars_107,
352 jjstrLiteralChars_108,
353 jjstrLiteralChars_109,
354 jjstrLiteralChars_110,
355 jjstrLiteralChars_111,
356 jjstrLiteralChars_112,
357 jjstrLiteralChars_113,
358 jjstrLiteralChars_114,
359 jjstrLiteralChars_115,
360 jjstrLiteralChars_116,
361 jjstrLiteralChars_117,
362 jjstrLiteralChars_118,
363 jjstrLiteralChars_119,
364 jjstrLiteralChars_120,
365 jjstrLiteralChars_121,
366 jjstrLiteralChars_122,
367 jjstrLiteralChars_123,
368 jjstrLiteralChars_124,
369 jjstrLiteralChars_125,
370 jjstrLiteralChars_126,
371 jjstrLiteralChars_127,
372 jjstrLiteralChars_128,
373 jjstrLiteralChars_129,
374 jjstrLiteralChars_130,
375 jjstrLiteralChars_131,
376 jjstrLiteralChars_132,
377 jjstrLiteralChars_133,
378 jjstrLiteralChars_134,
379 jjstrLiteralChars_135,
380 jjstrLiteralChars_136,
381 jjstrLiteralChars_137,
382 jjstrLiteralChars_138,
383 jjstrLiteralChars_139,
384 jjstrLiteralChars_140,
385 jjstrLiteralChars_141,
386 jjstrLiteralChars_142,
387 jjstrLiteralChars_143,
388 jjstrLiteralChars_144,
389 jjstrLiteralChars_145,
390 jjstrLiteralChars_146,
391 jjstrLiteralChars_147,
392 jjstrLiteralChars_148,
393 jjstrLiteralChars_149,
394 jjstrLiteralChars_150,
395 jjstrLiteralChars_151,
396 jjstrLiteralChars_152,
397 jjstrLiteralChars_153,
398 jjstrLiteralChars_154,
399 jjstrLiteralChars_155,
400 jjstrLiteralChars_156,
401 jjstrLiteralChars_157,
402 jjstrLiteralChars_158,
403 jjstrLiteralChars_159,
404 jjstrLiteralChars_160,
405 jjstrLiteralChars_161,
406 jjstrLiteralChars_162,
407 jjstrLiteralChars_163,
408 jjstrLiteralChars_164,
409 jjstrLiteralChars_165,
410 jjstrLiteralChars_166,
411 jjstrLiteralChars_167,
412 jjstrLiteralChars_168,
413 jjstrLiteralChars_169,
414 jjstrLiteralChars_170,
415 jjstrLiteralChars_171,
416 jjstrLiteralChars_172,
417 jjstrLiteralChars_173,
418 jjstrLiteralChars_174,
419 jjstrLiteralChars_175,
420 jjstrLiteralChars_176,
421 jjstrLiteralChars_177,
422 jjstrLiteralChars_178,
423 jjstrLiteralChars_179,
424 jjstrLiteralChars_180,
425 jjstrLiteralChars_181,
426 jjstrLiteralChars_182,
427 jjstrLiteralChars_183,
428 jjstrLiteralChars_184,
429 jjstrLiteralChars_185,
430 jjstrLiteralChars_186,
431 jjstrLiteralChars_187,
432 jjstrLiteralChars_188,
433 jjstrLiteralChars_189,
434 jjstrLiteralChars_190,
435 };
436 
437 /** Lexer state names. */
438 static const JJChar lexStateNames_arr_0[] =
439 {0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0};
440 static const JJString lexStateNames[] = {
441 lexStateNames_arr_0,
442 };
443 static const unsigned long long jjtoToken[] = {
444    0xfffffffffffff801ULL, 0xffffffffffffffffULL, 0x60101fffffffffffULL,
445 };
446 static const unsigned long long jjtoSkip[] = {
447    0x7deULL, 0x0ULL, 0x0ULL,
448 };
449 
setDebugStream(FILE * ds)450   void  VhdlParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; }
451 
jjStopAtPos(int pos,int kind)452  int  VhdlParserTokenManager::jjStopAtPos(int pos, int kind){
453    jjmatchedKind = kind;
454    jjmatchedPos = pos;
455    return pos + 1;
456 }
457 
jjMoveStringLiteralDfa0_0()458  int  VhdlParserTokenManager::jjMoveStringLiteralDfa0_0(){
459    switch(curChar)
460    {
461       case 9:
462          jjmatchedKind = 2;
463          return jjMoveNfa_0(11, 0);
464       case 10:
465          jjmatchedKind = 3;
466          return jjMoveNfa_0(11, 0);
467       case 13:
468          jjmatchedKind = 4;
469          return jjMoveNfa_0(11, 0);
470       case 32:
471          jjmatchedKind = 1;
472          return jjMoveNfa_0(11, 0);
473       case 38:
474          jjmatchedKind = 126;
475          return jjMoveNfa_0(11, 0);
476       case 39:
477          jjmatchedKind = 127;
478          return jjMoveNfa_0(11, 0);
479       case 40:
480          jjmatchedKind = 128;
481          return jjMoveNfa_0(11, 0);
482       case 41:
483          jjmatchedKind = 129;
484          return jjMoveNfa_0(11, 0);
485       case 42:
486          jjmatchedKind = 131;
487          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x4ULL);
488       case 43:
489          jjmatchedKind = 132;
490          return jjMoveNfa_0(11, 0);
491       case 44:
492          jjmatchedKind = 134;
493          return jjMoveNfa_0(11, 0);
494       case 45:
495          jjmatchedKind = 133;
496          return jjMoveNfa_0(11, 0);
497       case 46:
498          jjmatchedKind = 157;
499          return jjMoveNfa_0(11, 0);
500       case 47:
501          jjmatchedKind = 158;
502          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x8000ULL);
503       case 58:
504          jjmatchedKind = 136;
505          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x80ULL);
506       case 59:
507          jjmatchedKind = 137;
508          return jjMoveNfa_0(11, 0);
509       case 60:
510          jjmatchedKind = 140;
511          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x60400ULL);
512       case 61:
513          jjmatchedKind = 142;
514          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x10000ULL);
515       case 62:
516          jjmatchedKind = 141;
517          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x80800ULL);
518       case 63:
519          jjmatchedKind = 155;
520          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x7f00000ULL);
521       case 64:
522          jjmatchedKind = 159;
523          return jjMoveNfa_0(11, 0);
524       case 65:
525          return jjMoveStringLiteralDfa1_0(0x7ff800ULL, 0x0ULL, 0x0ULL);
526       case 66:
527          return jjMoveStringLiteralDfa1_0(0xf800000ULL, 0x0ULL, 0x0ULL);
528       case 67:
529          return jjMoveStringLiteralDfa1_0(0x3f0000000ULL, 0x0ULL, 0x0ULL);
530       case 68:
531          return jjMoveStringLiteralDfa1_0(0x1c00000000ULL, 0x0ULL, 0x0ULL);
532       case 69:
533          return jjMoveStringLiteralDfa1_0(0x3e000000000ULL, 0x0ULL, 0x0ULL);
534       case 70:
535          return jjMoveStringLiteralDfa1_0(0x7c0000000000ULL, 0x0ULL, 0x0ULL);
536       case 71:
537          return jjMoveStringLiteralDfa1_0(0x7800000000000ULL, 0x0ULL, 0x0ULL);
538       case 73:
539          return jjMoveStringLiteralDfa1_0(0x1f8000000000000ULL, 0x0ULL, 0x0ULL);
540       case 76:
541          return jjMoveStringLiteralDfa1_0(0x3e00000000000000ULL, 0x0ULL, 0x0ULL);
542       case 77:
543          return jjMoveStringLiteralDfa1_0(0xc000000000000000ULL, 0x0ULL, 0x0ULL);
544       case 78:
545          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3fULL, 0x0ULL);
546       case 79:
547          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xfc0ULL, 0x0ULL);
548       case 80:
549          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ff000ULL, 0x0ULL);
550       case 82:
551          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ffe00000ULL, 0x0ULL);
552       case 83:
553          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xffe00000000ULL, 0x0ULL);
554       case 84:
555          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000ULL, 0x0ULL);
556       case 85:
557          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf000000000000ULL, 0x0ULL);
558       case 86:
559          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf0000000000000ULL, 0x0ULL);
560       case 87:
561          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000000ULL, 0x0ULL);
562       case 88:
563          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3000000000000000ULL, 0x0ULL);
564       case 91:
565          jjmatchedKind = 161;
566          return jjMoveNfa_0(11, 0);
567       case 93:
568          jjmatchedKind = 162;
569          return jjMoveNfa_0(11, 0);
570       case 94:
571          jjmatchedKind = 160;
572          return jjMoveNfa_0(11, 0);
573       case 97:
574          return jjMoveStringLiteralDfa1_0(0x7ff800ULL, 0x0ULL, 0x0ULL);
575       case 98:
576          return jjMoveStringLiteralDfa1_0(0xf800000ULL, 0x0ULL, 0x0ULL);
577       case 99:
578          return jjMoveStringLiteralDfa1_0(0x3f0000000ULL, 0x0ULL, 0x0ULL);
579       case 100:
580          return jjMoveStringLiteralDfa1_0(0x1c00000000ULL, 0x0ULL, 0x0ULL);
581       case 101:
582          return jjMoveStringLiteralDfa1_0(0x3e000000000ULL, 0x0ULL, 0x0ULL);
583       case 102:
584          return jjMoveStringLiteralDfa1_0(0x7c0000000000ULL, 0x0ULL, 0x0ULL);
585       case 103:
586          return jjMoveStringLiteralDfa1_0(0x7800000000000ULL, 0x0ULL, 0x0ULL);
587       case 105:
588          return jjMoveStringLiteralDfa1_0(0x1f8000000000000ULL, 0x0ULL, 0x0ULL);
589       case 108:
590          return jjMoveStringLiteralDfa1_0(0x3e00000000000000ULL, 0x0ULL, 0x0ULL);
591       case 109:
592          return jjMoveStringLiteralDfa1_0(0xc000000000000000ULL, 0x0ULL, 0x0ULL);
593       case 110:
594          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3fULL, 0x0ULL);
595       case 111:
596          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xfc0ULL, 0x0ULL);
597       case 112:
598          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ff000ULL, 0x0ULL);
599       case 114:
600          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ffe00000ULL, 0x0ULL);
601       case 115:
602          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xffe00000000ULL, 0x0ULL);
603       case 116:
604          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000ULL, 0x0ULL);
605       case 117:
606          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf000000000000ULL, 0x0ULL);
607       case 118:
608          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf0000000000000ULL, 0x0ULL);
609       case 119:
610          return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000000ULL, 0x0ULL);
611       case 120:
612          return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3000000000000000ULL, 0x0ULL);
613       case 123:
614          jjmatchedKind = 163;
615          return jjMoveNfa_0(11, 0);
616       case 124:
617          jjmatchedKind = 156;
618          return jjMoveNfa_0(11, 0);
619       case 125:
620          jjmatchedKind = 164;
621          return jjMoveNfa_0(11, 0);
622       default :
623          return jjMoveNfa_0(11, 0);
624    }
625 }
626 
jjMoveStringLiteralDfa1_0(unsigned long long active0,unsigned long long active1,unsigned long long active2)627  int  VhdlParserTokenManager::jjMoveStringLiteralDfa1_0(unsigned long long active0, unsigned long long active1, unsigned long long active2){
628    if (input_stream->endOfInput()) {
629    return jjMoveNfa_0(11, 0);
630    }
631    curChar = input_stream->readChar();
632    switch(curChar)
633    {
634       case 42:
635          if ((active2 & 0x4ULL) != 0L)
636          {
637             jjmatchedKind = 130;
638             jjmatchedPos = 1;
639          }
640          break;
641       case 47:
642          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x4000000ULL);
643       case 60:
644          if ((active2 & 0x40000ULL) != 0L)
645          {
646             jjmatchedKind = 146;
647             jjmatchedPos = 1;
648          }
649          else if ((active2 & 0x1000000ULL) != 0L)
650          {
651             jjmatchedKind = 152;
652             jjmatchedPos = 1;
653          }
654          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x400000ULL);
655       case 61:
656          if ((active2 & 0x80ULL) != 0L)
657          {
658             jjmatchedKind = 135;
659             jjmatchedPos = 1;
660          }
661          else if ((active2 & 0x400ULL) != 0L)
662          {
663             jjmatchedKind = 138;
664             jjmatchedPos = 1;
665          }
666          else if ((active2 & 0x800ULL) != 0L)
667          {
668             jjmatchedKind = 139;
669             jjmatchedPos = 1;
670          }
671          else if ((active2 & 0x8000ULL) != 0L)
672          {
673             jjmatchedKind = 143;
674             jjmatchedPos = 1;
675          }
676          else if ((active2 & 0x2000000ULL) != 0L)
677          {
678             jjmatchedKind = 153;
679             jjmatchedPos = 1;
680          }
681          break;
682       case 62:
683          if ((active2 & 0x10000ULL) != 0L)
684          {
685             jjmatchedKind = 144;
686             jjmatchedPos = 1;
687          }
688          else if ((active2 & 0x20000ULL) != 0L)
689          {
690             jjmatchedKind = 145;
691             jjmatchedPos = 1;
692          }
693          else if ((active2 & 0x80000ULL) != 0L)
694          {
695             jjmatchedKind = 147;
696             jjmatchedPos = 1;
697          }
698          else if ((active2 & 0x800000ULL) != 0L)
699          {
700             jjmatchedKind = 151;
701             jjmatchedPos = 1;
702          }
703          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x200000ULL);
704       case 63:
705          if ((active2 & 0x100000ULL) != 0L)
706          {
707             jjmatchedKind = 148;
708             jjmatchedPos = 1;
709          }
710          break;
711       case 65:
712          return jjMoveStringLiteralDfa2_0(active0, 0x4200040020000000ULL, active1, 0x110000000203001ULL, active2, 0L);
713       case 66:
714          return jjMoveStringLiteralDfa2_0(active0, 0x800ULL, active1, 0L, active2, 0L);
715       case 67:
716          return jjMoveStringLiteralDfa2_0(active0, 0x1000ULL, active1, 0L, active2, 0L);
717       case 69:
718          return jjMoveStringLiteralDfa2_0(active0, 0x1800400800000ULL, active1, 0xf3fc00006ULL, active2, 0L);
719       case 70:
720          if ((active0 & 0x8000000000000ULL) != 0L)
721          {
722             jjmatchedKind = 51;
723             jjmatchedPos = 1;
724          }
725          else if ((active1 & 0x40ULL) != 0L)
726          {
727             jjmatchedKind = 70;
728             jjmatchedPos = 1;
729          }
730          return jjMoveStringLiteralDfa2_0(active0, 0x2000ULL, active1, 0L, active2, 0L);
731       case 72:
732          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x600102000000000ULL, active2, 0L);
733       case 73:
734          return jjMoveStringLiteralDfa2_0(active0, 0x1c00080800000000ULL, active1, 0x800001000000000ULL, active2, 0L);
735       case 76:
736          return jjMoveStringLiteralDfa2_0(active0, 0x600100c000ULL, active1, 0xc000000000ULL, active2, 0L);
737       case 77:
738          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0x20000000000000ULL, active2, 0L);
739       case 78:
740          if ((active0 & 0x20000000000000ULL) != 0L)
741          {
742             jjmatchedKind = 53;
743             jjmatchedPos = 1;
744          }
745          else if ((active1 & 0x80ULL) != 0L)
746          {
747             jjmatchedKind = 71;
748             jjmatchedPos = 1;
749          }
750          return jjMoveStringLiteralDfa2_0(active0, 0xc0018000010000ULL, active1, 0x2007000000000000ULL, active2, 0L);
751       case 79:
752          if ((active1 & 0x200000000000ULL) != 0L)
753          {
754             jjmatchedKind = 109;
755             jjmatchedPos = 1;
756          }
757          return jjMoveStringLiteralDfa2_0(active0, 0xa0003013d2000000ULL, active1, 0x10000000c000c018ULL, active2, 0L);
758       case 80:
759          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000100ULL, active2, 0L);
760       case 82:
761          if ((active1 & 0x200ULL) != 0L)
762          {
763             jjmatchedKind = 73;
764             jjmatchedPos = 1;
765          }
766          return jjMoveStringLiteralDfa2_0(active0, 0x2000000060000ULL, active1, 0x4300000f0000ULL, active2, 0L);
767       case 83:
768          if ((active0 & 0x100000000000000ULL) != 0L)
769          {
770             jjmatchedKind = 56;
771             jjmatchedPos = 1;
772          }
773          return jjMoveStringLiteralDfa2_0(active0, 0x380000ULL, active1, 0x8000000000000ULL, active2, 0L);
774       case 84:
775          return jjMoveStringLiteralDfa2_0(active0, 0x400000ULL, active1, 0x40000000400ULL, active2, 0L);
776       case 85:
777          return jjMoveStringLiteralDfa2_0(active0, 0x440000c000000ULL, active1, 0x80080000100820ULL, active2, 0L);
778       case 88:
779          return jjMoveStringLiteralDfa2_0(active0, 0x20000000000ULL, active1, 0L, active2, 0L);
780       case 89:
781          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000ULL, active2, 0L);
782       case 97:
783          return jjMoveStringLiteralDfa2_0(active0, 0x4200040020000000ULL, active1, 0x110000000203001ULL, active2, 0L);
784       case 98:
785          return jjMoveStringLiteralDfa2_0(active0, 0x800ULL, active1, 0L, active2, 0L);
786       case 99:
787          return jjMoveStringLiteralDfa2_0(active0, 0x1000ULL, active1, 0L, active2, 0L);
788       case 101:
789          return jjMoveStringLiteralDfa2_0(active0, 0x1800400800000ULL, active1, 0xf3fc00006ULL, active2, 0L);
790       case 102:
791          if ((active0 & 0x8000000000000ULL) != 0L)
792          {
793             jjmatchedKind = 51;
794             jjmatchedPos = 1;
795          }
796          else if ((active1 & 0x40ULL) != 0L)
797          {
798             jjmatchedKind = 70;
799             jjmatchedPos = 1;
800          }
801          return jjMoveStringLiteralDfa2_0(active0, 0x2000ULL, active1, 0L, active2, 0L);
802       case 104:
803          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x600102000000000ULL, active2, 0L);
804       case 105:
805          return jjMoveStringLiteralDfa2_0(active0, 0x1c00080800000000ULL, active1, 0x800001000000000ULL, active2, 0L);
806       case 108:
807          return jjMoveStringLiteralDfa2_0(active0, 0x600100c000ULL, active1, 0xc000000000ULL, active2, 0L);
808       case 109:
809          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0x20000000000000ULL, active2, 0L);
810       case 110:
811          if ((active0 & 0x20000000000000ULL) != 0L)
812          {
813             jjmatchedKind = 53;
814             jjmatchedPos = 1;
815          }
816          else if ((active1 & 0x80ULL) != 0L)
817          {
818             jjmatchedKind = 71;
819             jjmatchedPos = 1;
820          }
821          return jjMoveStringLiteralDfa2_0(active0, 0xc0018000010000ULL, active1, 0x2007000000000000ULL, active2, 0L);
822       case 111:
823          if ((active1 & 0x200000000000ULL) != 0L)
824          {
825             jjmatchedKind = 109;
826             jjmatchedPos = 1;
827          }
828          return jjMoveStringLiteralDfa2_0(active0, 0xa0003013d2000000ULL, active1, 0x10000000c000c018ULL, active2, 0L);
829       case 112:
830          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000100ULL, active2, 0L);
831       case 114:
832          if ((active1 & 0x200ULL) != 0L)
833          {
834             jjmatchedKind = 73;
835             jjmatchedPos = 1;
836          }
837          return jjMoveStringLiteralDfa2_0(active0, 0x2000000060000ULL, active1, 0x4300000f0000ULL, active2, 0L);
838       case 115:
839          if ((active0 & 0x100000000000000ULL) != 0L)
840          {
841             jjmatchedKind = 56;
842             jjmatchedPos = 1;
843          }
844          return jjMoveStringLiteralDfa2_0(active0, 0x380000ULL, active1, 0x8000000000000ULL, active2, 0L);
845       case 116:
846          return jjMoveStringLiteralDfa2_0(active0, 0x400000ULL, active1, 0x40000000400ULL, active2, 0L);
847       case 117:
848          return jjMoveStringLiteralDfa2_0(active0, 0x440000c000000ULL, active1, 0x80080000100820ULL, active2, 0L);
849       case 120:
850          return jjMoveStringLiteralDfa2_0(active0, 0x20000000000ULL, active1, 0L, active2, 0L);
851       case 121:
852          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000ULL, active2, 0L);
853       default :
854          break;
855    }
856    return jjMoveNfa_0(11, 1);
857 }
858 
jjMoveStringLiteralDfa2_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1,unsigned long long old2,unsigned long long active2)859  int  VhdlParserTokenManager::jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2){
860    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
861       return jjMoveNfa_0(11, 1);
862    if (input_stream->endOfInput()) {
863    return jjMoveNfa_0(11, 1);
864    }
865    curChar = input_stream->readChar();
866    switch(curChar)
867    {
868       case 61:
869          if ((active2 & 0x200000ULL) != 0L)
870          {
871             jjmatchedKind = 149;
872             jjmatchedPos = 2;
873          }
874          else if ((active2 & 0x400000ULL) != 0L)
875          {
876             jjmatchedKind = 150;
877             jjmatchedPos = 2;
878          }
879          else if ((active2 & 0x4000000ULL) != 0L)
880          {
881             jjmatchedKind = 154;
882             jjmatchedPos = 2;
883          }
884          break;
885       case 65:
886          if ((active1 & 0x4000000000ULL) != 0L)
887          {
888             jjmatchedKind = 102;
889             jjmatchedPos = 2;
890          }
891          else if ((active1 & 0x10000000000ULL) != 0L)
892          {
893             jjmatchedKind = 104;
894             jjmatchedPos = 2;
895          }
896          return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000ULL, active1, 0x1402000000000ULL, active2, 0L);
897       case 66:
898          return jjMoveStringLiteralDfa3_0(active0, 0x600000000000000ULL, active1, 0x80000000000ULL, active2, 0L);
899       case 67:
900          return jjMoveStringLiteralDfa3_0(active0, 0x21000ULL, active1, 0x401000ULL, active2, 0L);
901       case 68:
902          if ((active0 & 0x10000ULL) != 0L)
903          {
904             jjmatchedKind = 16;
905             jjmatchedPos = 2;
906          }
907          else if ((active0 & 0x8000000000ULL) != 0L)
908          {
909             jjmatchedKind = 39;
910             jjmatchedPos = 2;
911          }
912          else if ((active0 & 0x8000000000000000ULL) != 0L)
913          {
914             jjmatchedKind = 63;
915             jjmatchedPos = 2;
916          }
917          return jjMoveStringLiteralDfa3_0(active0, 0x2000000ULL, active1, 0L, active2, 0L);
918       case 69:
919          if ((active1 & 0x8000000000000ULL) != 0L)
920          {
921             jjmatchedKind = 115;
922             jjmatchedPos = 2;
923          }
924          return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000ULL, active1, 0x200100000000100ULL, active2, 0L);
925       case 70:
926          return jjMoveStringLiteralDfa3_0(active0, 0x404000000ULL, active1, 0L, active2, 0L);
927       case 71:
928          return jjMoveStringLiteralDfa3_0(active0, 0x800000ULL, active1, 0x1000800000ULL, active2, 0L);
929       case 72:
930          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400ULL, active2, 0L);
931       case 73:
932          return jjMoveStringLiteralDfa3_0(active0, 0x60000004000ULL, active1, 0x502000000000000ULL, active2, 0L);
933       case 74:
934          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000000ULL, active2, 0L);
935       case 76:
936          if ((active0 & 0x8000ULL) != 0L)
937          {
938             jjmatchedKind = 15;
939             jjmatchedPos = 2;
940          }
941          else if ((active1 & 0x40000000ULL) != 0L)
942          {
943             jjmatchedKind = 94;
944             jjmatchedPos = 2;
945          }
946          else if ((active1 & 0x8000000000ULL) != 0L)
947          {
948             jjmatchedKind = 103;
949             jjmatchedPos = 2;
950          }
951          else if ((active1 & 0x20000000000ULL) != 0L)
952          {
953             jjmatchedKind = 105;
954             jjmatchedPos = 2;
955          }
956          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000ULL, active1, 0x202000020ULL, active2, 0L);
957       case 77:
958          if ((active1 & 0x10000000ULL) != 0L)
959          {
960             jjmatchedKind = 92;
961             jjmatchedPos = 2;
962          }
963          return jjMoveStringLiteralDfa3_0(active0, 0x10000000ULL, active1, 0L, active2, 0L);
964       case 78:
965          return jjMoveStringLiteralDfa3_0(active0, 0x801c001c0000000ULL, active1, 0x80000000200001ULL, active2, 0L);
966       case 79:
967          return jjMoveStringLiteralDfa3_0(active0, 0x2082000001000000ULL, active1, 0x20200000000f0000ULL, active2, 0L);
968       case 80:
969          if ((active0 & 0x4000000000000000ULL) != 0L)
970          {
971             jjmatchedKind = 62;
972             jjmatchedPos = 2;
973          }
974          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000ULL, active1, 0x800020000000ULL, active2, 0L);
975       case 81:
976          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000ULL, active2, 0L);
977       case 82:
978          if ((active0 & 0x100000000000ULL) != 0L)
979          {
980             jjmatchedKind = 44;
981             jjmatchedPos = 2;
982          }
983          else if ((active1 & 0x8ULL) != 0L)
984          {
985             jjmatchedKind = 67;
986             jjmatchedPos = 2;
987          }
988          else if ((active1 & 0x80000000ULL) != 0L)
989          {
990             jjmatchedKind = 95;
991             jjmatchedPos = 2;
992          }
993          else if ((active1 & 0x1000000000000000ULL) != 0L)
994          {
995             jjmatchedKind = 124;
996             jjmatchedPos = 2;
997          }
998          return jjMoveStringLiteralDfa3_0(active0, 0x200000040000ULL, active1, 0x50040000106000ULL, active2, 0L);
999       case 83:
1000          if ((active0 & 0x800ULL) != 0L)
1001          {
1002             jjmatchedKind = 11;
1003             jjmatchedPos = 2;
1004          }
1005          else if ((active0 & 0x8000000ULL) != 0L)
1006          {
1007             jjmatchedKind = 27;
1008             jjmatchedPos = 2;
1009          }
1010          return jjMoveStringLiteralDfa3_0(active0, 0x6820380000ULL, active1, 0xc008000ULL, active2, 0L);
1011       case 84:
1012          if ((active1 & 0x10ULL) != 0L)
1013          {
1014             jjmatchedKind = 68;
1015             jjmatchedPos = 2;
1016          }
1017          else if ((active1 & 0x800ULL) != 0L)
1018          {
1019             jjmatchedKind = 75;
1020             jjmatchedPos = 2;
1021          }
1022          return jjMoveStringLiteralDfa3_0(active0, 0x1000010000402000ULL, active1, 0x804000100000000ULL, active2, 0L);
1023       case 86:
1024          return jjMoveStringLiteralDfa3_0(active0, 0x200000000ULL, active1, 0x800000000ULL, active2, 0L);
1025       case 87:
1026          if ((active1 & 0x2ULL) != 0L)
1027          {
1028             jjmatchedKind = 65;
1029             jjmatchedPos = 2;
1030          }
1031          return jjMoveStringLiteralDfa3_0(active0, 0x1000000000ULL, active1, 0L, active2, 0L);
1032       case 88:
1033          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4ULL, active2, 0L);
1034       case 97:
1035          if ((active1 & 0x4000000000ULL) != 0L)
1036          {
1037             jjmatchedKind = 102;
1038             jjmatchedPos = 2;
1039          }
1040          else if ((active1 & 0x10000000000ULL) != 0L)
1041          {
1042             jjmatchedKind = 104;
1043             jjmatchedPos = 2;
1044          }
1045          return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000ULL, active1, 0x1402000000000ULL, active2, 0L);
1046       case 98:
1047          return jjMoveStringLiteralDfa3_0(active0, 0x600000000000000ULL, active1, 0x80000000000ULL, active2, 0L);
1048       case 99:
1049          return jjMoveStringLiteralDfa3_0(active0, 0x21000ULL, active1, 0x401000ULL, active2, 0L);
1050       case 100:
1051          if ((active0 & 0x10000ULL) != 0L)
1052          {
1053             jjmatchedKind = 16;
1054             jjmatchedPos = 2;
1055          }
1056          else if ((active0 & 0x8000000000ULL) != 0L)
1057          {
1058             jjmatchedKind = 39;
1059             jjmatchedPos = 2;
1060          }
1061          else if ((active0 & 0x8000000000000000ULL) != 0L)
1062          {
1063             jjmatchedKind = 63;
1064             jjmatchedPos = 2;
1065          }
1066          return jjMoveStringLiteralDfa3_0(active0, 0x2000000ULL, active1, 0L, active2, 0L);
1067       case 101:
1068          if ((active1 & 0x8000000000000ULL) != 0L)
1069          {
1070             jjmatchedKind = 115;
1071             jjmatchedPos = 2;
1072          }
1073          return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000ULL, active1, 0x200100000000100ULL, active2, 0L);
1074       case 102:
1075          return jjMoveStringLiteralDfa3_0(active0, 0x404000000ULL, active1, 0L, active2, 0L);
1076       case 103:
1077          return jjMoveStringLiteralDfa3_0(active0, 0x800000ULL, active1, 0x1000800000ULL, active2, 0L);
1078       case 104:
1079          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400ULL, active2, 0L);
1080       case 105:
1081          return jjMoveStringLiteralDfa3_0(active0, 0x60000004000ULL, active1, 0x502000000000000ULL, active2, 0L);
1082       case 106:
1083          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000000ULL, active2, 0L);
1084       case 108:
1085          if ((active0 & 0x8000ULL) != 0L)
1086          {
1087             jjmatchedKind = 15;
1088             jjmatchedPos = 2;
1089          }
1090          else if ((active1 & 0x40000000ULL) != 0L)
1091          {
1092             jjmatchedKind = 94;
1093             jjmatchedPos = 2;
1094          }
1095          else if ((active1 & 0x8000000000ULL) != 0L)
1096          {
1097             jjmatchedKind = 103;
1098             jjmatchedPos = 2;
1099          }
1100          else if ((active1 & 0x20000000000ULL) != 0L)
1101          {
1102             jjmatchedKind = 105;
1103             jjmatchedPos = 2;
1104          }
1105          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000ULL, active1, 0x202000020ULL, active2, 0L);
1106       case 109:
1107          if ((active1 & 0x10000000ULL) != 0L)
1108          {
1109             jjmatchedKind = 92;
1110             jjmatchedPos = 2;
1111          }
1112          return jjMoveStringLiteralDfa3_0(active0, 0x10000000ULL, active1, 0L, active2, 0L);
1113       case 110:
1114          return jjMoveStringLiteralDfa3_0(active0, 0x801c001c0000000ULL, active1, 0x80000000200001ULL, active2, 0L);
1115       case 111:
1116          return jjMoveStringLiteralDfa3_0(active0, 0x2082000001000000ULL, active1, 0x20200000000f0000ULL, active2, 0L);
1117       case 112:
1118          if ((active0 & 0x4000000000000000ULL) != 0L)
1119          {
1120             jjmatchedKind = 62;
1121             jjmatchedPos = 2;
1122          }
1123          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000ULL, active1, 0x800020000000ULL, active2, 0L);
1124       case 113:
1125          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000ULL, active2, 0L);
1126       case 114:
1127          if ((active0 & 0x100000000000ULL) != 0L)
1128          {
1129             jjmatchedKind = 44;
1130             jjmatchedPos = 2;
1131          }
1132          else if ((active1 & 0x8ULL) != 0L)
1133          {
1134             jjmatchedKind = 67;
1135             jjmatchedPos = 2;
1136          }
1137          else if ((active1 & 0x80000000ULL) != 0L)
1138          {
1139             jjmatchedKind = 95;
1140             jjmatchedPos = 2;
1141          }
1142          else if ((active1 & 0x1000000000000000ULL) != 0L)
1143          {
1144             jjmatchedKind = 124;
1145             jjmatchedPos = 2;
1146          }
1147          return jjMoveStringLiteralDfa3_0(active0, 0x200000040000ULL, active1, 0x50040000106000ULL, active2, 0L);
1148       case 115:
1149          if ((active0 & 0x800ULL) != 0L)
1150          {
1151             jjmatchedKind = 11;
1152             jjmatchedPos = 2;
1153          }
1154          else if ((active0 & 0x8000000ULL) != 0L)
1155          {
1156             jjmatchedKind = 27;
1157             jjmatchedPos = 2;
1158          }
1159          return jjMoveStringLiteralDfa3_0(active0, 0x6820380000ULL, active1, 0xc008000ULL, active2, 0L);
1160       case 116:
1161          if ((active1 & 0x10ULL) != 0L)
1162          {
1163             jjmatchedKind = 68;
1164             jjmatchedPos = 2;
1165          }
1166          else if ((active1 & 0x800ULL) != 0L)
1167          {
1168             jjmatchedKind = 75;
1169             jjmatchedPos = 2;
1170          }
1171          return jjMoveStringLiteralDfa3_0(active0, 0x1000010000402000ULL, active1, 0x804000100000000ULL, active2, 0L);
1172       case 118:
1173          return jjMoveStringLiteralDfa3_0(active0, 0x200000000ULL, active1, 0x800000000ULL, active2, 0L);
1174       case 119:
1175          if ((active1 & 0x2ULL) != 0L)
1176          {
1177             jjmatchedKind = 65;
1178             jjmatchedPos = 2;
1179          }
1180          return jjMoveStringLiteralDfa3_0(active0, 0x1000000000ULL, active1, 0L, active2, 0L);
1181       case 120:
1182          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4ULL, active2, 0L);
1183       default :
1184          break;
1185    }
1186    return jjMoveNfa_0(11, 2);
1187 }
1188 
jjMoveStringLiteralDfa3_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1,unsigned long long old2,unsigned long long active2)1189  int  VhdlParserTokenManager::jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2){
1190    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1191       return jjMoveNfa_0(11, 2);
1192    if (input_stream->endOfInput()) {
1193    return jjMoveNfa_0(11, 2);
1194    }
1195    curChar = input_stream->readChar();
1196    switch(curChar)
1197    {
1198       case 65:
1199          return jjMoveStringLiteralDfa4_0(active0, 0x400044000ULL, active1, 0x2000ULL);
1200       case 67:
1201          return jjMoveStringLiteralDfa4_0(active0, 0x600801000000ULL, active1, 0x30000ULL);
1202       case 68:
1203          if ((active1 & 0x1ULL) != 0L)
1204          {
1205             jjmatchedKind = 64;
1206             jjmatchedPos = 3;
1207          }
1208          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20000000000000ULL);
1209       case 69:
1210          if ((active0 & 0x20000000ULL) != 0L)
1211          {
1212             jjmatchedKind = 29;
1213             jjmatchedPos = 3;
1214          }
1215          else if ((active0 & 0x2000000000ULL) != 0L)
1216          {
1217             jjmatchedKind = 37;
1218             jjmatchedPos = 3;
1219          }
1220          else if ((active0 & 0x80000000000ULL) != 0L)
1221          {
1222             jjmatchedKind = 43;
1223             jjmatchedPos = 3;
1224          }
1225          else if ((active1 & 0x100000ULL) != 0L)
1226          {
1227             jjmatchedKind = 84;
1228             jjmatchedPos = 3;
1229          }
1230          else if ((active1 & 0x800000000000ULL) != 0L)
1231          {
1232             jjmatchedKind = 111;
1233             jjmatchedPos = 3;
1234          }
1235          return jjMoveStringLiteralDfa4_0(active0, 0x1201800200083000ULL, active1, 0xa03000400ULL);
1236       case 70:
1237          return jjMoveStringLiteralDfa4_0(active0, 0x44000000ULL, active1, 0x1000000000000ULL);
1238       case 71:
1239          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000ULL);
1240       case 72:
1241          if ((active1 & 0x800000000000000ULL) != 0L)
1242          {
1243             jjmatchedKind = 123;
1244             jjmatchedPos = 3;
1245          }
1246          return jjMoveStringLiteralDfa4_0(active0, 0x20000ULL, active1, 0L);
1247       case 73:
1248          return jjMoveStringLiteralDfa4_0(active0, 0x14000800000ULL, active1, 0x94000000800000ULL);
1249       case 75:
1250          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000ULL, active1, 0x1000ULL);
1251       case 76:
1252          if ((active1 & 0x20ULL) != 0L)
1253          {
1254             jjmatchedKind = 69;
1255             jjmatchedPos = 3;
1256          }
1257          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400000000000000ULL);
1258       case 78:
1259          if ((active1 & 0x100ULL) != 0L)
1260          {
1261             jjmatchedKind = 72;
1262             jjmatchedPos = 3;
1263          }
1264          else if ((active1 & 0x100000000000ULL) != 0L)
1265          {
1266             jjmatchedKind = 108;
1267             jjmatchedPos = 3;
1268          }
1269          else if ((active1 & 0x200000000000000ULL) != 0L)
1270          {
1271             jjmatchedKind = 121;
1272             jjmatchedPos = 3;
1273          }
1274          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000ULL, active1, 0x401000000000ULL);
1275       case 79:
1276          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40040020400000ULL);
1277       case 80:
1278          if ((active0 & 0x2000000000000000ULL) != 0L)
1279          {
1280             jjmatchedKind = 61;
1281             jjmatchedPos = 3;
1282          }
1283          return jjMoveStringLiteralDfa4_0(active0, 0x10000000ULL, active1, 0x40000ULL);
1284       case 82:
1285          if ((active1 & 0x2000000000000000ULL) != 0L)
1286          {
1287             jjmatchedKind = 125;
1288             jjmatchedPos = 3;
1289          }
1290          return jjMoveStringLiteralDfa4_0(active0, 0x444040000400000ULL, active1, 0x2000000000ULL);
1291       case 83:
1292          return jjMoveStringLiteralDfa4_0(active0, 0x80000000ULL, active1, 0L);
1293       case 84:
1294          if ((active0 & 0x20000000000ULL) != 0L)
1295          {
1296             jjmatchedKind = 41;
1297             jjmatchedPos = 3;
1298          }
1299          else if ((active1 & 0x4ULL) != 0L)
1300          {
1301             jjmatchedKind = 66;
1302             jjmatchedPos = 3;
1303          }
1304          else if ((active1 & 0x4000ULL) != 0L)
1305          {
1306             jjmatchedKind = 78;
1307             jjmatchedPos = 3;
1308          }
1309          else if ((active1 & 0x100000000000000ULL) != 0L)
1310          {
1311             jjmatchedKind = 120;
1312             jjmatchedPos = 3;
1313          }
1314          return jjMoveStringLiteralDfa4_0(active0, 0x100000000ULL, active1, 0x208000c088000ULL);
1315       case 85:
1316          return jjMoveStringLiteralDfa4_0(active0, 0x92000000300000ULL, active1, 0x500000000ULL);
1317       case 89:
1318          if ((active0 & 0x2000000ULL) != 0L)
1319          {
1320             jjmatchedKind = 25;
1321             jjmatchedPos = 3;
1322          }
1323          break;
1324       case 97:
1325          return jjMoveStringLiteralDfa4_0(active0, 0x400044000ULL, active1, 0x2000ULL);
1326       case 99:
1327          return jjMoveStringLiteralDfa4_0(active0, 0x600801000000ULL, active1, 0x30000ULL);
1328       case 100:
1329          if ((active1 & 0x1ULL) != 0L)
1330          {
1331             jjmatchedKind = 64;
1332             jjmatchedPos = 3;
1333          }
1334          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20000000000000ULL);
1335       case 101:
1336          if ((active0 & 0x20000000ULL) != 0L)
1337          {
1338             jjmatchedKind = 29;
1339             jjmatchedPos = 3;
1340          }
1341          else if ((active0 & 0x2000000000ULL) != 0L)
1342          {
1343             jjmatchedKind = 37;
1344             jjmatchedPos = 3;
1345          }
1346          else if ((active0 & 0x80000000000ULL) != 0L)
1347          {
1348             jjmatchedKind = 43;
1349             jjmatchedPos = 3;
1350          }
1351          else if ((active1 & 0x100000ULL) != 0L)
1352          {
1353             jjmatchedKind = 84;
1354             jjmatchedPos = 3;
1355          }
1356          else if ((active1 & 0x800000000000ULL) != 0L)
1357          {
1358             jjmatchedKind = 111;
1359             jjmatchedPos = 3;
1360          }
1361          return jjMoveStringLiteralDfa4_0(active0, 0x1201800200083000ULL, active1, 0xa03000400ULL);
1362       case 102:
1363          return jjMoveStringLiteralDfa4_0(active0, 0x44000000ULL, active1, 0x1000000000000ULL);
1364       case 103:
1365          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000ULL);
1366       case 104:
1367          if ((active1 & 0x800000000000000ULL) != 0L)
1368          {
1369             jjmatchedKind = 123;
1370             jjmatchedPos = 3;
1371          }
1372          return jjMoveStringLiteralDfa4_0(active0, 0x20000ULL, active1, 0L);
1373       case 105:
1374          return jjMoveStringLiteralDfa4_0(active0, 0x14000800000ULL, active1, 0x94000000800000ULL);
1375       case 107:
1376          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000ULL, active1, 0x1000ULL);
1377       case 108:
1378          if ((active1 & 0x20ULL) != 0L)
1379          {
1380             jjmatchedKind = 69;
1381             jjmatchedPos = 3;
1382          }
1383          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400000000000000ULL);
1384       case 110:
1385          if ((active1 & 0x100ULL) != 0L)
1386          {
1387             jjmatchedKind = 72;
1388             jjmatchedPos = 3;
1389          }
1390          else if ((active1 & 0x100000000000ULL) != 0L)
1391          {
1392             jjmatchedKind = 108;
1393             jjmatchedPos = 3;
1394          }
1395          else if ((active1 & 0x200000000000000ULL) != 0L)
1396          {
1397             jjmatchedKind = 121;
1398             jjmatchedPos = 3;
1399          }
1400          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000ULL, active1, 0x401000000000ULL);
1401       case 111:
1402          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40040020400000ULL);
1403       case 112:
1404          if ((active0 & 0x2000000000000000ULL) != 0L)
1405          {
1406             jjmatchedKind = 61;
1407             jjmatchedPos = 3;
1408          }
1409          return jjMoveStringLiteralDfa4_0(active0, 0x10000000ULL, active1, 0x40000ULL);
1410       case 114:
1411          if ((active1 & 0x2000000000000000ULL) != 0L)
1412          {
1413             jjmatchedKind = 125;
1414             jjmatchedPos = 3;
1415          }
1416          return jjMoveStringLiteralDfa4_0(active0, 0x444040000400000ULL, active1, 0x2000000000ULL);
1417       case 115:
1418          return jjMoveStringLiteralDfa4_0(active0, 0x80000000ULL, active1, 0L);
1419       case 116:
1420          if ((active0 & 0x20000000000ULL) != 0L)
1421          {
1422             jjmatchedKind = 41;
1423             jjmatchedPos = 3;
1424          }
1425          else if ((active1 & 0x4ULL) != 0L)
1426          {
1427             jjmatchedKind = 66;
1428             jjmatchedPos = 3;
1429          }
1430          else if ((active1 & 0x4000ULL) != 0L)
1431          {
1432             jjmatchedKind = 78;
1433             jjmatchedPos = 3;
1434          }
1435          else if ((active1 & 0x100000000000000ULL) != 0L)
1436          {
1437             jjmatchedKind = 120;
1438             jjmatchedPos = 3;
1439          }
1440          return jjMoveStringLiteralDfa4_0(active0, 0x100000000ULL, active1, 0x208000c088000ULL);
1441       case 117:
1442          return jjMoveStringLiteralDfa4_0(active0, 0x92000000300000ULL, active1, 0x500000000ULL);
1443       case 121:
1444          if ((active0 & 0x2000000ULL) != 0L)
1445          {
1446             jjmatchedKind = 25;
1447             jjmatchedPos = 3;
1448          }
1449          break;
1450       default :
1451          break;
1452    }
1453    return jjMoveNfa_0(11, 3);
1454 }
1455 
jjMoveStringLiteralDfa4_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)1456  int  VhdlParserTokenManager::jjMoveStringLiteralDfa4_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
1457    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1458       return jjMoveNfa_0(11, 3);
1459    if (input_stream->endOfInput()) {
1460    return jjMoveNfa_0(11, 3);
1461    }
1462    curChar = input_stream->readChar();
1463    switch(curChar)
1464    {
1465       case 65:
1466          return jjMoveStringLiteralDfa5_0(active0, 0xc00000000000000ULL, active1, 0x10001002001000ULL);
1467       case 67:
1468          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x201000000ULL);
1469       case 68:
1470          return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000ULL, active1, 0L);
1471       case 69:
1472          if ((active0 & 0x200000000000ULL) != 0L)
1473          {
1474             jjmatchedKind = 45;
1475             jjmatchedPos = 4;
1476          }
1477          else if ((active1 & 0x200000ULL) != 0L)
1478          {
1479             jjmatchedKind = 85;
1480             jjmatchedPos = 4;
1481          }
1482          else if ((active1 & 0x20000000000000ULL) != 0L)
1483          {
1484             jjmatchedKind = 117;
1485             jjmatchedPos = 4;
1486          }
1487          else if ((active1 & 0x400000000000000ULL) != 0L)
1488          {
1489             jjmatchedKind = 122;
1490             jjmatchedPos = 4;
1491          }
1492          return jjMoveStringLiteralDfa5_0(active0, 0x104000000ULL, active1, 0x24000f0000ULL);
1493       case 70:
1494          if ((active0 & 0x4000000000ULL) != 0L)
1495          {
1496             jjmatchedKind = 38;
1497             jjmatchedPos = 4;
1498          }
1499          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000ULL);
1500       case 73:
1501          return jjMoveStringLiteralDfa5_0(active0, 0x40420000ULL, active1, 0L);
1502       case 75:
1503          if ((active0 & 0x1000000ULL) != 0L)
1504          {
1505             jjmatchedKind = 24;
1506             jjmatchedPos = 4;
1507          }
1508          break;
1509       case 76:
1510          if ((active0 & 0x200000000000000ULL) != 0L)
1511          {
1512             jjmatchedKind = 57;
1513             jjmatchedPos = 4;
1514          }
1515          else if ((active1 & 0x4000000000000ULL) != 0L)
1516          {
1517             jjmatchedKind = 114;
1518             jjmatchedPos = 4;
1519          }
1520          break;
1521       case 77:
1522          return jjMoveStringLiteralDfa5_0(active0, 0x300000ULL, active1, 0x2000ULL);
1523       case 78:
1524          if ((active0 & 0x800000ULL) != 0L)
1525          {
1526             jjmatchedKind = 23;
1527             jjmatchedPos = 4;
1528          }
1529          return jjMoveStringLiteralDfa5_0(active0, 0x40000000000ULL, active1, 0x40000000000ULL);
1530       case 79:
1531          return jjMoveStringLiteralDfa5_0(active0, 0x810000000ULL, active1, 0L);
1532       case 80:
1533          if ((active0 & 0x2000000000000ULL) != 0L)
1534          {
1535             jjmatchedKind = 49;
1536             jjmatchedPos = 4;
1537          }
1538          else if ((active1 & 0x40000000000000ULL) != 0L)
1539          {
1540             jjmatchedKind = 118;
1541             jjmatchedPos = 4;
1542          }
1543          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x8000ULL);
1544       case 82:
1545          if ((active0 & 0x2000ULL) != 0L)
1546          {
1547             jjmatchedKind = 13;
1548             jjmatchedPos = 4;
1549          }
1550          else if ((active0 & 0x200000000ULL) != 0L)
1551          {
1552             jjmatchedKind = 33;
1553             jjmatchedPos = 4;
1554          }
1555          return jjMoveStringLiteralDfa5_0(active0, 0x1011800000080000ULL, active1, 0x92c400400ULL);
1556       case 83:
1557          if ((active0 & 0x4000ULL) != 0L)
1558          {
1559             jjmatchedKind = 14;
1560             jjmatchedPos = 4;
1561          }
1562          else if ((active1 & 0x2000000000000ULL) != 0L)
1563          {
1564             jjmatchedKind = 113;
1565             jjmatchedPos = 4;
1566          }
1567          return jjMoveStringLiteralDfa5_0(active0, 0x1000ULL, active1, 0x400000800000ULL);
1568       case 84:
1569          if ((active0 & 0x80000000000000ULL) != 0L)
1570          {
1571             jjmatchedKind = 55;
1572             jjmatchedPos = 4;
1573          }
1574          else if ((active1 & 0x80000000000000ULL) != 0L)
1575          {
1576             jjmatchedKind = 119;
1577             jjmatchedPos = 4;
1578          }
1579          return jjMoveStringLiteralDfa5_0(active0, 0x40411080000000ULL, active1, 0L);
1580       case 85:
1581          return jjMoveStringLiteralDfa5_0(active0, 0x400000000ULL, active1, 0L);
1582       case 89:
1583          if ((active0 & 0x40000ULL) != 0L)
1584          {
1585             jjmatchedKind = 18;
1586             jjmatchedPos = 4;
1587          }
1588          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x80000000000ULL);
1589       case 97:
1590          return jjMoveStringLiteralDfa5_0(active0, 0xc00000000000000ULL, active1, 0x10001002001000ULL);
1591       case 99:
1592          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x201000000ULL);
1593       case 100:
1594          return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000ULL, active1, 0L);
1595       case 101:
1596          if ((active0 & 0x200000000000ULL) != 0L)
1597          {
1598             jjmatchedKind = 45;
1599             jjmatchedPos = 4;
1600          }
1601          else if ((active1 & 0x200000ULL) != 0L)
1602          {
1603             jjmatchedKind = 85;
1604             jjmatchedPos = 4;
1605          }
1606          else if ((active1 & 0x20000000000000ULL) != 0L)
1607          {
1608             jjmatchedKind = 117;
1609             jjmatchedPos = 4;
1610          }
1611          else if ((active1 & 0x400000000000000ULL) != 0L)
1612          {
1613             jjmatchedKind = 122;
1614             jjmatchedPos = 4;
1615          }
1616          return jjMoveStringLiteralDfa5_0(active0, 0x104000000ULL, active1, 0x24000f0000ULL);
1617       case 102:
1618          if ((active0 & 0x4000000000ULL) != 0L)
1619          {
1620             jjmatchedKind = 38;
1621             jjmatchedPos = 4;
1622          }
1623          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000ULL);
1624       case 105:
1625          return jjMoveStringLiteralDfa5_0(active0, 0x40420000ULL, active1, 0L);
1626       case 107:
1627          if ((active0 & 0x1000000ULL) != 0L)
1628          {
1629             jjmatchedKind = 24;
1630             jjmatchedPos = 4;
1631          }
1632          break;
1633       case 108:
1634          if ((active0 & 0x200000000000000ULL) != 0L)
1635          {
1636             jjmatchedKind = 57;
1637             jjmatchedPos = 4;
1638          }
1639          else if ((active1 & 0x4000000000000ULL) != 0L)
1640          {
1641             jjmatchedKind = 114;
1642             jjmatchedPos = 4;
1643          }
1644          break;
1645       case 109:
1646          return jjMoveStringLiteralDfa5_0(active0, 0x300000ULL, active1, 0x2000ULL);
1647       case 110:
1648          if ((active0 & 0x800000ULL) != 0L)
1649          {
1650             jjmatchedKind = 23;
1651             jjmatchedPos = 4;
1652          }
1653          return jjMoveStringLiteralDfa5_0(active0, 0x40000000000ULL, active1, 0x40000000000ULL);
1654       case 111:
1655          return jjMoveStringLiteralDfa5_0(active0, 0x810000000ULL, active1, 0L);
1656       case 112:
1657          if ((active0 & 0x2000000000000ULL) != 0L)
1658          {
1659             jjmatchedKind = 49;
1660             jjmatchedPos = 4;
1661          }
1662          else if ((active1 & 0x40000000000000ULL) != 0L)
1663          {
1664             jjmatchedKind = 118;
1665             jjmatchedPos = 4;
1666          }
1667          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x8000ULL);
1668       case 114:
1669          if ((active0 & 0x2000ULL) != 0L)
1670          {
1671             jjmatchedKind = 13;
1672             jjmatchedPos = 4;
1673          }
1674          else if ((active0 & 0x200000000ULL) != 0L)
1675          {
1676             jjmatchedKind = 33;
1677             jjmatchedPos = 4;
1678          }
1679          return jjMoveStringLiteralDfa5_0(active0, 0x1011800000080000ULL, active1, 0x92c400400ULL);
1680       case 115:
1681          if ((active0 & 0x4000ULL) != 0L)
1682          {
1683             jjmatchedKind = 14;
1684             jjmatchedPos = 4;
1685          }
1686          else if ((active1 & 0x2000000000000ULL) != 0L)
1687          {
1688             jjmatchedKind = 113;
1689             jjmatchedPos = 4;
1690          }
1691          return jjMoveStringLiteralDfa5_0(active0, 0x1000ULL, active1, 0x400000800000ULL);
1692       case 116:
1693          if ((active0 & 0x80000000000000ULL) != 0L)
1694          {
1695             jjmatchedKind = 55;
1696             jjmatchedPos = 4;
1697          }
1698          else if ((active1 & 0x80000000000000ULL) != 0L)
1699          {
1700             jjmatchedKind = 119;
1701             jjmatchedPos = 4;
1702          }
1703          return jjMoveStringLiteralDfa5_0(active0, 0x40411080000000ULL, active1, 0L);
1704       case 117:
1705          return jjMoveStringLiteralDfa5_0(active0, 0x400000000ULL, active1, 0L);
1706       case 121:
1707          if ((active0 & 0x40000ULL) != 0L)
1708          {
1709             jjmatchedKind = 18;
1710             jjmatchedPos = 4;
1711          }
1712          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x80000000000ULL);
1713       default :
1714          break;
1715    }
1716    return jjMoveNfa_0(11, 4);
1717 }
1718 
jjMoveStringLiteralDfa5_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)1719  int  VhdlParserTokenManager::jjMoveStringLiteralDfa5_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
1720    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1721       return jjMoveNfa_0(11, 4);
1722    if (input_stream->endOfInput()) {
1723    return jjMoveNfa_0(11, 4);
1724    }
1725    curChar = input_stream->readChar();
1726    switch(curChar)
1727    {
1728       case 65:
1729          return jjMoveStringLiteralDfa6_0(active0, 0x1000800080000000ULL, active1, 0L);
1730       case 66:
1731          return jjMoveStringLiteralDfa6_0(active0, 0x400000ULL, active1, 0x10000000000000ULL);
1732       case 67:
1733          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x80000ULL);
1734       case 68:
1735          if ((active1 & 0x400000ULL) != 0L)
1736          {
1737             jjmatchedKind = 86;
1738             jjmatchedPos = 5;
1739          }
1740          else if ((active1 & 0x2000000000ULL) != 0L)
1741          {
1742             jjmatchedKind = 101;
1743             jjmatchedPos = 5;
1744          }
1745          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x10000ULL);
1746       case 69:
1747          if ((active0 & 0x100000ULL) != 0L)
1748          {
1749             jjmatchedKind = 20;
1750             jjmatchedPos = 5;
1751          }
1752          else if ((active0 & 0x10000000000000ULL) != 0L)
1753          {
1754             jjmatchedKind = 52;
1755             jjmatchedPos = 5;
1756          }
1757          return jjMoveStringLiteralDfa6_0(active0, 0x4040000200000ULL, active1, 0x1000000002000ULL);
1758       case 71:
1759          if ((active1 & 0x40000000000ULL) != 0L)
1760          {
1761             jjmatchedKind = 106;
1762             jjmatchedPos = 5;
1763          }
1764          return jjMoveStringLiteralDfa6_0(active0, 0x800000040000000ULL, active1, 0x1000ULL);
1765       case 73:
1766          return jjMoveStringLiteralDfa6_0(active0, 0x41400000000000ULL, active1, 0x80c000000ULL);
1767       case 76:
1768          if ((active1 & 0x1000000000ULL) != 0L)
1769          {
1770             jjmatchedKind = 100;
1771             jjmatchedPos = 5;
1772          }
1773          return jjMoveStringLiteralDfa6_0(active0, 0x400000000ULL, active1, 0L);
1774       case 78:
1775          if ((active1 & 0x100000000ULL) != 0L)
1776          {
1777             jjmatchedKind = 96;
1778             jjmatchedPos = 5;
1779          }
1780          return jjMoveStringLiteralDfa6_0(active0, 0x810000000ULL, active1, 0x400000000ULL);
1781       case 79:
1782          if ((active0 & 0x1000000000ULL) != 0L)
1783          {
1784             jjmatchedKind = 36;
1785             jjmatchedPos = 5;
1786          }
1787          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8000ULL);
1788       case 80:
1789          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x480000000000ULL);
1790       case 82:
1791          if ((active0 & 0x4000000ULL) != 0L)
1792          {
1793             jjmatchedKind = 26;
1794             jjmatchedPos = 5;
1795          }
1796          return jjMoveStringLiteralDfa6_0(active0, 0x400000000000000ULL, active1, 0x40000ULL);
1797       case 83:
1798          if ((active0 & 0x1000ULL) != 0L)
1799          {
1800             jjmatchedKind = 12;
1801             jjmatchedPos = 5;
1802          }
1803          else if ((active1 & 0x400ULL) != 0L)
1804          {
1805             jjmatchedKind = 74;
1806             jjmatchedPos = 5;
1807          }
1808          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2020000ULL);
1809       case 84:
1810          if ((active0 & 0x80000ULL) != 0L)
1811          {
1812             jjmatchedKind = 19;
1813             jjmatchedPos = 5;
1814          }
1815          else if ((active1 & 0x1000000ULL) != 0L)
1816          {
1817             jjmatchedKind = 88;
1818             jjmatchedPos = 5;
1819          }
1820          else if ((active1 & 0x20000000ULL) != 0L)
1821          {
1822             jjmatchedKind = 93;
1823             jjmatchedPos = 5;
1824          }
1825          else if ((active1 & 0x200000000ULL) != 0L)
1826          {
1827             jjmatchedKind = 97;
1828             jjmatchedPos = 5;
1829          }
1830          return jjMoveStringLiteralDfa6_0(active0, 0x20000ULL, active1, 0x800000ULL);
1831       case 88:
1832          return jjMoveStringLiteralDfa6_0(active0, 0x100000000ULL, active1, 0L);
1833       case 89:
1834          if ((active0 & 0x10000000000ULL) != 0L)
1835          {
1836             jjmatchedKind = 40;
1837             jjmatchedPos = 5;
1838          }
1839          break;
1840       case 97:
1841          return jjMoveStringLiteralDfa6_0(active0, 0x1000800080000000ULL, active1, 0L);
1842       case 98:
1843          return jjMoveStringLiteralDfa6_0(active0, 0x400000ULL, active1, 0x10000000000000ULL);
1844       case 99:
1845          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x80000ULL);
1846       case 100:
1847          if ((active1 & 0x400000ULL) != 0L)
1848          {
1849             jjmatchedKind = 86;
1850             jjmatchedPos = 5;
1851          }
1852          else if ((active1 & 0x2000000000ULL) != 0L)
1853          {
1854             jjmatchedKind = 101;
1855             jjmatchedPos = 5;
1856          }
1857          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x10000ULL);
1858       case 101:
1859          if ((active0 & 0x100000ULL) != 0L)
1860          {
1861             jjmatchedKind = 20;
1862             jjmatchedPos = 5;
1863          }
1864          else if ((active0 & 0x10000000000000ULL) != 0L)
1865          {
1866             jjmatchedKind = 52;
1867             jjmatchedPos = 5;
1868          }
1869          return jjMoveStringLiteralDfa6_0(active0, 0x4040000200000ULL, active1, 0x1000000002000ULL);
1870       case 103:
1871          if ((active1 & 0x40000000000ULL) != 0L)
1872          {
1873             jjmatchedKind = 106;
1874             jjmatchedPos = 5;
1875          }
1876          return jjMoveStringLiteralDfa6_0(active0, 0x800000040000000ULL, active1, 0x1000ULL);
1877       case 105:
1878          return jjMoveStringLiteralDfa6_0(active0, 0x41400000000000ULL, active1, 0x80c000000ULL);
1879       case 108:
1880          if ((active1 & 0x1000000000ULL) != 0L)
1881          {
1882             jjmatchedKind = 100;
1883             jjmatchedPos = 5;
1884          }
1885          return jjMoveStringLiteralDfa6_0(active0, 0x400000000ULL, active1, 0L);
1886       case 110:
1887          if ((active1 & 0x100000000ULL) != 0L)
1888          {
1889             jjmatchedKind = 96;
1890             jjmatchedPos = 5;
1891          }
1892          return jjMoveStringLiteralDfa6_0(active0, 0x810000000ULL, active1, 0x400000000ULL);
1893       case 111:
1894          if ((active0 & 0x1000000000ULL) != 0L)
1895          {
1896             jjmatchedKind = 36;
1897             jjmatchedPos = 5;
1898          }
1899          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8000ULL);
1900       case 112:
1901          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x480000000000ULL);
1902       case 114:
1903          if ((active0 & 0x4000000ULL) != 0L)
1904          {
1905             jjmatchedKind = 26;
1906             jjmatchedPos = 5;
1907          }
1908          return jjMoveStringLiteralDfa6_0(active0, 0x400000000000000ULL, active1, 0x40000ULL);
1909       case 115:
1910          if ((active0 & 0x1000ULL) != 0L)
1911          {
1912             jjmatchedKind = 12;
1913             jjmatchedPos = 5;
1914          }
1915          else if ((active1 & 0x400ULL) != 0L)
1916          {
1917             jjmatchedKind = 74;
1918             jjmatchedPos = 5;
1919          }
1920          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2020000ULL);
1921       case 116:
1922          if ((active0 & 0x80000ULL) != 0L)
1923          {
1924             jjmatchedKind = 19;
1925             jjmatchedPos = 5;
1926          }
1927          else if ((active1 & 0x1000000ULL) != 0L)
1928          {
1929             jjmatchedKind = 88;
1930             jjmatchedPos = 5;
1931          }
1932          else if ((active1 & 0x20000000ULL) != 0L)
1933          {
1934             jjmatchedKind = 93;
1935             jjmatchedPos = 5;
1936          }
1937          else if ((active1 & 0x200000000ULL) != 0L)
1938          {
1939             jjmatchedKind = 97;
1940             jjmatchedPos = 5;
1941          }
1942          return jjMoveStringLiteralDfa6_0(active0, 0x20000ULL, active1, 0x800000ULL);
1943       case 120:
1944          return jjMoveStringLiteralDfa6_0(active0, 0x100000000ULL, active1, 0L);
1945       case 121:
1946          if ((active0 & 0x10000000000ULL) != 0L)
1947          {
1948             jjmatchedKind = 40;
1949             jjmatchedPos = 5;
1950          }
1951          break;
1952       default :
1953          break;
1954    }
1955    return jjMoveNfa_0(11, 5);
1956 }
1957 
jjMoveStringLiteralDfa6_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)1958  int  VhdlParserTokenManager::jjMoveStringLiteralDfa6_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
1959    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1960       return jjMoveNfa_0(11, 5);
1961    if (input_stream->endOfInput()) {
1962    return jjMoveNfa_0(11, 5);
1963    }
1964    curChar = input_stream->readChar();
1965    switch(curChar)
1966    {
1967       case 65:
1968          return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000ULL, active1, 0L);
1969       case 67:
1970          if ((active0 & 0x1000000000000ULL) != 0L)
1971          {
1972             jjmatchedKind = 48;
1973             jjmatchedPos = 6;
1974          }
1975          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x100040c000000ULL);
1976       case 68:
1977          if ((active0 & 0x4000000000000ULL) != 0L)
1978          {
1979             jjmatchedKind = 50;
1980             jjmatchedPos = 6;
1981          }
1982          break;
1983       case 69:
1984          if ((active0 & 0x800000000000000ULL) != 0L)
1985          {
1986             jjmatchedKind = 59;
1987             jjmatchedPos = 6;
1988          }
1989          else if ((active1 & 0x1000ULL) != 0L)
1990          {
1991             jjmatchedKind = 76;
1992             jjmatchedPos = 6;
1993          }
1994          else if ((active1 & 0x2000000ULL) != 0L)
1995          {
1996             jjmatchedKind = 89;
1997             jjmatchedPos = 6;
1998          }
1999          else if ((active1 & 0x80000000000ULL) != 0L)
2000          {
2001             jjmatchedKind = 107;
2002             jjmatchedPos = 6;
2003          }
2004          return jjMoveStringLiteralDfa7_0(active0, 0x10020000ULL, active1, 0x800000ULL);
2005       case 76:
2006          if ((active0 & 0x1000000000000000ULL) != 0L)
2007          {
2008             jjmatchedKind = 60;
2009             jjmatchedPos = 6;
2010          }
2011          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x10000000000000ULL);
2012       case 78:
2013          return jjMoveStringLiteralDfa7_0(active0, 0x880000000ULL, active1, 0x8000ULL);
2014       case 79:
2015          return jjMoveStringLiteralDfa7_0(active0, 0x400000000000ULL, active1, 0x400000000000ULL);
2016       case 83:
2017          if ((active1 & 0x20000ULL) != 0L)
2018          {
2019             jjmatchedKind = 81;
2020             jjmatchedPos = 6;
2021          }
2022          return jjMoveStringLiteralDfa7_0(active0, 0x40000000000ULL, active1, 0L);
2023       case 84:
2024          if ((active0 & 0x100000000ULL) != 0L)
2025          {
2026             jjmatchedKind = 32;
2027             jjmatchedPos = 6;
2028          }
2029          else if ((active0 & 0x400000000ULL) != 0L)
2030          {
2031             jjmatchedKind = 34;
2032             jjmatchedPos = 6;
2033          }
2034          return jjMoveStringLiteralDfa7_0(active0, 0x800000000000ULL, active1, 0x8000c2000ULL);
2035       case 85:
2036          return jjMoveStringLiteralDfa7_0(active0, 0x40400000ULL, active1, 0x10000ULL);
2037       case 89:
2038          if ((active0 & 0x400000000000000ULL) != 0L)
2039          {
2040             jjmatchedKind = 58;
2041             jjmatchedPos = 6;
2042          }
2043          break;
2044       case 95:
2045          return jjMoveStringLiteralDfa7_0(active0, 0x200000ULL, active1, 0L);
2046       case 97:
2047          return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000ULL, active1, 0L);
2048       case 99:
2049          if ((active0 & 0x1000000000000ULL) != 0L)
2050          {
2051             jjmatchedKind = 48;
2052             jjmatchedPos = 6;
2053          }
2054          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x100040c000000ULL);
2055       case 100:
2056          if ((active0 & 0x4000000000000ULL) != 0L)
2057          {
2058             jjmatchedKind = 50;
2059             jjmatchedPos = 6;
2060          }
2061          break;
2062       case 101:
2063          if ((active0 & 0x800000000000000ULL) != 0L)
2064          {
2065             jjmatchedKind = 59;
2066             jjmatchedPos = 6;
2067          }
2068          else if ((active1 & 0x1000ULL) != 0L)
2069          {
2070             jjmatchedKind = 76;
2071             jjmatchedPos = 6;
2072          }
2073          else if ((active1 & 0x2000000ULL) != 0L)
2074          {
2075             jjmatchedKind = 89;
2076             jjmatchedPos = 6;
2077          }
2078          else if ((active1 & 0x80000000000ULL) != 0L)
2079          {
2080             jjmatchedKind = 107;
2081             jjmatchedPos = 6;
2082          }
2083          return jjMoveStringLiteralDfa7_0(active0, 0x10020000ULL, active1, 0x800000ULL);
2084       case 108:
2085          if ((active0 & 0x1000000000000000ULL) != 0L)
2086          {
2087             jjmatchedKind = 60;
2088             jjmatchedPos = 6;
2089          }
2090          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x10000000000000ULL);
2091       case 110:
2092          return jjMoveStringLiteralDfa7_0(active0, 0x880000000ULL, active1, 0x8000ULL);
2093       case 111:
2094          return jjMoveStringLiteralDfa7_0(active0, 0x400000000000ULL, active1, 0x400000000000ULL);
2095       case 115:
2096          if ((active1 & 0x20000ULL) != 0L)
2097          {
2098             jjmatchedKind = 81;
2099             jjmatchedPos = 6;
2100          }
2101          return jjMoveStringLiteralDfa7_0(active0, 0x40000000000ULL, active1, 0L);
2102       case 116:
2103          if ((active0 & 0x100000000ULL) != 0L)
2104          {
2105             jjmatchedKind = 32;
2106             jjmatchedPos = 6;
2107          }
2108          else if ((active0 & 0x400000000ULL) != 0L)
2109          {
2110             jjmatchedKind = 34;
2111             jjmatchedPos = 6;
2112          }
2113          return jjMoveStringLiteralDfa7_0(active0, 0x800000000000ULL, active1, 0x8000c2000ULL);
2114       case 117:
2115          return jjMoveStringLiteralDfa7_0(active0, 0x40400000ULL, active1, 0x10000ULL);
2116       case 121:
2117          if ((active0 & 0x400000000000000ULL) != 0L)
2118          {
2119             jjmatchedKind = 58;
2120             jjmatchedPos = 6;
2121          }
2122          break;
2123       default :
2124          break;
2125    }
2126    return jjMoveNfa_0(11, 6);
2127 }
2128 
jjMoveStringLiteralDfa7_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2129  int  VhdlParserTokenManager::jjMoveStringLiteralDfa7_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2130    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2131       return jjMoveNfa_0(11, 6);
2132    if (input_stream->endOfInput()) {
2133    return jjMoveNfa_0(11, 6);
2134    }
2135    curChar = input_stream->readChar();
2136    switch(curChar)
2137    {
2138       case 67:
2139          return jjMoveStringLiteralDfa8_0(active0, 0x20000ULL, active1, 0L);
2140       case 69:
2141          if ((active0 & 0x800000000000ULL) != 0L)
2142          {
2143             jjmatchedKind = 47;
2144             jjmatchedPos = 7;
2145          }
2146          else if ((active1 & 0x400000000ULL) != 0L)
2147          {
2148             jjmatchedKind = 98;
2149             jjmatchedPos = 7;
2150          }
2151          else if ((active1 & 0x10000000000000ULL) != 0L)
2152          {
2153             jjmatchedKind = 116;
2154             jjmatchedPos = 7;
2155          }
2156          return jjMoveStringLiteralDfa8_0(active0, 0x800000000ULL, active1, 0x8a000ULL);
2157       case 71:
2158          return jjMoveStringLiteralDfa8_0(active0, 0x200000ULL, active1, 0L);
2159       case 76:
2160          if ((active0 & 0x40000000000000ULL) != 0L)
2161          {
2162             jjmatchedKind = 54;
2163             jjmatchedPos = 7;
2164          }
2165          break;
2166       case 78:
2167          if ((active0 & 0x400000000000ULL) != 0L)
2168          {
2169             jjmatchedKind = 46;
2170             jjmatchedPos = 7;
2171          }
2172          return jjMoveStringLiteralDfa8_0(active0, 0x10000000ULL, active1, 0L);
2173       case 82:
2174          if ((active1 & 0x800000ULL) != 0L)
2175          {
2176             jjmatchedKind = 87;
2177             jjmatchedPos = 7;
2178          }
2179          return jjMoveStringLiteralDfa8_0(active0, 0x40000000ULL, active1, 0x400000010000ULL);
2180       case 83:
2181          if ((active0 & 0x40000000000ULL) != 0L)
2182          {
2183             jjmatchedKind = 42;
2184             jjmatchedPos = 7;
2185          }
2186          break;
2187       case 84:
2188          if ((active0 & 0x80000000ULL) != 0L)
2189          {
2190             jjmatchedKind = 31;
2191             jjmatchedPos = 7;
2192          }
2193          else if ((active1 & 0x4000000ULL) != 0L)
2194          {
2195             jjmatchedKind = 90;
2196             jjmatchedPos = 7;
2197          }
2198          return jjMoveStringLiteralDfa8_0(active0, 0x400000ULL, active1, 0x1000008000000ULL);
2199       case 89:
2200          if ((active1 & 0x40000ULL) != 0L)
2201          {
2202             jjmatchedKind = 82;
2203             jjmatchedPos = 7;
2204          }
2205          else if ((active1 & 0x800000000ULL) != 0L)
2206          {
2207             jjmatchedKind = 99;
2208             jjmatchedPos = 7;
2209          }
2210          break;
2211       case 99:
2212          return jjMoveStringLiteralDfa8_0(active0, 0x20000ULL, active1, 0L);
2213       case 101:
2214          if ((active0 & 0x800000000000ULL) != 0L)
2215          {
2216             jjmatchedKind = 47;
2217             jjmatchedPos = 7;
2218          }
2219          else if ((active1 & 0x400000000ULL) != 0L)
2220          {
2221             jjmatchedKind = 98;
2222             jjmatchedPos = 7;
2223          }
2224          else if ((active1 & 0x10000000000000ULL) != 0L)
2225          {
2226             jjmatchedKind = 116;
2227             jjmatchedPos = 7;
2228          }
2229          return jjMoveStringLiteralDfa8_0(active0, 0x800000000ULL, active1, 0x8a000ULL);
2230       case 103:
2231          return jjMoveStringLiteralDfa8_0(active0, 0x200000ULL, active1, 0L);
2232       case 108:
2233          if ((active0 & 0x40000000000000ULL) != 0L)
2234          {
2235             jjmatchedKind = 54;
2236             jjmatchedPos = 7;
2237          }
2238          break;
2239       case 110:
2240          if ((active0 & 0x400000000000ULL) != 0L)
2241          {
2242             jjmatchedKind = 46;
2243             jjmatchedPos = 7;
2244          }
2245          return jjMoveStringLiteralDfa8_0(active0, 0x10000000ULL, active1, 0L);
2246       case 114:
2247          if ((active1 & 0x800000ULL) != 0L)
2248          {
2249             jjmatchedKind = 87;
2250             jjmatchedPos = 7;
2251          }
2252          return jjMoveStringLiteralDfa8_0(active0, 0x40000000ULL, active1, 0x400000010000ULL);
2253       case 115:
2254          if ((active0 & 0x40000000000ULL) != 0L)
2255          {
2256             jjmatchedKind = 42;
2257             jjmatchedPos = 7;
2258          }
2259          break;
2260       case 116:
2261          if ((active0 & 0x80000000ULL) != 0L)
2262          {
2263             jjmatchedKind = 31;
2264             jjmatchedPos = 7;
2265          }
2266          else if ((active1 & 0x4000000ULL) != 0L)
2267          {
2268             jjmatchedKind = 90;
2269             jjmatchedPos = 7;
2270          }
2271          return jjMoveStringLiteralDfa8_0(active0, 0x400000ULL, active1, 0x1000008000000ULL);
2272       case 121:
2273          if ((active1 & 0x40000ULL) != 0L)
2274          {
2275             jjmatchedKind = 82;
2276             jjmatchedPos = 7;
2277          }
2278          else if ((active1 & 0x800000000ULL) != 0L)
2279          {
2280             jjmatchedKind = 99;
2281             jjmatchedPos = 7;
2282          }
2283          break;
2284       default :
2285          break;
2286    }
2287    return jjMoveNfa_0(11, 7);
2288 }
2289 
jjMoveStringLiteralDfa8_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2290  int  VhdlParserTokenManager::jjMoveStringLiteralDfa8_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2291    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2292       return jjMoveNfa_0(11, 7);
2293    if (input_stream->endOfInput()) {
2294    return jjMoveNfa_0(11, 7);
2295    }
2296    curChar = input_stream->readChar();
2297    switch(curChar)
2298    {
2299       case 65:
2300          return jjMoveStringLiteralDfa9_0(active0, 0x40000000ULL, active1, 0L);
2301       case 67:
2302          return jjMoveStringLiteralDfa9_0(active0, 0x800000000ULL, active1, 0L);
2303       case 68:
2304          if ((active1 & 0x8000ULL) != 0L)
2305          {
2306             jjmatchedKind = 79;
2307             jjmatchedPos = 8;
2308          }
2309          else if ((active1 & 0x80000ULL) != 0L)
2310          {
2311             jjmatchedKind = 83;
2312             jjmatchedPos = 8;
2313          }
2314          break;
2315       case 69:
2316          if ((active0 & 0x400000ULL) != 0L)
2317          {
2318             jjmatchedKind = 22;
2319             jjmatchedPos = 8;
2320          }
2321          else if ((active1 & 0x10000ULL) != 0L)
2322          {
2323             jjmatchedKind = 80;
2324             jjmatchedPos = 8;
2325          }
2326          return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000ULL);
2327       case 82:
2328          if ((active1 & 0x2000ULL) != 0L)
2329          {
2330             jjmatchedKind = 77;
2331             jjmatchedPos = 8;
2332          }
2333          break;
2334       case 84:
2335          if ((active0 & 0x10000000ULL) != 0L)
2336          {
2337             jjmatchedKind = 28;
2338             jjmatchedPos = 8;
2339          }
2340          else if ((active1 & 0x400000000000ULL) != 0L)
2341          {
2342             jjmatchedKind = 110;
2343             jjmatchedPos = 8;
2344          }
2345          return jjMoveStringLiteralDfa9_0(active0, 0x20000ULL, active1, 0L);
2346       case 85:
2347          return jjMoveStringLiteralDfa9_0(active0, 0x200000ULL, active1, 0L);
2348       case 95:
2349          return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x8000000ULL);
2350       case 97:
2351          return jjMoveStringLiteralDfa9_0(active0, 0x40000000ULL, active1, 0L);
2352       case 99:
2353          return jjMoveStringLiteralDfa9_0(active0, 0x800000000ULL, active1, 0L);
2354       case 100:
2355          if ((active1 & 0x8000ULL) != 0L)
2356          {
2357             jjmatchedKind = 79;
2358             jjmatchedPos = 8;
2359          }
2360          else if ((active1 & 0x80000ULL) != 0L)
2361          {
2362             jjmatchedKind = 83;
2363             jjmatchedPos = 8;
2364          }
2365          break;
2366       case 101:
2367          if ((active0 & 0x400000ULL) != 0L)
2368          {
2369             jjmatchedKind = 22;
2370             jjmatchedPos = 8;
2371          }
2372          else if ((active1 & 0x10000ULL) != 0L)
2373          {
2374             jjmatchedKind = 80;
2375             jjmatchedPos = 8;
2376          }
2377          return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000ULL);
2378       case 114:
2379          if ((active1 & 0x2000ULL) != 0L)
2380          {
2381             jjmatchedKind = 77;
2382             jjmatchedPos = 8;
2383          }
2384          break;
2385       case 116:
2386          if ((active0 & 0x10000000ULL) != 0L)
2387          {
2388             jjmatchedKind = 28;
2389             jjmatchedPos = 8;
2390          }
2391          else if ((active1 & 0x400000000000ULL) != 0L)
2392          {
2393             jjmatchedKind = 110;
2394             jjmatchedPos = 8;
2395          }
2396          return jjMoveStringLiteralDfa9_0(active0, 0x20000ULL, active1, 0L);
2397       case 117:
2398          return jjMoveStringLiteralDfa9_0(active0, 0x200000ULL, active1, 0L);
2399       default :
2400          break;
2401    }
2402    return jjMoveNfa_0(11, 8);
2403 }
2404 
jjMoveStringLiteralDfa9_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2405  int  VhdlParserTokenManager::jjMoveStringLiteralDfa9_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2406    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2407       return jjMoveNfa_0(11, 8);
2408    if (input_stream->endOfInput()) {
2409    return jjMoveNfa_0(11, 8);
2410    }
2411    curChar = input_stream->readChar();
2412    switch(curChar)
2413    {
2414       case 65:
2415          return jjMoveStringLiteralDfa10_0(active0, 0x200000ULL, active1, 0L);
2416       case 68:
2417          if ((active1 & 0x1000000000000ULL) != 0L)
2418          {
2419             jjmatchedKind = 112;
2420             jjmatchedPos = 9;
2421          }
2422          break;
2423       case 71:
2424          return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000ULL);
2425       case 84:
2426          if ((active0 & 0x800000000ULL) != 0L)
2427          {
2428             jjmatchedKind = 35;
2429             jjmatchedPos = 9;
2430          }
2431          return jjMoveStringLiteralDfa10_0(active0, 0x40000000ULL, active1, 0L);
2432       case 85:
2433          return jjMoveStringLiteralDfa10_0(active0, 0x20000ULL, active1, 0L);
2434       case 97:
2435          return jjMoveStringLiteralDfa10_0(active0, 0x200000ULL, active1, 0L);
2436       case 100:
2437          if ((active1 & 0x1000000000000ULL) != 0L)
2438          {
2439             jjmatchedKind = 112;
2440             jjmatchedPos = 9;
2441          }
2442          break;
2443       case 103:
2444          return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000ULL);
2445       case 116:
2446          if ((active0 & 0x800000000ULL) != 0L)
2447          {
2448             jjmatchedKind = 35;
2449             jjmatchedPos = 9;
2450          }
2451          return jjMoveStringLiteralDfa10_0(active0, 0x40000000ULL, active1, 0L);
2452       case 117:
2453          return jjMoveStringLiteralDfa10_0(active0, 0x20000ULL, active1, 0L);
2454       default :
2455          break;
2456    }
2457    return jjMoveNfa_0(11, 9);
2458 }
2459 
jjMoveStringLiteralDfa10_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2460  int  VhdlParserTokenManager::jjMoveStringLiteralDfa10_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2461    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2462       return jjMoveNfa_0(11, 9);
2463    if (input_stream->endOfInput()) {
2464    return jjMoveNfa_0(11, 9);
2465    }
2466    curChar = input_stream->readChar();
2467    switch(curChar)
2468    {
2469       case 73:
2470          return jjMoveStringLiteralDfa11_0(active0, 0x40000000ULL, active1, 0L);
2471       case 82:
2472          return jjMoveStringLiteralDfa11_0(active0, 0x220000ULL, active1, 0L);
2473       case 85:
2474          return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x8000000ULL);
2475       case 105:
2476          return jjMoveStringLiteralDfa11_0(active0, 0x40000000ULL, active1, 0L);
2477       case 114:
2478          return jjMoveStringLiteralDfa11_0(active0, 0x220000ULL, active1, 0L);
2479       case 117:
2480          return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x8000000ULL);
2481       default :
2482          break;
2483    }
2484    return jjMoveNfa_0(11, 10);
2485 }
2486 
jjMoveStringLiteralDfa11_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2487  int  VhdlParserTokenManager::jjMoveStringLiteralDfa11_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2488    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2489       return jjMoveNfa_0(11, 10);
2490    if (input_stream->endOfInput()) {
2491    return jjMoveNfa_0(11, 10);
2492    }
2493    curChar = input_stream->readChar();
2494    switch(curChar)
2495    {
2496       case 65:
2497          return jjMoveStringLiteralDfa12_0(active0, 0x200000ULL, active1, 0x8000000ULL);
2498       case 69:
2499          if ((active0 & 0x20000ULL) != 0L)
2500          {
2501             jjmatchedKind = 17;
2502             jjmatchedPos = 11;
2503          }
2504          break;
2505       case 79:
2506          return jjMoveStringLiteralDfa12_0(active0, 0x40000000ULL, active1, 0L);
2507       case 97:
2508          return jjMoveStringLiteralDfa12_0(active0, 0x200000ULL, active1, 0x8000000ULL);
2509       case 101:
2510          if ((active0 & 0x20000ULL) != 0L)
2511          {
2512             jjmatchedKind = 17;
2513             jjmatchedPos = 11;
2514          }
2515          break;
2516       case 111:
2517          return jjMoveStringLiteralDfa12_0(active0, 0x40000000ULL, active1, 0L);
2518       default :
2519          break;
2520    }
2521    return jjMoveNfa_0(11, 11);
2522 }
2523 
jjMoveStringLiteralDfa12_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2524  int  VhdlParserTokenManager::jjMoveStringLiteralDfa12_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2525    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2526       return jjMoveNfa_0(11, 11);
2527    if (input_stream->endOfInput()) {
2528    return jjMoveNfa_0(11, 11);
2529    }
2530    curChar = input_stream->readChar();
2531    switch(curChar)
2532    {
2533       case 78:
2534          if ((active0 & 0x40000000ULL) != 0L)
2535          {
2536             jjmatchedKind = 30;
2537             jjmatchedPos = 12;
2538          }
2539          return jjMoveStringLiteralDfa13_0(active0, 0x200000ULL, active1, 0L);
2540       case 82:
2541          return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x8000000ULL);
2542       case 110:
2543          if ((active0 & 0x40000000ULL) != 0L)
2544          {
2545             jjmatchedKind = 30;
2546             jjmatchedPos = 12;
2547          }
2548          return jjMoveStringLiteralDfa13_0(active0, 0x200000ULL, active1, 0L);
2549       case 114:
2550          return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x8000000ULL);
2551       default :
2552          break;
2553    }
2554    return jjMoveNfa_0(11, 12);
2555 }
2556 
jjMoveStringLiteralDfa13_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2557  int  VhdlParserTokenManager::jjMoveStringLiteralDfa13_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2558    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2559       return jjMoveNfa_0(11, 12);
2560    if (input_stream->endOfInput()) {
2561    return jjMoveNfa_0(11, 12);
2562    }
2563    curChar = input_stream->readChar();
2564    switch(curChar)
2565    {
2566       case 65:
2567          return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x8000000ULL);
2568       case 84:
2569          return jjMoveStringLiteralDfa14_0(active0, 0x200000ULL, active1, 0L);
2570       case 97:
2571          return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x8000000ULL);
2572       case 116:
2573          return jjMoveStringLiteralDfa14_0(active0, 0x200000ULL, active1, 0L);
2574       default :
2575          break;
2576    }
2577    return jjMoveNfa_0(11, 13);
2578 }
2579 
jjMoveStringLiteralDfa14_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2580  int  VhdlParserTokenManager::jjMoveStringLiteralDfa14_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2581    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2582       return jjMoveNfa_0(11, 13);
2583    if (input_stream->endOfInput()) {
2584    return jjMoveNfa_0(11, 13);
2585    }
2586    curChar = input_stream->readChar();
2587    switch(curChar)
2588    {
2589       case 69:
2590          return jjMoveStringLiteralDfa15_0(active0, 0x200000ULL, active1, 0L);
2591       case 78:
2592          return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x8000000ULL);
2593       case 101:
2594          return jjMoveStringLiteralDfa15_0(active0, 0x200000ULL, active1, 0L);
2595       case 110:
2596          return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x8000000ULL);
2597       default :
2598          break;
2599    }
2600    return jjMoveNfa_0(11, 14);
2601 }
2602 
jjMoveStringLiteralDfa15_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2603  int  VhdlParserTokenManager::jjMoveStringLiteralDfa15_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2604    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2605       return jjMoveNfa_0(11, 14);
2606    if (input_stream->endOfInput()) {
2607    return jjMoveNfa_0(11, 14);
2608    }
2609    curChar = input_stream->readChar();
2610    switch(curChar)
2611    {
2612       case 69:
2613          if ((active0 & 0x200000ULL) != 0L)
2614          {
2615             jjmatchedKind = 21;
2616             jjmatchedPos = 15;
2617          }
2618          break;
2619       case 84:
2620          return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x8000000ULL);
2621       case 101:
2622          if ((active0 & 0x200000ULL) != 0L)
2623          {
2624             jjmatchedKind = 21;
2625             jjmatchedPos = 15;
2626          }
2627          break;
2628       case 116:
2629          return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x8000000ULL);
2630       default :
2631          break;
2632    }
2633    return jjMoveNfa_0(11, 15);
2634 }
2635 
jjMoveStringLiteralDfa16_0(unsigned long long old0,unsigned long long active0,unsigned long long old1,unsigned long long active1)2636  int  VhdlParserTokenManager::jjMoveStringLiteralDfa16_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1){
2637    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2638       return jjMoveNfa_0(11, 15);
2639    if (input_stream->endOfInput()) {
2640    return jjMoveNfa_0(11, 15);
2641    }
2642    curChar = input_stream->readChar();
2643    switch(curChar)
2644    {
2645       case 69:
2646          return jjMoveStringLiteralDfa17_0(active1, 0x8000000ULL);
2647       case 101:
2648          return jjMoveStringLiteralDfa17_0(active1, 0x8000000ULL);
2649       default :
2650          break;
2651    }
2652    return jjMoveNfa_0(11, 16);
2653 }
2654 
jjMoveStringLiteralDfa17_0(unsigned long long old1,unsigned long long active1)2655  int  VhdlParserTokenManager::jjMoveStringLiteralDfa17_0(unsigned long long old1, unsigned long long active1){
2656    if (((active1 &= old1)) == 0L)
2657       return jjMoveNfa_0(11, 16);
2658    if (input_stream->endOfInput()) {
2659    return jjMoveNfa_0(11, 16);
2660    }
2661    curChar = input_stream->readChar();
2662    switch(curChar)
2663    {
2664       case 69:
2665          if ((active1 & 0x8000000ULL) != 0L)
2666          {
2667             jjmatchedKind = 91;
2668             jjmatchedPos = 17;
2669          }
2670          break;
2671       case 101:
2672          if ((active1 & 0x8000000ULL) != 0L)
2673          {
2674             jjmatchedKind = 91;
2675             jjmatchedPos = 17;
2676          }
2677          break;
2678       default :
2679          break;
2680    }
2681    return jjMoveNfa_0(11, 17);
2682 }
2683 
jjMoveNfa_0(int startState,int curPos)2684 int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
2685    int strKind = jjmatchedKind;
2686    int strPos = jjmatchedPos;
2687    int seenUpto;
2688    input_stream->backup(seenUpto = curPos + 1);
2689    assert(!input_stream->endOfInput());
2690    curChar = input_stream->readChar();
2691    curPos = 0;
2692    int startsAt = 0;
2693    jjnewStateCnt = 87;
2694    int i = 1;
2695    jjstateSet[0] = startState;
2696    int kind = 0x7fffffff;
2697    for (;;)
2698    {
2699       if (++jjround == 0x7fffffff)
2700          ReInitRounds();
2701       if (curChar < 64)
2702       {
2703          unsigned long long l = 1ULL << curChar;
2704          (void)l;
2705          do
2706          {
2707             switch(jjstateSet[--i])
2708             {
2709                case 11:
2710                   if ((0x3ff000000000000ULL & l) != 0L)
2711                   {
2712                      if (kind > 165)
2713                         kind = 165;
2714                      { jjCheckNAddStates(0, 12); }
2715                   }
2716                   else if ((0x100000200ULL & l) != 0L)
2717                      { jjCheckNAddTwoStates(0, 3); }
2718                   else if (curChar == 39)
2719                      { jjAddStates(13, 14); }
2720                   else if (curChar == 47)
2721                      { jjAddStates(15, 16); }
2722                   else if (curChar == 45)
2723                      { jjCheckNAddStates(17, 19); }
2724                   else if (curChar == 34)
2725                      { jjCheckNAddTwoStates(9, 10); }
2726                   if ((0x3ff000000000000ULL & l) != 0L)
2727                   {
2728                      if (kind > 171)
2729                         kind = 171;
2730                      { jjCheckNAdd(17); }
2731                   }
2732                   break;
2733                case 0:
2734                   if ((0x100000200ULL & l) != 0L)
2735                      { jjCheckNAddTwoStates(0, 3); }
2736                   break;
2737                case 1:
2738                   if (curChar != 33)
2739                      break;
2740                   if (kind > 6)
2741                      kind = 6;
2742                   { jjCheckNAddStates(20, 24); }
2743                   break;
2744                case 2:
2745                   if (curChar == 45)
2746                      jjstateSet[jjnewStateCnt++] = 1;
2747                   break;
2748                case 3:
2749                   if (curChar == 45)
2750                      { jjCheckNAdd(2); }
2751                   break;
2752                case 4:
2753                   if ((0xffffffffffffdbffULL & l) == 0L)
2754                      break;
2755                   if (kind > 6)
2756                      kind = 6;
2757                   { jjCheckNAddStates(20, 24); }
2758                   break;
2759                case 5:
2760                   if ((0x2400ULL & l) == 0L)
2761                      break;
2762                   if (kind > 6)
2763                      kind = 6;
2764                   { jjCheckNAddTwoStates(0, 3); }
2765                   break;
2766                case 6:
2767                   if (curChar != 10)
2768                      break;
2769                   if (kind > 6)
2770                      kind = 6;
2771                   { jjCheckNAddTwoStates(0, 3); }
2772                   break;
2773                case 7:
2774                   if (curChar == 13)
2775                      jjstateSet[jjnewStateCnt++] = 6;
2776                   break;
2777                case 8:
2778                   if (curChar == 34)
2779                      { jjCheckNAddTwoStates(9, 10); }
2780                   break;
2781                case 9:
2782                   if ((0xfffffffb00000200ULL & l) != 0L)
2783                      { jjCheckNAddTwoStates(9, 10); }
2784                   break;
2785                case 10:
2786                   if (curChar != 34)
2787                      break;
2788                   if (kind > 166)
2789                      kind = 166;
2790                   jjstateSet[jjnewStateCnt++] = 8;
2791                   break;
2792                case 13:
2793                   if ((0x3ff000000000000ULL & l) == 0L)
2794                      break;
2795                   if (kind > 167)
2796                      kind = 167;
2797                   { jjAddStates(25, 26); }
2798                   break;
2799                case 15:
2800                   if ((0xfffffffb00000200ULL & l) != 0L)
2801                      { jjAddStates(27, 28); }
2802                   break;
2803                case 17:
2804                   if ((0x3ff000000000000ULL & l) == 0L)
2805                      break;
2806                   if (kind > 171)
2807                      kind = 171;
2808                   { jjCheckNAdd(17); }
2809                   break;
2810                case 20:
2811                   if (curChar == 34)
2812                      { jjCheckNAdd(21); }
2813                   break;
2814                case 21:
2815                   if ((0x3ff200000000000ULL & l) != 0L)
2816                      { jjCheckNAddStates(29, 31); }
2817                   break;
2818                case 23:
2819                   if (curChar == 34 && kind > 180)
2820                      kind = 180;
2821                   break;
2822                case 25:
2823                   if (curChar == 34)
2824                      { jjCheckNAddTwoStates(26, 27); }
2825                   break;
2826                case 26:
2827                   if ((0xfffffffb00000200ULL & l) != 0L)
2828                      { jjCheckNAddTwoStates(26, 27); }
2829                   break;
2830                case 27:
2831                   if (curChar != 34)
2832                      break;
2833                   if (kind > 189)
2834                      kind = 189;
2835                   { jjCheckNAddTwoStates(25, 28); }
2836                   break;
2837                case 28:
2838                   if ((0xfffffffb00000200ULL & l) == 0L)
2839                      break;
2840                   if (kind > 189)
2841                      kind = 189;
2842                   { jjCheckNAddTwoStates(25, 28); }
2843                   break;
2844                case 29:
2845                   if (curChar == 45)
2846                      { jjCheckNAddStates(17, 19); }
2847                   break;
2848                case 30:
2849                   if (curChar != 35)
2850                      break;
2851                   if (kind > 7)
2852                      kind = 7;
2853                   { jjCheckNAddStates(32, 34); }
2854                   break;
2855                case 31:
2856                   if ((0xffffffffffffdbffULL & l) == 0L)
2857                      break;
2858                   if (kind > 7)
2859                      kind = 7;
2860                   { jjCheckNAddStates(32, 34); }
2861                   break;
2862                case 32:
2863                   if ((0x2400ULL & l) != 0L && kind > 7)
2864                      kind = 7;
2865                   break;
2866                case 33:
2867                   if (curChar == 10 && kind > 7)
2868                      kind = 7;
2869                   break;
2870                case 34:
2871                   if (curChar == 13)
2872                      jjstateSet[jjnewStateCnt++] = 33;
2873                   break;
2874                case 35:
2875                   if (curChar == 45)
2876                      jjstateSet[jjnewStateCnt++] = 30;
2877                   break;
2878                case 36:
2879                   if (curChar != 45)
2880                      break;
2881                   if (kind > 8)
2882                      kind = 8;
2883                   { jjCheckNAddStates(35, 37); }
2884                   break;
2885                case 37:
2886                   if ((0xffffffffffffdbffULL & l) == 0L)
2887                      break;
2888                   if (kind > 8)
2889                      kind = 8;
2890                   { jjCheckNAddStates(35, 37); }
2891                   break;
2892                case 38:
2893                   if ((0x2400ULL & l) != 0L && kind > 8)
2894                      kind = 8;
2895                   break;
2896                case 39:
2897                   if (curChar == 10 && kind > 8)
2898                      kind = 8;
2899                   break;
2900                case 40:
2901                   if (curChar == 13)
2902                      jjstateSet[jjnewStateCnt++] = 39;
2903                   break;
2904                case 41:
2905                   if (curChar == 47)
2906                      { jjAddStates(15, 16); }
2907                   break;
2908                case 42:
2909                   if (curChar == 33)
2910                      { jjCheckNAddTwoStates(43, 44); }
2911                   break;
2912                case 43:
2913                   if ((0xfffffbffffffffffULL & l) != 0L)
2914                      { jjCheckNAddTwoStates(43, 44); }
2915                   break;
2916                case 44:
2917                   if (curChar == 42)
2918                      { jjCheckNAddStates(38, 40); }
2919                   break;
2920                case 45:
2921                   if ((0xffff7bffffffffffULL & l) != 0L)
2922                      { jjCheckNAddTwoStates(46, 44); }
2923                   break;
2924                case 46:
2925                   if ((0xfffffbffffffffffULL & l) != 0L)
2926                      { jjCheckNAddTwoStates(46, 44); }
2927                   break;
2928                case 47:
2929                   if (curChar == 47 && kind > 9)
2930                      kind = 9;
2931                   break;
2932                case 48:
2933                   if (curChar == 42)
2934                      jjstateSet[jjnewStateCnt++] = 42;
2935                   break;
2936                case 49:
2937                   if (curChar == 42)
2938                      { jjCheckNAddTwoStates(50, 51); }
2939                   break;
2940                case 50:
2941                   if ((0xfffffbffffffffffULL & l) != 0L)
2942                      { jjCheckNAddTwoStates(50, 51); }
2943                   break;
2944                case 51:
2945                   if (curChar == 42)
2946                      { jjCheckNAddStates(41, 43); }
2947                   break;
2948                case 52:
2949                   if ((0xffff7bffffffffffULL & l) != 0L)
2950                      { jjCheckNAddTwoStates(53, 51); }
2951                   break;
2952                case 53:
2953                   if ((0xfffffbffffffffffULL & l) != 0L)
2954                      { jjCheckNAddTwoStates(53, 51); }
2955                   break;
2956                case 54:
2957                   if (curChar == 47 && kind > 10)
2958                      kind = 10;
2959                   break;
2960                case 55:
2961                   if ((0x3ff000000000000ULL & l) == 0L)
2962                      break;
2963                   if (kind > 165)
2964                      kind = 165;
2965                   { jjCheckNAddStates(0, 12); }
2966                   break;
2967                case 57:
2968                   if ((0x3ff000000000000ULL & l) == 0L)
2969                      break;
2970                   if (kind > 165)
2971                      kind = 165;
2972                   { jjCheckNAddTwoStates(56, 57); }
2973                   break;
2974                case 59:
2975                   if ((0x3ff000000000000ULL & l) == 0L)
2976                      break;
2977                   if (kind > 170)
2978                      kind = 170;
2979                   { jjCheckNAddStates(44, 47); }
2980                   break;
2981                case 60:
2982                   if (curChar == 46)
2983                      { jjCheckNAdd(61); }
2984                   break;
2985                case 61:
2986                   if ((0x3ff000000000000ULL & l) == 0L)
2987                      break;
2988                   if (kind > 170)
2989                      kind = 170;
2990                   { jjCheckNAddStates(48, 50); }
2991                   break;
2992                case 64:
2993                   if ((0x280000000000ULL & l) != 0L)
2994                      { jjCheckNAdd(65); }
2995                   break;
2996                case 65:
2997                   if ((0x3ff000000000000ULL & l) == 0L)
2998                      break;
2999                   if (kind > 170)
3000                      kind = 170;
3001                   { jjCheckNAddTwoStates(66, 65); }
3002                   break;
3003                case 68:
3004                   if ((0x3ff000000000000ULL & l) != 0L)
3005                      { jjCheckNAddStates(51, 53); }
3006                   break;
3007                case 69:
3008                   if (curChar == 35)
3009                      { jjCheckNAdd(70); }
3010                   break;
3011                case 70:
3012                   if ((0x3ff000000000000ULL & l) != 0L)
3013                      { jjCheckNAddStates(54, 56); }
3014                   break;
3015                case 71:
3016                   if (curChar == 46)
3017                      { jjCheckNAdd(72); }
3018                   break;
3019                case 72:
3020                   if ((0x3ff000000000000ULL & l) != 0L)
3021                      { jjCheckNAddTwoStates(72, 73); }
3022                   break;
3023                case 73:
3024                   if (curChar != 35)
3025                      break;
3026                   if (kind > 172)
3027                      kind = 172;
3028                   jjstateSet[jjnewStateCnt++] = 74;
3029                   break;
3030                case 75:
3031                   if ((0x280000000000ULL & l) != 0L)
3032                      { jjCheckNAdd(76); }
3033                   break;
3034                case 76:
3035                   if ((0x3ff000000000000ULL & l) == 0L)
3036                      break;
3037                   if (kind > 172)
3038                      kind = 172;
3039                   { jjCheckNAddTwoStates(77, 76); }
3040                   break;
3041                case 78:
3042                   if ((0x3ff000000000000ULL & l) != 0L)
3043                      { jjCheckNAddStates(57, 59); }
3044                   break;
3045                case 79:
3046                   if ((0x3ff000000000000ULL & l) != 0L)
3047                      { jjCheckNAddStates(60, 63); }
3048                   break;
3049                case 80:
3050                   if (curChar == 39)
3051                      { jjAddStates(13, 14); }
3052                   break;
3053                case 81:
3054                   if ((0xffffffff00000200ULL & l) != 0L)
3055                      jjstateSet[jjnewStateCnt++] = 82;
3056                   break;
3057                case 82:
3058                   if (curChar == 39 && kind > 169)
3059                      kind = 169;
3060                   break;
3061                case 83:
3062                   if (curChar == 40)
3063                      jjstateSet[jjnewStateCnt++] = 84;
3064                   break;
3065                case 84:
3066                   if (curChar == 39)
3067                      jjstateSet[jjnewStateCnt++] = 85;
3068                   break;
3069                case 85:
3070                   if ((0xfffffffb00000200ULL & l) != 0L)
3071                      jjstateSet[jjnewStateCnt++] = 86;
3072                   break;
3073                case 86:
3074                   if (curChar == 39 && kind > 190)
3075                      kind = 190;
3076                   break;
3077                default : break;
3078             }
3079          } while(i != startsAt);
3080       }
3081       else if (curChar < 128)
3082       {
3083          unsigned long long l = 1ULL << (curChar & 077);
3084          (void)l;
3085          do
3086          {
3087             switch(jjstateSet[--i])
3088             {
3089                case 11:
3090                   if ((0x7fffffe07fffffeULL & l) != 0L)
3091                   {
3092                      if (kind > 171)
3093                         kind = 171;
3094                      { jjCheckNAdd(17); }
3095                   }
3096                   else if (curChar == 96)
3097                      { jjCheckNAddTwoStates(25, 28); }
3098                   else if (curChar == 92)
3099                      { jjCheckNAddTwoStates(15, 16); }
3100                   if ((0x7fffffe07fffffeULL & l) != 0L)
3101                   {
3102                      if (kind > 167)
3103                         kind = 167;
3104                      { jjCheckNAddTwoStates(12, 13); }
3105                   }
3106                   if ((0x100801401008014ULL & l) != 0L)
3107                      jjstateSet[jjnewStateCnt++] = 20;
3108                   else if ((0x280000ULL & l) != 0L)
3109                      { jjCheckNAddTwoStates(18, 19); }
3110                   break;
3111                case 4:
3112                   if (kind > 6)
3113                      kind = 6;
3114                   { jjAddStates(20, 24); }
3115                   break;
3116                case 9:
3117                   if ((0x7fffffffffffffffULL & l) != 0L)
3118                      { jjAddStates(64, 65); }
3119                   break;
3120                case 12:
3121                   if (curChar == 95)
3122                      { jjCheckNAddTwoStates(12, 13); }
3123                   break;
3124                case 13:
3125                   if ((0x7fffffe07fffffeULL & l) == 0L)
3126                      break;
3127                   if (kind > 167)
3128                      kind = 167;
3129                   { jjCheckNAddTwoStates(12, 13); }
3130                   break;
3131                case 14:
3132                   if (curChar == 92)
3133                      { jjCheckNAddTwoStates(15, 16); }
3134                   break;
3135                case 15:
3136                   if ((0x7fffffffffffffffULL & l) != 0L)
3137                      { jjCheckNAddTwoStates(15, 16); }
3138                   break;
3139                case 16:
3140                   if (curChar == 92 && kind > 168)
3141                      kind = 168;
3142                   break;
3143                case 17:
3144                   if ((0x7fffffe07fffffeULL & l) == 0L)
3145                      break;
3146                   if (kind > 171)
3147                      kind = 171;
3148                   { jjCheckNAdd(17); }
3149                   break;
3150                case 18:
3151                   if ((0x280000ULL & l) != 0L)
3152                      { jjCheckNAddTwoStates(18, 19); }
3153                   break;
3154                case 19:
3155                   if ((0x100801401008014ULL & l) != 0L)
3156                      jjstateSet[jjnewStateCnt++] = 20;
3157                   break;
3158                case 21:
3159                   if ((0x7fffffe07fffffeULL & l) != 0L)
3160                      { jjCheckNAddStates(29, 31); }
3161                   break;
3162                case 22:
3163                   if (curChar == 95)
3164                      { jjCheckNAddTwoStates(22, 21); }
3165                   break;
3166                case 24:
3167                   if (curChar == 96)
3168                      { jjCheckNAddTwoStates(25, 28); }
3169                   break;
3170                case 26:
3171                   if ((0x7fffffffffffffffULL & l) != 0L)
3172                      { jjAddStates(66, 67); }
3173                   break;
3174                case 28:
3175                   if ((0x7fffffffffffffffULL & l) == 0L)
3176                      break;
3177                   if (kind > 189)
3178                      kind = 189;
3179                   { jjCheckNAddTwoStates(25, 28); }
3180                   break;
3181                case 31:
3182                   if (kind > 7)
3183                      kind = 7;
3184                   { jjAddStates(32, 34); }
3185                   break;
3186                case 37:
3187                   if (kind > 8)
3188                      kind = 8;
3189                   { jjAddStates(35, 37); }
3190                   break;
3191                case 43:
3192                   { jjCheckNAddTwoStates(43, 44); }
3193                   break;
3194                case 45:
3195                case 46:
3196                   { jjCheckNAddTwoStates(46, 44); }
3197                   break;
3198                case 50:
3199                   { jjCheckNAddTwoStates(50, 51); }
3200                   break;
3201                case 52:
3202                case 53:
3203                   { jjCheckNAddTwoStates(53, 51); }
3204                   break;
3205                case 56:
3206                   if (curChar == 95)
3207                      jjstateSet[jjnewStateCnt++] = 57;
3208                   break;
3209                case 58:
3210                   if (curChar == 95)
3211                      jjstateSet[jjnewStateCnt++] = 59;
3212                   break;
3213                case 62:
3214                   if (curChar == 95)
3215                      jjstateSet[jjnewStateCnt++] = 61;
3216                   break;
3217                case 63:
3218                   if ((0x2000000020ULL & l) != 0L)
3219                      { jjCheckNAddTwoStates(64, 65); }
3220                   break;
3221                case 66:
3222                   if (curChar == 95)
3223                      { jjCheckNAdd(65); }
3224                   break;
3225                case 67:
3226                   if (curChar == 95)
3227                      jjstateSet[jjnewStateCnt++] = 68;
3228                   break;
3229                case 70:
3230                   if ((0x7fffffe07fffffeULL & l) != 0L)
3231                      { jjCheckNAddStates(54, 56); }
3232                   break;
3233                case 72:
3234                   if ((0x7fffffe07fffffeULL & l) != 0L)
3235                      { jjCheckNAddTwoStates(72, 73); }
3236                   break;
3237                case 74:
3238                   if ((0x2000000020ULL & l) != 0L)
3239                      { jjCheckNAddTwoStates(75, 76); }
3240                   break;
3241                case 77:
3242                   if (curChar == 95)
3243                      { jjCheckNAdd(76); }
3244                   break;
3245                case 81:
3246                   if ((0x7fffffffffffffffULL & l) != 0L)
3247                      jjstateSet[jjnewStateCnt++] = 82;
3248                   break;
3249                case 85:
3250                   if ((0x7fffffffffffffffULL & l) != 0L)
3251                      jjstateSet[jjnewStateCnt++] = 86;
3252                   break;
3253                default : break;
3254             }
3255          } while(i != startsAt);
3256       }
3257       else
3258       {
3259          int hiByte = (curChar >> 8);
3260          int i1 = hiByte >> 6;
3261          unsigned long long l1 = 1ULL << (hiByte & 077);
3262          int i2 = (curChar & 0xff) >> 6;
3263          unsigned long long l2 = 1ULL << (curChar & 077);
3264          do
3265          {
3266             switch(jjstateSet[--i])
3267             {
3268                case 4:
3269                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3270                      break;
3271                   if (kind > 6)
3272                      kind = 6;
3273                   { jjAddStates(20, 24); }
3274                   break;
3275                case 9:
3276                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3277                      { jjAddStates(64, 65); }
3278                   break;
3279                case 15:
3280                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3281                      { jjAddStates(27, 28); }
3282                   break;
3283                case 26:
3284                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3285                      { jjAddStates(66, 67); }
3286                   break;
3287                case 28:
3288                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3289                      break;
3290                   if (kind > 189)
3291                      kind = 189;
3292                   { jjAddStates(68, 69); }
3293                   break;
3294                case 31:
3295                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3296                      break;
3297                   if (kind > 7)
3298                      kind = 7;
3299                   { jjAddStates(32, 34); }
3300                   break;
3301                case 37:
3302                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3303                      break;
3304                   if (kind > 8)
3305                      kind = 8;
3306                   { jjAddStates(35, 37); }
3307                   break;
3308                case 43:
3309                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3310                      { jjCheckNAddTwoStates(43, 44); }
3311                   break;
3312                case 45:
3313                case 46:
3314                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3315                      { jjCheckNAddTwoStates(46, 44); }
3316                   break;
3317                case 50:
3318                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3319                      { jjCheckNAddTwoStates(50, 51); }
3320                   break;
3321                case 52:
3322                case 53:
3323                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3324                      { jjCheckNAddTwoStates(53, 51); }
3325                   break;
3326                case 81:
3327                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3328                      jjstateSet[jjnewStateCnt++] = 82;
3329                   break;
3330                case 85:
3331                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3332                      jjstateSet[jjnewStateCnt++] = 86;
3333                   break;
3334                default : if (i1 == 0 || l1 == 0 || i2 == 0 ||  l2 == 0) break; else break;
3335             }
3336          } while(i != startsAt);
3337       }
3338       if (kind != 0x7fffffff)
3339       {
3340          jjmatchedKind = kind;
3341          jjmatchedPos = curPos;
3342          kind = 0x7fffffff;
3343       }
3344       ++curPos;
3345       if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 87 - startsAt)))
3346          break;
3347       if (input_stream->endOfInput()) { break; }
3348       curChar = input_stream->readChar();
3349    }
3350    if (jjmatchedPos > strPos)
3351       return curPos;
3352 
3353    int toRet = MAX(curPos, seenUpto);
3354 
3355    if (curPos < toRet)
3356       for (i = toRet - MIN(curPos, seenUpto); i-- > 0; )
3357         {  assert(!input_stream->endOfInput());
3358            curChar = input_stream->readChar(); }
3359 
3360    if (jjmatchedPos < strPos)
3361    {
3362       jjmatchedKind = strKind;
3363       jjmatchedPos = strPos;
3364    }
3365    else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
3366       jjmatchedKind = strKind;
3367 
3368    return toRet;
3369 }
3370 
jjCanMove_0(int hiByte,int i1,int i2,unsigned long long l1,unsigned long long l2)3371 bool VhdlParserTokenManager::jjCanMove_0(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){
3372    switch(hiByte)
3373    {
3374       case 0:
3375          return ((jjbitVec2[i2] & l2) != 0L);
3376       default :
3377          if ((jjbitVec0[i1] & l1) != 0L)
3378             return true;
3379          return false;
3380    }
3381 }
3382 
jjCanMove_1(int hiByte,int i1,int i2,unsigned long long l1,unsigned long long l2)3383 bool VhdlParserTokenManager::jjCanMove_1(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2){
3384    switch(hiByte)
3385    {
3386       case 0:
3387          return ((jjbitVec3[i2] & l2) != 0L);
3388       default :
3389          return false;
3390    }
3391 }
3392 
3393 /** Token literal values. */
3394 
jjFillToken()3395 Token * VhdlParserTokenManager::jjFillToken(){
3396    Token *t;
3397    JJString curTokenImage;
3398    int beginLine   = -1;
3399    int endLine     = -1;
3400    int beginColumn = -1;
3401    int endColumn   = -1;
3402    JJString im = jjstrLiteralImages[jjmatchedKind];
3403    curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
3404    if (input_stream->getTrackLineColumn()) {
3405      beginLine = input_stream->getBeginLine();
3406      beginColumn = input_stream->getBeginColumn();
3407      endLine = input_stream->getEndLine();
3408      endColumn = input_stream->getEndColumn();
3409    }
3410    t = Token::newToken(jjmatchedKind);
3411    t->kind = jjmatchedKind;
3412    t->image = curTokenImage;
3413    t->specialToken = nullptr;
3414    t->next = nullptr;
3415 
3416    if (input_stream->getTrackLineColumn()) {
3417    t->beginLine = beginLine;
3418    t->endLine = endLine;
3419    t->beginColumn = beginColumn;
3420    t->endColumn = endColumn;
3421    }
3422 
3423    return t;
3424 }
3425 const int defaultLexState = 0;
3426 /** Get the next Token. */
3427 
getNextToken()3428 Token * VhdlParserTokenManager::getNextToken(){
3429   Token *matchedToken = nullptr;
3430   int curPos = 0;
3431 
3432   for (;;)
3433   {
3434    EOFLoop:
3435    if (input_stream->endOfInput())
3436    {
3437       jjmatchedKind = 0;
3438       jjmatchedPos = -1;
3439       matchedToken = jjFillToken();
3440       return matchedToken;
3441    }
3442    curChar = input_stream->BeginToken();
3443    image = jjimage;
3444    image.clear();
3445    jjimageLen = 0;
3446 
3447    jjmatchedKind = 0x7fffffff;
3448    jjmatchedPos = 0;
3449    curPos = jjMoveStringLiteralDfa0_0();
3450    if (jjmatchedKind != 0x7fffffff)
3451    {
3452       if (jjmatchedPos + 1 < curPos)
3453          input_stream->backup(curPos - jjmatchedPos - 1);
3454       if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
3455       {
3456          matchedToken = jjFillToken();
3457          TokenLexicalActions(matchedToken);
3458          return matchedToken;
3459       }
3460       else
3461       {
3462          SkipLexicalActions(nullptr);
3463          goto EOFLoop;
3464       }
3465    }
3466    int error_line = input_stream->getEndLine();
3467    int error_column = input_stream->getEndColumn();
3468    JJString error_after;
3469    bool EOFSeen = false;
3470    if (input_stream->endOfInput()) {
3471       EOFSeen = true;
3472       error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
3473       if (curChar == '\n' || curChar == '\r') {
3474          error_line++;
3475          error_column = 0;
3476       }
3477       else
3478          error_column++;
3479    }
3480    if (!EOFSeen) {
3481       error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
3482    }
3483    errorHandler->lexicalError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, this);
3484   }
3485 }
3486 
3487 
SkipLexicalActions(Token * matchedToken)3488 void  VhdlParserTokenManager::SkipLexicalActions(Token *matchedToken){
3489    switch(jjmatchedKind)
3490    {
3491       case 3 : {
3492          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3493         parser->outlineParser()->lineCount();
3494          break;
3495        }
3496       case 6 : {
3497          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3498     {
3499     QCString doc(image.data());
3500      int count=doc.contains("--!");
3501      parser->outlineParser()->setMultCommentLine();
3502     parser->outlineParser()->lineCount(image.data());
3503     if (count == 1)
3504       parser->outlineParser()->oneLineComment(doc);
3505     else
3506       parser->outlineParser()->handleCommentBlock(QCString(image),FALSE); ;
3507     }
3508          break;
3509        }
3510       case 7 : {
3511          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3512                                                                                parser->outlineParser()->handleFlowComment(image.data());
3513          break;
3514        }
3515       case 8 : {
3516          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3517     parser->outlineParser()->lineCount(image.data());
3518          break;
3519        }
3520       case 9 : {
3521          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3522    {
3523      QCString q = filter2008VhdlComment(image.data());
3524      parser->outlineParser()->lineCount(image.data());
3525      parser->outlineParser()->handleCommentBlock(QCString(q),TRUE);image.clear();
3526    }
3527          break;
3528        }
3529       case 10 : {
3530          image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3531       parser->outlineParser()->lineCount(image.data());image.clear();
3532          break;
3533        }
3534       default :
3535          break;
3536    }
3537 }
3538 
TokenLexicalActions(Token * matchedToken)3539 void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
3540    switch(jjmatchedKind)
3541    {
3542       case 14 : {
3543         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3544                       parser->outlineParser()->setLineParsed(ALIAS_T);
3545          break;
3546        }
3547       case 17 : {
3548         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3549                                     parser->outlineParser()->setLineParsed(ARCHITECTURE_T);
3550          break;
3551        }
3552       case 18 : {
3553         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3554                       parser->outlineParser()->setLineParsed(ARRAY_T);
3555          break;
3556        }
3557       case 22 : {
3558         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3559                               parser->outlineParser()->setLineParsed(ATTRIBUTE_T);
3560          break;
3561        }
3562       case 25 : {
3563         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3564                     parser->outlineParser()->setLineParsed(BODY_T);
3565          break;
3566        }
3567       case 28 : {
3568         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3569                               parser->outlineParser()->setLineParsed(COMPONENT_T);
3570          break;
3571        }
3572       case 30 : {
3573         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3574                                       parser->outlineParser()->setLineParsed(CONFIGURATION_T);
3575          break;
3576        }
3577       case 31 : {
3578         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3579                              parser->outlineParser()->setLineParsed(CONSTANT_T);
3580          break;
3581        }
3582       case 32 : {
3583         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3584                           parser->outlineParser()->setLineParsed(CONTEXT_T);
3585          break;
3586        }
3587       case 39 : {
3588         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3589                   parser->outlineParser()->setLineParsed(END_T);
3590          break;
3591        }
3592       case 40 : {
3593         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3594                         parser->outlineParser()->setLineParsed(ENTITY_T);
3595          break;
3596        }
3597       case 43 : {
3598         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3599                     parser->outlineParser()->setLineParsed(FILE_T);
3600          break;
3601        }
3602       case 46 : {
3603         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3604                              parser->outlineParser()->setLineParsed(FUNCTION_T);
3605          break;
3606        }
3607       case 49 : {
3608         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3609                       parser->outlineParser()->setLineParsed(GROUP_T);
3610          break;
3611        }
3612       case 58 : {
3613         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3614                           parser->outlineParser()->setLineParsed(LIBRARY_T);
3615          break;
3616        }
3617       case 76 : {
3618         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3619                           parser->outlineParser()->setLineParsed(PACKAGE_T);
3620          break;
3621        }
3622       case 78 : {
3623         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3624                     parser->outlineParser()->setLineParsed(PORT_T);
3625          break;
3626        }
3627       case 80 : {
3628         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3629                               parser->outlineParser()->setLineParsed(PROCEDURE_T);
3630          break;
3631        }
3632       case 81 : {
3633         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3634                           parser->outlineParser()->setLineParsed(PROCESS_T);
3635          break;
3636        }
3637       case 86 : {
3638         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3639                         parser->outlineParser()->setLineParsed(RECORD_T);
3640          break;
3641        }
3642       case 100 : {
3643         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3644                         parser->outlineParser()->setLineParsed(SIGNAL_T);
3645          break;
3646        }
3647       case 107 : {
3648         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3649                           parser->outlineParser()->setLineParsed(SUBTYPE_T);
3650          break;
3651        }
3652       case 111 : {
3653         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3654                     parser->outlineParser()->setLineParsed(TYPE_T);
3655          break;
3656        }
3657       case 113 : {
3658         image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3659                       parser->outlineParser()->setLineParsed(UNITS_T);
3660          break;
3661        }
3662       case 137 : {
3663         image.append(jjstrLiteralImages[137]);
3664         lengthOfMatch = jjstrLiteralImages[137].length();
3665                   parser->outlineParser()->setLineParsed(SEMI_T);
3666          break;
3667        }
3668       default :
3669          break;
3670    }
3671 }
3672   /** Reinitialise parser. */
ReInit(JAVACC_CHARSTREAM * stream,int lexState)3673   void VhdlParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState) {
3674     clear();
3675     jjmatchedPos = jjnewStateCnt = 0;
3676     curLexState = lexState;
3677     input_stream = stream;
3678     ReInitRounds();
3679     debugStream = stdout; // init
3680     SwitchTo(lexState);
3681     errorHandler = new TokenManagerErrorHandler();
3682   }
3683 
ReInitRounds()3684   void VhdlParserTokenManager::ReInitRounds() {
3685     int i;
3686     jjround = 0x80000001;
3687     for (i = 87; i-- > 0;)
3688       jjrounds[i] = 0x80000000;
3689   }
3690 
3691   /** Switch to specified lex state. */
SwitchTo(int lexState)3692   void VhdlParserTokenManager::SwitchTo(int lexState) {
3693     if (lexState >= 1 || lexState < 0) {
3694       JJString message;
3695 #ifdef WIDE_CHAR
3696       message += L"Error: Ignoring invalid lexical state : ";
3697       message += lexState; message += L". State unchanged.";
3698 #else
3699       message += "Error: Ignoring invalid lexical state : ";
3700       message += lexState; message += ". State unchanged.";
3701 #endif
3702       throw new TokenMgrError(message, INVALID_LEXICAL_STATE);
3703     } else
3704       curLexState = lexState;
3705   }
3706 
3707   /** Constructor. */
VhdlParserTokenManager(JAVACC_CHARSTREAM * stream,int lexState)3708   VhdlParserTokenManager::VhdlParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState)
3709   : TokenParser()
3710   {
3711     input_stream = nullptr;
3712     ReInit(stream, lexState);
3713   }
3714 
3715   // Destructor
~VhdlParserTokenManager()3716   VhdlParserTokenManager::~VhdlParserTokenManager () {
3717     clear();
3718   }
3719 
3720   // clear
clear()3721   void VhdlParserTokenManager::clear() {
3722     //Since input_stream was generated outside of TokenManager
3723     //TokenManager should not take care of deleting it
3724     //if (input_stream) delete input_stream;
3725     if (errorHandler) delete errorHandler, errorHandler = nullptr;
3726   }
3727 
3728 
3729 }
3730 }
3731