Subversion Repositories tendra.SVN

Rev

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

Rev Author Line No. Line
2 7u83 1
/*
2
 * Automatically generated from the files:
7 7u83 3
 *	syntax.sid
2 7u83 4
 * and
7 7u83 5
 *	syntax.act
2 7u83 6
 * by:
7
 *	sid
8
 */
9
 
10
/* BEGINNING OF HEADER */
11
 
12
 
13
/*
14
    		 Crown Copyright (c) 1997
15
 
16
    This TenDRA(r) Computer Program is subject to Copyright
17
    owned by the United Kingdom Secretary of State for Defence
18
    acting through the Defence Evaluation and Research Agency
19
    (DERA).  It is made available to Recipients with a
20
    royalty-free licence for its use, reproduction, transfer
21
    to other parties and amendment for any purpose not excluding
22
    product development provided that any such use et cetera
23
    shall be deemed to be acceptance of the following conditions:-
24
 
25
        (1) Its Recipients shall ensure that this Notice is
26
        reproduced upon any copies or amended versions of it;
27
 
28
        (2) Any amended version of it shall be clearly marked to
29
        show both the nature of and the organisation responsible
30
        for the relevant amendment or amendments;
31
 
32
        (3) Its onward transfer from a recipient to another
33
        party shall be deemed to be that party's acceptance of
34
        these conditions;
35
 
36
        (4) DERA gives no warranty or assurance as to its
37
        quality or suitability for any purpose and DERA accepts
38
        no liability whatsoever in relation to any use to which
39
        it may be put.
40
*/
41
 
42
 
43
#include "config.h"
44
#include "tdf.h"
45
#include "cmd_ops.h"
46
#include "cons_ops.h"
47
#include "info_ops.h"
48
#include "link_ops.h"
49
#include "par_ops.h"
50
#include "sort_ops.h"
51
#include "spec_ops.h"
52
#include "error.h"
53
#include "input.h"
54
#include "lex.h"
55
#include "syntax.h"
56
#include "xalloc.h"
57
 
58
 
59
/*
60
    LOCAL TYPE ALIASES
61
 
62
    These definitions give the aliases used for compound types within the
63
    grammar.
64
*/
65
 
66
typedef LIST ( CONSTRUCT ) SID_CONS_LIST ;
67
typedef LIST ( LINKAGE ) SID_LINK_LIST ;
68
typedef LIST ( PARAMETER ) SID_PARAM_LIST ;
69
 
70
 
71
/*
72
    COMPILATION MODE
73
 
74
    We allow unreached code and switch off the variable analysis in the
75
    automatically generated sections.
76
*/
77
 
78
#if FS_TENDRA
79
#pragma TenDRA begin
80
#pragma TenDRA variable analysis off
81
#ifndef OLD_PRODUCER
82
#pragma TenDRA unreachable code allow
83
#endif
84
#endif
85
 
86
 
87
 
88
/* BEGINNING OF FUNCTION DECLARATIONS */
89
 
7 7u83 90
static void ZRlink_Hpack(SID_LINK_LIST *);
91
static void ZRparam_Hlist(SID_PARAM_LIST *);
92
static void ZRclist_Hitem(void);
93
static void ZRslist_Hpack(void);
94
static void ZRedge_Hlist(void);
95
static void ZRkind_Hitem(LINKAGE *);
96
static void ZRoption_Hlist(void);
97
static void ZR139(CONSTRUCT *);
98
static void ZRold_Hsort_Hname(SORT *);
99
static void ZR140(CONSTRUCT *);
100
static void ZR141(CONSTRUCT *);
101
static void ZRclist_Hlist(void);
102
static void ZRlink_Hitem(LINKAGE *);
103
static void ZRslist_Hitem(void);
104
static void ZRkind_Hlist(SID_LINK_LIST *);
105
static void ZRnew_Hsort_Hname(SORT *);
106
static void ZRsort_Hpack(void);
107
static void ZRany_Hname(string *);
108
static void ZRlink_Hlist(SID_LINK_LIST *);
109
static void ZRslist_Hlist(void);
110
static void ZRsort_Hitem(void);
111
static void ZRsort_Hlist(void);
112
static void ZRconstruct_Hpack(SORT, SID_CONS_LIST *);
113
static void ZRconstruct_Hextra(CONSTRUCT);
114
static void ZRboundary_Hitem(CONSTRUCT);
115
static void ZRconstruct_Hitem(SORT, CONSTRUCT *);
116
static void ZRconstruct_Hlist(SORT, SID_CONS_LIST *);
117
static void ZRparam_Hpack(SID_PARAM_LIST *);
118
static void ZRedge_Hpack(void);
119
extern void read_spec(SPECIFICATION *);
120
static void ZRoption_Hpack(void);
121
static void ZRclist_Hpack(void);
122
static void ZRparam_Hitem(PARAMETER *);
123
static void ZRedge_Hitem(void);
124
static void ZRkind_Hpack(SID_LINK_LIST *);
125
static void ZRnumber_Hlist(CONSTRUCT);
126
static void ZRoption_Hitem(void);
2 7u83 127
 
128
/* BEGINNING OF STATIC VARIABLES */
129
 
130
 
131
/* BEGINNING OF FUNCTION DEFINITIONS */
132
 
133
static void
7 7u83 134
ZRlink_Hpack(SID_LINK_LIST *ZOp)
2 7u83 135
{
136
    SID_LINK_LIST ZIp;
137
 
138
    if ((CURRENT_TERMINAL) == 32) {
139
	return;
140
    }
141
    {
142
	SID_LINK_LIST ZIq;
143
 
144
	switch (CURRENT_TERMINAL) {
145
	  case 27:
146
	    break;
147
	  default:
148
	    goto ZL1;
149
	}
150
	ADVANCE_LEXER;
151
	{
152
	    switch (CURRENT_TERMINAL) {
153
	      case 27:
154
		{
155
		    ZRlink_Hlist (&ZIq);
156
		    if ((CURRENT_TERMINAL) == 32) {
157
			RESTORE_LEXER;
158
			goto ZL1;
159
		    }
160
		}
161
		break;
162
	      default:
163
		{
164
		    {
165
 
166
    (ZIq) = NULL_list ( LINKAGE ) ;
167
		    }
168
		}
169
		break;
170
	    }
171
	}
172
	switch (CURRENT_TERMINAL) {
173
	  case 28:
174
	    break;
175
	  default:
176
	    goto ZL1;
177
	}
178
	ADVANCE_LEXER;
179
	ZIp = ZIq;
180
    }
181
    goto ZL0;
182
  ZL1:;
183
    SAVE_LEXER (32);
184
    return;
185
  ZL0:;
186
    *ZOp = ZIp;
187
}
188
 
189
static void
7 7u83 190
ZRparam_Hlist(SID_PARAM_LIST *ZOp)
2 7u83 191
{
192
    SID_PARAM_LIST ZIp;
193
 
194
    if ((CURRENT_TERMINAL) == 32) {
195
	return;
196
    }
197
    {
198
	PARAMETER ZIa;
199
	SID_PARAM_LIST ZIq;
200
 
201
	ZRparam_Hitem (&ZIa);
202
	{
203
	    switch (CURRENT_TERMINAL) {
204
	      case 29:
205
		{
206
		    ADVANCE_LEXER;
207
		    ZRparam_Hlist (&ZIq);
208
		    if ((CURRENT_TERMINAL) == 32) {
209
			RESTORE_LEXER;
210
			goto ZL1;
211
		    }
212
		}
213
		break;
214
	      default:
215
		{
216
		    {
217
 
218
    (ZIq) = NULL_list ( PARAMETER ) ;
219
		    }
220
		}
221
		break;
222
	      case 32:
223
		RESTORE_LEXER;
224
		goto ZL1;
225
	    }
226
	}
227
	{
228
 
229
    CONS_par ( (ZIa), (ZIq), (ZIp) ) ;
230
	}
231
    }
232
    goto ZL0;
233
  ZL1:;
234
    SAVE_LEXER (32);
235
    return;
236
  ZL0:;
237
    *ZOp = ZIp;
238
}
239
 
240
static void
7 7u83 241
ZRclist_Hitem(void)
2 7u83 242
{
243
    if ((CURRENT_TERMINAL) == 32) {
244
	return;
245
    }
246
    {
247
	SORT ZIs;
248
 
249
	ZRnew_Hsort_Hname (&ZIs);
250
	if ((CURRENT_TERMINAL) == 32) {
251
	    RESTORE_LEXER;
252
	    goto ZL1;
253
	}
254
	{
255
 
256
    compound_sort ( (ZIs), "_list", info_clist_tag, '*' ) ;
257
	}
258
    }
259
    return;
260
  ZL1:;
261
    SAVE_LEXER (32);
262
    return;
263
}
264
 
265
static void
7 7u83 266
ZRslist_Hpack(void)
2 7u83 267
{
268
    if ((CURRENT_TERMINAL) == 32) {
269
	return;
270
    }
271
    {
272
	switch (CURRENT_TERMINAL) {
273
	  case 27:
274
	    break;
275
	  default:
276
	    goto ZL1;
277
	}
278
	ADVANCE_LEXER;
279
	{
280
	    switch (CURRENT_TERMINAL) {
281
	      case 0:
282
		{
283
		    ZRslist_Hlist ();
284
		    if ((CURRENT_TERMINAL) == 32) {
285
			RESTORE_LEXER;
286
			goto ZL1;
287
		    }
288
		}
289
		break;
290
	      default:
291
		break;
292
	    }
293
	}
294
	switch (CURRENT_TERMINAL) {
295
	  case 28:
296
	    break;
297
	  default:
298
	    goto ZL1;
299
	}
300
	ADVANCE_LEXER;
301
    }
302
    return;
303
  ZL1:;
304
    SAVE_LEXER (32);
305
    return;
306
}
307
 
