Subversion Repositories tendra.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 7u83 1 
/*
2 
 * Automatically generated from the files:
7 7u83 3 
 *	syntax.sid
2 7u83 4 
 * and
7 7u83 5 
 *	syntax.act
2 7u83 6 
 * by:
7 
 *	sid
8 
 */
9 
 
10 
/* BEGINNING OF HEADER */
11 
 
12 
 
13 
/*
14 
    		 Crown Copyright (c) 1997
15 
 
16 
    This TenDRA(r) Computer Program is subject to Copyright
17 
    owned by the United Kingdom Secretary of State for Defence
18 
    acting through the Defence Evaluation and Research Agency
19 
    (DERA).  It is made available to Recipients with a
20 
    royalty-free licence for its use, reproduction, transfer
21 
    to other parties and amendment for any purpose not excluding
22 
    product development provided that any such use et cetera
23 
    shall be deemed to be acceptance of the following conditions:-
24 
 
25 
        (1) Its Recipients shall ensure that this Notice is
26 
        reproduced upon any copies or amended versions of it;
27 
 
28 
        (2) Any amended version of it shall be clearly marked to
29 
        show both the nature of and the organisation responsible
30 
        for the relevant amendment or amendments;
31 
 
32 
        (3) Its onward transfer from a recipient to another
33 
        party shall be deemed to be that party's acceptance of
34 
        these conditions;
35 
 
36 
        (4) DERA gives no warranty or assurance as to its
37 
        quality or suitability for any purpose and DERA accepts
38 
        no liability whatsoever in relation to any use to which
39 
        it may be put.
40 
*/
41 
 
42 
 
43 
#include "config.h"
44 
#include "object.h"
45 
#include "hash.h"
46 
#include "lex.h"
47 
#include "name.h"
48 
#include "syntax.h"
49 
#include "type.h"
50 
#include "utility.h"
51 
#include "variable.h"
52 
 
53 
 
54 
/*
55 
    PARSER TYPES
56 
 
57 
    These types give the implementations of the various types used
58 
    in the syntax.
59 
*/
60 
 
61 
typedef char *SID_STRING ;
62 
typedef type *SID_TYPE ;
63 
 
64 
typedef struct {
65 
    char *iname ;
66 
    char *ename ;
67 
    int ivers ;
68 
    int evers ;
69 
} SID_IDENTIFIER ;
70 
 
71 
 
72 
/*
73 
    CURRENT FIELD NAME
74 
 
75 
    The name of the current structure is stored during a +FIELD
76 
    construct.
77 
*/
78 
 
79 
static char *crt_field_name = null ;
80 
static int anon_no = 0 ;
81 
 
82 
 
83 
/*
84 
    CV-QUALIFIER NAMES
85 
 
86 
    This table gives the mapping between the values used to represent
87 
    cv-qualifiers in the parser and the qualifier names used in the
88 
    internal representation.
89 
*/
90 
 
91 
static char *cv_qualifier [] = {
92 
    null, "const", "volatile", "const volatile"
93 
} ;
94 
 
95 
/*
96 
    COMPILATION MODE
97 
 
98 
    We allow unreached code in the automatically generated sections.
99 
*/
100 
 
101 
#if FS_TENDRA
102 
#pragma TenDRA begin
103 
#pragma TenDRA unreachable code allow
104 
#pragma TenDRA variable analysis off
105 
#endif
106 
 
107 
 
108 
 
109 
/* BEGINNING OF FUNCTION DECLARATIONS */
110 
 
7 7u83 111 
static void ZRsimple_Htype(SID_TYPE *);
112 
static void ZRparameter_Hdeclaration(SID_TYPE *);
113 
static void ZRnat_Hdeclarator_Hlist(SID_COMMAND *);
114 
static void ZRtype_Hdeclarator_Hlist(SID_COMMAND *);
115 
static void ZRfunction_Hoperator(SID_TYPE *);
116 
static void ZRexp_Hdeclarator_Hlist(int, SID_TYPE, int, SID_COMMAND *);
117 
static void ZRsubset_Hkey(SID_STRING *);
118 
static void ZRmacro_Hparam_Hdeclaration(SID_TYPE *);
119 
static void ZRifdef_Hmacro_Hname(SID_STRING *);
120 
static void ZRdefine_Hparam_Hlist(SID_STRING *);
121 
static void ZR287(SID_TYPE *);
122 
static void ZRdeclarator(SID_IDENTIFIER *, SID_TYPE *);
123 
static void ZRidentifier(SID_IDENTIFIER *);
124 
static void ZRsubset_Hcommand(SID_COMMAND *);
125 
static void ZRqualified_Htype(SID_TYPE *);
126 
static void ZRabstract_Hdeclarator(SID_STRING *, SID_TYPE *);
127 
static void ZRparameter_Hlist(SID_TYPE *);
128 
static void ZRinternal_Hname(SID_STRING *, int *);
129 
static void ZR308(SID_STRING, SID_TYPE, SID_STRING *, SID_TYPE *);
130 
static void ZRmacro_Hoperator(SID_TYPE *);
131 
static void ZRenumerator_Hlist(SID_COMMAND *);
132 
static void ZRexternal_Hname(SID_STRING *, int *);
133 
static void ZRtype_Hqualifier(unsigned *);
134 
static void ZRtype_Hkey(int *);
135 
static void ZRtype_Hqualifier_Hopt(unsigned *);
136 
static void ZRconstant_Hvalue(SID_STRING *);
137 
static void ZR318(SID_IDENTIFIER, SID_TYPE, SID_IDENTIFIER *, SID_TYPE *);
138 
static void ZRspec_Hcommand(SID_COMMAND *);
139 
static void ZRfunc_Hcommand(int *);
140 
static void ZR320(SID_STRING *, SID_STRING *);
141 
static void ZR321(SID_STRING *, SID_STRING *, SID_STRING *);
142 
static void ZRarray_Hoperator(SID_TYPE *);
143 
static void ZR322(SID_COMMAND *);
144 
static void ZR323(int *, SID_COMMAND *);
145 
static void ZRmacro_Hparam_Hlist(SID_TYPE *);
146 
static void ZR324(SID_STRING *, int *, SID_IDENTIFIER *);
147 
static void ZR325(SID_STRING *);
148 
static void ZR328(SID_STRING *, SID_STRING *);
149 
static void ZRenum_Hcommand(int *);
150 
static void ZRenumerator(SID_COMMAND *);
151 
static void ZR329(int *);
152 
static void ZRfield_Hdeclarator_Hlist(SID_TYPE, SID_TYPE, SID_COMMAND *);
153 
static void ZR330(int *);
154 
static void ZRfield_Hexact(int *);
155 
static void ZR333(SID_TYPE *, SID_TYPE *);
156 
static void ZR335(SID_TYPE *);
157 
static void ZRcommand_Hlist(SID_COMMAND *);
158 
static void ZR338(SID_STRING *, SID_TYPE *, SID_STRING *, SID_TYPE *);
159 
static void ZR339(SID_TYPE *);
160 
static void ZR340(int *);
161 
static void ZRdirect_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
162 
static void ZRtype_Hcommand(int *);
163 
static void ZRtext_Hcommand(SID_COMMAND *);
164 
static void ZR347(SID_IDENTIFIER *, SID_IDENTIFIER *, SID_TYPE *);
165 
static void ZRname_Hversion(int *);
166 
static void ZR348(int *);
167 
static void ZRdirect_Habstract_Hdeclarator(SID_STRING *, SID_TYPE *);
168 
static void ZRfield_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
169 
static void ZRvariable_Hcommand(void);
170 
static void ZR349(int *);
171 
static void ZR350(SID_TYPE *);
172 
static void ZR351(SID_STRING *);
173 
static void ZRdefine_Hparam_Hclause(SID_STRING *);
174 
static void ZRexp_Hcommand(int *);
175 
static void ZR352(SID_STRING *);
176 
static void ZRif_Hcommand(SID_COMMAND *, SID_STRING *);
177 
static void ZR353(SID_STRING *);
178 
static void ZR354(SID_STRING *);
179 
static void ZRbitfield_Hoperator(SID_TYPE *);
180 
static void ZRuse_Hsubset_Hname(SID_STRING *);
181 
extern void read_spec(SID_COMMAND *);
182 
static void ZRmacro_Hdeclarator(SID_IDENTIFIER *, SID_TYPE *);
183 
static void ZRsubset_Hname(SID_STRING *);
184 
static void ZRbuiltin_Htype(unsigned *);
185 
static void ZRobject_Hqualifier(int *);
186 
static void ZRfield_Hlist(SID_TYPE, SID_COMMAND *);
187 
static void ZRptr_Hoperator(SID_TYPE *);
188 
static void ZRtype_Hkeyword(unsigned *);
2 7u83 189 
 
190 
/* BEGINNING OF STATIC VARIABLES */
191 
 
192 
 
193 
/* BEGINNING OF FUNCTION DEFINITIONS */
194 
 
195 
static void
7 7u83 196 
ZRsimple_Htype(SID_TYPE *ZOt)
2 7u83 197 
{
198 
    SID_TYPE ZIt;
199 
 
200 
    switch (CURRENT_TERMINAL) {
7 7u83 201 
      case 32: case 34: case 37: case 38: case 39:
202 
      case 42: case 43: case 46: case 47:
2 7u83 203 
	{
204 
	    unsigned ZIb;
205 
 
206 
	    ZRbuiltin_Htype (&ZIb);
7 7u83 207 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 208 
		RESTORE_LEXER;
209 
		goto ZL1;
210 
	    }
211 
	    {
212 
 
213 
    (ZIt) = basic_type ( (ZIb) ) ;
214 
	    }
215 
	}
216 
	break;
7 7u83 217 
      case 0: case 35: case 44: case 45:
2 7u83 218 
	{
219 
	    int ZItag;
220 
	    SID_STRING ZInm;
221 
 
222 
	    ZRtype_Hkey (&ZItag);
223 
	    switch (CURRENT_TERMINAL) {
224 
	      case 0:
225 
		{
226 
 ZInm = token_value ;
227 
		}
228 
		break;
7 7u83 229 
	      case 75:
2 7u83 230 
		RESTORE_LEXER;
231 
		goto ZL1;
232 
	      default:
233 
		goto ZL1;
234 
	    }
235 
	    ADVANCE_LEXER;
236 
	    {
237 
 
238 
    (ZIt) = find_type ( (ZInm), any_version, (ZItag), 1 ) ;
239 
	    }
240 
	}
241 
	break;
7 7u83 242 
      case 75:
2 7u83 243 
	return;
244 
      default:
245 
	goto ZL1;
246 
    }
247 
    goto ZL0;
248 
  ZL1:;
7 7u83 249 
    SAVE_LEXER (75);
2 7u83 250 
    return;
251 
  ZL0:;
252 
    *ZOt = ZIt;
253 
}
254 
 
255 
static void
7 7u83 256 
ZRparameter_Hdeclaration(SID_TYPE *ZOt)
2 7u83 257 
{
258 
    SID_TYPE ZIt;
259 
 
7 7u83 260 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 261 
	return;
262 
    }
263 
    {
264 
	SID_TYPE ZIs;
265 
	SID_STRING ZInm;
266 
	SID_TYPE ZIp;
267 
 
268 
	ZRqualified_Htype (&ZIs);
269 
	ZRabstract_Hdeclarator (&ZInm, &ZIp);
7 7u83 270 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 271 
	    RESTORE_LEXER;
272 
	    goto ZL1;
273 
	}
274 
	{
275 
 
276 
    (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
277 
	}
278 
	{
279 
 
280 
    UNUSED ( (ZInm) ) ;
281 
	}
282 
    }
283 
    goto ZL0;
284 
  ZL1:;
7 7u83 285 
    SAVE_LEXER (75);
2 7u83 286 
    return;
287 
  ZL0:;
288 
    *ZOt = ZIt;
289 
}
290 
 
291 
static void
7 7u83 292 
ZRnat_Hdeclarator_Hlist(SID_COMMAND *ZOc)
2 7u83 293 
{
294 
    SID_COMMAND ZIc;
295 
 
7 7u83 296 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 297 
	return;
298 
    }
299 
    {
300 
	SID_IDENTIFIER ZIid;
301 
	SID_COMMAND ZIa;
302 
	SID_COMMAND ZIb;
303 
 
304 
	ZRidentifier (&ZIid);
7 7u83 305 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 306 
	    RESTORE_LEXER;
307 
	    goto ZL1;
308 
	}
309 
	{
310 
 
311 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_NAT ) ;
312 
    (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_NAT ) ;
313 
	}
314 
	{
315 
	    switch (CURRENT_TERMINAL) {
7 7u83 316 
	      case 62:
2 7u83 317 
		{
318 
		    ADVANCE_LEXER;
319 
		    ZRnat_Hdeclarator_Hlist (&ZIb);
7 7u83 320 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 321 
			RESTORE_LEXER;
322 
			goto ZL1;
323 
		    }
324 
		}
325 
		break;
326 
	      default:
327 
		{
328 
		    {
329 
 
330 
    (ZIb) = null ;
331 
		    }
332 
		}
333 
		break;
334 
	    }
335 
	}
336 
	{
337 
 
338 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
339 
	}
340 
    }
341 
    goto ZL0;
342 
  ZL1:;
7 7u83 343 
    SAVE_LEXER (75);
2 7u83 344 
    return;
345 
  ZL0:;
346 
    *ZOc = ZIc;
347 
}
348 
 
349 
static void
7 7u83 350 
ZRtype_Hdeclarator_Hlist(SID_COMMAND *ZOc)
2 7u83 351 
{
352 
    SID_COMMAND ZIc;
353 
 
7 7u83 354 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 355 
	return;
356 
    }
357 
    {
358 
	int ZItag;
359 
	SID_IDENTIFIER ZIid;
360 
	SID_COMMAND ZIa;
361 
	SID_COMMAND ZIb;
362 
 
363 
	ZRtype_Hcommand (&ZItag);
364 
	ZRidentifier (&ZIid);
7 7u83 365 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 366 
	    RESTORE_LEXER;
367 
	    goto ZL1;
368 
	}
369 
	{
370 
 
371 
    type *t = make_type ( (ZIid).iname, (ZIid).ivers, (ZItag) ) ;
372 
    (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_TYPE ) ;
373 
	}
374 
	{
375 
	    switch (CURRENT_TERMINAL) {
7 7u83 376 
	      case 62:
2 7u83 377 
		{
378 
		    ADVANCE_LEXER;
379 
		    ZRtype_Hdeclarator_Hlist (&ZIb);
7 7u83 380 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 381 
			RESTORE_LEXER;
382 
			goto ZL1;
383 
		    }
384 
		}
385 
		break;
386 
	      default:
387 
		{
388 
		    {
389 
 
390 
    (ZIb) = null ;
391 
		    }
392 
		}
393 
		break;
394 
	    }
395 
	}
396 
	{
397 
 
398 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
399 
	}
400 
    }
401 
    goto ZL0;
402 
  ZL1:;
7 7u83 403 
    SAVE_LEXER (75);
2 7u83 404 
    return;
405 
  ZL0:;
406 
    *ZOc = ZIc;
407 
}
408 
 
409 
static void
7 7u83 410 
ZRfunction_Hoperator(SID_TYPE *ZOt)
2 7u83 411 
{
412 
    SID_TYPE ZIt;
413 
 
7 7u83 414 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 415 
	return;
416 
    }
417 
    {
418 
	switch (CURRENT_TERMINAL) {
7 7u83 419 
	  case 56:
2 7u83 420 
	    break;
421 
	  default:
422 
	    goto ZL1;
423 
	}
424 
	ADVANCE_LEXER;
7 7u83 425 
	ZR335 (&ZIt);
426 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 427 
	    RESTORE_LEXER;
428 
	    goto ZL1;
429 
	}
430 
    }
431 
    goto ZL0;
432 
  ZL1:;
7 7u83 433 
    SAVE_LEXER (75);
2 7u83 434 
    return;
435 
  ZL0:;
436 
    *ZOt = ZIt;
437 
}
438 
 
439 
static void
7 7u83 440 
ZRexp_Hdeclarator_Hlist(int ZIcmd, SID_TYPE ZIs, int ZIlv, SID_COMMAND *ZOc)
2 7u83 441 
{
442 
    SID_COMMAND ZIc;
443 
 
7 7u83 444 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 445 
	return;
446 
    }
447 
    {
448 
	SID_IDENTIFIER ZIid;
449 
	SID_TYPE ZIp;
450 
	SID_TYPE ZIu;
451 
	SID_TYPE ZIt;
452 
	SID_COMMAND ZIa;
453 
	SID_COMMAND ZIb;
454 
 
455 
	ZRdeclarator (&ZIid, &ZIp);
7 7u83 456 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 457 
	    RESTORE_LEXER;
458 
	    goto ZL1;
459 
	}
460 
	{
461 
 
462 
    (ZIu) = inject_type ( (ZIp), (ZIs) ) ;
463 
	}
464 
	{
465 
 
466 
    (ZIt) = make_subtype ( (ZIu), (ZIlv) ) ;
467 
	}
468 
	{
469 
 
470 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, (ZIcmd) ) ;
471 
    p->u.u_type = check_type ( (ZIt), (ZIcmd) ) ;
472 
    (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, p, (ZIcmd) ) ;
473 
	}
474 
	{
475 
	    switch (CURRENT_TERMINAL) {
7 7u83 476 
	      case 62:
2 7u83 477 
		{
478 
		    ADVANCE_LEXER;
479 
		    ZRexp_Hdeclarator_Hlist (ZIcmd, ZIs, ZIlv, &ZIb);
7 7u83 480 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 481 
			RESTORE_LEXER;
482 
			goto ZL1;
483 
		    }
484 
		}
485 
		break;
486 
	      default:
487 
		{
488 
		    {
489 
 
490 
    (ZIb) = null ;
491 
		    }
492 
		}
493 
		break;
494 
	    }
495 
	}
496 
	{
497 
 
498 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
499 
	}
500 
    }
501 
    goto ZL0;
502 
  ZL1:;
7 7u83 503 
    SAVE_LEXER (75);
2 7u83 504 
    return;
505 
  ZL0:;
506 
    *ZOc = ZIc;
507 
}
508 
 
509 
static void
7 7u83 510 
ZRsubset_Hkey(SID_STRING *ZOkey)
2 7u83 511 
{
512 
    SID_STRING ZIkey;
513 
 
514 
    switch (CURRENT_TERMINAL) {
7 7u83 515 
      case 56:
2 7u83 516 
	{
517 
	    ADVANCE_LEXER;
7 7u83 518 
	    ZR351 (&ZIkey);
519 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 520 
		RESTORE_LEXER;
521 
		goto ZL1;
522 
	    }
523 
	}
524 
	break;
525 
      default:
526 
	{
527 
	    {
528 
 (ZIkey) = "11" ;
529 
	    }
530 
	}
531 
	break;
7 7u83 532 
      case 75:
2 7u83 533 
	return;
534 
    }
535 
    goto ZL0;
536 
  ZL1:;
7 7u83 537 
    SAVE_LEXER (75);
2 7u83 538 
    return;
539 
  ZL0:;
540 
    *ZOkey = ZIkey;
541 
}
542 
 
543 
static void
7 7u83 544 
ZRmacro_Hparam_Hdeclaration(SID_TYPE *ZOt)
2 7u83 545 
{
546 
    SID_TYPE ZIt;
547 
 
7 7u83 548 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 549 
	return;
550 
    }
551 
    {
552 
	int ZIlv;
553 
	SID_TYPE ZIs;
554 
	SID_STRING ZInm;
555 
	SID_TYPE ZIp;
556 
	SID_TYPE ZIu;
557 
 
558 
	ZRobject_Hqualifier (&ZIlv);
559 
	ZRqualified_Htype (&ZIs);
560 
	ZRabstract_Hdeclarator (&ZInm, &ZIp);
7 7u83 561 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 562 
	    RESTORE_LEXER;
563 
	    goto ZL1;
564 
	}
565 
	{
566 
 
567 
    (ZIu) = inject_type ( (ZIp), (ZIs) ) ;
568 
	}
569 
	{
570 
 
571 
    (ZIt) = make_subtype ( (ZIu), (ZIlv) ) ;
572 
	}
573 
	{
574 
 
575 
    UNUSED ( (ZInm) ) ;
576 
	}
577 
    }
578 
    goto ZL0;
579 
  ZL1:;
7 7u83 580 
    SAVE_LEXER (75);
2 7u83 581 
    return;
582 
  ZL0:;
583 
    *ZOt = ZIt;
584 
}
585 
 
