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