308
static void
7 7u83 309
ZRedge_Hlist(void)
2 7u83 310
{
311
    if ((CURRENT_TERMINAL) == 32) {
312
	return;
313
    }
314
  ZL2_edge_Hlist:;
315
    {
316
	switch (CURRENT_TERMINAL) {
317
	  case 27:
318
	    break;
319
	  default:
320
	    goto ZL1;
321
	}
322
	ADVANCE_LEXER;
323
	ZRedge_Hitem ();
324
	switch (CURRENT_TERMINAL) {
325
	  case 28:
326
	    break;
327
	  case 32:
328
	    RESTORE_LEXER;
329
	    goto ZL1;
330
	  default:
331
	    goto ZL1;
332
	}
333
	ADVANCE_LEXER;
334
	{
335
	    switch (CURRENT_TERMINAL) {
336
	      case 29:
337
		{
338
		    ADVANCE_LEXER;
339
		    goto ZL2_edge_Hlist;
340
		}
341
		/*UNREACHED*/
342
	      default:
343
		break;
344
	    }
345
	}
346
    }
347
    return;
348
  ZL1:;
349
    SAVE_LEXER (32);
350
    return;
351
}
352
 
353
static void
7 7u83 354
ZRkind_Hitem(LINKAGE *ZOa)
2 7u83 355
{
356
    LINKAGE ZIa;
357
 
358
    if ((CURRENT_TERMINAL) == 32) {
359
	return;
360
    }
361
    {
362
	SORT ZIs;
363
	string ZIe;
364
 
365
	switch (CURRENT_TERMINAL) {
366
	  case 27:
367
	    break;
368
	  default:
369
	    goto ZL1;
370
	}
371
	ADVANCE_LEXER;
372
	switch (CURRENT_TERMINAL) {
373
	  case 25:
374
	    break;
375
	  default:
376
	    goto ZL1;
377
	}
378
	ADVANCE_LEXER;
379
	switch (CURRENT_TERMINAL) {
380
	  case 29:
381
	    break;
382
	  default:
383
	    goto ZL1;
384
	}
385
	ADVANCE_LEXER;
386
	ZRold_Hsort_Hname (&ZIs);
387
	switch (CURRENT_TERMINAL) {
388
	  case 28:
389
	    break;
390
	  case 32:
391
	    RESTORE_LEXER;
392
	    goto ZL1;
393
	  default:
394
	    goto ZL1;
395
	}
396
	ADVANCE_LEXER;
397
	switch (CURRENT_TERMINAL) {
398
	  case 29:
399
	    break;
400
	  default:
401
	    goto ZL1;
402
	}
403
	ADVANCE_LEXER;
404
	switch (CURRENT_TERMINAL) {
405
	  case 27:
406
	    break;
407
	  default:
408
	    goto ZL1;
409
	}
410
	ADVANCE_LEXER;
411
	switch (CURRENT_TERMINAL) {
412
	  case 26:
413
	    break;
414
	  default:
415
	    goto ZL1;
416
	}
417
	ADVANCE_LEXER;
418
	switch (CURRENT_TERMINAL) {
419
	  case 29:
420
	    break;
421
	  default:
422
	    goto ZL1;
423
	}
424
	ADVANCE_LEXER;
425
	ZRany_Hname (&ZIe);
426
	switch (CURRENT_TERMINAL) {
427
	  case 28:
428
	    break;
429
	  case 32:
430
	    RESTORE_LEXER;
431
	    goto ZL1;
432
	  default:
433
	    goto ZL1;
434
	}
435
	ADVANCE_LEXER;
436
	{
437
 
438
    MAKE_link_basic ( (ZIe), (ZIs), (ZIa) ) ;
439
    COPY_string ( sort_unit ( (ZIs) ), (ZIe) ) ;
440
	}
441
    }
442
    goto ZL0;
443
  ZL1:;
444
    SAVE_LEXER (32);
445
    return;
446
  ZL0:;
447
    *ZOa = ZIa;
448
}
449
 
450
static void
7 7u83 451
ZRoption_Hlist(void)
2 7u83 452
{
453
    if ((CURRENT_TERMINAL) == 32) {
454
	return;
455
    }
456
  ZL2_option_Hlist:;
457
    {
458
	ZRoption_Hitem ();
459
	{
460
	    switch (CURRENT_TERMINAL) {
461
	      case 29:
462
		{
463
		    ADVANCE_LEXER;
464
		    goto ZL2_option_Hlist;
465
		}
466
		/*UNREACHED*/
467
	      case 32:
468
		RESTORE_LEXER;
469
		goto ZL1;
470
	      default:
471
		break;
472
	    }
473
	}
474
    }
475
    return;
476
  ZL1:;
477
    SAVE_LEXER (32);
478
    return;
479
}
480
 
481
static void
7 7u83 482
ZR139(CONSTRUCT *ZIc)
2 7u83 483
{
484
    if ((CURRENT_TERMINAL) == 32) {
485
	return;
486
    }
487
    {
488
	switch (CURRENT_TERMINAL) {
489
	  case 27:
490
	    break;
491
	  default:
492
	    goto ZL1;
493
	}
494
	ADVANCE_LEXER;
495
	ZR140 (ZIc);
496
	if ((CURRENT_TERMINAL) == 32) {
497
	    RESTORE_LEXER;
498
	    goto ZL1;
499
	}
500
    }
501
    return;
502
  ZL1:;
503
    SAVE_LEXER (32);
504
    return;
505
}
506
 
507
static void
7 7u83 508
ZRold_Hsort_Hname(SORT *ZOs)
2 7u83 509
{
510
    SORT ZIs;
511
 
512
    if ((CURRENT_TERMINAL) == 32) {
513
	return;
514
    }
515
    {
516
	string ZIa;
517
 
518
	switch (CURRENT_TERMINAL) {
519
	  case 0:
520
	    {
521
 
522
    ZIa = xstrcpy ( token_buff ) ;
523
	    }
524
	    break;
525
	  default:
526
	    goto ZL1;
527
	}
528
	ADVANCE_LEXER;
529
	{
530
 
531
    (ZIs) = find_sort ( (ZIa), 0 ) ;
532
	}
533
    }
534
    goto ZL0;
535
  ZL1:;
536
    SAVE_LEXER (32);
537
    return;
538
  ZL0:;
539
    *ZOs = ZIs;
540
}
541
 
542
static void
7 7u83 543
ZR140(CONSTRUCT *ZIc)
2 7u83 544
{
545
    switch (CURRENT_TERMINAL) {
546
      case 3:
547
	{
548
	    ADVANCE_LEXER;
549
	    switch (CURRENT_TERMINAL) {
550
	      case 29:
551
		break;
552
	      default:
553
		goto ZL1;
554
	    }
555
	    ADVANCE_LEXER;
556
	    switch (CURRENT_TERMINAL) {
557
	      case 27:
558
		break;
559
	      default:
560
		goto ZL1;
561
	    }
562
	    ADVANCE_LEXER;
563
	    ZRnumber_Hlist (*ZIc);
564
	    switch (CURRENT_TERMINAL) {
565
	      case 28:
566
		break;
567
	      case 32:
568
		RESTORE_LEXER;
569
		goto ZL1;
570
	      default:
571
		goto ZL1;
572
	    }
573
	    ADVANCE_LEXER;
574
	    switch (CURRENT_TERMINAL) {
575
	      case 28:
576
		break;
577
	      default:
578
		goto ZL1;
579
	    }
580
	    ADVANCE_LEXER;
581
	}
582
	break;
583
      case 2:
584
	{
585
	    unsigned ZIa;
586
 
587
	    ADVANCE_LEXER;
588
	    switch (CURRENT_TERMINAL) {
589
	      case 29:
590
		break;
591
	      default:
592
		goto ZL1;
593
	    }
594
	    ADVANCE_LEXER;
595
	    switch (CURRENT_TERMINAL) {
596
	      case 1:
597
		{
598
 
599
    ZIa = token_value ;
600
		}
601
		break;
602
	      default:
603
		goto ZL1;
604
	    }
605
	    ADVANCE_LEXER;
606
	    switch (CURRENT_TERMINAL) {
607
	      case 28:
608
		break;
609
	      default:
610
		goto ZL1;
611
	    }
612
	    ADVANCE_LEXER;
613
	    {
614
 
615
    PARAMETER p = find_param ( (*ZIc), (ZIa) ) ;
616
    if ( !IS_NULL_par ( p ) ) COPY_int ( par_brk ( p ), 1 ) ;
617
	    }
618
	    ZR141 (ZIc);
619
	    if ((CURRENT_TERMINAL) == 32) {
620
		RESTORE_LEXER;
621
		goto ZL1;
622
	    }
623
	}
624
	break;
625
      case 32:
626
	return;
627
      default:
628
	goto ZL1;
629
    }
630
    return;
631
  ZL1:;
632
    SAVE_LEXER (32);
633
    return;
634
}
635
 
636
static void
7 7u83 637
ZR141(CONSTRUCT *ZIc)
2 7u83 638
{
639
    switch (CURRENT_TERMINAL) {
640
      case 29:
641
	{
642
	    ADVANCE_LEXER;
643
	    ZRboundary_Hitem (*ZIc);
644
	    if ((CURRENT_TERMINAL) == 32) {
645
		RESTORE_LEXER;
646
		goto ZL1;
647
	    }
648
	}
649
	break;
650
      case 32:
651
	return;
652
      default:
653
	break;
654
    }
655
    return;
656
  ZL1:;
657
    SAVE_LEXER (32);
658
    return;
659
}
660
 
661
static void
7 7u83 662
ZRclist_Hlist(void)
2 7u83 663
{
664
    if ((CURRENT_TERMINAL) == 32) {
665
	return;
666
    }
667
  ZL2_clist_Hlist:;
668
    {
669
	ZRclist_Hitem ();
670
	{
671
	    switch (CURRENT_TERMINAL) {
672
	      case 29:
673
		{
674
		    ADVANCE_LEXER;
675
		    goto ZL2_clist_Hlist;
676
		}
677
		/*UNREACHED*/
678
	      case 32:
679
		RESTORE_LEXER;
680
		goto ZL1;
681
	      default:
682
		break;
683
	    }
684
	}
685
    }
686
    return;
687
  ZL1:;
688
    SAVE_LEXER (32);
689
    return;
690
}
691
 