586 
static void
7 7u83 587 
ZRifdef_Hmacro_Hname(SID_STRING *ZOc)
2 7u83 588 
{
589 
    SID_STRING ZIc;
590 
 
591 
    switch (CURRENT_TERMINAL) {
7 7u83 592 
      case 50:
2 7u83 593 
	{
594 
	    ADVANCE_LEXER;
595 
	    {
596 
 
597 
    (ZIc) = BUILDING_MACRO ;
598 
	    }
599 
	}
600 
	break;
601 
      case 0:
602 
	{
603 
	    {
604 
 ZIc = token_value ;
605 
	    }
606 
	    ADVANCE_LEXER;
607 
	}
608 
	break;
7 7u83 609 
      case 52:
2 7u83 610 
	{
611 
	    SID_STRING ZIa;
612 
	    SID_STRING ZIb;
613 
 
614 
	    ADVANCE_LEXER;
615 
	    switch (CURRENT_TERMINAL) {
7 7u83 616 
	      case 56:
2 7u83 617 
		break;
618 
	      default:
619 
		goto ZL1;
620 
	    }
621 
	    ADVANCE_LEXER;
622 
	    switch (CURRENT_TERMINAL) {
623 
	      case 2:
624 
		{
625 
 ZIa = token_value ;
626 
		}
627 
		break;
628 
	      default:
629 
		goto ZL1;
630 
	    }
631 
	    ADVANCE_LEXER;
632 
	    switch (CURRENT_TERMINAL) {
7 7u83 633 
	      case 62:
2 7u83 634 
		break;
635 
	      default:
636 
		goto ZL1;
637 
	    }
638 
	    ADVANCE_LEXER;
639 
	    switch (CURRENT_TERMINAL) {
640 
	      case 2:
641 
		{
642 
 ZIb = token_value ;
643 
		}
644 
		break;
645 
	      default:
646 
		goto ZL1;
647 
	    }
648 
	    ADVANCE_LEXER;
649 
	    switch (CURRENT_TERMINAL) {
7 7u83 650 
	      case 57:
2 7u83 651 
		break;
652 
	      default:
653 
		goto ZL1;
654 
	    }
655 
	    ADVANCE_LEXER;
656 
	    {
657 
 
658 
    (ZIc) = macro_name ( PROTECT_PREFIX, (ZIa), (ZIb), null_str ) ;
659 
	    }
660 
	}
661 
	break;
7 7u83 662 
      case 75:
2 7u83 663 
	return;
664 
      default:
665 
	goto ZL1;
666 
    }
667 
    goto ZL0;
668 
  ZL1:;
7 7u83 669 
    SAVE_LEXER (75);
2 7u83 670 
    return;
671 
  ZL0:;
672 
    *ZOc = ZIc;
673 
}
674 
 
675 
static void
7 7u83 676 
ZRdefine_Hparam_Hlist(SID_STRING *ZOp)
2 7u83 677 
{
7 7u83 678 
    SID_STRING ZIp;
679 
 
680 
    if ((CURRENT_TERMINAL) == 75) {
681 
	return;
682 
    }
683 
    {
684 
	SID_STRING ZI326;
685 
 
686 
	switch (CURRENT_TERMINAL) {
687 
	  case 0:
688 
	    {
689 
 ZI326 = token_value ;
690 
	    }
691 
	    break;
692 
	  default:
693 
	    goto ZL1;
694 
	}
695 
	ADVANCE_LEXER;
696 
	ZR328 (&ZI326, &ZIp);
697 
	if ((CURRENT_TERMINAL) == 75) {
698 
	    RESTORE_LEXER;
699 
	    goto ZL1;
700 
	}
701 
    }
702 
    goto ZL0;
703 
  ZL1:;
704 
    SAVE_LEXER (75);
705 
    return;
706 
  ZL0:;
707 
    *ZOp = ZIp;
708 
}
709 
 
710 
static void
711 
ZR287(SID_TYPE *ZOt)
712 
{
2 7u83 713 
    SID_TYPE ZIt;
714 
 
715 
    switch (CURRENT_TERMINAL) {
7 7u83 716 
      case 56:
2 7u83 717 
	{
718 
	    ZRmacro_Hoperator (&ZIt);
7 7u83 719 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 720 
		RESTORE_LEXER;
721 
		goto ZL1;
722 
	    }
723 
	}
724 
	break;
725 
      default:
726 
	{
727 
	    {
728 
 
729 
    (ZIt) = null ;
730 
	    }
731 
	}
732 
	break;
7 7u83 733 
      case 75:
2 7u83 734 
	return;
735 
    }
736 
    goto ZL0;
737 
  ZL1:;
7 7u83 738 
    SAVE_LEXER (75);
2 7u83 739 
    return;
740 
  ZL0:;
741 
    *ZOt = ZIt;
742 
}
743 
 
744 
static void
7 7u83 745 
ZRdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
2 7u83 746 
{
747 
    SID_IDENTIFIER ZIid;
748 
    SID_TYPE ZIt;
749 
 
750 
    switch (CURRENT_TERMINAL) {
7 7u83 751 
      case 0: case 56:
2 7u83 752 
	{
753 
	    ZRdirect_Hdeclarator (&ZIid, &ZIt);
7 7u83 754 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 755 
		RESTORE_LEXER;
756 
		goto ZL1;
757 
	    }
758 
	}
759 
	break;
7 7u83 760 
      case 72:
2 7u83 761 
	{
762 
	    SID_TYPE ZIp;
763 
	    SID_TYPE ZIs;
764 
 
765 
	    ZRptr_Hoperator (&ZIp);
766 
	    ZRdeclarator (&ZIid, &ZIs);
7 7u83 767 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 768 
		RESTORE_LEXER;
769 
		goto ZL1;
770 
	    }
771 
	    {
772 
 
773 
    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
774 
	    }
775 
	}
776 
	break;
7 7u83 777 
      case 75:
2 7u83 778 
	return;
779 
      default:
780 
	goto ZL1;
781 
    }
782 
    goto ZL0;
783 
  ZL1:;
7 7u83 784 
    SAVE_LEXER (75);
2 7u83 785 
    return;
786 
  ZL0:;
787 
    *ZOid = ZIid;
788 
    *ZOt = ZIt;
789 
}
790 
 
791 
static void
7 7u83 792 
ZRidentifier(SID_IDENTIFIER *ZOid)
2 7u83 793 
{
794 
    SID_IDENTIFIER ZIid;
795 
 
7 7u83 796 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 797 
	return;
798 
    }
799 
    {
800 
	SID_STRING ZInm;
801 
	int ZIv;
802 
 
803 
	ZRinternal_Hname (&ZInm, &ZIv);
7 7u83 804 
	ZR324 (&ZInm, &ZIv, &ZIid);
805 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 806 
	    RESTORE_LEXER;
807 
	    goto ZL1;
808 
	}
809 
    }
810 
    goto ZL0;
811 
  ZL1:;
7 7u83 812 
    SAVE_LEXER (75);
2 7u83 813 
    return;
814 
  ZL0:;
815 
    *ZOid = ZIid;
816 
}
817 
 
818 
static void
7 7u83 819 
ZRsubset_Hcommand(SID_COMMAND *ZOc)
2 7u83 820 
{
821 
    SID_COMMAND ZIc;
822 
 
7 7u83 823 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 824 
	return;
825 
    }
826 
    {
827 
	SID_STRING ZIs;
828 
	SID_COMMAND ZIa;
829 
	SID_COMMAND ZIb;
830 
 
831 
	switch (CURRENT_TERMINAL) {
832 
	  case 23:
833 
	    break;
834 
	  default:
835 
	    goto ZL1;
836 
	}
837 
	ADVANCE_LEXER;
838 
	ZRsubset_Hname (&ZIs);
839 
	switch (CURRENT_TERMINAL) {
7 7u83 840 
	  case 60:
2 7u83 841 
	    break;
7 7u83 842 
	  case 75:
2 7u83 843 
	    RESTORE_LEXER;
844 
	    goto ZL1;
845 
	  default:
846 
	    goto ZL1;
847 
	}
848 
	ADVANCE_LEXER;
849 
	{
850 
 
851 
    object *p = make_subset ( (ZIs) ) ;
852 
    info *i = p->u.u_info ;
853 
    if ( i->subset ) {
854 
	char *nm = subset_name ( i->api, i->file, null_str ) ;
855 
	object *q = search_hash ( subsets, nm, no_version ) ;
856 
	update_time ( p, q ) ;
857 
    }
858 
    (ZIa) = crt_object ;
859 
    crt_object = p ;
860 
	}
861 
	switch (CURRENT_TERMINAL) {
7 7u83 862 
	  case 54:
2 7u83 863 
	    break;
864 
	  default:
865 
	    goto ZL1;
866 
	}
867 
	ADVANCE_LEXER;
868 
	ZRcommand_Hlist (&ZIb);
869 
	switch (CURRENT_TERMINAL) {
7 7u83 870 
	  case 55:
2 7u83 871 
	    break;
7 7u83 872 
	  case 75:
2 7u83 873 
	    RESTORE_LEXER;
874 
	    goto ZL1;
875 
	  default:
876 
	    goto ZL1;
877 
	}
878 
	ADVANCE_LEXER;
879 
	{
880 
 
881 
    object *p = crt_object ;
882 
    if ( p ) p->u.u_info->elements = (ZIb) ;
883 
    (ZIc) = make_object ( null_str, OBJ_SET ) ;
884 
    (ZIc)->u.u_obj = p ;
885 
    crt_object = (ZIa) ;
886 
	}
887 
    }
888 
    goto ZL0;
889 
  ZL1:;
7 7u83 890 
    SAVE_LEXER (75);
2 7u83 891 
    return;
892 
  ZL0:;
893 
    *ZOc = ZIc;
894 
}
895 
 
896 
static void
7 7u83 897 
ZRqualified_Htype(SID_TYPE *ZOt)
2 7u83 898 
{
899 
    SID_TYPE ZIt;
900 
 
901 
    switch (CURRENT_TERMINAL) {
7 7u83 902 
      case 0: case 32: case 34: case 35: case 37:
903 
      case 38: case 39: case 42: case 43: case 44:
904 
      case 45: case 46: case 47:
2 7u83 905 
	{
7 7u83 906 
	    SID_TYPE ZI331;
2 7u83 907 
 
7 7u83 908 
	    ZRsimple_Htype (&ZI331);
909 
	    ZR333 (&ZI331, &ZIt);
910 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 911 
		RESTORE_LEXER;
912 
		goto ZL1;
913 
	    }
914 
	}
915 
	break;
7 7u83 916 
      case 33: case 48:
2 7u83 917 
	{
918 
	    unsigned ZIcv;
919 
	    SID_TYPE ZIs;
920 
 
921 
	    ZRtype_Hqualifier (&ZIcv);
922 
	    ZRsimple_Htype (&ZIs);
7 7u83 923 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 924 
		RESTORE_LEXER;
925 
		goto ZL1;
926 
	    }
927 
	    {
928 
 
929 
    (ZIt) = make_subtype ( (ZIs), TYPE_QUALIFIER ) ;
930 
    (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
931 
	    }
932 
	}
933 
	break;
7 7u83 934 
      case 75:
2 7u83 935 
	return;
936 
      default:
937 
	goto ZL1;
938 
    }
939 
    goto ZL0;
940 
  ZL1:;
7 7u83 941 
    SAVE_LEXER (75);
2 7u83 942 
    return;
943 
  ZL0:;
944 
    *ZOt = ZIt;
945 
}
946 
 
947 
static void
7 7u83 948 
ZRabstract_Hdeclarator(SID_STRING *ZOnm, SID_TYPE *ZOt)
2 7u83 949 
{
950 
    SID_STRING ZInm;
951 
    SID_TYPE ZIt;
952 
 
953 
    switch (CURRENT_TERMINAL) {
954 
      default:
955 
	{
956 
	    ZRdirect_Habstract_Hdeclarator (&ZInm, &ZIt);
7 7u83 957 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 958 
		RESTORE_LEXER;
959 
		goto ZL1;
960 
	    }
961 
	}
962 
	break;
7 7u83 963 
      case 72:
2 7u83 964 
	{
965 
	    SID_TYPE ZIp;
966 
	    SID_TYPE ZIs;
967 
 
968 
	    ZRptr_Hoperator (&ZIp);
969 
	    ZRabstract_Hdeclarator (&ZInm, &ZIs);
7 7u83 970 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 971 
		RESTORE_LEXER;
972 
		goto ZL1;
973 
	    }
974 
	    {
975 
 
976 
    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
977 
	    }
978 
	}
979 
	break;
7 7u83 980 
      case 75:
2 7u83 981 
	return;
982 
    }
983 
    goto ZL0;
984 
  ZL1:;
7 7u83 985 
    SAVE_LEXER (75);
2 7u83 986 
    return;
987 
  ZL0:;
988 
    *ZOnm = ZInm;
989 
    *ZOt = ZIt;
990 
}
991 
 
992 
static void
7 7u83 993 
ZRparameter_Hlist(SID_TYPE *ZOp)
2 7u83 994 
{
995 
    SID_TYPE ZIp;
996 
 
7 7u83 997 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 998 
	return;
999 
    }
1000 
    {
1001 
	SID_TYPE ZIt;
1002 
	SID_TYPE ZIq;
1003 
 
1004 
	ZRparameter_Hdeclaration (&ZIt);
1005 
	{
1006 
	    switch (CURRENT_TERMINAL) {
7 7u83 1007 
	      case 62:
2 7u83 1008 
		{
1009 
		    ADVANCE_LEXER;
7 7u83 1010 
		    ZR339 (&ZIq);
1011 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1012 
			RESTORE_LEXER;
1013 
			goto ZL1;
1014 
		    }
1015 
		}
1016 
		break;
1017 
	      default:
1018 
		{
1019 
		    {
1020 
 
1021 
    (ZIq) = null ;
1022 
		    }
1023 
		}
1024 
		break;
7 7u83 1025 
	      case 75:
2 7u83 1026 
		RESTORE_LEXER;
1027 
		goto ZL1;
1028 
	    }
1029 
	}
1030 
	{
1031 
 
1032 
    (ZIp) = make_subtype ( (ZIt), TYPE_LIST ) ;
1033 
    (ZIp)->v.next = (ZIq) ;
1034 
	}
1035 
    }
1036 
    goto ZL0;
1037 
  ZL1:;
7 7u83 1038 
    SAVE_LEXER (75);
2 7u83 1039 
    return;
1040 
  ZL0:;
1041 
    *ZOp = ZIp;
1042 
}
1043 
 
1044 
static void
7 7u83 1045 
ZRinternal_Hname(SID_STRING *ZOnm, int *ZOv)
2 7u83 1046 
{
1047 
    SID_STRING ZInm;
1048 
    int ZIv;
1049 
 
7 7u83 1050 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1051 
	return;
1052 
    }
1053 
    {
1054 
	SID_STRING ZIa;
1055 
 
1056 
	switch (CURRENT_TERMINAL) {
1057 
	  case 0:
1058 
	    {
1059 
 ZIa = token_value ;
1060 
	    }
1061 
	    break;
1062 
	  default:
1063 
	    goto ZL1;
1064 
	}
1065 
	ADVANCE_LEXER;
1066 
	ZRname_Hversion (&ZIv);
7 7u83 1067 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 1068 
	    RESTORE_LEXER;
1069 
	    goto ZL1;
1070 
	}
1071 
	{
1072 
 
1073 
    if ( crt_field_name ) {
1074 
	(ZInm) = string_printf ( "%s.%s", crt_field_name, (ZIa) ) ;
1075 
    } else {
1076 
	(ZInm) = (ZIa) ;
1077 
    }
1078 
	}
1079 
    }
1080 
    goto ZL0;
1081 
  ZL1:;
7 7u83 1082 
    SAVE_LEXER (75);
2 7u83 1083 
    return;
1084 
  ZL0:;
1085 
    *ZOnm = ZInm;
1086 
    *ZOv = ZIv;
1087 
}
1088 
 
1089 
static void
7 7u83 1090 
ZR308(SID_STRING ZI304, SID_TYPE ZI305, SID_STRING *ZO306, SID_TYPE *ZO307)
2 7u83 1091 
{
7 7u83 1092 
    SID_STRING ZI306;
1093 
    SID_TYPE ZI307;
1094 
 
1095 
  ZL2_308:;
1096 
    switch (CURRENT_TERMINAL) {
1097 
      case 58:
1098 
	{
1099 
	    SID_STRING ZInm;
1100 
	    SID_TYPE ZIs;
1101 
	    SID_TYPE ZIt;
1102 
 
1103 
	    ZInm = ZI304;
1104 
	    ZRarray_Hoperator (&ZIs);
1105 
	    if ((CURRENT_TERMINAL) == 75) {
1106 
		RESTORE_LEXER;
1107 
		goto ZL1;
1108 
	    }
1109 
	    {
1110 
 
1111 
    (ZIt) = inject_type ( (ZI305), (ZIs) ) ;
1112 
	    }
1113 
	    ZI304 = ZInm;
1114 
	    ZI305 = ZIt;
1115 
	    goto ZL2_308;
1116 
	}
1117 
	/*UNREACHED*/
1118 
      default:
1119 
	{
1120 
	    ZI306 = ZI304;
1121 
	    ZI307 = ZI305;
1122 
	}
1123 
	break;
1124 
      case 75:
1125 
	return;
1126 
    }
1127 
    goto ZL0;
1128 
  ZL1:;
1129 
    SAVE_LEXER (75);
1130 
    return;
1131 
  ZL0:;
1132 
    *ZO306 = ZI306;
1133 
    *ZO307 = ZI307;
1134 
}
1135 
 
1136 
static void
1137 
ZRmacro_Hoperator(SID_TYPE *ZOt)
1138 
{
2 7u83 1139 
    SID_TYPE ZIt;
1140 
 
7 7u83 1141 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1142 
	return;
1143 
    }
1144 
    {
1145 
	switch (CURRENT_TERMINAL) {
7 7u83 1146 
	  case 56:
2 7u83 1147 
	    break;
1148 
	  default:
1149 
	    goto ZL1;
1150 
	}
1151 
	ADVANCE_LEXER;
7 7u83 1152 
	ZR350 (&ZIt);
1153 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 1154 
	    RESTORE_LEXER;
1155 
	    goto ZL1;
1156 
	}
1157 
    }
1158 
    goto ZL0;
1159 
  ZL1:;
7 7u83 1160 
    SAVE_LEXER (75);
2 7u83 1161 
    return;
1162 
  ZL0:;
1163 
    *ZOt = ZIt;
1164 
}
1165 
 
1166 
static void
7 7u83 1167 
ZRenumerator_Hlist(SID_COMMAND *ZOc)
2 7u83 1168 
{
1169 
    SID_COMMAND ZIc;
1170 
 
7 7u83 1171 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1172 
	return;
1173 
    }
1174 
    {
1175 
	SID_COMMAND ZIa;
1176 
	SID_COMMAND ZIb;
1177 
 
1178 
	ZRenumerator (&ZIa);
1179 
	{
1180 
	    switch (CURRENT_TERMINAL) {
7 7u83 1181 
	      case 62:
2 7u83 1182 
		{
1183 
		    ADVANCE_LEXER;
1184 
		    ZRenumerator_Hlist (&ZIb);
7 7u83 1185 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1186 
			RESTORE_LEXER;
1187 
			goto ZL1;
1188 
		    }
1189 
		}
1190 
		break;
1191 
	      default:
1192 
		{
1193 
		    {
1194 
 
1195 
    (ZIb) = null ;
1196 
		    }
1197 
		}
1198 
		break;
7 7u83 1199 
	      case 75:
2 7u83 1200 
		RESTORE_LEXER;
1201 
		goto ZL1;
1202 
	    }
1203 
	}
1204 
	{
1205 
 
1206 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
1207 
	}
1208 
    }
1209 
    goto ZL0;
1210 
  ZL1:;
7 7u83 1211 
    SAVE_LEXER (75);
2 7u83 1212 
    return;
1213 
  ZL0:;
1214 
    *ZOc = ZIc;
1215 
}
1216 
 
1217 
static void
7 7u83 1218 
ZRexternal_Hname(SID_STRING *ZOnm, int *ZOv)
2 7u83 1219 
{
1220 
    SID_STRING ZInm;
1221 
    int ZIv;
1222 
 
1223 
    switch (CURRENT_TERMINAL) {
1224 
      case 0:
1225 
	{
1226 
	    SID_STRING ZIa;
1227 
	    SID_STRING ZIb;
1228 
 
1229 
	    {
1230 
 ZIa = token_value ;
1231 
	    }
1232 
	    ADVANCE_LEXER;
1233 
	    ZRname_Hversion (&ZIv);
7 7u83 1234 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1235 
		RESTORE_LEXER;
1236 
		goto ZL1;
1237 
	    }
1238 
	    {
1239 
 
1240 
    if ( crt_field_name ) {
1241 
	(ZIb) = string_printf ( "%s.%s", crt_field_name, (ZIa) ) ;
1242 
    } else {
1243 
	(ZIb) = (ZIa) ;
1244 
    }
1245 
	    }
1246 
	    {
1247 
 
1248 
    (ZInm) = token_name ( (ZIb) ) ;
1249 
	    }
1250 
	}
1251 
	break;
1252 
      case 2:
1253 
	{
1254 
	    {
1255 
 ZInm = token_value ;
1256 
	    }
1257 
	    ADVANCE_LEXER;
1258 
	    ZRname_Hversion (&ZIv);
7 7u83 1259 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1260 
		RESTORE_LEXER;
1261 
		goto ZL1;
1262 
	    }
1263 
	}