692
static void
7 7u83 693
ZRlink_Hitem(LINKAGE *ZOa)
2 7u83 694
{
695
    LINKAGE ZIa;
696
 
697
    if ((CURRENT_TERMINAL) == 32) {
698
	return;
699
    }
700
    {
701
	SORT ZIs;
702
	string ZIe;
703
 
704
	switch (CURRENT_TERMINAL) {
705
	  case 27:
706
	    break;
707
	  default:
708
	    goto ZL1;
709
	}
710
	ADVANCE_LEXER;
711
	switch (CURRENT_TERMINAL) {
712
	  case 11:
713
	    break;
714
	  default:
715
	    goto ZL1;
716
	}
717
	ADVANCE_LEXER;
718
	switch (CURRENT_TERMINAL) {
719
	  case 29:
720
	    break;
721
	  default:
722
	    goto ZL1;
723
	}
724
	ADVANCE_LEXER;
725
	ZRold_Hsort_Hname (&ZIs);
726
	switch (CURRENT_TERMINAL) {
727
	  case 28:
728
	    break;
729
	  case 32:
730
	    RESTORE_LEXER;
731
	    goto ZL1;
732
	  default:
733
	    goto ZL1;
734
	}
735
	ADVANCE_LEXER;
736
	switch (CURRENT_TERMINAL) {
737
	  case 29:
738
	    break;
739
	  default:
740
	    goto ZL1;
741
	}
742
	ADVANCE_LEXER;
743
	switch (CURRENT_TERMINAL) {
744
	  case 27:
745
	    break;
746
	  default:
747
	    goto ZL1;
748
	}
749
	ADVANCE_LEXER;
750
	switch (CURRENT_TERMINAL) {
751
	  case 10:
752
	    break;
753
	  default:
754
	    goto ZL1;
755
	}
756
	ADVANCE_LEXER;
757
	switch (CURRENT_TERMINAL) {
758
	  case 29:
759
	    break;
760
	  default:
761
	    goto ZL1;
762
	}
763
	ADVANCE_LEXER;
764
	ZRany_Hname (&ZIe);
765
	switch (CURRENT_TERMINAL) {
766
	  case 28:
767
	    break;
768
	  case 32:
769
	    RESTORE_LEXER;
770
	    goto ZL1;
771
	  default:
772
	    goto ZL1;
773
	}
774
	ADVANCE_LEXER;
775
	{
776
 
777
    MAKE_link_basic ( (ZIe), (ZIs), (ZIa) ) ;
778
    COPY_string ( sort_link ( (ZIs) ), (ZIe) ) ;
779
	}
780
    }
781
    goto ZL0;
782
  ZL1:;
783
    SAVE_LEXER (32);
784
    return;
785
  ZL0:;
786
    *ZOa = ZIa;
787
}
788
 
789
static void
7 7u83 790
ZRslist_Hitem(void)
2 7u83 791
{
792
    if ((CURRENT_TERMINAL) == 32) {
793
	return;
794
    }
795
    {
796
	SORT ZIs;
797
 
798
	ZRnew_Hsort_Hname (&ZIs);
799
	if ((CURRENT_TERMINAL) == 32) {
800
	    RESTORE_LEXER;
801
	    goto ZL1;
802
	}
803
	{
804
 
805
    compound_sort ( (ZIs), "_list", info_slist_tag, '%' ) ;
806
	}
807
    }
808
    return;
809
  ZL1:;
810
    SAVE_LEXER (32);
811
    return;
812
}
813
 
814
static void
7 7u83 815
ZRkind_Hlist(SID_LINK_LIST *ZOp)
2 7u83 816
{
817
    SID_LINK_LIST ZIp;
818
 
819
    if ((CURRENT_TERMINAL) == 32) {
820
	return;
821
    }
822
    {
823
	LINKAGE ZIa;
824
	SID_LINK_LIST ZIq;
825
 
826
	switch (CURRENT_TERMINAL) {
827
	  case 27:
828
	    break;
829
	  default:
830
	    goto ZL1;
831
	}
832
	ADVANCE_LEXER;
833
	ZRkind_Hitem (&ZIa);
834
	switch (CURRENT_TERMINAL) {
835
	  case 28:
836
	    break;
837
	  case 32:
838
	    RESTORE_LEXER;
839
	    goto ZL1;
840
	  default:
841
	    goto ZL1;
842
	}
843
	ADVANCE_LEXER;
844
	{
845
	    switch (CURRENT_TERMINAL) {
846
	      case 29:
847
		{
848
		    ADVANCE_LEXER;
849
		    ZRkind_Hlist (&ZIq);
850
		    if ((CURRENT_TERMINAL) == 32) {
851
			RESTORE_LEXER;
852
			goto ZL1;
853
		    }
854
		}
855
		break;
856
	      default:
857
		{
858
		    {
859
 
860
    (ZIq) = NULL_list ( LINKAGE ) ;
861
		    }
862
		}
863
		break;
864
	    }
865
	}
866
	{
867
 
868
    CONS_link ( (ZIa), (ZIq), (ZIp) ) ;
869
	}
870
    }
871
    goto ZL0;
872
  ZL1:;
873
    SAVE_LEXER (32);
874
    return;
875
  ZL0:;
876
    *ZOp = ZIp;
877
}
878
 
879
static void
7 7u83 880
ZRnew_Hsort_Hname(SORT *ZOs)
2 7u83 881
{
882
    SORT ZIs;
883
 
884
    if ((CURRENT_TERMINAL) == 32) {
885
	return;
886
    }
887
    {
888
	string ZIa;
889
 
890
	switch (CURRENT_TERMINAL) {
891
	  case 0:
892
	    {
893
 
894
    ZIa = xstrcpy ( token_buff ) ;
895
	    }
896
	    break;
897
	  default:
898
	    goto ZL1;
899
	}
900
	ADVANCE_LEXER;
901
	{
902
 
903
    (ZIs) = find_sort ( (ZIa), 1 ) ;
904
	}
905
    }
906
    goto ZL0;
907
  ZL1:;
908
    SAVE_LEXER (32);
909
    return;
910
  ZL0:;
911
    *ZOs = ZIs;
912
}
913
 
914
static void
7 7u83 915
ZRsort_Hpack(void)
2 7u83 916
{
917
    if ((CURRENT_TERMINAL) == 32) {
918
	return;
919
    }
920
    {
921
	switch (CURRENT_TERMINAL) {
922
	  case 27:
923
	    break;
924
	  default:
925
	    goto ZL1;
926
	}
927
	ADVANCE_LEXER;
928
	{
929
	    switch (CURRENT_TERMINAL) {
930
	      case 27:
931
		{
932
		    ZRsort_Hlist ();
933
		    if ((CURRENT_TERMINAL) == 32) {
934
			RESTORE_LEXER;
935
			goto ZL1;
936
		    }
937
		}
938
		break;
939
	      default:
940
		break;
941
	    }
942
	}
943
	switch (CURRENT_TERMINAL) {
944
	  case 28:
945
	    break;
946
	  default:
947
	    goto ZL1;
948
	}
949
	ADVANCE_LEXER;
950
    }
951
    return;
952
  ZL1:;
953
    SAVE_LEXER (32);
954
    return;
955
}
956
 
957
static void
7 7u83 958
ZRany_Hname(string *ZOn)
2 7u83 959
{
960
    string ZIn;
961
 
962
    switch (CURRENT_TERMINAL) {
963
      case 0:
964
	{
965
	    {
966
 
967
    ZIn = xstrcpy ( token_buff ) ;
968
	    }
969
	    ADVANCE_LEXER;
970
	}
971
	break;
972
      case 2: case 3: case 4: case 5: case 6:
973
      case 7: case 8: case 9: case 10: case 11:
974
      case 12: case 13: case 14: case 15: case 16:
975
      case 17: case 18: case 19: case 20: case 21:
976
      case 22: case 23: case 24: case 25: case 26:
977
	{
978
	    {
979
 
980
    (ZIn) = xstrcpy ( token_buff ) ;
981
	    }
982
	    {
983
		switch (CURRENT_TERMINAL) {
984
		  case 3:
985
		    {
986
			ADVANCE_LEXER;
987
		    }
988
		    break;
989
		  case 2:
990
		    {
991
			ADVANCE_LEXER;
992
		    }
993
		    break;
994
		  case 5:
995
		    {
996
			ADVANCE_LEXER;
997
		    }
998
		    break;
999
		  case 4:
1000
		    {
1001
			ADVANCE_LEXER;
1002
		    }
1003
		    break;
1004
		  case 6:
1005
		    {
1006
			ADVANCE_LEXER;
1007
		    }
1008
		    break;
1009
		  case 7:
1010
		    {
1011
			ADVANCE_LEXER;
1012
		    }
1013
		    break;
1014
		  case 8:
1015
		    {
1016
			ADVANCE_LEXER;
1017
		    }
1018
		    break;
1019
		  case 9:
1020
		    {
1021
			ADVANCE_LEXER;
1022
		    }
1023
		    break;
1024
		  case 10:
1025
		    {
1026
			ADVANCE_LEXER;
1027
		    }
1028
		    break;
1029
		  case 11:
1030
		    {
1031
			ADVANCE_LEXER;
1032
		    }
1033
		    break;
1034
		  case 12:
1035
		    {
1036
			ADVANCE_LEXER;
1037
		    }
1038
		    break;
1039
		  case 13:
1040
		    {
1041
			ADVANCE_LEXER;
1042
		    }
1043
		    break;
1044
		  case 14:
1045
		    {
1046
			ADVANCE_LEXER;
1047
		    }
1048
		    break;
1049
		  case 15:
1050
		    {
1051
			ADVANCE_LEXER;
1052
		    }
1053
		    break;
1054
		  case 16:
1055
		    {
1056
			ADVANCE_LEXER;
1057
		    }
1058
		    break;
1059
		  case 17:
1060
		    {
1061
			ADVANCE_LEXER;
1062
		    }
1063
		    break;
1064
		  case 18:
1065
		    {
1066
			ADVANCE_LEXER;
1067
		    }
1068
		    break;
1069
		  case 19:
1070
		    {
1071
			ADVANCE_LEXER;
1072
		    }
1073
		    break;
1074
		  case 20:
1075
		    {
1076
			ADVANCE_LEXER;
1077
		    }
1078
		    break;
1079
		  case 21:
1080
		    {
1081
			ADVANCE_LEXER;
1082
		    }
1083
		    break;
1084
		  case 22:
1085
		    {
1086
			ADVANCE_LEXER;
1087
		    }
1088
		    break;
1089
		  case 23:
1090
		    {
1091
			ADVANCE_LEXER;
1092
		    }
1093
		    break;
1094
		  case 24:
1095
		    {
1096
			ADVANCE_LEXER;
1097
		    }
1098
		    break;
1099
		  case 25:
1100
		    {
1101
			ADVANCE_LEXER;
1102
		    }
1103
		    break;
1104
		  case 26:
1105
		    {
1106
			ADVANCE_LEXER;
1107
		    }
1108
		    break;
1109
		  default:
1110
		    goto ZL1;
1111
		}
1112
	    }
1113
	}
1114
	break;
1115
      case 32:
1116
	return;
1117
      default:
1118
	goto ZL1;
1119
    }
1120
    goto ZL0;
1121
  ZL1:;
1122
    SAVE_LEXER (32);
1123
    return;
1124
  ZL0:;
1125
    *ZOn = ZIn;
1126
}
1127
 
1128
static void
7 7u83 1129
ZRlink_Hlist(SID_LINK_LIST *ZOp)
2 7u83 1130
{
1131
    SID_LINK_LIST ZIp;
1132
 
1133
    if ((CURRENT_TERMINAL) == 32) {
1134
	return;
1135
    }
1136
    {
1137
	LINKAGE ZIa;
1138
	SID_LINK_LIST ZIq;
1139
 
1140
	switch (CURRENT_TERMINAL) {
1141
	  case 27:
1142
	    break;
1143
	  default:
1144
	    goto ZL1;
1145
	}
1146
	ADVANCE_LEXER;
1147
	ZRlink_Hitem (&ZIa);
1148
	switch (CURRENT_TERMINAL) {
1149
	  case 28:
1150
	    break;
1151
	  case 32:
1152
	    RESTORE_LEXER;
1153
	    goto ZL1;
1154
	  default:
1155
	    goto ZL1;
1156
	}
1157
	ADVANCE_LEXER;
1158
	{
1159
	    switch (CURRENT_TERMINAL) {
1160
	      case 29:
1161
		{
1162
		    ADVANCE_LEXER;
1163
		    ZRlink_Hlist (&ZIq);
1164
		    if ((CURRENT_TERMINAL) == 32) {
1165
			RESTORE_LEXER;
1166
			goto ZL1;
1167
		    }
1168
		}
1169
		break;
1170
	      default:
1171
		{
1172
		    {
1173
 
1174
    (ZIq) = NULL_list ( LINKAGE ) ;
1175
		    }
1176
		}
1177
		break;
1178
	    }
1179
	}
1180
	{
1181
 
1182
    CONS_link ( (ZIa), (ZIq), (ZIp) ) ;
1183
	}
1184
    }
1185
    goto ZL0;
1186
  ZL1:;
1187
    SAVE_LEXER (32);
1188
    return;
1189
  ZL0:;
1190
    *ZOp = ZIp;
1191
}
1192
 
1193
static void
7 7u83 1194
ZRslist_Hlist(void)
2 7u83 1195
{
1196
    if ((CURRENT_TERMINAL) == 32) {
1197
	return;
1198
    }
1199
  ZL2_slist_Hlist:;
1200
    {
1201
	ZRslist_Hitem ();
1202
	{
1203
	    switch (CURRENT_TERMINAL) {
1204
	      case 29:
1205
		{
1206
		    ADVANCE_LEXER;
1207
		    goto ZL2_slist_Hlist;
1208
		}
1209
		/*UNREACHED*/
1210
	      case 32:
1211
		RESTORE_LEXER;
1212
		goto ZL1;
1213
	      default:
1214
		break;
1215
	    }
1216
	}
1217
    }
1218
    return;
1219
  ZL1:;
1220
    SAVE_LEXER (32);
1221
    return;
1222
}
1223
 
1224
static void
7 7u83 1225
ZRsort_Hitem(void)
2 7u83 1226
{
1227
    if ((CURRENT_TERMINAL) == 32) {
1228
	return;
1229
    }
1230
    {
1231
	SORT ZIs;
1232
	unsigned ZIb;
1233
	unsigned ZIe;
1234
	SID_CONS_LIST ZIp;
1235
 
1236
	switch (CURRENT_TERMINAL) {
1237
	  case 27:
1238
	    break;
1239
	  default:
1240
	    goto ZL1;
1241
	}
1242
	ADVANCE_LEXER;
1243
	switch (CURRENT_TERMINAL) {
1244
	  case 23:
1245
	    break;
1246
	  default:
1247
	    goto ZL1;
1248
	}
1249
	ADVANCE_LEXER;
1250
	switch (CURRENT_TERMINAL) {
1251
	  case 29:
1252
	    break;
1253
	  default:
1254
	    goto ZL1;
1255
	}
1256
	ADVANCE_LEXER;
1257
	ZRnew_Hsort_Hname (&ZIs);
1258
	switch (CURRENT_TERMINAL) {
1259
	  case 28:
1260
	    break;
1261
	  case 32:
1262
	    RESTORE_LEXER;
1263
	    goto ZL1;
1264
	  default:
1265
	    goto ZL1;
1266
	}
1267
	ADVANCE_LEXER;
1268
	switch (CURRENT_TERMINAL) {
1269
	  case 29:
1270
	    break;
1271
	  default:
1272
	    goto ZL1;
1273
	}
1274
	ADVANCE_LEXER;
1275
	switch (CURRENT_TERMINAL) {
1276
	  case 27:
1277
	    break;
1278
	  default:
1279
	    goto ZL1;
1280
	}
1281
	ADVANCE_LEXER;
1282
	switch (CURRENT_TERMINAL) {
1283
	  case 9:
1284
	    break;
1285
	  default:
1286
	    goto ZL1;
1287
	}
1288
	ADVANCE_LEXER;
1289
	switch (CURRENT_TERMINAL) {
1290
	  case 29:
1291
	    break;
1292
	  default:
1293
	    goto ZL1;
1294
	}
1295
	ADVANCE_LEXER;
1296
	switch (CURRENT_TERMINAL) {
1297
	  case 1:
1298
	    {
1299
 
1300
    ZIb = token_value ;
1301
	    }
1302
	    break;
1303
	  default:
1304
	    goto ZL1;
1305
	}
1306
	ADVANCE_LEXER;
1307
	switch (CURRENT_TERMINAL) {
1308
	  case 28:
1309
	    break;
1310
	  default:
1311
	    goto ZL1;
1312
	}
1313
	ADVANCE_LEXER;
1314
	switch (CURRENT_TERMINAL) {
1315
	  case 29:
1316
	    break;
1317
	  default:
1318
	    goto ZL1;
1319
	}
1320
	ADVANCE_LEXER;
1321
	switch (CURRENT_TERMINAL) {
1322
	  case 27:
1323
	    break;
1324
	  default:
1325
	    goto ZL1;
1326
	}
1327
	ADVANCE_LEXER;
1328
	switch (CURRENT_TERMINAL) {
1329
	  case 13:
1330
	    break;
1331
	  default:
1332
	    goto ZL1;
1333
	}
1334
	ADVANCE_LEXER;
1335
	switch (CURRENT_TERMINAL) {
1336
	  case 29:
1337
	    break;
1338
	  default:
1339
	    goto ZL1;
1340
	}
1341
	ADVANCE_LEXER;
1342
	switch (CURRENT_TERMINAL) {
1343
	  case 1:
1344
	    {
1345
 
1346
    ZIe = token_value ;
1347
	    }
1348
	    break;
1349
	  default:
1350
	    goto ZL1;
1351
	}
1352
	ADVANCE_LEXER;
1353
	switch (CURRENT_TERMINAL) {
1354
	  case 28:
1355
	    break;
1356
	  default:
1357
	    goto ZL1;
1358
	}
1359
	ADVANCE_LEXER;
1360
	switch (CURRENT_TERMINAL) {
1361
	  case 29:
1362
	    break;
1363
	  default:
1364
	    goto ZL1;
1365
	}
1366
	ADVANCE_LEXER;
1367
	switch (CURRENT_TERMINAL) {
1368
	  case 27:
1369
	    break;
1370
	  default:
1371
	    goto ZL1;
1372
	}
1373
	ADVANCE_LEXER;
1374
	switch (CURRENT_TERMINAL) {
1375
	  case 4:
1376
	    break;
1377
	  default:
1378
	    goto ZL1;
1379
	}
1380
	ADVANCE_LEXER;
1381
	switch (CURRENT_TERMINAL) {
1382
	  case 29:
1383
	    break;
1384
	  default:
1385
	    goto ZL1;
1386
	}
1387
	ADVANCE_LEXER;
1388
	ZRconstruct_Hpack (ZIs, &ZIp);
1389
	switch (CURRENT_TERMINAL) {
1390
	  case 28:
1391
	    break;
1392
	  case 32:
1393
	    RESTORE_LEXER;
1394
	    goto ZL1;
1395
	  default:
1396
	    goto ZL1;
1397
	}
1398
	ADVANCE_LEXER;
1399
	{
1400
 
1401
    basic_sort ( (ZIs), (ZIb), (ZIe), (ZIp) ) ;
1402
	}
1403
    }
1404
    return;
1405
  ZL1:;
1406
    SAVE_LEXER (32);
1407
    return;
1408
}
1409
 