1264 
	break;
7 7u83 1265 
      case 75:
2 7u83 1266 
	return;
1267 
      default:
1268 
	goto ZL1;
1269 
    }
1270 
    goto ZL0;
1271 
  ZL1:;
7 7u83 1272 
    SAVE_LEXER (75);
2 7u83 1273 
    return;
1274 
  ZL0:;
1275 
    *ZOnm = ZInm;
1276 
    *ZOv = ZIv;
1277 
}
1278 
 
1279 
static void
7 7u83 1280 
ZRtype_Hqualifier(unsigned *ZOcv)
2 7u83 1281 
{
1282 
    unsigned ZIcv;
1283 
 
1284 
    switch (CURRENT_TERMINAL) {
7 7u83 1285 
      case 33:
2 7u83 1286 
	{
1287 
	    unsigned ZIa;
1288 
 
1289 
	    ADVANCE_LEXER;
1290 
	    ZRtype_Hqualifier_Hopt (&ZIa);
7 7u83 1291 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1292 
		RESTORE_LEXER;
1293 
		goto ZL1;
1294 
	    }
1295 
	    {
1296 
 
1297 
    if ( (ZIa) & 1 ) error ( ERR_SERIOUS, "Duplicate type qualifier" ) ;
1298 
    (ZIcv) = ( (ZIa) | 1 ) ;
1299 
	    }
1300 
	}
1301 
	break;
7 7u83 1302 
      case 48:
2 7u83 1303 
	{
1304 
	    unsigned ZIa;
1305 
 
1306 
	    ADVANCE_LEXER;
1307 
	    ZRtype_Hqualifier_Hopt (&ZIa);
7 7u83 1308 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1309 
		RESTORE_LEXER;
1310 
		goto ZL1;
1311 
	    }
1312 
	    {
1313 
 
1314 
    if ( (ZIa) & 2 ) error ( ERR_SERIOUS, "Duplicate type qualifier" ) ;
1315 
    (ZIcv) = ( (ZIa) | 2 ) ;
1316 
	    }
1317 
	}
1318 
	break;
7 7u83 1319 
      case 75:
2 7u83 1320 
	return;
1321 
      default:
1322 
	goto ZL1;
1323 
    }
1324 
    goto ZL0;
1325 
  ZL1:;
7 7u83 1326 
    SAVE_LEXER (75);
2 7u83 1327 
    return;
1328 
  ZL0:;
1329 
    *ZOcv = ZIcv;
1330 
}
1331 
 
1332 
static void
7 7u83 1333 
ZRtype_Hkey(int *ZOtag)
2 7u83 1334 
{
1335 
    int ZItag;
1336 
 
1337 
    switch (CURRENT_TERMINAL) {
7 7u83 1338 
      case 35:
2 7u83 1339 
	{
1340 
	    ADVANCE_LEXER;
1341 
	    {
1342 
 (ZItag) = TYPE_ENUM_TAG ;
1343 
	    }
1344 
	}
1345 
	break;
7 7u83 1346 
      case 44:
2 7u83 1347 
	{
1348 
	    ADVANCE_LEXER;
1349 
	    {
1350 
 (ZItag) = TYPE_STRUCT_TAG ;
1351 
	    }
1352 
	}
1353 
	break;
7 7u83 1354 
      case 45:
2 7u83 1355 
	{
1356 
	    ADVANCE_LEXER;
1357 
	    {
1358 
 (ZItag) = TYPE_UNION_TAG ;
1359 
	    }
1360 
	}
1361 
	break;
1362 
      default:
1363 
	{
1364 
	    {
1365 
 (ZItag) = TYPE_GENERIC ;
1366 
	    }
1367 
	}
1368 
	break;
7 7u83 1369 
      case 75:
2 7u83 1370 
	return;
1371 
    }
1372 
    *ZOtag = ZItag;
1373 
}
1374 
 
1375 
static void
7 7u83 1376 
ZRtype_Hqualifier_Hopt(unsigned *ZOcv)
2 7u83 1377 
{
1378 
    unsigned ZIcv;
1379 
 
1380 
    switch (CURRENT_TERMINAL) {
7 7u83 1381 
      case 33: case 48:
2 7u83 1382 
	{
1383 
	    ZRtype_Hqualifier (&ZIcv);
7 7u83 1384 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1385 
		RESTORE_LEXER;
1386 
		goto ZL1;
1387 
	    }
1388 
	}
1389 
	break;
1390 
      default:
1391 
	{
1392 
	    {
1393 
 
1394 
    (ZIcv) = 0 ;
1395 
	    }
1396 
	}
1397 
	break;
7 7u83 1398 
      case 75:
2 7u83 1399 
	return;
1400 
    }
1401 
    goto ZL0;
1402 
  ZL1:;
7 7u83 1403 
    SAVE_LEXER (75);
2 7u83 1404 
    return;
1405 
  ZL0:;
1406 
    *ZOcv = ZIcv;
1407 
}
1408 
 
1409 
static void
7 7u83 1410 
ZRconstant_Hvalue(SID_STRING *ZOs)
2 7u83 1411 
{
1412 
    SID_STRING ZIs;
1413 
 
1414 
    switch (CURRENT_TERMINAL) {
7 7u83 1415 
      case 67:
2 7u83 1416 
	{
1417 
	    SID_STRING ZIa;
1418 
 
1419 
	    ADVANCE_LEXER;
1420 
	    ZRconstant_Hvalue (&ZIa);
7 7u83 1421 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1422 
		RESTORE_LEXER;
1423 
		goto ZL1;
1424 
	    }
1425 
	    {
1426 
 
1427 
    (ZIs) = string_concat ( "!", (ZIa) ) ;
1428 
	    }
1429 
	}
1430 
	break;
1431 
      case 5:
1432 
	{
1433 
	    {
1434 
 ZIs = token_value ;
1435 
	    }
1436 
	    ADVANCE_LEXER;
1437 
	}
1438 
	break;
7 7u83 1439 
      case 68:
2 7u83 1440 
	{
1441 
	    SID_STRING ZIa;
1442 
 
1443 
	    ADVANCE_LEXER;
1444 
	    ZRconstant_Hvalue (&ZIa);
7 7u83 1445 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1446 
		RESTORE_LEXER;
1447 
		goto ZL1;
1448 
	    }
1449 
	    {
1450 
 
1451 
    (ZIs) = string_concat ( "-", (ZIa) ) ;
1452 
	    }
1453 
	}
1454 
	break;
1455 
      case 0:
1456 
	{
1457 
	    SID_STRING ZIa;
1458 
 
1459 
	    {
1460 
 ZIa = token_value ;
1461 
	    }
1462 
	    ADVANCE_LEXER;
1463 
	    {
1464 
 
1465 
    object *p = search_hash ( exps, (ZIa), any_version ) ;
1466 
    if ( p == null ) {
1467 
	error ( ERR_SERIOUS, "Undefined NAT, '%s'", (ZIa) ) ;
1468 
    } else if ( p->objtype != OBJ_NAT ) {
1469 
	error ( ERR_SERIOUS, "'%s' is not a NAT", (ZIa) ) ;
1470 
    }
1471 
    (ZIs) = (ZIa) ;
1472 
	    }
1473 
	}
1474 
	break;
1475 
      case 1:
1476 
	{
1477 
	    {
1478 
 ZIs = token_value ;
1479 
	    }
1480 
	    ADVANCE_LEXER;
1481 
	}
1482 
	break;
7 7u83 1483 
      case 75:
2 7u83 1484 
	return;
1485 
      default:
1486 
	goto ZL1;
1487 
    }
1488 
    goto ZL0;
1489 
  ZL1:;
7 7u83 1490 
    SAVE_LEXER (75);
2 7u83 1491 
    return;
1492 
  ZL0:;
1493 
    *ZOs = ZIs;
1494 
}
1495 
 
1496 
static void
7 7u83 1497 
ZR318(SID_IDENTIFIER ZI312, SID_TYPE ZI313, SID_IDENTIFIER *ZO316, SID_TYPE *ZO317)
2 7u83 1498 
{
7 7u83 1499 
    SID_IDENTIFIER ZI316;
1500 
    SID_TYPE ZI317;
2 7u83 1501 
 
7 7u83 1502 
  ZL2_318:;
2 7u83 1503 
    switch (CURRENT_TERMINAL) {
7 7u83 1504 
      case 56: case 58:
2 7u83 1505 
	{
7 7u83 1506 
	    SID_IDENTIFIER ZIid;
2 7u83 1507 
 
7 7u83 1508 
	    ZIid = ZI312;
1509 
	    {
1510 
		switch (CURRENT_TERMINAL) {
1511 
		  case 58:
1512 
		    {
1513 
			SID_TYPE ZIs;
1514 
			SID_TYPE ZIt;
1515 
 
1516 
			ZRarray_Hoperator (&ZIs);
1517 
			if ((CURRENT_TERMINAL) == 75) {
1518 
			    RESTORE_LEXER;
1519 
			    goto ZL1;
1520 
			}
1521 
			{
1522 
 
1523 
    (ZIt) = inject_type ( (ZI313), (ZIs) ) ;
1524 
			}
1525 
			ZI312 = ZIid;
1526 
			ZI313 = ZIt;
1527 
			goto ZL2_318;
1528 
		    }
1529 
		    /*UNREACHED*/
1530 
		  case 56:
1531 
		    {
1532 
			SID_TYPE ZIs;
1533 
			SID_TYPE ZIt;
1534 
 
1535 
			ZRfunction_Hoperator (&ZIs);
1536 
			if ((CURRENT_TERMINAL) == 75) {
1537 
			    RESTORE_LEXER;
1538 
			    goto ZL1;
1539 
			}
1540 
			{
1541 
 
1542 
    (ZIt) = inject_type ( (ZI313), (ZIs) ) ;
1543 
			}
1544 
			ZI312 = ZIid;
1545 
			ZI313 = ZIt;
1546 
			goto ZL2_318;
1547 
		    }
1548 
		    /*UNREACHED*/
1549 
		  default:
1550 
		    goto ZL1;
2 7u83 1551 
		}
1552 
	    }
1553 
	}
7 7u83 1554 
	/*UNREACHED*/
2 7u83 1555 
      default:
1556 
	{
7 7u83 1557 
	    ZI316 = ZI312;
1558 
	    ZI317 = ZI313;
2 7u83 1559 
	}
1560 
	break;
7 7u83 1561 
      case 75:
2 7u83 1562 
	return;
1563 
    }
1564 
    goto ZL0;
1565 
  ZL1:;
7 7u83 1566 
    SAVE_LEXER (75);
2 7u83 1567 
    return;
1568 
  ZL0:;
7 7u83 1569 
    *ZO316 = ZI316;
1570 
    *ZO317 = ZI317;
2 7u83 1571 
}
1572 
 
1573 
static void
7 7u83 1574 
ZRspec_Hcommand(SID_COMMAND *ZOc)
2 7u83 1575 
{
1576 
    SID_COMMAND ZIc;
1577 
 
1578 
    switch (CURRENT_TERMINAL) {
1579 
      case 7:
1580 
	{
1581 
	    ADVANCE_LEXER;
1582 
	    {
1583 
 
1584 
    (ZIc) = null ;
1585 
	    }
1586 
	}
1587 
	break;
1588 
      case 9:
1589 
	{
1590 
	    SID_IDENTIFIER ZIid;
1591 
	    SID_STRING ZIp;
1592 
	    SID_STRING ZIs;
1593 
 
1594 
	    ADVANCE_LEXER;
1595 
	    ZRidentifier (&ZIid);
1596 
	    ZRdefine_Hparam_Hclause (&ZIp);
1597 
	    ZRconstant_Hvalue (&ZIs);
7 7u83 1598 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1599 
		RESTORE_LEXER;
1600 
		goto ZL1;
1601 
	    }
1602 
	    {
1603 
 
1604 
    char *def ;
1605 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_DEFINE ) ;
1606 
    if ( (ZIp) ) {
1607 
	if ( *(ZIp) ) {
1608 
	    def = string_printf ( "( %s ) %s", (ZIp), (ZIs) ) ;
1609 
	} else {
1610 
	    def = string_printf ( "() %s", (ZIs) ) ;
1611 
	}
1612 
    } else {
1613 
	def = string_printf ( " %s", (ZIs) ) ;
1614 
    }
1615 
    p->u.u_str = def ;
1616 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
1617 
	    }
1618 
	}
1619 
	break;
7 7u83 1620 
      case 30:
1621 
	{
1622 
	    SID_IDENTIFIER ZIid;
1623 
	    SID_STRING ZIp;
1624 
	    SID_STRING ZIs;
1625 
 
1626 
	    ADVANCE_LEXER;
1627 
	    ZRidentifier (&ZIid);
1628 
	    ZRdefine_Hparam_Hclause (&ZIp);
1629 
	    ZRconstant_Hvalue (&ZIs);
1630 
	    if ((CURRENT_TERMINAL) == 75) {
1631 
		RESTORE_LEXER;
1632 
		goto ZL1;
1633 
	    }
1634 
	    {
1635 
 
1636 
    char *def ;
1637 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_DEFMIN ) ;
1638 
    if ( (ZIp) ) {
1639 
	if ( *(ZIp) ) {
1640 
	    def = string_printf ( "( %s ) %s", (ZIp), (ZIs) ) ;
1641 
	} else {
1642 
	    def = string_printf ( "() %s", (ZIs) ) ;
1643 
	}
1644 
    } else {
1645 
	def = string_printf ( " %s", (ZIs) ) ;
1646 
    }
1647 
    p->u.u_str = def ;
1648 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
1649 
	    }
1650 
	}
1651 
	break;
2 7u83 1652 
      case 12:
1653 
	{
1654 
	    int ZItag;
1655 
	    SID_IDENTIFIER ZIid;
1656 
	    SID_COMMAND ZIe;
1657 
 
1658 
	    ADVANCE_LEXER;
1659 
	    ZRenum_Hcommand (&ZItag);
1660 
	    ZRidentifier (&ZIid);
1661 
	    switch (CURRENT_TERMINAL) {
7 7u83 1662 
	      case 60:
2 7u83 1663 
		break;
7 7u83 1664 
	      case 75:
2 7u83 1665 
		RESTORE_LEXER;
1666 
		goto ZL1;
1667 
	      default:
1668 
		goto ZL1;
1669 
	    }
1670 
	    ADVANCE_LEXER;
1671 
	    switch (CURRENT_TERMINAL) {
7 7u83 1672 
	      case 54:
2 7u83 1673 
		break;
1674 
	      default:
1675 
		goto ZL1;
1676 
	    }
1677 
	    ADVANCE_LEXER;
1678 
	    ZRenumerator_Hlist (&ZIe);
1679 
	    switch (CURRENT_TERMINAL) {
7 7u83 1680 
	      case 55:
2 7u83 1681 
		break;
7 7u83 1682 
	      case 75:
2 7u83 1683 
		RESTORE_LEXER;
1684 
		goto ZL1;
1685 
	      default:
1686 
		goto ZL1;
1687 
	    }
1688 
	    ADVANCE_LEXER;
1689 
	    {
1690 
 
1691 
    type *t = make_type ( (ZIid).iname, (ZIid).ivers, (ZItag) ) ;
1692 
    t->v.obj2 = (ZIe) ;
1693 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_TYPE ) ;
1694 
	    }
1695 
	}
1696 
	break;
1697 
      case 14:
1698 
	{
1699 
	    int ZItag;
1700 
	    SID_IDENTIFIER ZIid;
1701 
	    int ZIe;
1702 
	    SID_TYPE ZIt;
1703 
	    SID_COMMAND ZIa;
1704 
	    SID_COMMAND ZIb;
1705 
 
1706 
	    ADVANCE_LEXER;
1707 
	    ZRtype_Hcommand (&ZItag);
1708 
	    ZRidentifier (&ZIid);
1709 
	    ZRfield_Hexact (&ZIe);
7 7u83 1710 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1711 
		RESTORE_LEXER;
1712 
		goto ZL1;
1713 
	    }
1714 
	    {
1715 
 
1716 
    (ZIt) = find_type ( (ZIid).iname, any_version, (ZItag), 0 ) ;
1717 
    if ( (ZIt) == null ) {
1718 
	(ZIt) = make_type ( (ZIid).iname, (ZIid).ivers, (ZItag) ) ;
1719 
	(ZIa) = make_token ( (ZIid).ename, (ZIid).evers, (ZIt)->u.obj, OBJ_TYPE ) ;
1720 
    } else {
1721 
	(ZIa) = null ;
1722 
    }
1723 
    (ZIt) = expand_type ( (ZIt) ) ;
1724 
    switch ( (ZIt)->id ) {
1725 
	case TYPE_STRUCT :
1726 
	case TYPE_UNION :
1727 
	case TYPE_STRUCT_TAG :
1728 
	case TYPE_UNION_TAG : {
1729 
	    break ;
1730 
	}
1731 
	default : {
1732 
	    error ( ERR_SERIOUS, "Illegal field type, '%s'", (ZIid).iname ) ;
1733 
	    break ;
1734 
	}
1735 
    }
1736 
    crt_field_name = (ZIt)->u.obj->name ;
1737 
	    }
1738 
	    switch (CURRENT_TERMINAL) {
7 7u83 1739 
	      case 54:
2 7u83 1740 
		break;
1741 
	      default:
1742 
		goto ZL1;
1743 
	    }
1744 
	    ADVANCE_LEXER;
1745 
	    ZRfield_Hlist (ZIt, &ZIb);
1746 
	    switch (CURRENT_TERMINAL) {
7 7u83 1747 
	      case 55:
2 7u83 1748 
		break;
7 7u83 1749 
	      case 75:
2 7u83 1750 
		RESTORE_LEXER;
1751 
		goto ZL1;
1752 
	      default:
1753 
		goto ZL1;
1754 
	    }
1755 
	    ADVANCE_LEXER;
1756 
	    {
1757 
 
1758 
    if ( (ZIe) ) {
1759 
	if ( (ZIt)->v.obj2 ) {
1760 
	    char *nm = crt_field_name ;
1761 
	    error ( ERR_SERIOUS, "Redefinition of type '%s'", nm ) ;
1762 
	}
1763 
	if ( (ZIb) == null ) {
1764 
	    error ( ERR_SERIOUS, "Empty struct/union definition" ) ;
1765 
	} else {
1766 
	    (ZIt)->v.obj2 = (ZIb) ;
1767 
	}
1768 
	if ( (ZIa) == null ) {
1769 
	    /* This is a hack, do properly later */
1770 
	    (ZIc) = make_object ( null_str, OBJ_TYPE ) ;
1771 
	    (ZIc)->u.u_type = (ZIt) ;
1772 
	    if ( streq ( (ZIc)->filename, (ZIt)->u.obj->filename ) ) {
1773 
		(ZIt)->state = 1 ;
1774 
	    } else {
1775 
		(ZIt)->state = 3 ;
1776 
	    }
1777 
	} else {
1778 
	    (ZIc) = (ZIa) ;
1779 
	}
1780 
    } else {
1781 
	(ZIc) = join_object ( (ZIa), (ZIb) ) ;
1782 
    }
1783 
    crt_field_name = null ;
1784 
	    }
1785 
	}
1786 
	break;
1787 
      case 19:
1788 
	{
1789 
	    int ZIcmd;
1790 
	    SID_STRING ZIs;
1791 
	    SID_STRING ZIkey;
1792 
 
1793 
	    ADVANCE_LEXER;
1794 
	    {
1795 
 (ZIcmd) = OBJ_IMPLEMENT ;
1796 
	    }
1797 
	    ZRsubset_Hname (&ZIs);
1798 
	    ZRsubset_Hkey (&ZIkey);
7 7u83 1799 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1800 
		RESTORE_LEXER;
1801 
		goto ZL1;
1802 
	    }
1803 
	    {
1804 
 
1805 
    object *p = make_subset ( (ZIs) ) ;
1806 
    update_time ( crt_object, p ) ;
1807 
    (ZIc) = make_object ( (ZIkey), (ZIcmd) ) ;
1808 
    (ZIc)->u.u_obj = p ;
1809 
	    }
1810 
	}
1811 
	break;
1812 
      case 21:
1813 
	{
1814 
	    int ZIlv;
1815 
	    SID_TYPE ZIs;
1816 
	    SID_IDENTIFIER ZIid;
1817 
	    SID_TYPE ZIp;
1818 
	    SID_TYPE ZIu;
1819 
	    SID_TYPE ZIv;
1820 
	    SID_TYPE ZIq;
1821 
	    SID_TYPE ZIt;
1822 
 
1823 
	    ADVANCE_LEXER;
1824 
	    ZRobject_Hqualifier (&ZIlv);
1825 
	    ZRqualified_Htype (&ZIs);
1826 
	    ZRmacro_Hdeclarator (&ZIid, &ZIp);
7 7u83 1827 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1828 
		RESTORE_LEXER;
1829 
		goto ZL1;
1830 
	    }