1410
static void
7 7u83 1411
ZRsort_Hlist(void)
2 7u83 1412
{
1413
    if ((CURRENT_TERMINAL) == 32) {
1414
	return;
1415
    }
1416
  ZL2_sort_Hlist:;
1417
    {
1418
	switch (CURRENT_TERMINAL) {
1419
	  case 27:
1420
	    break;
1421
	  default:
1422
	    goto ZL1;
1423
	}
1424
	ADVANCE_LEXER;
1425
	ZRsort_Hitem ();
1426
	switch (CURRENT_TERMINAL) {
1427
	  case 28:
1428
	    break;
1429
	  case 32:
1430
	    RESTORE_LEXER;
1431
	    goto ZL1;
1432
	  default:
1433
	    goto ZL1;
1434
	}
1435
	ADVANCE_LEXER;
1436
	{
1437
	    switch (CURRENT_TERMINAL) {
1438
	      case 29:
1439
		{
1440
		    ADVANCE_LEXER;
1441
		    goto ZL2_sort_Hlist;
1442
		}
1443
		/*UNREACHED*/
1444
	      default:
1445
		break;
1446
	    }
1447
	}
1448
    }
1449
    return;
1450
  ZL1:;
1451
    SAVE_LEXER (32);
1452
    return;
1453
}
1454
 
1455
static void
7 7u83 1456
ZRconstruct_Hpack(SORT ZIs, SID_CONS_LIST *ZOp)
2 7u83 1457
{
1458
    SID_CONS_LIST ZIp;
1459
 
1460
    if ((CURRENT_TERMINAL) == 32) {
1461
	return;
1462
    }
1463
    {
1464
	SID_CONS_LIST ZIq;
1465
 
1466
	switch (CURRENT_TERMINAL) {
1467
	  case 27:
1468
	    break;
1469
	  default:
1470
	    goto ZL1;
1471
	}
1472
	ADVANCE_LEXER;
1473
	{
1474
	    switch (CURRENT_TERMINAL) {
1475
	      case 27:
1476
		{
1477
		    ZRconstruct_Hlist (ZIs, &ZIq);
1478
		    if ((CURRENT_TERMINAL) == 32) {
1479
			RESTORE_LEXER;
1480
			goto ZL1;
1481
		    }
1482
		}
1483
		break;
1484
	      default:
1485
		{
1486
		    {
1487
 
1488
    (ZIq) = NULL_list ( CONSTRUCT ) ;
1489
		    }
1490
		}
1491
		break;
1492
	    }
1493
	}
1494
	switch (CURRENT_TERMINAL) {
1495
	  case 28:
1496
	    break;
1497
	  default:
1498
	    goto ZL1;
1499
	}
1500
	ADVANCE_LEXER;
1501
	ZIp = ZIq;
1502
    }
1503
    goto ZL0;
1504
  ZL1:;
1505
    SAVE_LEXER (32);
1506
    return;
1507
  ZL0:;
1508
    *ZOp = ZIp;
1509
}
1510
 
1511
static void
7 7u83 1512
ZRconstruct_Hextra(CONSTRUCT ZIc)
2 7u83 1513
{
1514
    switch (CURRENT_TERMINAL) {
1515
      case 29:
1516
	{
1517
	    ADVANCE_LEXER;
1518
	    ZR139 (&ZIc);
1519
	    if ((CURRENT_TERMINAL) == 32) {
1520
		RESTORE_LEXER;
1521
		goto ZL1;
1522
	    }
1523
	}
1524
	break;
1525
      case 32:
1526
	return;
1527
      default:
1528
	break;
1529
    }
1530
    return;
1531
  ZL1:;
1532
    SAVE_LEXER (32);
1533
    return;
1534
}
1535
 
1536
static void
7 7u83 1537
ZRboundary_Hitem(CONSTRUCT ZIc)
2 7u83 1538
{
1539
    if ((CURRENT_TERMINAL) == 32) {
1540
	return;
1541
    }
1542
    {
1543
	switch (CURRENT_TERMINAL) {
1544
	  case 27:
1545
	    break;
1546
	  default:
1547
	    goto ZL1;
1548
	}
1549
	ADVANCE_LEXER;
1550
	switch (CURRENT_TERMINAL) {
1551
	  case 3:
1552
	    break;
1553
	  default:
1554
	    goto ZL1;
1555
	}
1556
	ADVANCE_LEXER;
1557
	switch (CURRENT_TERMINAL) {
1558
	  case 29:
1559
	    break;
1560
	  default:
1561
	    goto ZL1;
1562
	}
1563
	ADVANCE_LEXER;
1564
	switch (CURRENT_TERMINAL) {
1565
	  case 27:
1566
	    break;
1567
	  default:
1568
	    goto ZL1;
1569
	}
1570
	ADVANCE_LEXER;
1571
	ZRnumber_Hlist (ZIc);
1572
	switch (CURRENT_TERMINAL) {
1573
	  case 28:
1574
	    break;
1575
	  case 32:
1576
	    RESTORE_LEXER;
1577
	    goto ZL1;
1578
	  default:
1579
	    goto ZL1;
1580
	}
1581
	ADVANCE_LEXER;
1582
	switch (CURRENT_TERMINAL) {
1583
	  case 28:
1584
	    break;
1585
	  default:
1586
	    goto ZL1;
1587
	}
1588
	ADVANCE_LEXER;
1589
    }
1590
    return;
1591
  ZL1:;
1592
    SAVE_LEXER (32);
1593
    return;
1594
}
1595
 
1596
static void
7 7u83 1597
ZRconstruct_Hitem(SORT ZIs, CONSTRUCT *ZOc)
2 7u83 1598
{
1599
    CONSTRUCT ZIc;
1600
 
1601
    if ((CURRENT_TERMINAL) == 32) {
1602
	return;
1603
    }
1604
    {
1605
	string ZIn;
1606
	unsigned ZIe;
1607
	SORT ZIr;
1608
	SID_PARAM_LIST ZIp;
1609
 
1610
	switch (CURRENT_TERMINAL) {
1611
	  case 27:
1612
	    break;
1613
	  default:
1614
	    goto ZL1;
1615
	}
1616
	ADVANCE_LEXER;
1617
	switch (CURRENT_TERMINAL) {
1618
	  case 5:
1619
	    break;
1620
	  default:
1621
	    goto ZL1;
1622
	}
1623
	ADVANCE_LEXER;
1624
	switch (CURRENT_TERMINAL) {
1625
	  case 29:
1626
	    break;
1627
	  default:
1628
	    goto ZL1;
1629
	}
1630
	ADVANCE_LEXER;
1631
	switch (CURRENT_TERMINAL) {
1632
	  case 0:
1633
	    {
1634
 
1635
    ZIn = xstrcpy ( token_buff ) ;
1636
	    }
1637
	    break;
1638
	  default:
1639
	    goto ZL1;
1640
	}
1641
	ADVANCE_LEXER;
1642
	switch (CURRENT_TERMINAL) {
1643
	  case 28:
1644
	    break;
1645
	  default:
1646
	    goto ZL1;
1647
	}
1648
	ADVANCE_LEXER;
1649
	switch (CURRENT_TERMINAL) {
1650
	  case 29:
1651
	    break;
1652
	  default:
1653
	    goto ZL1;
1654
	}
1655
	ADVANCE_LEXER;
1656
	switch (CURRENT_TERMINAL) {
1657
	  case 27:
1658
	    break;
1659
	  default:
1660
	    goto ZL1;
1661
	}
1662
	ADVANCE_LEXER;
1663
	switch (CURRENT_TERMINAL) {
1664
	  case 8:
1665
	    break;
1666
	  default:
1667
	    goto ZL1;
1668
	}
1669
	ADVANCE_LEXER;
1670
	switch (CURRENT_TERMINAL) {
1671
	  case 29:
1672
	    break;
1673
	  default:
1674
	    goto ZL1;
1675
	}
1676
	ADVANCE_LEXER;
1677
	switch (CURRENT_TERMINAL) {
1678
	  case 1:
1679
	    {
1680
 
1681
    ZIe = token_value ;
1682
	    }
1683
	    break;
1684
	  default:
1685
	    goto ZL1;
1686
	}
1687
	ADVANCE_LEXER;
1688
	switch (CURRENT_TERMINAL) {
1689
	  case 28:
1690
	    break;
1691
	  default:
1692
	    goto ZL1;
1693
	}
1694
	ADVANCE_LEXER;
1695
	switch (CURRENT_TERMINAL) {
1696
	  case 29:
1697
	    break;
1698
	  default:
1699
	    goto ZL1;
1700
	}
1701
	ADVANCE_LEXER;
1702
	switch (CURRENT_TERMINAL) {
1703
	  case 27:
1704
	    break;
1705
	  default:
1706
	    goto ZL1;
1707
	}
1708
	ADVANCE_LEXER;
1709
	switch (CURRENT_TERMINAL) {
1710
	  case 21:
1711
	    break;
1712
	  default:
1713
	    goto ZL1;
1714
	}
1715
	ADVANCE_LEXER;
1716
	switch (CURRENT_TERMINAL) {
1717
	  case 29:
1718
	    break;
1719
	  default:
1720
	    goto ZL1;
1721
	}
1722
	ADVANCE_LEXER;
1723
	ZRnew_Hsort_Hname (&ZIr);
1724
	switch (CURRENT_TERMINAL) {
1725
	  case 28:
1726
	    break;
1727
	  case 32:
1728
	    RESTORE_LEXER;
1729
	    goto ZL1;
1730
	  default:
1731
	    goto ZL1;
1732
	}
1733
	ADVANCE_LEXER;
1734
	switch (CURRENT_TERMINAL) {
1735
	  case 29:
1736
	    break;
1737
	  default:
1738
	    goto ZL1;
1739
	}
1740
	ADVANCE_LEXER;
1741
	switch (CURRENT_TERMINAL) {
1742
	  case 27:
1743
	    break;
1744
	  default:
1745
	    goto ZL1;
1746
	}
1747
	ADVANCE_LEXER;
1748
	switch (CURRENT_TERMINAL) {
1749
	  case 20:
1750
	    break;
1751
	  default:
1752
	    goto ZL1;
1753
	}
1754
	ADVANCE_LEXER;
1755
	switch (CURRENT_TERMINAL) {
1756
	  case 29:
1757
	    break;
1758
	  default:
1759
	    goto ZL1;
1760
	}
1761
	ADVANCE_LEXER;
1762
	ZRparam_Hpack (&ZIp);
1763
	switch (CURRENT_TERMINAL) {
1764
	  case 28:
1765
	    break;
1766
	  case 32:
1767
	    RESTORE_LEXER;
1768
	    goto ZL1;
1769
	  default:
1770
	    goto ZL1;
1771
	}
1772
	ADVANCE_LEXER;
1773
	{
1774
 
1775
    if ( !EQ_sort ( (ZIr), (ZIs) ) ) {
1776
	error ( ERROR_SERIOUS, "Wrong result sort for '%s'", (ZIn) ) ;
1777
    }
1778
    (ZIc) = make_construct ( (ZIn), (ZIe), (ZIs), (ZIp) ) ;
1779
	}
1780
	ZRconstruct_Hextra (ZIc);
1781
	if ((CURRENT_TERMINAL) == 32) {
1782
	    RESTORE_LEXER;
1783
	    goto ZL1;
1784
	}
1785
    }
1786
    goto ZL0;
1787
  ZL1:;
1788
    SAVE_LEXER (32);
1789
    return;
1790
  ZL0:;
1791
    *ZOc = ZIc;
1792
}
1793
 