1831 
	    {
1832 
 
1833 
    (ZIu) = inject_type ( (ZIp), (ZIs) ) ;
1834 
	    }
1835 
	    {
1836 
 
1837 
    (ZIv) = make_subtype ( (ZIu), (ZIlv) ) ;
1838 
	    }
7 7u83 1839 
	    ZR287 (&ZIq);
1840 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1841 
		RESTORE_LEXER;
1842 
		goto ZL1;
1843 
	    }
1844 
	    {
1845 
 
1846 
    (ZIt) = inject_type ( (ZIq), (ZIv) ) ;
1847 
	    }
1848 
	    {
1849 
 
1850 
    object *p ;
1851 
    int cmd = OBJ_MACRO ;
1852 
    if ( (ZIt)->id != TYPE_PROC ) cmd = OBJ_EXP ;
1853 
    p = make_exp ( (ZIid).iname, (ZIid).ivers, cmd ) ;
1854 
    p->u.u_type = check_type ( (ZIt), cmd ) ;
1855 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, cmd ) ;
1856 
	    }
1857 
	}
1858 
	break;
1859 
      case 22:
1860 
	{
1861 
	    ADVANCE_LEXER;
1862 
	    ZRnat_Hdeclarator_Hlist (&ZIc);
7 7u83 1863 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1864 
		RESTORE_LEXER;
1865 
		goto ZL1;
1866 
	    }
1867 
	}
1868 
	break;
1869 
      case 24:
1870 
	{
1871 
	    SID_IDENTIFIER ZIid;
1872 
	    SID_TYPE ZIt;
1873 
 
1874 
	    ADVANCE_LEXER;
1875 
	    ZRidentifier (&ZIid);
7 7u83 1876 
	    ZR287 (&ZIt);
1877 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1878 
		RESTORE_LEXER;
1879 
		goto ZL1;
1880 
	    }
1881 
	    {
1882 
 
1883 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_STATEMENT ) ;
1884 
    p->u.u_type = check_type ( (ZIt), OBJ_STATEMENT ) ;
1885 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_STATEMENT ) ;
1886 
	    }
1887 
	}
1888 
	break;
1889 
      case 26:
1890 
	{
1891 
	    SID_IDENTIFIER ZIid;
1892 
	    SID_STRING ZIs;
1893 
 
1894 
	    ADVANCE_LEXER;
1895 
	    ZRidentifier (&ZIid);
1896 
	    switch (CURRENT_TERMINAL) {
1897 
	      case 5:
1898 
		{
1899 
 ZIs = token_value ;
1900 
		}
1901 
		break;
7 7u83 1902 
	      case 75:
2 7u83 1903 
		RESTORE_LEXER;
1904 
		goto ZL1;
1905 
	      default:
1906 
		goto ZL1;
1907 
	    }
1908 
	    ADVANCE_LEXER;
1909 
	    {
1910 
 
1911 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_TOKEN ) ;
1912 
    p->u.u_str = (ZIs) ;
1913 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_TOKEN ) ;
1914 
	    }
1915 
	}
1916 
	break;
1917 
      case 27:
1918 
	{
1919 
	    ADVANCE_LEXER;
1920 
	    ZRtype_Hdeclarator_Hlist (&ZIc);
7 7u83 1921 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1922 
		RESTORE_LEXER;
1923 
		goto ZL1;
1924 
	    }
1925 
	}
1926 
	break;
1927 
      case 28:
1928 
	{
1929 
	    ADVANCE_LEXER;
7 7u83 1930 
	    ZR322 (&ZIc);
1931 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1932 
		RESTORE_LEXER;
1933 
		goto ZL1;
1934 
	    }
1935 
	}
1936 
	break;
1937 
      case 29:
1938 
	{
1939 
	    int ZIcmd;
1940 
 
1941 
	    ADVANCE_LEXER;
1942 
	    {
1943 
 (ZIcmd) = OBJ_USE ;
1944 
	    }
7 7u83 1945 
	    ZR323 (&ZIcmd, &ZIc);
1946 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1947 
		RESTORE_LEXER;
1948 
		goto ZL1;
1949 
	    }
1950 
	}
1951 
	break;
1952 
      case 8: case 13:
1953 
	{
1954 
	    int ZIcmd;
1955 
	    int ZIlv1;
1956 
	    int ZIlv;
1957 
	    SID_TYPE ZIt;
1958 
 
1959 
	    ZRexp_Hcommand (&ZIcmd);
1960 
	    ZRobject_Hqualifier (&ZIlv1);
7 7u83 1961 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1962 
		RESTORE_LEXER;
1963 
		goto ZL1;
1964 
	    }
1965 
	    {
1966 
 
1967 
    if ( (ZIcmd) == OBJ_CONST ) {
1968 
	if ( (ZIlv1) == TYPE_LVALUE ) {
1969 
	    error ( ERR_SERIOUS, "Constant can't be an lvalue" ) ;
1970 
	}
1971 
	(ZIlv) = TYPE_RVALUE ;
1972 
    } else if ( (ZIcmd) == OBJ_EXTERN ) {
1973 
	(ZIlv) = TYPE_LVALUE ;
1974 
    } else {
1975 
	(ZIlv) = (ZIlv1) ;
1976 
    }
1977 
	    }
1978 
	    ZRqualified_Htype (&ZIt);
1979 
	    ZRexp_Hdeclarator_Hlist (ZIcmd, ZIt, ZIlv, &ZIc);
7 7u83 1980 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1981 
		RESTORE_LEXER;
1982 
		goto ZL1;
1983 
	    }
1984 
	}
1985 
	break;
1986 
      case 15:
1987 
	{
1988 
	    int ZIcmd;
1989 
	    SID_TYPE ZIs;
1990 
	    SID_IDENTIFIER ZIid;
1991 
	    SID_TYPE ZIp;
1992 
	    SID_TYPE ZIt;
1993 
 
1994 
	    ZRfunc_Hcommand (&ZIcmd);
1995 
	    ZRqualified_Htype (&ZIs);
1996 
	    ZRdeclarator (&ZIid, &ZIp);
7 7u83 1997 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 1998 
		RESTORE_LEXER;
1999 
		goto ZL1;
2000 
	    }
2001 
	    {
2002 
 
2003 
    (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
2004 
	    }
2005 
	    {
2006 
 
2007 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, (ZIcmd) ) ;
2008 
    p->u.u_type = check_type ( (ZIt), OBJ_FUNC ) ;
2009 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, (ZIcmd) ) ;
2010 
	    }
2011 
	}
2012 
	break;
2013 
      case 23:
2014 
	{
2015 
	    ZRsubset_Hcommand (&ZIc);
7 7u83 2016 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2017 
		RESTORE_LEXER;
2018 
		goto ZL1;
2019 
	    }
2020 
	}
2021 
	break;
7 7u83 2022 
      case 75:
2 7u83 2023 
	return;
2024 
      default:
2025 
	goto ZL1;
2026 
    }
2027 
    goto ZL0;
2028 
  ZL1:;
7 7u83 2029 
    SAVE_LEXER (75);
2 7u83 2030 
    return;
2031 
  ZL0:;
2032 
    *ZOc = ZIc;
2033 
}
2034 
 
2035 
static void
7 7u83 2036 
ZRfunc_Hcommand(int *ZOcmd)
2 7u83 2037 
{
7 7u83 2038 
    int ZIcmd;
2039 
 
2040 
    if ((CURRENT_TERMINAL) == 75) {
2041 
	return;
2042 
    }
2043 
    {
2044 
	switch (CURRENT_TERMINAL) {
2045 
	  case 15:
2046 
	    break;
2047 
	  default:
2048 
	    goto ZL1;
2049 
	}
2050 
	ADVANCE_LEXER;
2051 
	ZR348 (&ZIcmd);
2052 
	if ((CURRENT_TERMINAL) == 75) {
2053 
	    RESTORE_LEXER;
2054 
	    goto ZL1;
2055 
	}
2056 
    }
2057 
    goto ZL0;
2058 
  ZL1:;
2059 
    SAVE_LEXER (75);
2060 
    return;
2061 
  ZL0:;
2062 
    *ZOcmd = ZIcmd;
2063 
}
2064 
 
2065 
static void
2066 
ZR320(SID_STRING *ZIa, SID_STRING *ZOs)
2067 
{
2 7u83 2068 
    SID_STRING ZIs;
2069 
 
2070 
    switch (CURRENT_TERMINAL) {
7 7u83 2071 
      case 62:
2 7u83 2072 
	{
7 7u83 2073 
	    SID_STRING ZIb;
2074 
 
2075 
	    ADVANCE_LEXER;
2076 
	    switch (CURRENT_TERMINAL) {
2077 
	      case 2:
2078 
		{
2079 
 ZIb = token_value ;
2080 
		}
2081 
		break;
2082 
	      default:
2083 
		goto ZL1;
2084 
	    }
2085 
	    ADVANCE_LEXER;
2086 
	    ZR321 (ZIa, &ZIb, &ZIs);
2087 
	    if ((CURRENT_TERMINAL) == 75) {
2088 
		RESTORE_LEXER;
2089 
		goto ZL1;
2090 
	    }
2091 
	}
2092 
	break;
2093 
      default:
2094 
	{
2095 
	    {
2096 
 
2097 
    (ZIs) = subset_name ( (*ZIa), null_str, null_str ) ;
2098 
	    }
2099 
	}
2100 
	break;
2101 
      case 75:
2102 
	return;
2103 
    }
2104 
    goto ZL0;
2105 
  ZL1:;
2106 
    SAVE_LEXER (75);
2107 
    return;
2108 
  ZL0:;
2109 
    *ZOs = ZIs;
2110 
}
2111 
 
2112 
static void
2113 
ZR321(SID_STRING *ZIa, SID_STRING *ZIb, SID_STRING *ZOs)
2114 
{
2115 
    SID_STRING ZIs;
2116 
 
2117 
    switch (CURRENT_TERMINAL) {
2118 
      case 62:
2119 
	{
2 7u83 2120 
	    SID_STRING ZIc;
2121 
 
2122 
	    ADVANCE_LEXER;
2123 
	    switch (CURRENT_TERMINAL) {
2124 
	      case 2:
2125 
		{
2126 
 ZIc = token_value ;
2127 
		}
2128 
		break;
2129 
	      default:
2130 
		goto ZL1;
2131 
	    }
2132 
	    ADVANCE_LEXER;
2133 
	    {
2134 
 
2135 
    if ( (*ZIb) [0] == 0 ) (*ZIb) = null ;
2136 
    (ZIs) = subset_name ( (*ZIa), (*ZIb), (ZIc) ) ;
2137 
	    }
2138 
	}
2139 
	break;
2140 
      default:
2141 
	{
2142 
	    {
2143 
 
2144 
    (ZIs) = subset_name ( (*ZIa), (*ZIb), null_str ) ;
2145 
	    }
2146 
	}
2147 
	break;
7 7u83 2148 
      case 75:
2 7u83 2149 
	return;
2150 
    }
2151 
    goto ZL0;
2152 
  ZL1:;
7 7u83 2153 
    SAVE_LEXER (75);
2 7u83 2154 
    return;
2155 
  ZL0:;
2156 
    *ZOs = ZIs;
2157 
}
2158 
 
2159 
static void
7 7u83 2160 
ZRarray_Hoperator(SID_TYPE *ZOt)
2 7u83 2161 
{
7 7u83 2162 
    SID_TYPE ZIt;
2 7u83 2163 
 
7 7u83 2164 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2165 
	return;
2166 
    }
2167 
    {
7 7u83 2168 
	SID_STRING ZIa;
2169 
 
2 7u83 2170 
	switch (CURRENT_TERMINAL) {
7 7u83 2171 
	  case 58:
2 7u83 2172 
	    break;
2173 
	  default:
2174 
	    goto ZL1;
2175 
	}
2176 
	ADVANCE_LEXER;
7 7u83 2177 
	{
2178 
	    switch (CURRENT_TERMINAL) {
2179 
	      case 0: case 1: case 5: case 67: case 68:
2180 
		{
2181 
		    ZRconstant_Hvalue (&ZIa);
2182 
		    if ((CURRENT_TERMINAL) == 75) {
2183 
			RESTORE_LEXER;
2184 
			goto ZL1;
2185 
		    }
2186 
		}
2187 
		break;
2188 
	      default:
2189 
		{
2190 
		    {
2191 
 
2192 
    (ZIa) = "" ;
2193 
		    }
2194 
		}
2195 
		break;
2196 
	    }
2197 
	}
2198 
	switch (CURRENT_TERMINAL) {
2199 
	  case 59:
2200 
	    break;
2201 
	  default:
2 7u83 2202 
	    goto ZL1;
2203 
	}
7 7u83 2204 
	ADVANCE_LEXER;
2205 
	{
2206 
 
2207 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_ARRAY ) ;
2208 
    (ZIt)->v.str = (ZIa) ;
2209 
	}
2 7u83 2210 
    }
2211 
    goto ZL0;
2212 
  ZL1:;
7 7u83 2213 
    SAVE_LEXER (75);
2 7u83 2214 
    return;
2215 
  ZL0:;
7 7u83 2216 
    *ZOt = ZIt;
2 7u83 2217 
}
2218 
 
2219 
static void
7 7u83 2220 
ZR322(SID_COMMAND *ZOc)
2 7u83 2221 
{
2222 
    SID_COMMAND ZIc;
2223 
 
2224 
    switch (CURRENT_TERMINAL) {
7 7u83 2225 
      case 51:
2 7u83 2226 
	{
2227 
	    SID_TYPE ZIt;
2228 
	    SID_IDENTIFIER ZIid;
2229 
 
2230 
	    ADVANCE_LEXER;
2231 
	    switch (CURRENT_TERMINAL) {
7 7u83 2232 
	      case 56:
2 7u83 2233 
		break;
2234 
	      default:
2235 
		goto ZL1;
2236 
	    }
2237 
	    ADVANCE_LEXER;
2238 
	    ZRqualified_Htype (&ZIt);
2239 
	    switch (CURRENT_TERMINAL) {
7 7u83 2240 
	      case 57:
2 7u83 2241 
		break;
7 7u83 2242 
	      case 75:
2 7u83 2243 
		RESTORE_LEXER;
2244 
		goto ZL1;
2245 
	      default:
2246 
		goto ZL1;
2247 
	    }
2248 
	    ADVANCE_LEXER;
2249 
	    ZRidentifier (&ZIid);
7 7u83 2250 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2251 
		RESTORE_LEXER;
2252 
		goto ZL1;
2253 
	    }
2254 
	    {
2255 
 
2256 
    type *t = make_type ( (ZIid).iname, (ZIid).ivers, TYPE_PROMOTE ) ;
2257 
    type *s = expand_type ( (ZIt) ) ;
2258 
    switch ( s->id ) {
2259 
	case TYPE_INT :
2260 
	case TYPE_SIGNED :
2261 
	case TYPE_UNSIGNED : {
2262 
	    break ;
2263 
	}
2264 
	default : {
2265 
	    error ( ERR_SERIOUS, "Non-integral promotion type" ) ;
2266 
	    break ;
2267 
	}
2268 
    }
2269 
    t->v.next = s ;
2270 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
2271 
	    }
2272 
	}
2273 
	break;
7 7u83 2274 
      case 53:
2 7u83 2275 
	{
2276 
	    SID_STRING ZIs;
2277 
	    SID_TYPE ZIt;
2278 
	    SID_IDENTIFIER ZIid;
2279 
 
2280 
	    ADVANCE_LEXER;
2281 
	    switch (CURRENT_TERMINAL) {
7 7u83 2282 
	      case 56:
2 7u83 2283 
		break;
2284 
	      default:
2285 
		goto ZL1;
2286 
	    }
2287 
	    ADVANCE_LEXER;
2288 
	    switch (CURRENT_TERMINAL) {
2289 
	      case 2:
2290 
		{
2291 
 ZIs = token_value ;
2292 
		}
2293 
		break;
2294 
	      default:
2295 
		goto ZL1;
2296 
	    }
2297 
	    ADVANCE_LEXER;
2298 
	    switch (CURRENT_TERMINAL) {
7 7u83 2299 
	      case 57:
2 7u83 2300 
		break;
2301 
	      default:
2302 
		goto ZL1;
2303 
	    }
2304 
	    ADVANCE_LEXER;
2305 
	    {
2306 
 
2307 
    (ZIt) = special_type ( (ZIs) ) ;
2308 
	    }
2309 
	    ZRidentifier (&ZIid);
7 7u83 2310 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2311 
		RESTORE_LEXER;
2312 
		goto ZL1;
2313 
	    }
2314 
	    {
2315 
 
2316 
    type *t = make_type ( (ZIid).iname, (ZIid).ivers, TYPE_DEFINED ) ;
2317 
    t->v.next = check_type ( (ZIt), OBJ_TYPE ) ;
2318 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
2319 
	    }
2320 
	}
2321 
	break;
7 7u83 2322 
      case 0: case 32: case 33: case 34: case 35:
2323 
      case 37: case 38: case 39: case 42: case 43:
2324 
      case 44: case 45: case 46: case 47: case 48:
2 7u83 2325 
	{
2326 
	    SID_TYPE ZIs;
2327 
	    SID_IDENTIFIER ZIid;
2328 
	    SID_TYPE ZIp;
2329 
	    SID_TYPE ZIt;
2330 
 
2331 
	    ZRqualified_Htype (&ZIs);
2332 
	    ZRdeclarator (&ZIid, &ZIp);
7 7u83 2333 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2334 
		RESTORE_LEXER;
2335 
		goto ZL1;
2336 
	    }
2337 
	    {
2338 
 
2339 
    (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
2340 
	    }
2341 
	    {
2342 
 
2343 
    type *t = make_type ( (ZIid).iname, (ZIid).ivers, TYPE_DEFINED ) ;
2344 
    t->v.next = check_type ( (ZIt), OBJ_TYPE ) ;
2345 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, t->u.obj, OBJ_EXTERN ) ;
2346 
	    }
2347 
	}
2348 
	break;
7 7u83 2349 
      case 75:
2 7u83 2350 
	return;
2351 
      default:
2352 
	goto ZL1;
2353 
    }
2354 
    goto ZL0;
2355 
  ZL1:;
7 7u83 2356 
    SAVE_LEXER (75);
2 7u83 2357 
    return;
2358 
  ZL0:;
2359 
    *ZOc = ZIc;
2360 
}
2361 
 
2362 
static void
7 7u83 2363 
ZR323(int *ZIcmd, SID_COMMAND *ZOc)
2 7u83 2364 
{
2365 
    SID_COMMAND ZIc;
2366 
 
2367 
    switch (CURRENT_TERMINAL) {
2368 
      case 2:
2369 
	{
2370 
	    SID_STRING ZIs;
2371 
	    SID_STRING ZIkey;
2372 
 
2373 
	    ZRsubset_Hname (&ZIs);
2374 
	    ZRsubset_Hkey (&ZIkey);
7 7u83 2375 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2376 
		RESTORE_LEXER;
2377 
		goto ZL1;
2378 
	    }
2379 
	    {
2380 
 
2381 
    object *p = make_subset ( (ZIs) ) ;
2382 
    update_time ( crt_object, p ) ;
2383 
    (ZIc) = make_object ( (ZIkey), (*ZIcmd) ) ;
2384 
    (ZIc)->u.u_obj = p ;
2385 
	    }
2386 
	}
2387 
	break;
7 7u83 2388 
      case 56:
2 7u83 2389 
	{
2390 
	    SID_STRING ZIs;
2391 
	    SID_STRING ZIkey1;
2392 
	    SID_STRING ZIkey;
2393 
 
2394 
	    ZRuse_Hsubset_Hname (&ZIs);
2395 
	    ZRsubset_Hkey (&ZIkey1);
7 7u83 2396 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2397 
		RESTORE_LEXER;
2398 
		goto ZL1;
2399 
	    }
2400 
	    {
2401 
 (ZIkey) = string_concat ( (ZIkey1), "G" ) ;
2402 
	    }
2403 
	    {
2404 
 
2405 
    object *p = make_subset ( (ZIs) ) ;
2406 
    update_time ( crt_object, p ) ;
2407 
    (ZIc) = make_object ( (ZIkey), (*ZIcmd) ) ;
2408 
    (ZIc)->u.u_obj = p ;
2409 
	    }
2410 
	}
2411 
	break;
7 7u83 2412 
      case 75:
2 7u83 2413 
	return;
2414 
      default:
2415 
	goto ZL1;
2416 
    }
2417 
    goto ZL0;
2418 
  ZL1:;
7 7u83 2419 
    SAVE_LEXER (75);
2 7u83 2420 
    return;
2421 
  ZL0:;
2422 
    *ZOc = ZIc;
2423 
}
2424 
 