1794
static void
7 7u83 1795
ZRconstruct_Hlist(SORT ZIs, SID_CONS_LIST *ZOp)
2 7u83 1796
{
1797
    SID_CONS_LIST ZIp;
1798
 
1799
    if ((CURRENT_TERMINAL) == 32) {
1800
	return;
1801
    }
1802
    {
1803
	CONSTRUCT ZIc;
1804
	SID_CONS_LIST ZIq;
1805
 
1806
	switch (CURRENT_TERMINAL) {
1807
	  case 27:
1808
	    break;
1809
	  default:
1810
	    goto ZL1;
1811
	}
1812
	ADVANCE_LEXER;
1813
	ZRconstruct_Hitem (ZIs, &ZIc);
1814
	switch (CURRENT_TERMINAL) {
1815
	  case 28:
1816
	    break;
1817
	  case 32:
1818
	    RESTORE_LEXER;
1819
	    goto ZL1;
1820
	  default:
1821
	    goto ZL1;
1822
	}
1823
	ADVANCE_LEXER;
1824
	{
1825
	    switch (CURRENT_TERMINAL) {
1826
	      case 29:
1827
		{
1828
		    ADVANCE_LEXER;
1829
		    ZRconstruct_Hlist (ZIs, &ZIq);
1830
		    if ((CURRENT_TERMINAL) == 32) {
1831
			RESTORE_LEXER;
1832
			goto ZL1;
1833
		    }
1834
		}
1835
		break;
1836
	      default:
1837
		{
1838
		    {
1839
 
1840
    (ZIq) = NULL_list ( CONSTRUCT ) ;
1841
		    }
1842
		}
1843
		break;
1844
	    }
1845
	}
1846
	{
1847
 
1848
    CONS_cons ( (ZIc), (ZIq), (ZIp) ) ;
1849
	}
1850
    }
1851
    goto ZL0;
1852
  ZL1:;
1853
    SAVE_LEXER (32);
1854
    return;
1855
  ZL0:;
1856
    *ZOp = ZIp;
1857
}
1858
 
1859
static void
7 7u83 1860
ZRparam_Hpack(SID_PARAM_LIST *ZOp)
2 7u83 1861
{
1862
    SID_PARAM_LIST ZIp;
1863
 
1864
    if ((CURRENT_TERMINAL) == 32) {
1865
	return;
1866
    }
1867
    {
1868
	SID_PARAM_LIST ZIq;
1869
 
1870
	switch (CURRENT_TERMINAL) {
1871
	  case 27:
1872
	    break;
1873
	  default:
1874
	    goto ZL1;
1875
	}
1876
	ADVANCE_LEXER;
1877
	{
1878
	    switch (CURRENT_TERMINAL) {
1879
	      case 27:
1880
		{
1881
		    ZRparam_Hlist (&ZIq);
1882
		    if ((CURRENT_TERMINAL) == 32) {
1883
			RESTORE_LEXER;
1884
			goto ZL1;
1885
		    }
1886
		}
1887
		break;
1888
	      default:
1889
		{
1890
		    {
1891
 
1892
    (ZIq) = NULL_list ( PARAMETER ) ;
1893
		    }
1894
		}
1895
		break;
1896
	    }
1897
	}
1898
	switch (CURRENT_TERMINAL) {
1899
	  case 28:
1900
	    break;
1901
	  default:
1902
	    goto ZL1;
1903
	}
1904
	ADVANCE_LEXER;
1905
	ZIp = ZIq;
1906
    }
1907
    goto ZL0;
1908
  ZL1:;
1909
    SAVE_LEXER (32);
1910
    return;
1911
  ZL0:;
1912
    *ZOp = ZIp;
1913
}
1914
 
1915
static void
7 7u83 1916
ZRedge_Hpack(void)
2 7u83 1917
{
1918
    if ((CURRENT_TERMINAL) == 32) {
1919
	return;
1920
    }
1921
    {
1922
	switch (CURRENT_TERMINAL) {
1923
	  case 27:
1924
	    break;
1925
	  default:
1926
	    goto ZL1;
1927
	}
1928
	ADVANCE_LEXER;
1929
	{
1930
	    switch (CURRENT_TERMINAL) {
1931
	      case 27:
1932
		{
1933
		    ZRedge_Hlist ();
1934
		    if ((CURRENT_TERMINAL) == 32) {
1935
			RESTORE_LEXER;
1936
			goto ZL1;
1937
		    }
1938
		}
1939
		break;
1940
	      default:
1941
		break;
1942
	    }
1943
	}
1944
	switch (CURRENT_TERMINAL) {
1945
	  case 28:
1946
	    break;
1947
	  default:
1948
	    goto ZL1;
1949
	}
1950
	ADVANCE_LEXER;
1951
    }
1952
    return;
1953
  ZL1:;
1954
    SAVE_LEXER (32);
1955
    return;
1956
}
1957
 