2425 
static void
7 7u83 2426 
ZRmacro_Hparam_Hlist(SID_TYPE *ZOp)
2 7u83 2427 
{
7 7u83 2428 
    SID_TYPE ZIp;
2 7u83 2429 
 
7 7u83 2430 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2431 
	return;
2432 
    }
2433 
    {
7 7u83 2434 
	SID_TYPE ZIt;
2435 
	SID_TYPE ZIq;
2 7u83 2436 
 
7 7u83 2437 
	ZRmacro_Hparam_Hdeclaration (&ZIt);
2 7u83 2438 
	{
2439 
	    switch (CURRENT_TERMINAL) {
7 7u83 2440 
	      case 62:
2 7u83 2441 
		{
7 7u83 2442 
		    ADVANCE_LEXER;
2443 
		    ZRmacro_Hparam_Hlist (&ZIq);
2444 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2445 
			RESTORE_LEXER;
2446 
			goto ZL1;
2447 
		    }
2448 
		}
2449 
		break;
2450 
	      default:
2451 
		{
2452 
		    {
2453 
 
7 7u83 2454 
    (ZIq) = null ;
2 7u83 2455 
		    }
2456 
		}
2457 
		break;
7 7u83 2458 
	      case 75:
2459 
		RESTORE_LEXER;
2460 
		goto ZL1;
2 7u83 2461 
	    }
2462 
	}
2463 
	{
2464 
 
7 7u83 2465 
    (ZIp) = make_subtype ( (ZIt), TYPE_LIST ) ;
2466 
    (ZIp)->v.next = (ZIq) ;
2 7u83 2467 
	}
2468 
    }
2469 
    goto ZL0;
2470 
  ZL1:;
7 7u83 2471 
    SAVE_LEXER (75);
2 7u83 2472 
    return;
2473 
  ZL0:;
7 7u83 2474 
    *ZOp = ZIp;
2 7u83 2475 
}
2476 
 
2477 
static void
7 7u83 2478 
ZR324(SID_STRING *ZInm, int *ZIv, SID_IDENTIFIER *ZOid)
2 7u83 2479 
{
2480 
    SID_IDENTIFIER ZIid;
2481 
 
2482 
    switch (CURRENT_TERMINAL) {
7 7u83 2483 
      case 69:
2 7u83 2484 
	{
2485 
	    SID_STRING ZItnm;
2486 
	    int ZItv;
2487 
 
2488 
	    ADVANCE_LEXER;
2489 
	    ZRexternal_Hname (&ZItnm, &ZItv);
7 7u83 2490 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2491 
		RESTORE_LEXER;
2492 
		goto ZL1;
2493 
	    }
2494 
	    {
2495 
 
2496 
    (ZIid).iname = (*ZInm) ;
2497 
    (ZIid).ivers = (*ZIv) ;
2498 
    (ZIid).ename = (ZItnm) ;
2499 
    (ZIid).evers = (ZItv) ;
2500 
	    }
2501 
	}
2502 
	break;
2503 
      default:
2504 
	{
2505 
	    SID_STRING ZItnm;
2506 
 
2507 
	    {
2508 
 
2509 
    (ZItnm) = token_name ( (*ZInm) ) ;
2510 
	    }
2511 
	    {
2512 
 
2513 
    (ZIid).iname = (*ZInm) ;
2514 
    (ZIid).ivers = (*ZIv) ;
2515 
    (ZIid).ename = (ZItnm) ;
2516 
    (ZIid).evers = (*ZIv) ;
2517 
	    }
2518 
	}
2519 
	break;
7 7u83 2520 
      case 75:
2 7u83 2521 
	return;
2522 
    }
2523 
    goto ZL0;
2524 
  ZL1:;
7 7u83 2525 
    SAVE_LEXER (75);
2 7u83 2526 
    return;
2527 
  ZL0:;
2528 
    *ZOid = ZIid;
2529 
}
2530 
 
2531 
static void
7 7u83 2532 
ZR325(SID_STRING *ZOp)
2 7u83 2533 
{
2534 
    SID_STRING ZIp;
2535 
 
2536 
    switch (CURRENT_TERMINAL) {
7 7u83 2537 
      case 57:
2 7u83 2538 
	{
2539 
	    ADVANCE_LEXER;
2540 
	    {
2541 
 (ZIp) = "" ;
2542 
	    }
2543 
	}
2544 
	break;
2545 
      case 0:
2546 
	{
2547 
	    ZRdefine_Hparam_Hlist (&ZIp);
2548 
	    switch (CURRENT_TERMINAL) {
7 7u83 2549 
	      case 57:
2 7u83 2550 
		break;
7 7u83 2551 
	      case 75:
2 7u83 2552 
		RESTORE_LEXER;
2553 
		goto ZL1;
2554 
	      default:
2555 
		goto ZL1;
2556 
	    }
2557 
	    ADVANCE_LEXER;
2558 
	}
2559 
	break;
7 7u83 2560 
      case 75:
2 7u83 2561 
	return;
2562 
      default:
2563 
	goto ZL1;
2564 
    }
2565 
    goto ZL0;
2566 
  ZL1:;
7 7u83 2567 
    SAVE_LEXER (75);
2 7u83 2568 
    return;
2569 
  ZL0:;
2570 
    *ZOp = ZIp;
2571 
}
2572 
 
2573 
static void
7 7u83 2574 
ZR328(SID_STRING *ZI326, SID_STRING *ZOp)
2 7u83 2575 
{
2576 
    SID_STRING ZIp;
2577 
 
2578 
    switch (CURRENT_TERMINAL) {
7 7u83 2579 
      case 62:
2 7u83 2580 
	{
2581 
	    SID_STRING ZIq;
2582 
 
2583 
	    ADVANCE_LEXER;
2584 
	    ZRdefine_Hparam_Hlist (&ZIq);
7 7u83 2585 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2586 
		RESTORE_LEXER;
2587 
		goto ZL1;
2588 
	    }
2589 
	    {
2590 
 
7 7u83 2591 
    (ZIp) = string_printf ( "%s, %s", (*ZI326), (ZIq) ) ;
2 7u83 2592 
	    }
2593 
	}
2594 
	break;
2595 
      default:
2596 
	{
7 7u83 2597 
	    ZIp = *ZI326;
2 7u83 2598 
	}
2599 
	break;
7 7u83 2600 
      case 75:
2 7u83 2601 
	return;
2602 
    }
2603 
    goto ZL0;
2604 
  ZL1:;
7 7u83 2605 
    SAVE_LEXER (75);
2 7u83 2606 
    return;
2607 
  ZL0:;
2608 
    *ZOp = ZIp;
2609 
}
2610 
 
2611 
static void
7 7u83 2612 
ZRenum_Hcommand(int *ZOtag)
2 7u83 2613 
{
7 7u83 2614 
    int ZItag;
2 7u83 2615 
 
2616 
    switch (CURRENT_TERMINAL) {
2617 
      case 35:
2618 
	{
2619 
	    ADVANCE_LEXER;
2620 
	    {
2621 
 (ZItag) = TYPE_ENUM_TAG ;
2622 
	    }
2623 
	}
2624 
	break;
2625 
      default:
2626 
	{
2627 
	    {
2628 
 (ZItag) = TYPE_ENUM ;
2629 
	    }
2630 
	}
2631 
	break;
7 7u83 2632 
      case 75:
2 7u83 2633 
	return;
2634 
    }
2635 
    *ZOtag = ZItag;
2636 
}
2637 
 
2638 
static void
7 7u83 2639 
ZRenumerator(SID_COMMAND *ZOc)
2 7u83 2640 
{
2641 
    SID_COMMAND ZIc;
2642 
 
7 7u83 2643 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2644 
	return;
2645 
    }
2646 
    {
2647 
	SID_IDENTIFIER ZIid;
2648 
	SID_STRING ZIs;
2649 
 
2650 
	ZRidentifier (&ZIid);
2651 
	{
2652 
	    switch (CURRENT_TERMINAL) {
7 7u83 2653 
	      case 66:
2 7u83 2654 
		{
2655 
		    ADVANCE_LEXER;
2656 
		    ZRconstant_Hvalue (&ZIs);
7 7u83 2657 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2658 
			RESTORE_LEXER;
2659 
			goto ZL1;
2660 
		    }
2661 
		}
2662 
		break;
2663 
	      default:
2664 
		{
2665 
		    {
2666 
 
2667 
    (ZIs) = "" ;
2668 
		    }
2669 
		}
2670 
		break;
7 7u83 2671 
	      case 75:
2 7u83 2672 
		RESTORE_LEXER;
2673 
		goto ZL1;
2674 
	    }
2675 
	}
2676 
	{
2677 
 
2678 
    object *p = make_exp ( (ZIid).iname, (ZIid).ivers, OBJ_ENUMVAL ) ;
2679 
    p->u.u_str = (ZIs) ;
2680 
    (ZIc) = make_token ( (ZIid).ename, (ZIid).evers, p, OBJ_EXTERN ) ;
2681 
	}
2682 
    }
2683 
    goto ZL0;
2684 
  ZL1:;
7 7u83 2685 
    SAVE_LEXER (75);
2 7u83 2686 
    return;
2687 
  ZL0:;
2688 
    *ZOc = ZIc;
2689 
}
2690 
 
2691 
static void
7 7u83 2692 
ZR329(int *ZOcmd)
2 7u83 2693 
{
7 7u83 2694 
    int ZIcmd;
2695 
 
2696 
    switch (CURRENT_TERMINAL) {
2697 
      case 56:
2698 
	{
2699 
	    ADVANCE_LEXER;
2700 
	    ZR330 (&ZIcmd);
2701 
	    if ((CURRENT_TERMINAL) == 75) {
2702 
		RESTORE_LEXER;
2703 
		goto ZL1;
2704 
	    }
2705 
	}
2706 
	break;
2707 
      default:
2708 
	{
2709 
	    {
2710 
 (ZIcmd) = OBJ_EXP ;
2711 
	    }
2712 
	}
2713 
	break;
2714 
      case 75:
2715 
	return;
2716 
    }
2717 
    goto ZL0;
2718 
  ZL1:;
2719 
    SAVE_LEXER (75);
2720 
    return;
2721 
  ZL0:;
2722 
    *ZOcmd = ZIcmd;
2723 
}
2724 
 
2725 
static void
2726 
ZRfield_Hdeclarator_Hlist(SID_TYPE ZIm, SID_TYPE ZIs, SID_COMMAND *ZOc)
2727 
{
2 7u83 2728 
    SID_COMMAND ZIc;
2729 
 
7 7u83 2730 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2731 
	return;
2732 
    }
2733 
    {
2734 
	SID_IDENTIFIER ZIid;
2735 
	SID_TYPE ZIp;
2736 
	SID_TYPE ZIt;
2737 
	SID_COMMAND ZIa;
2738 
	SID_COMMAND ZIb;
2739 
 
2740 
	ZRfield_Hdeclarator (&ZIid, &ZIp);
7 7u83 2741 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 2742 
	    RESTORE_LEXER;
2743 
	    goto ZL1;
2744 
	}
2745 
	{
2746 
 
2747 
    (ZIt) = inject_type ( (ZIp), (ZIs) ) ;
2748 
	}
2749 
	{
2750 
 
2751 
    type *t = check_type ( (ZIt), OBJ_FIELD ) ;
2752 
    field *f = make_field ( (ZIid).iname, (ZIid).ivers, (ZIm), t ) ;
2753 
    (ZIa) = make_token ( (ZIid).ename, (ZIid).evers, f->obj, OBJ_FIELD ) ;
2754 
	}
2755 
	{
2756 
	    switch (CURRENT_TERMINAL) {
7 7u83 2757 
	      case 62:
2 7u83 2758 
		{
2759 
		    ADVANCE_LEXER;
2760 
		    ZRfield_Hdeclarator_Hlist (ZIm, ZIs, &ZIb);
7 7u83 2761 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2762 
			RESTORE_LEXER;
2763 
			goto ZL1;
2764 
		    }
2765 
		}
2766 
		break;
2767 
	      default:
2768 
		{
2769 
		    {
2770 
 
2771 
    (ZIb) = null ;
2772 
		    }
2773 
		}
2774 
		break;
2775 
	    }
2776 
	}
2777 
	{
2778 
 
2779 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
2780 
	}
2781 
    }
2782 
    goto ZL0;
2783 
  ZL1:;
7 7u83 2784 
    SAVE_LEXER (75);
2 7u83 2785 
    return;
2786 
  ZL0:;
2787 
    *ZOc = ZIc;
2788 
}
2789 
 
2790 
static void
7 7u83 2791 
ZR330(int *ZOcmd)
2 7u83 2792 
{
7 7u83 2793 
    int ZIcmd;
2 7u83 2794 
 
2795 
    switch (CURRENT_TERMINAL) {
7 7u83 2796 
      case 33:
2 7u83 2797 
	{
7 7u83 2798 
	    ADVANCE_LEXER;
2799 
	    switch (CURRENT_TERMINAL) {
2800 
	      case 57:
2801 
		break;
2802 
	      default:
2 7u83 2803 
		goto ZL1;
2804 
	    }
7 7u83 2805 
	    ADVANCE_LEXER;
2 7u83 2806 
	    {
7 7u83 2807 
 (ZIcmd) = OBJ_CONST ;
2 7u83 2808 
	    }
2809 
	}
2810 
	break;
7 7u83 2811 
      case 36:
2 7u83 2812 
	{
7 7u83 2813 
	    ADVANCE_LEXER;
2814 
	    switch (CURRENT_TERMINAL) {
2815 
	      case 57:
2816 
		break;
2817 
	      default:
2818 
		goto ZL1;
2819 
	    }
2820 
	    ADVANCE_LEXER;
2821 
	    {
2822 
 (ZIcmd) = OBJ_EXTERN ;
2823 
	    }
2 7u83 2824 
	}
2825 
	break;
7 7u83 2826 
      case 75:
2 7u83 2827 
	return;
7 7u83 2828 
      default:
2829 
	goto ZL1;
2 7u83 2830 
    }
2831 
    goto ZL0;
2832 
  ZL1:;
7 7u83 2833 
    SAVE_LEXER (75);
2 7u83 2834 
    return;
2835 
  ZL0:;
7 7u83 2836 
    *ZOcmd = ZIcmd;
2 7u83 2837 
}
2838 
 
2839 
static void
7 7u83 2840 
ZRfield_Hexact(int *ZOe)
2 7u83 2841 
{
2842 
    int ZIe;
2843 
 
2844 
    switch (CURRENT_TERMINAL) {
7 7u83 2845 
      case 60:
2 7u83 2846 
	{
2847 
	    ADVANCE_LEXER;
2848 
	    {
2849 
 (ZIe) = 1 ;
2850 
	    }
2851 
	}
2852 
	break;
2853 
      default:
2854 
	{
2855 
	    {
2856 
 (ZIe) = 0 ;
2857 
	    }
2858 
	}
2859 
	break;
7 7u83 2860 
      case 75:
2 7u83 2861 
	return;
2862 
    }
2863 
    *ZOe = ZIe;
2864 
}
2865 
 
2866 
static void
7 7u83 2867 
ZR333(SID_TYPE *ZI331, SID_TYPE *ZOt)
2 7u83 2868 
{
2869 
    SID_TYPE ZIt;
2870 
 
2871 
    switch (CURRENT_TERMINAL) {
7 7u83 2872 
      case 33: case 48:
2 7u83 2873 
	{
7 7u83 2874 
	    unsigned ZIcv;
2875 
 
2876 
	    ZRtype_Hqualifier (&ZIcv);
2877 
	    if ((CURRENT_TERMINAL) == 75) {
2878 
		RESTORE_LEXER;
2879 
		goto ZL1;
2880 
	    }
2881 
	    {
2882 
 
2883 
    (ZIt) = make_subtype ( (*ZI331), TYPE_QUALIFIER ) ;
2884 
    (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
2885 
	    }
2886 
	}
2887 
	break;
2888 
      default:
2889 
	{
2890 
	    ZIt = *ZI331;
2891 
	}
2892 
	break;
2893 
      case 75:
2894 
	return;
2895 
    }
2896 
    goto ZL0;
2897 
  ZL1:;
2898 
    SAVE_LEXER (75);
2899 
    return;
2900 
  ZL0:;
2901 
    *ZOt = ZIt;
2902 
}
2903 
 
2904 
static void
2905 
ZR335(SID_TYPE *ZOt)
2906 
{
2907 
    SID_TYPE ZIt;
2908 
 
2909 
    switch (CURRENT_TERMINAL) {
2910 
      case 57:
2911 
	{
2 7u83 2912 
	    SID_TYPE ZIp;
2913 
 
2914 
	    ADVANCE_LEXER;
2915 
	    {
2916 
 
2917 
    error ( ERR_WARNING, "Empty parameter list" ) ;
2918 
    (ZIp) = null ;
2919 
	    }
2920 
	    {
2921 
 
2922 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
2923 
    (ZIt)->v.next = (ZIp) ;
2924 
	    }
2925 
	}
2926 
	break;
7 7u83 2927 
      case 0: case 32: case 33: case 34: case 35:
2928 
      case 37: case 38: case 39: case 42: case 43:
2929 
      case 44: case 45: case 46: case 47: case 48:
2 7u83 2930 
	{
2931 
	    SID_TYPE ZIp;
2932 
 
2933 
	    ZRparameter_Hlist (&ZIp);
2934 
	    switch (CURRENT_TERMINAL) {
7 7u83 2935 
	      case 57:
2 7u83 2936 
		break;
7 7u83 2937 
	      case 75:
2 7u83 2938 
		RESTORE_LEXER;
2939 
		goto ZL1;
2940 
	      default:
2941 
		goto ZL1;
2942 
	    }
2943 
	    ADVANCE_LEXER;
2944 
	    {
2945 
 
2946 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
2947 
    (ZIt)->v.next = (ZIp) ;
2948 
	    }
2949 
	}
2950 
	break;
7 7u83 2951 
      case 75:
2 7u83 2952 
	return;
2953 
      default:
2954 
	goto ZL1;
2955 
    }
2956 
    goto ZL0;
2957 
  ZL1:;
7 7u83 2958 
    SAVE_LEXER (75);
2 7u83 2959 
    return;
2960 
  ZL0:;
2961 
    *ZOt = ZIt;
2962 
}
2963 
 
2964 
static void
7 7u83 2965 
ZRcommand_Hlist(SID_COMMAND *ZOc)
2 7u83 2966 
{
2967 
    SID_COMMAND ZIc;
2968 
 
2969 
  ZL2_command_Hlist:;
2970 
    switch (CURRENT_TERMINAL) {
2971 
      case 7: case 8: case 9: case 12: case 13:
2972 
      case 14: case 15: case 19: case 21: case 22:
2973 
      case 23: case 24: case 26: case 27: case 28:
7 7u83 2974 
      case 29: case 30:
2 7u83 2975 
	{
2976 
	    SID_COMMAND ZIa;
2977 
	    SID_COMMAND ZIb;
2978 
 
2979 
	    ZRspec_Hcommand (&ZIa);
2980 
	    switch (CURRENT_TERMINAL) {
7 7u83 2981 
	      case 71:
2 7u83 2982 
		break;
7 7u83 2983 
	      case 75:
2 7u83 2984 
		RESTORE_LEXER;
2985 
		goto ZL1;
2986 
	      default:
2987 
		goto ZL1;
2988 
	    }
2989 
	    ADVANCE_LEXER;
2990 
	    ZRcommand_Hlist (&ZIb);
7 7u83 2991 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 2992 
		RESTORE_LEXER;
2993 
		goto ZL1;
2994 
	    }
2995 
	    {
2996 
 
2997 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
2998 
	    }
2999 
	}
3000 
	break;
3001 
      case 4: case 5: case 6: case 16: case 17:
3002 
      case 18:
3003 
	{
3004 
	    SID_COMMAND ZIa;
3005 
	    SID_COMMAND ZIb;
3006 
 
3007 
	    ZRtext_Hcommand (&ZIa);
3008 
	    ZRcommand_Hlist (&ZIb);
7 7u83 3009 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3010 
		RESTORE_LEXER;
3011 
		goto ZL1;
3012 
	    }
3013 
	    {
3014 
 
3015 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
3016 
	    }
3017 
	}
3018 
	break;
3019 
      case 3: case 20:
3020 
	{
3021 
	    ZRvariable_Hcommand ();
3022 
	    switch (CURRENT_TERMINAL) {
7 7u83 3023 
	      case 71:
2 7u83 3024 
		break;
7 7u83 3025 
	      case 75:
2 7u83 3026 
		RESTORE_LEXER;
3027 
		goto ZL1;
3028 
	      default:
3029 
		goto ZL1;
3030 
	    }
3031 
	    ADVANCE_LEXER;
3032 
	    goto ZL2_command_Hlist;
3033 
	}
3034 
	/*UNREACHED*/
3035 
      default:
3036 
	{
3037 
	    {
3038 
 
3039 
    (ZIc) = null ;
3040 
	    }
3041 
	}
3042 
	break;
7 7u83 3043 
      case 75:
2 7u83 3044 
	return;
3045 
    }
3046 
    goto ZL0;
3047 
  ZL1:;
7 7u83 3048 
    SAVE_LEXER (75);
2 7u83 3049 
    return;
3050 
  ZL0:;
3051 
    *ZOc = ZIc;
3052 
}
3053 
 
3054 
static void
7 7u83 3055 
ZR338(SID_STRING *ZI336, SID_TYPE *ZI337, SID_STRING *ZO306, SID_TYPE *ZO307)
2 7u83 3056 
{
7 7u83 3057 
    SID_STRING ZI306;
3058 
    SID_TYPE ZI307;
2 7u83 3059 
 
3060 
    switch (CURRENT_TERMINAL) {
7 7u83 3061 
      case 56:
2 7u83 3062 
	{
3063 
	    SID_TYPE ZIs;
3064 
	    SID_TYPE ZIt;
3065 
 
3066 
	    ZRfunction_Hoperator (&ZIs);
7 7u83 3067 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3068 
		RESTORE_LEXER;
3069 
		goto ZL1;
3070 
	    }
3071 
	    {
3072 
 
7 7u83 3073 
    (ZIt) = inject_type ( (*ZI337), (ZIs) ) ;
2 7u83 3074 
	    }
7 7u83 3075 
	    ZR308 (*ZI336, ZIt, &ZI306, &ZI307);
3076 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3077 
		RESTORE_LEXER;
3078 
		goto ZL1;
3079 
	    }
3080 
	}
3081 
	break;
3082 
      default:
3083 
	{
7 7u83 3084 
	    ZR308 (*ZI336, *ZI337, &ZI306, &ZI307);
3085 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3086 
		RESTORE_LEXER;
3087 
		goto ZL1;
3088 
	    }
3089 
	}
3090 
	break;
7 7u83 3091 
      case 75:
2 7u83 3092 
	return;
3093 
    }
3094 
    goto ZL0;
3095 
  ZL1:;
7 7u83 3096 
    SAVE_LEXER (75);
2 7u83 3097 
    return;
3098 
  ZL0:;
7 7u83 3099 
    *ZO306 = ZI306;
3100 
    *ZO307 = ZI307;
2 7u83 3101 
}
3102 
 
3103 
static void
7 7u83 3104 
ZR339(SID_TYPE *ZOq)
2 7u83 3105 
{
3106 
    SID_TYPE ZIq;
3107 
 
3108 
    switch (CURRENT_TERMINAL) {
7 7u83 3109 
      case 65:
2 7u83 3110 
	{
3111 
	    ADVANCE_LEXER;
3112 
	    {
3113 
 
3114 
    (ZIq) = make_subtype ( type_ellipsis, TYPE_LIST ) ;
3115 
    (ZIq)->v.next = null ;
3116 
	    }
3117 
	}
3118 
	break;
7 7u83 3119 
      case 0: case 32: case 33: case 34: case 35:
3120 
      case 37: case 38: case 39: case 42: case 43:
3121 
      case 44: case 45: case 46: case 47: case 48:
2 7u83 3122 
	{
3123 
	    ZRparameter_Hlist (&ZIq);
7 7u83 3124 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3125 
		RESTORE_LEXER;
3126 
		goto ZL1;
3127 
	    }
3128 
	}
3129 
	break;
7 7u83 3130 
      case 75:
2 7u83 3131 
	return;
3132 
      default:
3133 
	goto ZL1;
3134 
    }
3135 
    goto ZL0;
3136 
  ZL1:;
7 7u83 3137 
    SAVE_LEXER (75);
2 7u83 3138 
    return;
3139 
  ZL0:;
3140 
    *ZOq = ZIq;
3141 
}
3142 
 
3143 
static void
7 7u83 3144 
ZR340(int *ZOtag)
2 7u83 3145 
{
3146 
    int ZItag;
3147 
 
3148 
    switch (CURRENT_TERMINAL) {
7 7u83 3149 
      case 31:
2 7u83 3150 
	{
3151 
	    ADVANCE_LEXER;
3152 
	    switch (CURRENT_TERMINAL) {
7 7u83 3153 
	      case 57:
2 7u83 3154 
		break;
3155 
	      default:
3156 
		goto ZL1;
3157 
	    }
3158 
	    ADVANCE_LEXER;
3159 
	    {
3160 
 (ZItag) = TYPE_ARITH ;
3161 
	    }
3162 
	}
3163 
	break;
7 7u83 3164 
      case 37:
2 7u83 3165 
	{
3166 
	    ADVANCE_LEXER;
3167 
	    switch (CURRENT_TERMINAL) {
7 7u83 3168 
	      case 57:
2 7u83 3169 
		break;
3170 
	      default:
3171 
		goto ZL1;
3172 
	    }
3173 
	    ADVANCE_LEXER;
3174 
	    {
3175 
 (ZItag) = TYPE_FLOAT ;
3176 
	    }
3177 
	}
3178 
	break;
7 7u83 3179 
      case 38:
2 7u83 3180 
	{
3181 
	    ADVANCE_LEXER;
3182 
	    switch (CURRENT_TERMINAL) {
7 7u83 3183 
	      case 57:
2 7u83 3184 
		break;
3185 
	      default:
3186 
		goto ZL1;
3187 
	    }
3188 
	    ADVANCE_LEXER;
3189 
	    {
3190 
 (ZItag) = TYPE_INT ;
3191 
	    }
3192 
	}
3193 
	break;
7 7u83 3194 
      case 41:
2 7u83 3195 
	{
3196 
	    ADVANCE_LEXER;
3197 
	    switch (CURRENT_TERMINAL) {
7 7u83 3198 
	      case 57:
2 7u83 3199 
		break;
3200 
	      default:
3201 
		goto ZL1;
3202 
	    }
3203 
	    ADVANCE_LEXER;
3204 
	    {
3205 
 (ZItag) = TYPE_SCALAR ;
3206 
	    }
3207 
	}
3208 
	break;
7 7u83 3209 
      case 43:
2 7u83 3210 
	{
3211 
	    ADVANCE_LEXER;
3212 
	    switch (CURRENT_TERMINAL) {
7 7u83 3213 
	      case 57:
2 7u83 3214 
		break;
3215 
	      default:
3216 
		goto ZL1;
3217 
	    }
3218 
	    ADVANCE_LEXER;
3219 
	    {
3220 
 (ZItag) = TYPE_SIGNED ;
3221 
	    }
3222 
	}
3223 
	break;
7 7u83 3224 
      case 44:
2 7u83 3225 
	{
3226 
	    ADVANCE_LEXER;
3227 
	    switch (CURRENT_TERMINAL) {
7 7u83 3228 
	      case 57:
2 7u83 3229 
		break;
3230 
	      default:
3231 
		goto ZL1;
3232 
	    }
3233 
	    ADVANCE_LEXER;
3234 
	    {
3235 
 (ZItag) = TYPE_STRUCT ;
3236 
	    }
3237 
	}
3238 
	break;
7 7u83 3239 
      case 45:
2 7u83 3240 
	{
3241 
	    ADVANCE_LEXER;
3242 
	    switch (CURRENT_TERMINAL) {
7 7u83 3243 
	      case 57:
2 7u83 3244 
		break;
3245 
	      default:
3246 
		goto ZL1;
3247 
	    }
3248 
	    ADVANCE_LEXER;
3249 
	    {
3250 
 (ZItag) = TYPE_UNION ;
3251 
	    }
3252 
	}
3253 
	break;
7 7u83 3254 
      case 46:
2 7u83 3255 
	{
3256 
	    ADVANCE_LEXER;
3257 
	    switch (CURRENT_TERMINAL) {
7 7u83 3258 
	      case 57:
2 7u83 3259 
		break;
3260 
	      default:
3261 
		goto ZL1;
3262 
	    }
3263 
	    ADVANCE_LEXER;
3264 
	    {
3265 
 (ZItag) = TYPE_UNSIGNED ;
3266 
	    }
3267 
	}
3268 
	break;
7 7u83 3269 
      case 75:
2 7u83 3270 
	return;
3271 
      default:
3272 
	goto ZL1;
3273 
    }
3274 
    goto ZL0;
3275 
  ZL1:;
7 7u83 3276 
    SAVE_LEXER (75);
2 7u83 3277 
    return;
3278 
  ZL0:;
3279 
    *ZOtag = ZItag;
3280 
}
3281 
 
3282 
static void
7 7u83 3283 
ZRdirect_Hdeclarator(SID_IDENTIFIER *ZO316, SID_TYPE *ZO317)
2 7u83 3284 
{
7 7u83 3285 
    SID_IDENTIFIER ZI316;
3286 
    SID_TYPE ZI317;
2 7u83 3287 
 
3288 
    switch (CURRENT_TERMINAL) {
7 7u83 3289 
      case 56:
2 7u83 3290 
	{
3291 
	    SID_IDENTIFIER ZIid;
3292 
	    SID_TYPE ZIt;
3293 
 
3294 
	    ADVANCE_LEXER;
3295 
	    ZRdeclarator (&ZIid, &ZIt);
3296 
	    switch (CURRENT_TERMINAL) {
7 7u83 3297 
	      case 57:
2 7u83 3298 
		break;
7 7u83 3299 
	      case 75:
2 7u83 3300 
		RESTORE_LEXER;
3301 
		goto ZL1;
3302 
	      default:
3303 
		goto ZL1;
3304 
	    }
3305 
	    ADVANCE_LEXER;
7 7u83 3306 
	    ZR318 (ZIid, ZIt, &ZI316, &ZI317);
3307 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3308 
		RESTORE_LEXER;
3309 
		goto ZL1;
3310 
	    }
3311 
	}
3312 
	break;
3313 
      case 0:
3314 
	{
3315 
	    SID_IDENTIFIER ZIid;
3316 
	    SID_TYPE ZIt;
3317 
 
3318 
	    ZRidentifier (&ZIid);
7 7u83 3319 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3320 
		RESTORE_LEXER;
3321 
		goto ZL1;
3322 
	    }
3323 
	    {
3324 
 
3325 
    (ZIt) = null ;
3326 
	    }
7 7u83 3327 
	    ZR318 (ZIid, ZIt, &ZI316, &ZI317);
3328 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3329 
		RESTORE_LEXER;
3330 
		goto ZL1;
3331 
	    }
3332 
	}
3333 
	break;
7 7u83 3334 
      case 75:
2 7u83 3335 
	return;
3336 
      default:
3337 
	goto ZL1;
3338 
    }
3339 
    goto ZL0;
3340 
  ZL1:;
7 7u83 3341 
    SAVE_LEXER (75);
2 7u83 3342 
    return;
3343 
  ZL0:;
7 7u83 3344 
    *ZO316 = ZI316;
3345 
    *ZO317 = ZI317;
2 7u83 3346 
}
3347 
 
3348 
static void
7 7u83 3349 
ZRtype_Hcommand(int *ZOtag)
2 7u83 3350 
{
3351 
    int ZItag;
3352 
 
3353 
    switch (CURRENT_TERMINAL) {
7 7u83 3354 
      case 56:
2 7u83 3355 
	{
3356 
	    ADVANCE_LEXER;
7 7u83 3357 
	    ZR340 (&ZItag);
3358 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3359 
		RESTORE_LEXER;
3360 
		goto ZL1;
3361 
	    }
3362 
	}
3363 
	break;
7 7u83 3364 
      case 44:
2 7u83 3365 
	{
3366 
	    ADVANCE_LEXER;
3367 
	    {
3368 
 (ZItag) = TYPE_STRUCT_TAG ;
3369 
	    }
3370 
	}
3371 
	break;
7 7u83 3372 
      case 45:
2 7u83 3373 
	{
3374 
	    ADVANCE_LEXER;
3375 
	    {
3376 
 (ZItag) = TYPE_UNION_TAG ;
3377 
	    }
3378 
	}
3379 
	break;
3380 
      default:
3381 
	{
3382 
	    {
3383 
 (ZItag) = TYPE_GENERIC ;
3384 
	    }
3385 
	}
3386 
	break;
7 7u83 3387 
      case 75:
2 7u83 3388 
	return;
3389 
    }
3390 
    goto ZL0;
3391 
  ZL1:;
7 7u83 3392 
    SAVE_LEXER (75);
2 7u83 3393 
    return;
3394 
  ZL0:;
3395 
    *ZOtag = ZItag;
3396 
}
3397 
 
3398 
static void
7 7u83 3399 
ZRtext_Hcommand(SID_COMMAND *ZOc)
2 7u83 3400 
{
3401 
    SID_COMMAND ZIc;
3402 
 
3403 
    switch (CURRENT_TERMINAL) {
3404 
      case 6:
3405 
	{
3406 
	    SID_STRING ZIs;
3407 
 
3408 
	    {
3409 
 ZIs = token_value ;
3410 
	    }
3411 
	    ADVANCE_LEXER;
3412 
	    {
3413 
 
3414 
    (ZIc) = make_object ( (ZIs), OBJ_TEXT_SRC ) ;
3415 
	    }
3416 
	}
3417 
	break;
3418 
      case 4:
3419 
	{
3420 
	    SID_STRING ZIs;
3421 
 
3422 
	    {
3423 
 ZIs = token_value ;
3424 
	    }
3425 
	    ADVANCE_LEXER;
3426 
	    {
3427 
 
3428 
    (ZIc) = make_object ( (ZIs), OBJ_TEXT_INCL ) ;
3429 
	    }
3430 
	}
3431 
	break;
3432 
      case 5:
3433 
	{
3434 
	    SID_STRING ZIs;
3435 
 
3436 
	    {
3437 
 ZIs = token_value ;
3438 
	    }
3439 
	    ADVANCE_LEXER;
3440 
	    {
3441 
 
3442 
    (ZIc) = make_object ( (ZIs), OBJ_TEXT_INCL ) ;
3443 
	    }
3444 
	}
3445 
	break;
3446 
      case 16: case 17: case 18:
3447 
	{
3448 
	    SID_COMMAND ZIi;
3449 
	    SID_STRING ZIs;
3450 
	    SID_COMMAND ZIa;
3451 
	    SID_COMMAND ZIb;
3452 
 
3453 
	    ZRif_Hcommand (&ZIi, &ZIs);
3454 
	    ZRcommand_Hlist (&ZIa);
3455 
	    {
3456 
		switch (CURRENT_TERMINAL) {
3457 
		  case 10:
3458 
		    {
3459 
			ADVANCE_LEXER;
3460 
			ZRcommand_Hlist (&ZIb);
7 7u83 3461 
			if ((CURRENT_TERMINAL) == 75) {
2 7u83 3462 
			    RESTORE_LEXER;
3463 
			    goto ZL1;
3464 
			}
3465 
		    }
3466 
		    break;
3467 
		  default:
3468 
		    {
3469 
			{
3470 
 
3471 
    (ZIb) = null ;
3472 
			}
3473 
		    }
3474 
		    break;
7 7u83 3475 
		  case 75:
2 7u83 3476 
		    RESTORE_LEXER;
3477 
		    goto ZL1;
3478 
		}
3479 
	    }
3480 
	    switch (CURRENT_TERMINAL) {
3481 
	      case 11:
3482 
		break;
3483 
	      default:
3484 
		goto ZL1;
3485 
	    }
3486 
	    ADVANCE_LEXER;
3487 
	    {
3488 
 
3489 
    object *p, *q ;
3490 
    p = join_object ( (ZIi), (ZIa) ) ;
3491 
    if ( (ZIb) ) {
3492 
	q = make_object ( (ZIs), OBJ_IF ) ;
3493 
	q->u.u_num = CMD_ELSE ;
3494 
	p = join_object ( p, q ) ;
3495 
	p = join_object ( p, (ZIb) ) ;
3496 
    }
3497 
    q = make_object ( (ZIs), OBJ_IF ) ;
3498 
    q->u.u_num = CMD_ENDIF ;
3499 
    (ZIc) = join_object ( p, q ) ;
3500 
	    }
3501 
	}
3502 
	break;
7 7u83 3503 
      case 75:
2 7u83 3504 
	return;
3505 
      default:
3506 
	goto ZL1;
3507 
    }
3508 
    goto ZL0;
3509 
  ZL1:;
7 7u83 3510 
    SAVE_LEXER (75);
2 7u83 3511 
    return;
3512 
  ZL0:;
3513 
    *ZOc = ZIc;
3514 
}
3515 
 
3516 
static void
7 7u83 3517 
ZR347(SID_IDENTIFIER *ZI345, SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
2 7u83 3518 
{
3519 
    SID_IDENTIFIER ZIid;
3520 
    SID_TYPE ZIt;
3521 
 
3522 
    switch (CURRENT_TERMINAL) {
7 7u83 3523 
      case 61:
2 7u83 3524 
	{
3525 
	    ZRbitfield_Hoperator (&ZIt);
7 7u83 3526 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3527 
		RESTORE_LEXER;
3528 
		goto ZL1;
3529 
	    }
7 7u83 3530 
	    ZIid = *ZI345;
2 7u83 3531 
	}
3532 
	break;
3533 
      default:
3534 
	{
7 7u83 3535 
	    SID_TYPE ZI344;
2 7u83 3536 
 
3537 
	    {
3538 
 
7 7u83 3539 
    (ZI344) = null ;
2 7u83 3540 
	    }
7 7u83 3541 
	    ZR318 (*ZI345, ZI344, &ZIid, &ZIt);
3542 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3543 
		RESTORE_LEXER;
3544 
		goto ZL1;
3545 
	    }
3546 
	}
3547 
	break;
7 7u83 3548 
      case 75:
2 7u83 3549 
	return;
3550 
    }
3551 
    goto ZL0;
3552 
  ZL1:;
7 7u83 3553 
    SAVE_LEXER (75);
2 7u83 3554 
    return;
3555 
  ZL0:;
3556 
    *ZOid = ZIid;
3557 
    *ZOt = ZIt;
3558 
}
3559 
 
3560 
static void
7 7u83 3561 
ZRname_Hversion(int *ZOv)
2 7u83 3562 
{
3563 
    int ZIv;
3564 
 
3565 
    switch (CURRENT_TERMINAL) {
7 7u83 3566 
      case 63:
2 7u83 3567 
	{
3568 
	    SID_STRING ZIn;
3569 
 
3570 
	    ADVANCE_LEXER;
3571 
	    switch (CURRENT_TERMINAL) {
3572 
	      case 1:
3573 
		{
3574 
 ZIn = token_value ;
3575 
		}
3576 
		break;
3577 
	      default:
3578 
		goto ZL1;
3579 
	    }
3580 
	    ADVANCE_LEXER;
3581 
	    {
3582 
 
3583 
    (ZIv) = atoi ( (ZIn) ) ;
3584 
	    }
3585 
	}
3586 
	break;
3587 
      default:
3588 
	{
3589 
	    {
3590 
 
3591 
    (ZIv) = no_version ;
3592 
	    }
3593 
	}
3594 
	break;
7 7u83 3595 
      case 75:
2 7u83 3596 
	return;
3597 
    }
3598 
    goto ZL0;
3599 
  ZL1:;
7 7u83 3600 
    SAVE_LEXER (75);
2 7u83 3601 
    return;
3602 
  ZL0:;
3603 
    *ZOv = ZIv;
3604 
}
3605 
 
3606 
static void
7 7u83 3607 
ZR348(int *ZOcmd)
2 7u83 3608 
{
7 7u83 3609 
    int ZIcmd;
2 7u83 3610 
 
3611 
    switch (CURRENT_TERMINAL) {
3612 
      case 56:
3613 
	{
3614 
	    ADVANCE_LEXER;
7 7u83 3615 
	    ZR349 (&ZIcmd);
3616 
	    if ((CURRENT_TERMINAL) == 75) {
3617 
		RESTORE_LEXER;
3618 
		goto ZL1;
2 7u83 3619 
	    }
3620 
	}
3621 
	break;
7 7u83 3622 
      default:
2 7u83 3623 
	{
3624 
	    {
7 7u83 3625 
 (ZIcmd) = OBJ_FUNC ;
2 7u83 3626 
	    }
3627 
	}
3628 
	break;
7 7u83 3629 
      case 75:
2 7u83 3630 
	return;
3631 
    }
3632 
    goto ZL0;
3633 
  ZL1:;
7 7u83 3634 
    SAVE_LEXER (75);
2 7u83 3635 
    return;
3636 
  ZL0:;
7 7u83 3637 
    *ZOcmd = ZIcmd;
2 7u83 3638 
}
3639 
 