1958
void
7 7u83 1959
read_spec(SPECIFICATION *ZOspec)
2 7u83 1960
{
1961
    SPECIFICATION ZIspec;
1962
 
1963
    if ((CURRENT_TERMINAL) == 32) {
1964
	return;
1965
    }
1966
    {
1967
	SID_LINK_LIST ZIp;
1968
	SID_LINK_LIST ZIq;
1969
	unsigned ZIv1;
1970
	unsigned ZIv2;
1971
 
1972
	switch (CURRENT_TERMINAL) {
1973
	  case 27:
1974
	    break;
1975
	  default:
1976
	    goto ZL1;
1977
	}
1978
	ADVANCE_LEXER;
1979
	switch (CURRENT_TERMINAL) {
1980
	  case 27:
1981
	    break;
1982
	  default:
1983
	    goto ZL1;
1984
	}
1985
	ADVANCE_LEXER;
1986
	switch (CURRENT_TERMINAL) {
1987
	  case 24:
1988
	    break;
1989
	  default:
1990
	    goto ZL1;
1991
	}
1992
	ADVANCE_LEXER;
1993
	switch (CURRENT_TERMINAL) {
1994
	  case 29:
1995
	    break;
1996
	  default:
1997
	    goto ZL1;
1998
	}
1999
	ADVANCE_LEXER;
2000
	ZRsort_Hpack ();
2001
	switch (CURRENT_TERMINAL) {
2002
	  case 28:
2003
	    break;
2004
	  case 32:
2005
	    RESTORE_LEXER;
2006
	    goto ZL1;
2007
	  default:
2008
	    goto ZL1;
2009
	}
2010
	ADVANCE_LEXER;
2011
	switch (CURRENT_TERMINAL) {
2012
	  case 29:
2013
	    break;
2014
	  default:
2015
	    goto ZL1;
2016
	}
2017
	ADVANCE_LEXER;
2018
	switch (CURRENT_TERMINAL) {
2019
	  case 27:
2020
	    break;
2021
	  default:
2022
	    goto ZL1;
2023
	}
2024
	ADVANCE_LEXER;
2025
	switch (CURRENT_TERMINAL) {
2026
	  case 16:
2027
	    break;
2028
	  default:
2029
	    goto ZL1;
2030
	}
2031
	ADVANCE_LEXER;
2032
	switch (CURRENT_TERMINAL) {
2033
	  case 29:
2034
	    break;
2035
	  default:
2036
	    goto ZL1;
2037
	}
2038
	ADVANCE_LEXER;
2039
	ZRclist_Hpack ();
2040
	switch (CURRENT_TERMINAL) {
2041
	  case 28:
2042
	    break;
2043
	  case 32:
2044
	    RESTORE_LEXER;
2045
	    goto ZL1;
2046
	  default:
2047
	    goto ZL1;
2048
	}
2049
	ADVANCE_LEXER;
2050
	switch (CURRENT_TERMINAL) {
2051
	  case 29:
2052
	    break;
2053
	  default:
2054
	    goto ZL1;
2055
	}
2056
	ADVANCE_LEXER;
2057
	switch (CURRENT_TERMINAL) {
2058
	  case 27:
2059
	    break;
2060
	  default:
2061
	    goto ZL1;
2062
	}
2063
	ADVANCE_LEXER;
2064
	switch (CURRENT_TERMINAL) {
2065
	  case 22:
2066
	    break;
2067
	  default:
2068
	    goto ZL1;
2069
	}
2070
	ADVANCE_LEXER;
2071
	switch (CURRENT_TERMINAL) {
2072
	  case 29:
2073
	    break;
2074
	  default:
2075
	    goto ZL1;
2076
	}
2077
	ADVANCE_LEXER;
2078
	ZRslist_Hpack ();
2079
	switch (CURRENT_TERMINAL) {
2080
	  case 28:
2081
	    break;
2082
	  case 32:
2083
	    RESTORE_LEXER;
2084
	    goto ZL1;
2085
	  default:
2086
	    goto ZL1;
2087
	}
2088
	ADVANCE_LEXER;
2089
	switch (CURRENT_TERMINAL) {
2090
	  case 29:
2091
	    break;
2092
	  default:
2093
	    goto ZL1;
2094
	}
2095
	ADVANCE_LEXER;
2096
	switch (CURRENT_TERMINAL) {
2097
	  case 27:
2098
	    break;
2099
	  default:
2100
	    goto ZL1;
2101
	}
2102
	ADVANCE_LEXER;
2103
	switch (CURRENT_TERMINAL) {
2104
	  case 19:
2105
	    break;
2106
	  default:
2107
	    goto ZL1;
2108
	}
2109
	ADVANCE_LEXER;
2110
	switch (CURRENT_TERMINAL) {
2111
	  case 29:
2112
	    break;
2113
	  default:
2114
	    goto ZL1;
2115
	}
2116
	ADVANCE_LEXER;
2117
	ZRoption_Hpack ();
2118
	switch (CURRENT_TERMINAL) {
2119
	  case 28:
2120
	    break;
2121
	  case 32:
2122
	    RESTORE_LEXER;
2123
	    goto ZL1;
2124
	  default:
2125
	    goto ZL1;
2126
	}
2127
	ADVANCE_LEXER;
2128
	switch (CURRENT_TERMINAL) {
2129
	  case 29:
2130
	    break;
2131
	  default:
2132
	    goto ZL1;
2133
	}
2134
	ADVANCE_LEXER;
2135
	switch (CURRENT_TERMINAL) {
2136
	  case 27:
2137
	    break;
2138
	  default:
2139
	    goto ZL1;
2140
	}
2141
	ADVANCE_LEXER;
2142
	switch (CURRENT_TERMINAL) {
2143
	  case 15:
2144
	    break;
2145
	  default:
2146
	    goto ZL1;
2147
	}
2148
	ADVANCE_LEXER;
2149
	switch (CURRENT_TERMINAL) {
2150
	  case 29:
2151
	    break;
2152
	  default:
2153
	    goto ZL1;
2154
	}
2155
	ADVANCE_LEXER;
2156
	ZRlink_Hpack (&ZIp);
2157
	switch (CURRENT_TERMINAL) {
2158
	  case 28:
2159
	    break;
2160
	  case 32:
2161
	    RESTORE_LEXER;
2162
	    goto ZL1;
2163
	  default:
2164
	    goto ZL1;
2165
	}
2166
	ADVANCE_LEXER;
2167
	switch (CURRENT_TERMINAL) {
2168
	  case 29:
2169
	    break;
2170
	  default:
2171
	    goto ZL1;
2172
	}
2173
	ADVANCE_LEXER;
2174
	switch (CURRENT_TERMINAL) {
2175
	  case 27:
2176
	    break;
2177
	  default:
2178
	    goto ZL1;
2179
	}
2180
	ADVANCE_LEXER;
2181
	switch (CURRENT_TERMINAL) {
2182
	  case 14:
2183
	    break;
2184
	  default:
2185
	    goto ZL1;
2186
	}
2187
	ADVANCE_LEXER;
2188
	switch (CURRENT_TERMINAL) {
2189
	  case 29:
2190
	    break;
2191
	  default:
2192
	    goto ZL1;
2193
	}
2194
	ADVANCE_LEXER;
2195
	ZRkind_Hpack (&ZIq);
2196
	switch (CURRENT_TERMINAL) {
2197
	  case 28:
2198
	    break;
2199
	  case 32:
2200
	    RESTORE_LEXER;
2201
	    goto ZL1;
2202
	  default:
2203
	    goto ZL1;
2204
	}
2205
	ADVANCE_LEXER;
2206
	switch (CURRENT_TERMINAL) {
2207
	  case 29:
2208
	    break;
2209
	  default:
2210
	    goto ZL1;
2211
	}
2212
	ADVANCE_LEXER;
2213
	switch (CURRENT_TERMINAL) {
2214
	  case 27:
2215
	    break;
2216
	  default:
2217
	    goto ZL1;
2218
	}
2219
	ADVANCE_LEXER;
2220
	switch (CURRENT_TERMINAL) {
2221
	  case 12:
2222
	    break;
2223
	  default:
2224
	    goto ZL1;
2225
	}
2226
	ADVANCE_LEXER;
2227
	switch (CURRENT_TERMINAL) {
2228
	  case 29:
2229
	    break;
2230
	  default:
2231
	    goto ZL1;
2232
	}
2233
	ADVANCE_LEXER;
2234
	ZRedge_Hpack ();
2235
	switch (CURRENT_TERMINAL) {
2236
	  case 28:
2237
	    break;
2238
	  case 32:
2239
	    RESTORE_LEXER;
2240
	    goto ZL1;
2241
	  default:
2242
	    goto ZL1;
2243
	}
2244
	ADVANCE_LEXER;
2245
	switch (CURRENT_TERMINAL) {
2246
	  case 29:
2247
	    break;
2248
	  default:
2249
	    goto ZL1;
2250
	}
2251
	ADVANCE_LEXER;
2252
	switch (CURRENT_TERMINAL) {
2253
	  case 27:
2254
	    break;
2255
	  default:
2256
	    goto ZL1;
2257
	}
2258
	ADVANCE_LEXER;
2259
	switch (CURRENT_TERMINAL) {
2260
	  case 17:
2261
	    break;
2262
	  default:
2263
	    goto ZL1;
2264
	}
2265
	ADVANCE_LEXER;
2266
	switch (CURRENT_TERMINAL) {
2267
	  case 29:
2268
	    break;
2269
	  default:
2270
	    goto ZL1;
2271
	}
2272
	ADVANCE_LEXER;
2273
	switch (CURRENT_TERMINAL) {
2274
	  case 1:
2275
	    {
2276
 
2277
    ZIv1 = token_value ;
2278
	    }
2279
	    break;
2280
	  default:
2281
	    goto ZL1;
2282
	}
2283
	ADVANCE_LEXER;
2284
	switch (CURRENT_TERMINAL) {
2285
	  case 28:
2286
	    break;
2287
	  default:
2288
	    goto ZL1;
2289
	}
2290
	ADVANCE_LEXER;
2291
	switch (CURRENT_TERMINAL) {
2292
	  case 29:
2293
	    break;
2294
	  default:
2295
	    goto ZL1;
2296
	}
2297
	ADVANCE_LEXER;
2298
	switch (CURRENT_TERMINAL) {
2299
	  case 27:
2300
	    break;
2301
	  default:
2302
	    goto ZL1;
2303
	}
2304
	ADVANCE_LEXER;
2305
	switch (CURRENT_TERMINAL) {
2306
	  case 18:
2307
	    break;
2308
	  default:
2309
	    goto ZL1;
2310
	}
2311
	ADVANCE_LEXER;
2312
	switch (CURRENT_TERMINAL) {
2313
	  case 29:
2314
	    break;
2315
	  default:
2316
	    goto ZL1;
2317
	}
2318
	ADVANCE_LEXER;
2319
	switch (CURRENT_TERMINAL) {
2320
	  case 1:
2321
	    {
2322
 
2323
    ZIv2 = token_value ;
2324
	    }
2325
	    break;
2326
	  default:
2327
	    goto ZL1;
2328
	}
2329
	ADVANCE_LEXER;
2330
	switch (CURRENT_TERMINAL) {
2331
	  case 28:
2332
	    break;
2333
	  default:
2334
	    goto ZL1;
2335
	}
2336
	ADVANCE_LEXER;
2337
	switch (CURRENT_TERMINAL) {
2338
	  case 28:
2339
	    break;
2340
	  default:
2341
	    goto ZL1;
2342
	}
2343
	ADVANCE_LEXER;
2344
	switch (CURRENT_TERMINAL) {
2345
	  case 30:
2346
	    break;
2347
	  default:
2348
	    goto ZL1;
2349
	}
2350
	ADVANCE_LEXER;
2351
	{
2352
 
2353
    LIST ( SORT ) p = check_sorts () ;
2354
    LIST ( LINKAGE ) q = foreign_sorts () ;
2355
    MAKE_spec_basic ( (ZIv1), (ZIv2), p, (ZIp), (ZIq), q, (ZIspec) ) ;
2356
	}
2357
    }
2358
    goto ZL0;
2359
  ZL1:;
2360
    {
2361
	{
2362
 
2363
    error ( ERROR_SERIOUS, "Syntax error" ) ;
2364
	}
2365
	{
2366
 
2367
    (ZIspec) = NULL_spec ;
2368
	}
2369
    }
2370
  ZL0:;
2371
    *ZOspec = ZIspec;
2372
}
2373
 
2374
static void
7 7u83 2375
ZRoption_Hpack(void)
2 7u83 2376
{
2377
    if ((CURRENT_TERMINAL) == 32) {
2378
	return;
2379
    }
2380
    {
2381
	switch (CURRENT_TERMINAL) {
2382
	  case 27:
2383
	    break;
2384
	  default:
2385
	    goto ZL1;
2386
	}
2387
	ADVANCE_LEXER;
2388
	{
2389
	    switch (CURRENT_TERMINAL) {
2390
	      case 0:
2391
		{
2392
		    ZRoption_Hlist ();
2393
		    if ((CURRENT_TERMINAL) == 32) {
2394
			RESTORE_LEXER;
2395
			goto ZL1;
2396
		    }
2397
		}
2398
		break;
2399
	      default:
2400
		break;
2401
	    }
2402
	}
2403
	switch (CURRENT_TERMINAL) {
2404
	  case 28:
2405
	    break;
2406
	  default:
2407
	    goto ZL1;
2408
	}
2409
	ADVANCE_LEXER;
2410
    }
2411
    return;
2412
  ZL1:;
2413
    SAVE_LEXER (32);
2414
    return;
2415
}
2416
 