3640 
static void
7 7u83 3641 
ZRdirect_Habstract_Hdeclarator(SID_STRING *ZO306, SID_TYPE *ZO307)
2 7u83 3642 
{
7 7u83 3643 
    SID_STRING ZI306;
3644 
    SID_TYPE ZI307;
2 7u83 3645 
 
3646 
    switch (CURRENT_TERMINAL) {
3647 
      case 0:
3648 
	{
3649 
	    SID_STRING ZInm;
3650 
	    SID_TYPE ZIt;
3651 
 
3652 
	    {
3653 
 ZInm = token_value ;
3654 
	    }
3655 
	    ADVANCE_LEXER;
3656 
	    {
3657 
 
3658 
    (ZIt) = null ;
3659 
	    }
7 7u83 3660 
	    ZR308 (ZInm, ZIt, &ZI306, &ZI307);
3661 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3662 
		RESTORE_LEXER;
3663 
		goto ZL1;
3664 
	    }
3665 
	}
3666 
	break;
7 7u83 3667 
      case 56:
2 7u83 3668 
	{
7 7u83 3669 
	    SID_STRING ZI336;
3670 
	    SID_TYPE ZI337;
2 7u83 3671 
 
3672 
	    ADVANCE_LEXER;
7 7u83 3673 
	    ZRabstract_Hdeclarator (&ZI336, &ZI337);
2 7u83 3674 
	    switch (CURRENT_TERMINAL) {
7 7u83 3675 
	      case 57:
2 7u83 3676 
		break;
7 7u83 3677 
	      case 75:
2 7u83 3678 
		RESTORE_LEXER;
3679 
		goto ZL1;
3680 
	      default:
3681 
		goto ZL1;
3682 
	    }
3683 
	    ADVANCE_LEXER;
7 7u83 3684 
	    ZR338 (&ZI336, &ZI337, &ZI306, &ZI307);
3685 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3686 
		RESTORE_LEXER;
3687 
		goto ZL1;
3688 
	    }
3689 
	}
3690 
	break;
3691 
      default:
3692 
	{
3693 
	    SID_STRING ZInm;
3694 
	    SID_TYPE ZIt;
3695 
 
3696 
	    {
3697 
 
3698 
    (ZInm) = null ;
3699 
	    }
3700 
	    {
3701 
 
3702 
    (ZIt) = null ;
3703 
	    }
7 7u83 3704 
	    ZR308 (ZInm, ZIt, &ZI306, &ZI307);
3705 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3706 
		RESTORE_LEXER;
3707 
		goto ZL1;
3708 
	    }
3709 
	}
3710 
	break;
7 7u83 3711 
      case 75:
2 7u83 3712 
	return;
3713 
    }
3714 
    goto ZL0;
3715 
  ZL1:;
7 7u83 3716 
    SAVE_LEXER (75);
2 7u83 3717 
    return;
3718 
  ZL0:;
7 7u83 3719 
    *ZO306 = ZI306;
3720 
    *ZO307 = ZI307;
2 7u83 3721 
}
3722 
 
3723 
static void
7 7u83 3724 
ZRfield_Hdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
2 7u83 3725 
{
3726 
    SID_IDENTIFIER ZIid;
3727 
    SID_TYPE ZIt;
3728 
 
3729 
    switch (CURRENT_TERMINAL) {
7 7u83 3730 
      case 56:
2 7u83 3731 
	{
7 7u83 3732 
	    SID_IDENTIFIER ZI341;
3733 
	    SID_TYPE ZI342;
2 7u83 3734 
 
3735 
	    ADVANCE_LEXER;
7 7u83 3736 
	    ZRdeclarator (&ZI341, &ZI342);
2 7u83 3737 
	    switch (CURRENT_TERMINAL) {
7 7u83 3738 
	      case 57:
2 7u83 3739 
		break;
7 7u83 3740 
	      case 75:
2 7u83 3741 
		RESTORE_LEXER;
3742 
		goto ZL1;
3743 
	      default:
3744 
		goto ZL1;
3745 
	    }
3746 
	    ADVANCE_LEXER;
7 7u83 3747 
	    ZR318 (ZI341, ZI342, &ZIid, &ZIt);
3748 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3749 
		RESTORE_LEXER;
3750 
		goto ZL1;
3751 
	    }
3752 
	}
3753 
	break;
7 7u83 3754 
      case 61:
2 7u83 3755 
	{
3756 
	    ZRbitfield_Hoperator (&ZIt);
7 7u83 3757 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3758 
		RESTORE_LEXER;
3759 
		goto ZL1;
3760 
	    }
3761 
	    {
3762 
 
3763 
    char *nm = string_printf ( "%s%d", HIDDEN_NAME, anon_no++ ) ;
3764 
    if ( crt_field_name ) {
3765 
	nm = string_printf ( "%s.%s", crt_field_name, nm ) ;
3766 
    }
3767 
    (ZIid).iname = nm ;
3768 
    (ZIid).ivers = no_version ;
3769 
    (ZIid).ename = token_name ( nm ) ;
3770 
    (ZIid).evers = no_version ;
3771 
	    }
3772 
	}
3773 
	break;
3774 
      case 0:
3775 
	{
7 7u83 3776 
	    SID_IDENTIFIER ZI345;
2 7u83 3777 
 
7 7u83 3778 
	    ZRidentifier (&ZI345);
3779 
	    ZR347 (&ZI345, &ZIid, &ZIt);
3780 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3781 
		RESTORE_LEXER;
3782 
		goto ZL1;
3783 
	    }
3784 
	}
3785 
	break;
7 7u83 3786 
      case 72:
2 7u83 3787 
	{
3788 
	    SID_TYPE ZIp;
3789 
	    SID_TYPE ZIs;
3790 
 
3791 
	    ZRptr_Hoperator (&ZIp);
3792 
	    ZRdeclarator (&ZIid, &ZIs);
7 7u83 3793 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3794 
		RESTORE_LEXER;
3795 
		goto ZL1;
3796 
	    }
3797 
	    {
3798 
 
3799 
    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
3800 
	    }
3801 
	}
3802 
	break;
7 7u83 3803 
      case 75:
2 7u83 3804 
	return;
3805 
      default:
3806 
	goto ZL1;
3807 
    }
3808 
    goto ZL0;
3809 
  ZL1:;
7 7u83 3810 
    SAVE_LEXER (75);
2 7u83 3811 
    return;
3812 
  ZL0:;
3813 
    *ZOid = ZIid;
3814 
    *ZOt = ZIt;
3815 
}
3816 
 
3817 
static void
7 7u83 3818 
ZRvariable_Hcommand(void)
2 7u83 3819 
{
3820 
    switch (CURRENT_TERMINAL) {
3821 
      case 20:
3822 
	{
3823 
	    SID_STRING ZIs;
3824 
 
3825 
	    ADVANCE_LEXER;
3826 
	    switch (CURRENT_TERMINAL) {
3827 
	      case 2:
3828 
		{
3829 
 ZIs = token_value ;
3830 
		}
3831 
		break;
3832 
	      default:
3833 
		goto ZL1;
3834 
	    }
3835 
	    ADVANCE_LEXER;
3836 
	}
3837 
	break;
3838 
      case 3:
3839 
	{
3840 
	    SID_STRING ZInm;
3841 
 
3842 
	    {
3843 
 ZInm = token_value ;
3844 
	    }
3845 
	    ADVANCE_LEXER;
3846 
	    switch (CURRENT_TERMINAL) {
7 7u83 3847 
	      case 66:
2 7u83 3848 
		break;
3849 
	      default:
3850 
		goto ZL1;
3851 
	    }
3852 
	    ADVANCE_LEXER;
7 7u83 3853 
	    ZR354 (&ZInm);
3854 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 3855 
		RESTORE_LEXER;
3856 
		goto ZL1;
3857 
	    }
3858 
	}
3859 
	break;
7 7u83 3860 
      case 75:
2 7u83 3861 
	return;
3862 
      default:
3863 
	goto ZL1;
3864 
    }
3865 
    return;
3866 
  ZL1:;
7 7u83 3867 
    SAVE_LEXER (75);
2 7u83 3868 
    return;
3869 
}
3870 
 
3871 
static void
7 7u83 3872 
ZR349(int *ZOcmd)
2 7u83 3873 
{
7 7u83 3874 
    int ZIcmd;
2 7u83 3875 
 
3876 
    switch (CURRENT_TERMINAL) {
7 7u83 3877 
      case 36:
2 7u83 3878 
	{
3879 
	    ADVANCE_LEXER;
7 7u83 3880 
	    switch (CURRENT_TERMINAL) {
3881 
	      case 57:
3882 
		break;
3883 
	      default:
2 7u83 3884 
		goto ZL1;
3885 
	    }
7 7u83 3886 
	    ADVANCE_LEXER;
3887 
	    {
3888 
 (ZIcmd) = OBJ_EXTERN ;
3889 
	    }
2 7u83 3890 
	}
3891 
	break;
7 7u83 3892 
      case 49:
2 7u83 3893 
	{
3894 
	    ADVANCE_LEXER;
7 7u83 3895 
	    switch (CURRENT_TERMINAL) {
3896 
	      case 57:
3897 
		break;
3898 
	      default:
2 7u83 3899 
		goto ZL1;
3900 
	    }
7 7u83 3901 
	    ADVANCE_LEXER;
3902 
	    {
3903 
 (ZIcmd) = OBJ_WEAK ;
3904 
	    }
2 7u83 3905 
	}
3906 
	break;
7 7u83 3907 
      case 75:
2 7u83 3908 
	return;
3909 
      default:
3910 
	goto ZL1;
3911 
    }
3912 
    goto ZL0;
3913 
  ZL1:;
7 7u83 3914 
    SAVE_LEXER (75);
2 7u83 3915 
    return;
3916 
  ZL0:;
7 7u83 3917 
    *ZOcmd = ZIcmd;
2 7u83 3918 
}
3919 
 
3920 
static void
7 7u83 3921 
ZR350(SID_TYPE *ZOt)
2 7u83 3922 
{
7 7u83 3923 
    SID_TYPE ZIt;
2 7u83 3924 
 
3925 
    switch (CURRENT_TERMINAL) {
7 7u83 3926 
      case 57:
2 7u83 3927 
	{
7 7u83 3928 
	    SID_TYPE ZIp;
3929 
 
2 7u83 3930 
	    ADVANCE_LEXER;
7 7u83 3931 
	    {
3932 
 
3933 
    (ZIp) = null ;
2 7u83 3934 
	    }
3935 
	    {
7 7u83 3936 
 
3937 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
3938 
    (ZIt)->v.next = (ZIp) ;
2 7u83 3939 
	    }
3940 
	}
3941 
	break;
7 7u83 3942 
      case 0: case 32: case 33: case 34: case 35:
3943 
      case 37: case 38: case 39: case 40: case 42:
3944 
      case 43: case 44: case 45: case 46: case 47:
3945 
      case 48:
2 7u83 3946 
	{
7 7u83 3947 
	    SID_TYPE ZIp;
3948 
 
3949 
	    ZRmacro_Hparam_Hlist (&ZIp);
2 7u83 3950 
	    switch (CURRENT_TERMINAL) {
7 7u83 3951 
	      case 57:
2 7u83 3952 
		break;
7 7u83 3953 
	      case 75:
3954 
		RESTORE_LEXER;
3955 
		goto ZL1;
2 7u83 3956 
	      default:
3957 
		goto ZL1;
3958 
	    }
3959 
	    ADVANCE_LEXER;
3960 
	    {
7 7u83 3961 
 
3962 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_PROC ) ;
3963 
    (ZIt)->v.next = (ZIp) ;
2 7u83 3964 
	    }
3965 
	}
3966 
	break;
7 7u83 3967 
      case 75:
2 7u83 3968 
	return;
3969 
      default:
3970 
	goto ZL1;
3971 
    }
3972 
    goto ZL0;
3973 
  ZL1:;
7 7u83 3974 
    SAVE_LEXER (75);
2 7u83 3975 
    return;
3976 
  ZL0:;
7 7u83 3977 
    *ZOt = ZIt;
2 7u83 3978 
}
3979 
 
3980 
static void
7 7u83 3981 
ZR351(SID_STRING *ZOkey)
2 7u83 3982 
{
3983 
    SID_STRING ZIkey;
3984 
 
3985 
    switch (CURRENT_TERMINAL) {
7 7u83 3986 
      case 67:
2 7u83 3987 
	{
3988 
	    ADVANCE_LEXER;
7 7u83 3989 
	    ZR352 (&ZIkey);
3990 
	    if ((CURRENT_TERMINAL) == 75) {
3991 
		RESTORE_LEXER;
2 7u83 3992 
		goto ZL1;
3993 
	    }
3994 
	}
3995 
	break;
7 7u83 3996 
      case 70:
2 7u83 3997 
	{
3998 
	    ADVANCE_LEXER;
7 7u83 3999 
	    ZR353 (&ZIkey);
4000 
	    if ((CURRENT_TERMINAL) == 75) {
4001 
		RESTORE_LEXER;
2 7u83 4002 
		goto ZL1;
4003 
	    }
4004 
	}
4005 
	break;
7 7u83 4006 
      case 75:
2 7u83 4007 
	return;
4008 
      default:
4009 
	goto ZL1;
4010 
    }
4011 
    goto ZL0;
4012 
  ZL1:;
7 7u83 4013 
    SAVE_LEXER (75);
2 7u83 4014 
    return;
4015 
  ZL0:;
4016 
    *ZOkey = ZIkey;
4017 
}
4018 
 
4019 
static void
7 7u83 4020 
ZRdefine_Hparam_Hclause(SID_STRING *ZOp)
2 7u83 4021 
{
4022 
    SID_STRING ZIp;
4023 
 
4024 
    switch (CURRENT_TERMINAL) {
7 7u83 4025 
      case 56:
2 7u83 4026 
	{
4027 
	    ADVANCE_LEXER;
7 7u83 4028 
	    ZR325 (&ZIp);
4029 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4030 
		RESTORE_LEXER;
4031 
		goto ZL1;
4032 
	    }
4033 
	}
4034 
	break;
4035 
      default:
4036 
	{
4037 
	    {
4038 
 (ZIp) = null ;
4039 
	    }
4040 
	}
4041 
	break;
7 7u83 4042 
      case 75:
2 7u83 4043 
	return;
4044 
    }
4045 
    goto ZL0;
4046 
  ZL1:;
7 7u83 4047 
    SAVE_LEXER (75);
2 7u83 4048 
    return;
4049 
  ZL0:;
4050 
    *ZOp = ZIp;
4051 
}
4052 
 
4053 
static void
7 7u83 4054 
ZRexp_Hcommand(int *ZOcmd)
2 7u83 4055 
{
4056 
    int ZIcmd;
4057 
 
4058 
    switch (CURRENT_TERMINAL) {
4059 
      case 8:
4060 
	{
4061 
	    ADVANCE_LEXER;
4062 
	    {
4063 
 (ZIcmd) = OBJ_CONST ;
4064 
	    }
4065 
	}
4066 
	break;
4067 
      case 13:
4068 
	{
4069 
	    ADVANCE_LEXER;
7 7u83 4070 
	    ZR329 (&ZIcmd);
4071 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4072 
		RESTORE_LEXER;
4073 
		goto ZL1;
4074 
	    }
4075 
	}
4076 
	break;
7 7u83 4077 
      case 75:
2 7u83 4078 
	return;
4079 
      default:
4080 
	goto ZL1;
4081 
    }
4082 
    goto ZL0;
4083 
  ZL1:;
7 7u83 4084 
    SAVE_LEXER (75);
2 7u83 4085 
    return;
4086 
  ZL0:;
4087 
    *ZOcmd = ZIcmd;
4088 
}
4089 
 
4090 
static void
7 7u83 4091 
ZR352(SID_STRING *ZOkey)
2 7u83 4092 
{
7 7u83 4093 
    SID_STRING ZIkey;
4094 
 
2 7u83 4095 
    switch (CURRENT_TERMINAL) {
4096 
      case 67:
4097 
	{
4098 
	    ADVANCE_LEXER;
4099 
	    switch (CURRENT_TERMINAL) {
7 7u83 4100 
	      case 57:
2 7u83 4101 
		break;
4102 
	      default:
4103 
		goto ZL1;
4104 
	    }
4105 
	    ADVANCE_LEXER;
4106 
	    {
7 7u83 4107 
 (ZIkey) = "11" ;
2 7u83 4108 
	    }
4109 
	}
4110 
	break;
7 7u83 4111 
      case 70:
2 7u83 4112 
	{
4113 
	    ADVANCE_LEXER;
7 7u83 4114 
	    switch (CURRENT_TERMINAL) {
4115 
	      case 57:
4116 
		break;
4117 
	      default:
4118 
		goto ZL1;
2 7u83 4119 
	    }
4120 
	    ADVANCE_LEXER;
4121 
	    {
7 7u83 4122 
 (ZIkey) = "10" ;
2 7u83 4123 
	    }
4124 
	}
4125 
	break;
7 7u83 4126 
      case 75:
2 7u83 4127 
	return;
4128 
      default:
4129 
	goto ZL1;
4130 
    }
7 7u83 4131 
    goto ZL0;
2 7u83 4132 
  ZL1:;
7 7u83 4133 
    SAVE_LEXER (75);
2 7u83 4134 
    return;
7 7u83 4135 
  ZL0:;
4136 
    *ZOkey = ZIkey;
2 7u83 4137 
}
4138 
 
4139 
static void
7 7u83 4140 
ZRif_Hcommand(SID_COMMAND *ZOc, SID_STRING *ZOs)
2 7u83 4141 
{
4142 
    SID_COMMAND ZIc;
4143 
    SID_STRING ZIs;
4144 
 
4145 
    switch (CURRENT_TERMINAL) {
4146 
      case 16:
4147 
	{
4148 
	    ADVANCE_LEXER;
4149 
	    ZRconstant_Hvalue (&ZIs);
7 7u83 4150 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4151 
		RESTORE_LEXER;
4152 
		goto ZL1;
4153 
	    }
4154 
	    {
4155 
 
4156 
    (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
4157 
    (ZIc)->u.u_num = CMD_IF ;
4158 
	    }
4159 
	}
4160 
	break;
4161 
      case 17:
4162 
	{
4163 
	    ADVANCE_LEXER;
4164 
	    ZRifdef_Hmacro_Hname (&ZIs);
7 7u83 4165 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4166 
		RESTORE_LEXER;
4167 
		goto ZL1;
4168 
	    }
4169 
	    {
4170 
 
4171 
    (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
4172 
    (ZIc)->u.u_num = CMD_IFDEF ;
4173 
	    }
4174 
	}
4175 
	break;
4176 
      case 18:
4177 
	{
4178 
	    ADVANCE_LEXER;
4179 
	    ZRifdef_Hmacro_Hname (&ZIs);
7 7u83 4180 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4181 
		RESTORE_LEXER;
4182 
		goto ZL1;
4183 
	    }
4184 
	    {
4185 
 
4186 
    (ZIc) = make_object ( (ZIs), OBJ_IF ) ;
4187 
    (ZIc)->u.u_num = CMD_IFNDEF ;
4188 
	    }
4189 
	}
4190 
	break;
7 7u83 4191 
      case 75:
2 7u83 4192 
	return;
4193 
      default:
4194 
	goto ZL1;
4195 
    }
4196 
    goto ZL0;
4197 
  ZL1:;
7 7u83 4198 
    SAVE_LEXER (75);
2 7u83 4199 
    return;
4200 
  ZL0:;
4201 
    *ZOc = ZIc;
4202 
    *ZOs = ZIs;
4203 
}
4204 
 
4205 
static void
7 7u83 4206 
ZR353(SID_STRING *ZOkey)
2 7u83 4207 
{
7 7u83 4208 
    SID_STRING ZIkey;
4209 
 
4210 
    switch (CURRENT_TERMINAL) {
4211 
      case 67:
4212 
	{
4213 
	    ADVANCE_LEXER;
4214 
	    switch (CURRENT_TERMINAL) {
4215 
	      case 57:
4216 
		break;
4217 
	      default:
4218 
		goto ZL1;
4219 
	    }
4220 
	    ADVANCE_LEXER;
4221 
	    {
4222 
 (ZIkey) = "01" ;
4223 
	    }
4224 
	}
4225 
	break;
4226 
      case 70:
4227 
	{
4228 
	    ADVANCE_LEXER;
4229 
	    switch (CURRENT_TERMINAL) {
4230 
	      case 57:
4231 
		break;
4232 
	      default:
4233 
		goto ZL1;
4234 
	    }
4235 
	    ADVANCE_LEXER;
4236 
	    {
4237 
 (ZIkey) = "00" ;
4238 
	    }
4239 
	}
4240 
	break;
4241 
      case 75:
4242 
	return;
4243 
      default:
4244 
	goto ZL1;
4245 
    }
4246 
    goto ZL0;
4247 
  ZL1:;
4248 
    SAVE_LEXER (75);
4249 
    return;
4250 
  ZL0:;
4251 
    *ZOkey = ZIkey;
4252 
}
4253 
 
4254 
static void
4255 
ZR354(SID_STRING *ZInm)
4256 
{
4257 
    switch (CURRENT_TERMINAL) {
4258 
      case 68:
4259 
	{
4260 
	    SID_STRING ZIs;
4261 
 
4262 
	    ADVANCE_LEXER;
4263 
	    switch (CURRENT_TERMINAL) {
4264 
	      case 1:
4265 
		{
4266 
 ZIs = token_value ;
4267 
		}
4268 
		break;
4269 
	      default:
4270 
		goto ZL1;
4271 
	    }
4272 
	    ADVANCE_LEXER;
4273 
	    {
4274 
 
4275 
    set_integer ( (*ZInm), -atoi ( (ZIs) ) ) ;
4276 
	    }
4277 
	}
4278 
	break;
4279 
      case 1:
4280 
	{
4281 
	    SID_STRING ZIs;
4282 
 
4283 
	    {
4284 
 ZIs = token_value ;
4285 
	    }
4286 
	    ADVANCE_LEXER;
4287 
	    {
4288 
 
4289 
    set_integer ( (*ZInm), atoi ( (ZIs) ) ) ;
4290 
	    }
4291 
	}
4292 
	break;
4293 
      case 2:
4294 
	{
4295 
	    SID_STRING ZIs;
4296 
 
4297 
	    {
4298 
 ZIs = token_value ;
4299 
	    }
4300 
	    ADVANCE_LEXER;
4301 
	    {
4302 
 
4303 
    set_string ( (*ZInm), (ZIs) ) ;
4304 
	    }
4305 
	}
4306 
	break;
4307 
      case 75:
4308 
	return;
4309 
      default:
4310 
	goto ZL1;
4311 
    }
4312 
    return;
4313 
  ZL1:;
4314 
    SAVE_LEXER (75);
4315 
    return;
4316 
}
4317 
 
4318 
static void
4319 
ZRbitfield_Hoperator(SID_TYPE *ZOt)
4320 
{
2 7u83 4321 
    SID_TYPE ZIt;
4322 
 
7 7u83 4323 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4324 
	return;
4325 
    }
4326 
    {
4327 
	SID_STRING ZIa;
4328 
 
4329 
	switch (CURRENT_TERMINAL) {
7 7u83 4330 
	  case 61:
2 7u83 4331 
	    break;
4332 
	  default:
4333 
	    goto ZL1;
4334 
	}
4335 
	ADVANCE_LEXER;
4336 
	ZRconstant_Hvalue (&ZIa);
7 7u83 4337 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 4338 
	    RESTORE_LEXER;
4339 
	    goto ZL1;
4340 
	}
4341 
	{
4342 
 
4343 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_BITFIELD ) ;
4344 
    (ZIt)->v.str = (ZIa) ;
4345 
	}
4346 
    }
4347 
    goto ZL0;
4348 
  ZL1:;
7 7u83 4349 
    SAVE_LEXER (75);
2 7u83 4350 
    return;
4351 
  ZL0:;
4352 
    *ZOt = ZIt;
4353 
}
4354 
 
4355 
static void
7 7u83 4356 
ZRuse_Hsubset_Hname(SID_STRING *ZOs)
2 7u83 4357 
{
4358 
    SID_STRING ZIs;
4359 
 
7 7u83 4360 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4361 
	return;
4362 
    }
4363 
    {
4364 
	SID_STRING ZIa;
4365 
	SID_STRING ZIb;
4366 
 
4367 
	switch (CURRENT_TERMINAL) {
7 7u83 4368 
	  case 56:
2 7u83 4369 
	    break;
4370 
	  default:
4371 
	    goto ZL1;
4372 
	}
4373 
	ADVANCE_LEXER;
4374 
	switch (CURRENT_TERMINAL) {
4375 
	  case 2:
4376 
	    {
4377 
 ZIa = token_value ;
4378 
	    }
4379 
	    break;
4380 
	  default:
4381 
	    goto ZL1;
4382 
	}
4383 
	ADVANCE_LEXER;
4384 
	switch (CURRENT_TERMINAL) {
7 7u83 4385 
	  case 57:
2 7u83 4386 
	    break;
4387 
	  default:
4388 
	    goto ZL1;
4389 
	}
4390 
	ADVANCE_LEXER;
4391 
	switch (CURRENT_TERMINAL) {
7 7u83 4392 
	  case 62:
2 7u83 4393 
	    break;
4394 
	  default:
4395 
	    goto ZL1;
4396 
	}
4397 
	ADVANCE_LEXER;
4398 
	switch (CURRENT_TERMINAL) {
4399 
	  case 2:
4400 
	    {
4401 
 ZIb = token_value ;
4402 
	    }
4403 
	    break;
4404 
	  default:
4405 
	    goto ZL1;
4406 
	}
4407 
	ADVANCE_LEXER;
4408 
	{
4409 
 
4410 
    (ZIs) = subset_name ( (ZIa), (ZIb), null_str ) ;
4411 
	}
4412 
    }
4413 
    goto ZL0;
4414 
  ZL1:;
7 7u83 4415 
    SAVE_LEXER (75);
2 7u83 4416 
    return;
4417 
  ZL0:;
4418 
    *ZOs = ZIs;
4419 
}
4420 
 
4421 
void
7 7u83 4422 
read_spec(SID_COMMAND *ZOc)
2 7u83 4423 
{
4424 
    SID_COMMAND ZIc;
4425 
 
7 7u83 4426 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4427 
	return;
4428 
    }
4429 
    {
4430 
	ZRsubset_Hcommand (&ZIc);
4431 
	switch (CURRENT_TERMINAL) {
7 7u83 4432 
	  case 71:
2 7u83 4433 
	    break;
7 7u83 4434 
	  case 75:
2 7u83 4435 
	    RESTORE_LEXER;
4436 
	    goto ZL1;
4437 
	  default:
4438 
	    goto ZL1;
4439 
	}
4440 
	ADVANCE_LEXER;
4441 
	switch (CURRENT_TERMINAL) {
7 7u83 4442 
	  case 73:
2 7u83 4443 
	    break;
4444 
	  default:
4445 
	    goto ZL1;
4446 
	}
4447 
	ADVANCE_LEXER;
4448 
    }
4449 
    goto ZL0;
4450 
  ZL1:;
4451 
    {
4452 
	{
4453 
 
4454 
    error ( ERR_SERIOUS, "Syntax error" ) ;
4455 
	}
4456 
	{
4457 
 
4458 
    (ZIc) = null ;
4459 
	}
4460 
    }
4461 
  ZL0:;
4462 
    *ZOc = ZIc;
4463 
}
4464 
 
4465 
static void
7 7u83 4466 
ZRmacro_Hdeclarator(SID_IDENTIFIER *ZOid, SID_TYPE *ZOt)
2 7u83 4467 
{
4468 
    SID_IDENTIFIER ZIid;
4469 
    SID_TYPE ZIt;
4470 
 
4471 
    switch (CURRENT_TERMINAL) {
4472 
      case 0:
4473 
	{
4474 
	    ZRidentifier (&ZIid);
7 7u83 4475 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4476 
		RESTORE_LEXER;
4477 
		goto ZL1;
4478 
	    }
4479 
	    {
4480 
 
4481 
    (ZIt) = null ;
4482 
	    }
4483 
	}
4484 
	break;
7 7u83 4485 
      case 72:
2 7u83 4486 
	{
4487 
	    SID_TYPE ZIp;
4488 
	    SID_TYPE ZIs;
4489 
 
4490 
	    ZRptr_Hoperator (&ZIp);
4491 
	    ZRmacro_Hdeclarator (&ZIid, &ZIs);
7 7u83 4492 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4493 
		RESTORE_LEXER;
4494 
		goto ZL1;
4495 
	    }
4496 
	    {
4497 
 
4498 
    (ZIt) = inject_type ( (ZIs), (ZIp) ) ;
4499 
	    }
4500 
	}
4501 
	break;
7 7u83 4502 
      case 75:
2 7u83 4503 
	return;
4504 
      default:
4505 
	goto ZL1;
4506 
    }
4507 
    goto ZL0;
4508 
  ZL1:;
7 7u83 4509 
    SAVE_LEXER (75);
2 7u83 4510 
    return;
4511 
  ZL0:;
4512 
    *ZOid = ZIid;
4513 
    *ZOt = ZIt;
4514 
}
4515 
 
4516 
static void
7 7u83 4517 
ZRsubset_Hname(SID_STRING *ZOs)
2 7u83 4518 
{
4519 
    SID_STRING ZIs;
4520 
 
7 7u83 4521 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4522 
	return;
4523 
    }
4524 
    {
4525 
	SID_STRING ZIa;
4526 
 
4527 
	switch (CURRENT_TERMINAL) {
4528 
	  case 2:
4529 
	    {
4530 
 ZIa = token_value ;
4531 
	    }
4532 
	    break;
4533 
	  default:
4534 
	    goto ZL1;
4535 
	}
4536 
	ADVANCE_LEXER;
7 7u83 4537 
	ZR320 (&ZIa, &ZIs);
4538 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 4539 
	    RESTORE_LEXER;
4540 
	    goto ZL1;
4541 
	}
4542 
    }
4543 
    goto ZL0;
4544 
  ZL1:;
7 7u83 4545 
    SAVE_LEXER (75);
2 7u83 4546 
    return;
4547 
  ZL0:;
4548 
    *ZOs = ZIs;
4549 
}
4550 
 
4551 
static void
7 7u83 4552 
ZRbuiltin_Htype(unsigned *ZOb)
2 7u83 4553 
{
4554 
    unsigned ZIb;
4555 
 
7 7u83 4556 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4557 
	return;
4558 
    }
4559 
    {
4560 
	unsigned ZIa;
4561 
	unsigned ZIc;
4562 
 
4563 
	ZRtype_Hkeyword (&ZIa);
4564 
	{
4565 
	    switch (CURRENT_TERMINAL) {
7 7u83 4566 
	      case 32: case 34: case 37: case 38: case 39:
4567 
	      case 42: case 43: case 46: case 47:
2 7u83 4568 
		{
4569 
		    unsigned ZId;
4570 
 
4571 
		    ZRbuiltin_Htype (&ZId);
7 7u83 4572 
		    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4573 
			RESTORE_LEXER;
4574 
			goto ZL1;
4575 
		    }
4576 
		    {
4577 
 
4578 
    while ( (ZIa) & (ZId) ) {
4579 
	if ( (ZIa) == BTYPE_LONG && allow_long_long ) {
4580 
	    (ZIa) = BTYPE_LLONG ;
4581 
	} else {
4582 
	    error ( ERR_SERIOUS, "Duplicate type specifier" ) ;
4583 
	    break ;
4584 
	}
4585 
    }
4586 
    (ZIc) = ( (ZIa) | (ZId) ) ;
4587 
		    }
4588 
		}
4589 
		break;
4590 
	      default:
4591 
		{
4592 
		    ZIc = ZIa;
4593 
		}
4594 
		break;
7 7u83 4595 
	      case 75:
2 7u83 4596 
		RESTORE_LEXER;
4597 
		goto ZL1;
4598 
	    }
4599 
	}
4600 
	ZIb = ZIc;
4601 
    }
4602 
    goto ZL0;
4603 
  ZL1:;
7 7u83 4604 
    SAVE_LEXER (75);
2 7u83 4605 
    return;
4606 
  ZL0:;
4607 
    *ZOb = ZIb;
4608 
}
4609 
 
4610 
static void
7 7u83 4611 
ZRobject_Hqualifier(int *ZOlv)
2 7u83 4612 
{
4613 
    int ZIlv;
4614 
 
4615 
    switch (CURRENT_TERMINAL) {
7 7u83 4616 
      case 40:
2 7u83 4617 
	{
4618 
	    ADVANCE_LEXER;
4619 
	    {
4620 
 (ZIlv) = TYPE_LVALUE ;
4621 
	    }
4622 
	}
4623 
	break;
4624 
      default:
4625 
	{
4626 
	    {
4627 
 (ZIlv) = TYPE_RVALUE ;
4628 
	    }
4629 
	}
4630 
	break;
7 7u83 4631 
      case 75:
2 7u83 4632 
	return;
4633 
    }
4634 
    *ZOlv = ZIlv;
4635 
}
4636 
 
4637 
static void
7 7u83 4638 
ZRfield_Hlist(SID_TYPE ZIm, SID_COMMAND *ZOc)
2 7u83 4639 
{
4640 
    SID_COMMAND ZIc;
4641 
 
4642 
    switch (CURRENT_TERMINAL) {
4643 
      case 16: case 17: case 18:
4644 
	{
4645 
	    SID_COMMAND ZIi;
4646 
	    SID_STRING ZIs;
4647 
	    SID_COMMAND ZIa;
4648 
	    SID_COMMAND ZIb;
4649 
	    SID_COMMAND ZIc1;
4650 
	    SID_COMMAND ZIc2;
4651 
 
4652 
	    ZRif_Hcommand (&ZIi, &ZIs);
4653 
	    ZRfield_Hlist (ZIm, &ZIa);
4654 
	    {
4655 
		switch (CURRENT_TERMINAL) {
4656 
		  case 10:
4657 
		    {
4658 
			ADVANCE_LEXER;
4659 
			ZRfield_Hlist (ZIm, &ZIb);
7 7u83 4660 
			if ((CURRENT_TERMINAL) == 75) {
2 7u83 4661 
			    RESTORE_LEXER;
4662 
			    goto ZL1;
4663 
			}
4664 
		    }
4665 
		    break;
4666 
		  default:
4667 
		    {
4668 
			{
4669 
 
4670 
    (ZIb) = null ;
4671 
			}
4672 
		    }
4673 
		    break;
7 7u83 4674 
		  case 75:
2 7u83 4675 
		    RESTORE_LEXER;
4676 
		    goto ZL1;
4677 
		}
4678 
	    }
4679 
	    switch (CURRENT_TERMINAL) {
4680 
	      case 11:
4681 
		break;
4682 
	      default:
4683 
		goto ZL1;
4684 
	    }
4685 
	    ADVANCE_LEXER;
4686 
	    {
4687 
 
4688 
    object *p, *q ;
4689 
    p = join_object ( (ZIi), (ZIa) ) ;
4690 
    if ( (ZIb) ) {
4691 
	q = make_object ( (ZIs), OBJ_IF ) ;
4692 
	q->u.u_num = CMD_ELSE ;
4693 
	p = join_object ( p, q ) ;
4694 
	p = join_object ( p, (ZIb) ) ;
4695 
    }
4696 
    q = make_object ( (ZIs), OBJ_IF ) ;
4697 
    q->u.u_num = CMD_ENDIF ;
4698 
    (ZIc1) = join_object ( p, q ) ;
4699 
	    }
4700 
	    ZRfield_Hlist (ZIm, &ZIc2);
7 7u83 4701 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4702 
		RESTORE_LEXER;
4703 
		goto ZL1;
4704 
	    }
4705 
	    {
4706 
 
4707 
    (ZIc) = join_object ( (ZIc1), (ZIc2) ) ;
4708 
	    }
4709 
	}
4710 
	break;
7 7u83 4711 
      case 0: case 32: case 33: case 34: case 35:
4712 
      case 37: case 38: case 39: case 42: case 43:
4713 
      case 44: case 45: case 46: case 47: case 48:
2 7u83 4714 
	{
4715 
	    SID_TYPE ZIt;
4716 
	    SID_COMMAND ZIa;
4717 
	    SID_COMMAND ZIb;
4718 
 
4719 
	    ZRqualified_Htype (&ZIt);
4720 
	    ZRfield_Hdeclarator_Hlist (ZIm, ZIt, &ZIa);
4721 
	    switch (CURRENT_TERMINAL) {
7 7u83 4722 
	      case 71:
2 7u83 4723 
		break;
7 7u83 4724 
	      case 75:
2 7u83 4725 
		RESTORE_LEXER;
4726 
		goto ZL1;
4727 
	      default:
4728 
		goto ZL1;
4729 
	    }
4730 
	    ADVANCE_LEXER;
4731 
	    ZRfield_Hlist (ZIm, &ZIb);
7 7u83 4732 
	    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4733 
		RESTORE_LEXER;
4734 
		goto ZL1;
4735 
	    }
4736 
	    {
4737 
 
4738 
    (ZIc) = join_object ( (ZIa), (ZIb) ) ;
4739 
	    }
4740 
	}
4741 
	break;
4742 
      default:
4743 
	{
4744 
	    {
4745 
 
4746 
    (ZIc) = null ;
4747 
	    }
4748 
	}
4749 
	break;
7 7u83 4750 
      case 75:
2 7u83 4751 
	return;
4752 
    }
4753 
    goto ZL0;
4754 
  ZL1:;
7 7u83 4755 
    SAVE_LEXER (75);
2 7u83 4756 
    return;
4757 
  ZL0:;
4758 
    *ZOc = ZIc;
4759 
}
4760 
 
4761 
static void
7 7u83 4762 
ZRptr_Hoperator(SID_TYPE *ZOt)
2 7u83 4763 
{
4764 
    SID_TYPE ZIt;
4765 
 
7 7u83 4766 
    if ((CURRENT_TERMINAL) == 75) {
2 7u83 4767 
	return;
4768 
    }
4769 
    {
4770 
	unsigned ZIcv;
4771 
 
4772 
	switch (CURRENT_TERMINAL) {
7 7u83 4773 
	  case 72:
2 7u83 4774 
	    break;
4775 
	  default:
4776 
	    goto ZL1;
4777 
	}
4778 
	ADVANCE_LEXER;
4779 
	ZRtype_Hqualifier_Hopt (&ZIcv);
7 7u83 4780 
	if ((CURRENT_TERMINAL) == 75) {
2 7u83 4781 
	    RESTORE_LEXER;
4782 
	    goto ZL1;
4783 
	}
4784 
	{
4785 
 
4786 
    (ZIt) = make_subtype ( ( type * ) null, TYPE_PTR ) ;
4787 
    (ZIt)->v.str = cv_qualifier [ (ZIcv) ] ;
4788 
	}
4789 
    }
4790 
    goto ZL0;
4791 
  ZL1:;
7 7u83 4792 
    SAVE_LEXER (75);
2 7u83 4793 
    return;
4794 
  ZL0:;
4795 
    *ZOt = ZIt;
4796 
}
4797 
 
4798 
static void
7 7u83 4799 
ZRtype_Hkeyword(unsigned *ZOb)
2 7u83 4800 
{
4801 
    unsigned ZIb;
4802 
 
4803 
    switch (CURRENT_TERMINAL) {
7 7u83 4804 
      case 32:
2 7u83 4805 
	{
4806 
	    ADVANCE_LEXER;
4807 
	    {
4808 
 (ZIb) = BTYPE_CHAR ;
4809 
	    }
4810 
	}
4811 
	break;
7 7u83 4812 
      case 34:
2 7u83 4813 
	{
4814 
	    ADVANCE_LEXER;
4815 
	    {
4816 
 (ZIb) = BTYPE_DOUBLE ;
4817 
	    }
4818 
	}
4819 
	break;
7 7u83 4820 
      case 37:
2 7u83 4821 
	{
4822 
	    ADVANCE_LEXER;
4823 
	    {
4824 
 (ZIb) = BTYPE_FLOAT ;
4825 
	    }
4826 
	}
4827 
	break;
7 7u83 4828 
      case 38:
2 7u83 4829 
	{
4830 
	    ADVANCE_LEXER;
4831 
	    {
4832 
 (ZIb) = BTYPE_INT ;
4833 
	    }
4834 
	}
4835 
	break;
7 7u83 4836 
      case 39:
2 7u83 4837 
	{
4838 
	    ADVANCE_LEXER;
4839 
	    {
4840 
 (ZIb) = BTYPE_LONG ;
4841 
	    }
4842 
	}
4843 
	break;
7 7u83 4844 
      case 42:
2 7u83 4845 
	{
4846 
	    ADVANCE_LEXER;
4847 
	    {
4848 
 (ZIb) = BTYPE_SHORT ;
4849 
	    }
4850 
	}
4851 
	break;
7 7u83 4852 
      case 43:
2 7u83 4853 
	{
4854 
	    ADVANCE_LEXER;
4855 
	    {
4856 
 (ZIb) = BTYPE_SIGNED ;
4857 
	    }
4858 
	}
4859 
	break;
7 7u83 4860 
      case 46:
2 7u83 4861 
	{
4862 
	    ADVANCE_LEXER;
4863 
	    {
4864 
 (ZIb) = BTYPE_UNSIGNED ;
4865 
	    }
4866 
	}
4867 
	break;
7 7u83 4868 
      case 47:
2 7u83 4869 
	{
4870 
	    ADVANCE_LEXER;
4871 
	    {
4872 
 (ZIb) = BTYPE_VOID ;
4873 
	    }
4874 
	}
4875 
	break;
7 7u83 4876 
      case 75:
2 7u83 4877 
	return;
4878 
      default:
4879 
	goto ZL1;
4880 
    }
4881 
    goto ZL0;
4882 
  ZL1:;
7 7u83 4883 
    SAVE_LEXER (75);
2 7u83 4884 
    return;
4885 
  ZL0:;
4886 
    *ZOb = ZIb;
4887 
}
4888 
 
4889 
/* BEGINNING OF TRAILER */
4890 
 
4891 
 
4892 
 
4893 
/* END OF FILE */