2417
static void
7 7u83 2418
ZRclist_Hpack(void)
2 7u83 2419
{
2420
    if ((CURRENT_TERMINAL) == 32) {
2421
	return;
2422
    }
2423
    {
2424
	switch (CURRENT_TERMINAL) {
2425
	  case 27:
2426
	    break;
2427
	  default:
2428
	    goto ZL1;
2429
	}
2430
	ADVANCE_LEXER;
2431
	{
2432
	    switch (CURRENT_TERMINAL) {
2433
	      case 0:
2434
		{
2435
		    ZRclist_Hlist ();
2436
		    if ((CURRENT_TERMINAL) == 32) {
2437
			RESTORE_LEXER;
2438
			goto ZL1;
2439
		    }
2440
		}
2441
		break;
2442
	      default:
2443
		break;
2444
	    }
2445
	}
2446
	switch (CURRENT_TERMINAL) {
2447
	  case 28:
2448
	    break;
2449
	  default:
2450
	    goto ZL1;
2451
	}
2452
	ADVANCE_LEXER;
2453
    }
2454
    return;
2455
  ZL1:;
2456
    SAVE_LEXER (32);
2457
    return;
2458
}
2459
 
2460
static void
7 7u83 2461
ZRparam_Hitem(PARAMETER *ZOa)
2 7u83 2462
{
2463
    PARAMETER ZIa;
2464
 
2465
    if ((CURRENT_TERMINAL) == 32) {
2466
	return;
2467
    }
2468
    {
2469
	string ZIn;
2470
	SORT ZIs;
2471
 
2472
	switch (CURRENT_TERMINAL) {
2473
	  case 27:
2474
	    break;
2475
	  default:
2476
	    goto ZL1;
2477
	}
2478
	ADVANCE_LEXER;
2479
	ZRany_Hname (&ZIn);
2480
	switch (CURRENT_TERMINAL) {
2481
	  case 29:
2482
	    break;
2483
	  case 32:
2484
	    RESTORE_LEXER;
2485
	    goto ZL1;
2486
	  default:
2487
	    goto ZL1;
2488
	}
2489
	ADVANCE_LEXER;
2490
	ZRnew_Hsort_Hname (&ZIs);
2491
	switch (CURRENT_TERMINAL) {
2492
	  case 28:
2493
	    break;
2494
	  case 32:
2495
	    RESTORE_LEXER;
2496
	    goto ZL1;
2497
	  default:
2498
	    goto ZL1;
2499
	}
2500
	ADVANCE_LEXER;
2501
	{
2502
 
2503
    int intro = 0 ;
2504
    if ( ends_in ( (ZIn), "_intro" ) ) intro = 1 ;
2505
    MAKE_par_basic ( (ZIn), (ZIs), 0, 0, intro, (ZIa) ) ;
2506
	}
2507
    }
2508
    goto ZL0;
2509
  ZL1:;
2510
    SAVE_LEXER (32);
2511
    return;
2512
  ZL0:;
2513
    *ZOa = ZIa;
2514
}
2515
 
2516
static void
7 7u83 2517
ZRedge_Hitem(void)
2 7u83 2518
{
2519
    if ((CURRENT_TERMINAL) == 32) {
2520
	return;
2521
    }
2522
    {
2523
	SORT ZIs;
2524
	string ZIc;
2525
 
2526
	switch (CURRENT_TERMINAL) {
2527
	  case 27:
2528
	    break;
2529
	  default:
2530
	    goto ZL1;
2531
	}
2532
	ADVANCE_LEXER;
2533
	switch (CURRENT_TERMINAL) {
2534
	  case 7:
2535
	    break;
2536
	  default:
2537
	    goto ZL1;
2538
	}
2539
	ADVANCE_LEXER;
2540
	switch (CURRENT_TERMINAL) {
2541
	  case 29:
2542
	    break;
2543
	  default:
2544
	    goto ZL1;
2545
	}
2546
	ADVANCE_LEXER;
2547
	ZRold_Hsort_Hname (&ZIs);
2548
	switch (CURRENT_TERMINAL) {
2549
	  case 28:
2550
	    break;
2551
	  case 32:
2552
	    RESTORE_LEXER;
2553
	    goto ZL1;
2554
	  default:
2555
	    goto ZL1;
2556
	}
2557
	ADVANCE_LEXER;
2558
	switch (CURRENT_TERMINAL) {
2559
	  case 29:
2560
	    break;
2561
	  default:
2562
	    goto ZL1;
2563
	}
2564
	ADVANCE_LEXER;
2565
	switch (CURRENT_TERMINAL) {
2566
	  case 27:
2567
	    break;
2568
	  default:
2569
	    goto ZL1;
2570
	}
2571
	ADVANCE_LEXER;
2572
	switch (CURRENT_TERMINAL) {
2573
	  case 6:
2574
	    break;
2575
	  default:
2576
	    goto ZL1;
2577
	}
2578
	ADVANCE_LEXER;
2579
	switch (CURRENT_TERMINAL) {
2580
	  case 29:
2581
	    break;
2582
	  default:
2583
	    goto ZL1;
2584
	}
2585
	ADVANCE_LEXER;
2586
	switch (CURRENT_TERMINAL) {
2587
	  case 0:
2588
	    {
2589
 
2590
    ZIc = xstrcpy ( token_buff ) ;
2591
	    }
2592
	    break;
2593
	  default:
2594
	    goto ZL1;
2595
	}
2596
	ADVANCE_LEXER;
2597
	switch (CURRENT_TERMINAL) {
2598
	  case 28:
2599
	    break;
2600
	  default:
2601
	    goto ZL1;
2602
	}
2603
	ADVANCE_LEXER;
2604
	{
2605
 
2606
    set_special ( (ZIs), (ZIc), KIND_edge ) ;
2607
    COPY_int ( sort_edge ( (ZIs) ), 1 ) ;
2608
	}
2609
    }
2610
    return;
2611
  ZL1:;
2612
    SAVE_LEXER (32);
2613
    return;
2614
}
2615
 
2616
static void
7 7u83 2617
ZRkind_Hpack(SID_LINK_LIST *ZOp)
2 7u83 2618
{
2619
    SID_LINK_LIST ZIp;
2620
 
2621
    if ((CURRENT_TERMINAL) == 32) {
2622
	return;
2623
    }
2624
    {
2625
	SID_LINK_LIST ZIq;
2626
 
2627
	switch (CURRENT_TERMINAL) {
2628
	  case 27:
2629
	    break;
2630
	  default:
2631
	    goto ZL1;
2632
	}
2633
	ADVANCE_LEXER;
2634
	{
2635
	    switch (CURRENT_TERMINAL) {
2636
	      case 27:
2637
		{
2638
		    ZRkind_Hlist (&ZIq);
2639
		    if ((CURRENT_TERMINAL) == 32) {
2640
			RESTORE_LEXER;
2641
			goto ZL1;
2642
		    }
2643
		}
2644
		break;
2645
	      default:
2646
		{
2647
		    {
2648
 
2649
    (ZIq) = NULL_list ( LINKAGE ) ;
2650
		    }
2651
		}
2652
		break;
2653
	    }
2654
	}
2655
	switch (CURRENT_TERMINAL) {
2656
	  case 28:
2657
	    break;
2658
	  default:
2659
	    goto ZL1;
2660
	}
2661
	ADVANCE_LEXER;
2662
	ZIp = ZIq;
2663
    }
2664
    goto ZL0;
2665
  ZL1:;
2666
    SAVE_LEXER (32);
2667
    return;
2668
  ZL0:;
2669
    *ZOp = ZIp;
2670
}
2671
 
2672
static void
7 7u83 2673
ZRnumber_Hlist(CONSTRUCT ZIc)
2 7u83 2674
{
2675
    if ((CURRENT_TERMINAL) == 32) {
2676
	return;
2677
    }
2678
  ZL2_number_Hlist:;
2679
    {
2680
	unsigned ZIa;
2681
 
2682
	switch (CURRENT_TERMINAL) {
2683
	  case 1:
2684
	    {
2685
 
2686
    ZIa = token_value ;
2687
	    }
2688
	    break;
2689
	  default:
2690
	    goto ZL1;
2691
	}
2692
	ADVANCE_LEXER;
2693
	{
2694
 
2695
    PARAMETER p = find_param ( (ZIc), (ZIa) ) ;
2696
    if ( !IS_NULL_par ( p ) ) COPY_int ( par_align ( p ), 1 ) ;
2697
	}
2698
	{
2699
	    switch (CURRENT_TERMINAL) {
2700
	      case 29:
2701
		{
2702
		    ADVANCE_LEXER;
2703
		    goto ZL2_number_Hlist;
2704
		}
2705
		/*UNREACHED*/
2706
	      default:
2707
		break;
2708
	    }
2709
	}
2710
    }
2711
    return;
2712
  ZL1:;
2713
    SAVE_LEXER (32);
2714
    return;
2715
}
2716
 
2717
static void
7 7u83 2718
ZRoption_Hitem(void)
2 7u83 2719
{
2720
    if ((CURRENT_TERMINAL) == 32) {
2721
	return;
2722
    }
2723
    {
2724
	SORT ZIs;
2725
 
2726
	ZRnew_Hsort_Hname (&ZIs);
2727
	if ((CURRENT_TERMINAL) == 32) {
2728
	    RESTORE_LEXER;
2729
	    goto ZL1;
2730
	}
2731
	{
2732
 
2733
    compound_sort ( (ZIs), "_option", info_option_tag, '?' ) ;
2734
	}
2735
    }
2736
    return;
2737
  ZL1:;
2738
    SAVE_LEXER (32);
2739
    return;
2740
}
2741
 
2742
/* BEGINNING OF TRAILER */
2743
 
2744
 
2745
 
2746
/* END OF FILE */