Warning: Attempt to read property "date" on null in /usr/local/www/websvn.planix.org/blame.php on line 247

Warning: Attempt to read property "msg" on null in /usr/local/www/websvn.planix.org/blame.php on line 247
WebSVN – tendra.SVN – Blame – /branches/tendra5-amd64/src/tools/tpl/fnsfile.c – Rev 6

Subversion Repositories tendra.SVN

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
6 7u83 1
/*
2
 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions are met:
7
 *
8
 * 1. Redistributions of source code must retain the above copyright notice,
9
 *    this list of conditions and the following disclaimer.
10
 * 2. Redistributions in binary form must reproduce the above copyright notice,
11
 *    this list of conditions and the following disclaimer in the documentation
12
 *    and/or other materials provided with the distribution.
13
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
14
 *    may be used to endorse or promote products derived from this software
15
 *    without specific, prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
18
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
19
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
21
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 *
29
 * $Id$
30
 */
31
/*
32
    		 Crown Copyright (c) 1997
33
 
34
    This TenDRA(r) Computer Program is subject to Copyright
35
    owned by the United Kingdom Secretary of State for Defence
36
    acting through the Defence Evaluation and Research Agency
37
    (DERA).  It is made available to Recipients with a
38
    royalty-free licence for its use, reproduction, transfer
39
    to other parties and amendment for any purpose not excluding
40
    product development provided that any such use et cetera
41
    shall be deemed to be acceptance of the following conditions:-
42
 
43
        (1) Its Recipients shall ensure that this Notice is
44
        reproduced upon any copies or amended versions of it;
45
 
46
        (2) Any amended version of it shall be clearly marked to
47
        show both the nature of and the organisation responsible
48
        for the relevant amendment or amendments;
49
 
50
        (3) Its onward transfer from a recipient to another
51
        party shall be deemed to be that party's acceptance of
52
        these conditions;
53
 
54
        (4) DERA gives no warranty or assurance as to its
55
        quality or suitability for any purpose and DERA accepts
56
        no liability whatsoever in relation to any use to which
57
        it may be put.
58
*/
59
 
60
 
61
/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.0 */
62
 
63
#include "config.h"
64
#include "encodings.h"
65
#include "enc_nos.h"
66
#include "defs.h"
67
#include "analyse_sort.h"
68
#include "consfile.h"
69
#include "lex.h"
70
#include "syntax.h"
71
 
72
void
73
c_add_accesses(void)
74
{
75
	    skip_term(lex_ord);
76
	o_add_accesses(
77
	      read_access();
78
	      skip_term(lex_comma),
79
	      read_access();
80
	      skip_term(lex_crd)
81
	     )
82
	    return;
83
}
84
 
85
void
86
c_constant(void)
87
{
88
	    o_constant;
89
	    return;
90
}
91
 
92
void
93
c_long_jump_access(void)
94
{
95
	    o_long_jump_access;
96
	    return;
97
}
98
 
99
void
100
c_no_other_read(void)
101
{
102
	    o_no_other_read;
103
	    return;
104
}
105
 
106
void
107
c_no_other_write(void)
108
{
109
	    o_no_other_write;
110
	    return;
111
}
112
 
113
void
114
c_out_par(void)
115
{
116
	    o_out_par;
117
	    return;
118
}
119
 
120
void
121
c_preserve(void)
122
{
123
	    o_preserve;
124
	    return;
125
}
126
 
127
void
128
c_register(void)
129
{
130
	    o_register;
131
	    return;
132
}
133
 
134
void
135
c_standard_access(void)
136
{
137
	    o_standard_access;
138
	    return;
139
}
140
 
141
void
142
c_used_as_volatile(void)
143
{
144
	    o_used_as_volatile;
145
	    return;
146
}
147
 
148
void
149
c_visible(void)
150
{
151
	    o_visible;
152
	    return;
153
}
154
 
155
void
156
c_alignment(void)
157
{
158
	    skip_term(lex_ord);
159
	o_alignment(
160
	      read_shape();
161
	      skip_term(lex_crd)
162
	     )
163
	    return;
164
}
165
 
166
void
167
c_alloca_alignment(void)
168
{
169
	    o_alloca_alignment;
170
	    return;
171
}
172
 
173
void
174
c_callees_alignment(void)
175
{
176
	    skip_term(lex_ord);
177
	o_callees_alignment(
178
	      read_bool();
179
	      skip_term(lex_crd)
180
	     )
181
	    return;
182
}
183
 
184
void
185
c_callers_alignment(void)
186
{
187
	    skip_term(lex_ord);
188
	o_callers_alignment(
189
	      read_bool();
190
	      skip_term(lex_crd)
191
	     )
192
	    return;
193
}
194
 
195
void
196
c_code_alignment(void)
197
{
198
	    o_code_alignment;
199
	    return;
200
}
201
 
202
void
203
c_locals_alignment(void)
204
{
205
	    o_locals_alignment;
206
	    return;
207
}
208
 
209
void
210
c_parameter_alignment(void)
211
{
212
	    skip_term(lex_ord);
213
	o_parameter_alignment(
214
	      read_shape();
215
	      skip_term(lex_crd)
216
	     )
217
	    return;
218
}
219
 
220
void
221
c_unite_alignments(void)
222
{
223
	    skip_term(lex_ord);
224
	o_unite_alignments(
225
	      read_alignment();
226
	      skip_term(lex_comma),
227
	      read_alignment();
228
	      skip_term(lex_crd)
229
	     )
230
	    return;
231
}
232
 
233
void
234
c_var_param_alignment(void)
235
{
236
	    o_var_param_alignment;
237
	    return;
238
}
239
 
240
void
241
c_bfvar_bits(void)
242
{
243
	    skip_term(lex_ord);
244
	o_bfvar_bits(
245
	      read_bool();
246
	      skip_term(lex_comma),
247
	      read_nat();
248
	      skip_term(lex_crd)
249
	     )
250
	    return;
251
}
252
 
253
void
254
c_false(void)
255
{
256
	    o_false;
257
	    return;
258
}
259
 
260
void
261
c_true(void)
262
{
263
	    o_true;
264
	    return;
265
}
266
 
267
void
268
c_nil_access(void)
269
{
270
	    o_nil_access;
271
	    return;
272
}
273
 
274
void
275
c_overflow(void)
276
{
277
	    o_overflow;
278
	    return;
279
}
280
 
281
void
282
c_stack_overflow(void)
283
{
284
	    o_stack_overflow;
285
	    return;
286
}
287
 
288
void
289
c_continue(void)
290
{
291
	    o_continue;
292
	    return;
293
}
294
 
295
void
296
c_trap(void)
297
{
298
	    skip_term(lex_ord);
299
	o_trap(
300
	      read_error_code_list();
301
	      skip_term(lex_crd)
302
	     )
303
	    return;
304
}
305
 
306
void
307
c_wrap(void)
308
{
309
	    o_wrap;
310
	    return;
311
}
312
 
313
void
314
c_impossible(void)
315
{
316
	    o_impossible;
317
	    return;
318
}
319
 
320
void
321
c_abs(void)
322
{
323
	    skip_term(lex_ord);
324
	o_abs(
325
	      read_error_treatment();
326
	      skip_term(lex_comma),
327
	      read_exp();
328
	      skip_term(lex_crd)
329
	     )
330
	    return;
331
}
332
 
333
void
334
c_add_to_ptr(void)
335
{
336
	    skip_term(lex_ord);
337
	o_add_to_ptr(
338
	      read_exp();
339
	      skip_term(lex_comma),
340
	      read_exp();
341
	      skip_term(lex_crd)
342
	     )
343
	    return;
344
}
345
 
346
void
347
c_and(void)
348
{
349
	    skip_term(lex_ord);
350
	o_and(
351
	      read_exp();
352
	      skip_term(lex_comma),
353
	      read_exp();
354
	      skip_term(lex_crd)
355
	     )
356
	    return;
357
}
358
 
359
void
360
c_assign(void)
361
{
362
	    skip_term(lex_ord);
363
	o_assign(
364
	      read_exp();
365
	      skip_term(lex_comma),
366
	      read_exp();
367
	      skip_term(lex_crd)
368
	     )
369
	    return;
370
}
371
 
372
void
373
c_assign_with_mode(void)
374
{
375
	    skip_term(lex_ord);
376
	o_assign_with_mode(
377
	      read_transfer_mode();
378
	      skip_term(lex_comma),
379
	      read_exp();
380
	      skip_term(lex_comma),
381
	      read_exp();
382
	      skip_term(lex_crd)
383
	     )
384
	    return;
385
}
386
 
387
void
388
c_bitfield_assign(void)
389
{
390
	    skip_term(lex_ord);
391
	o_bitfield_assign(
392
	      read_exp();
393
	      skip_term(lex_comma),
394
	      read_exp();
395
	      skip_term(lex_comma),
396
	      read_exp();
397
	      skip_term(lex_crd)
398
	     )
399
	    return;
400
}
401
 
402
void
403
c_bitfield_assign_with_mode(void)
404
{
405
	    skip_term(lex_ord);
406
	o_bitfield_assign_with_mode(
407
	      read_transfer_mode();
408
	      skip_term(lex_comma),
409
	      read_exp();
410
	      skip_term(lex_comma),
411
	      read_exp();
412
	      skip_term(lex_comma),
413
	      read_exp();
414
	      skip_term(lex_crd)
415
	     )
416
	    return;
417
}
418
 
419
void
420
c_bitfield_contents(void)
421
{
422
	    skip_term(lex_ord);
423
	o_bitfield_contents(
424
	      read_bitfield_variety();
425
	      skip_term(lex_comma),
426
	      read_exp();
427
	      skip_term(lex_comma),
428
	      read_exp();
429
	      skip_term(lex_crd)
430
	     )
431
	    return;
432
}
433
 
434
void
435
c_bitfield_contents_with_mode(void)
436
{
437
	    skip_term(lex_ord);
438
	o_bitfield_contents_with_mode(
439
	      read_transfer_mode();
440
	      skip_term(lex_comma),
441
	      read_bitfield_variety();
442
	      skip_term(lex_comma),
443
	      read_exp();
444
	      skip_term(lex_comma),
445
	      read_exp();
446
	      skip_term(lex_crd)
447
	     )
448
	    return;
449
}
450
 
451
void
452
c_change_bitfield_to_int(void)
453
{
454
	    skip_term(lex_ord);
455
	o_change_bitfield_to_int(
456
	      read_variety();
457
	      skip_term(lex_comma),
458
	      read_exp();
459
	      skip_term(lex_crd)
460
	     )
461
	    return;
462
}
463
 
464
void
465
c_change_floating_variety(void)
466
{
467
	    skip_term(lex_ord);
468
	o_change_floating_variety(
469
	      read_error_treatment();
470
	      skip_term(lex_comma),
471
	      read_floating_variety();
472
	      skip_term(lex_comma),
473
	      read_exp();
474
	      skip_term(lex_crd)
475
	     )
476
	    return;
477
}
478
 
479
void
480
c_change_variety(void)
481
{
482
	    skip_term(lex_ord);
483
	o_change_variety(
484
	      read_error_treatment();
485
	      skip_term(lex_comma),
486
	      read_variety();
487
	      skip_term(lex_comma),
488
	      read_exp();
489
	      skip_term(lex_crd)
490
	     )
491
	    return;
492
}
493
 
494
void
495
c_change_int_to_bitfield(void)
496
{
497
	    skip_term(lex_ord);
498
	o_change_int_to_bitfield(
499
	      read_bitfield_variety();
500
	      skip_term(lex_comma),
501
	      read_exp();
502
	      skip_term(lex_crd)
503
	     )
504
	    return;
505
}
506
 
507
void
508
c_complex_conjugate(void)
509
{
510
	    skip_term(lex_ord);
511
	o_complex_conjugate(
512
	      read_exp();
513
	      skip_term(lex_crd)
514
	     )
515
	    return;
516
}
517
 
518
void
519
c_component(void)
520
{
521
	    skip_term(lex_ord);
522
	o_component(
523
	      read_shape();
524
	      skip_term(lex_comma),
525
	      read_exp();
526
	      skip_term(lex_comma),
527
	      read_exp();
528
	      skip_term(lex_crd)
529
	     )
530
	    return;
531
}
532
 
533
void
534
c_concat_nof(void)
535
{
536
	    skip_term(lex_ord);
537
	o_concat_nof(
538
	      read_exp();
539
	      skip_term(lex_comma),
540
	      read_exp();
541
	      skip_term(lex_crd)
542
	     )
543
	    return;
544
}
545
 
546
void
547
c_conditional(void)
548
{
549
	    skip_term(lex_ord);
550
	o_conditional(
551
	      read_label();
552
	      skip_term(lex_comma),
553
	      read_exp();
554
	      skip_term(lex_comma),
555
	      read_exp();
556
	      skip_term(lex_crd)
557
	     )
558
	    return;
559
}
560
 
561
void
562
c_contents(void)
563
{
564
	    skip_term(lex_ord);
565
	o_contents(
566
	      read_shape();
567
	      skip_term(lex_comma),
568
	      read_exp();
569
	      skip_term(lex_crd)
570
	     )
571
	    return;
572
}
573
 
574
void
575
c_contents_with_mode(void)
576
{
577
	    skip_term(lex_ord);
578
	o_contents_with_mode(
579
	      read_transfer_mode();
580
	      skip_term(lex_comma),
581
	      read_shape();
582
	      skip_term(lex_comma),
583
	      read_exp();
584
	      skip_term(lex_crd)
585
	     )
586
	    return;
587
}
588
 
589
void
590
c_current_env(void)
591
{
592
	    o_current_env;
593
	    return;
594
}
595
 
596
void
597
c_div0(void)
598
{
599
	    skip_term(lex_ord);
600
	o_div0(
601
	      read_error_treatment();
602
	      skip_term(lex_comma),
603
	      read_error_treatment();
604
	      skip_term(lex_comma),
605
	      read_exp();
606
	      skip_term(lex_comma),
607
	      read_exp();
608
	      skip_term(lex_crd)
609
	     )
610
	    return;
611
}
612
 
613
void
614
c_div1(void)
615
{
616
	    skip_term(lex_ord);
617
	o_div1(
618
	      read_error_treatment();
619
	      skip_term(lex_comma),
620
	      read_error_treatment();
621
	      skip_term(lex_comma),
622
	      read_exp();
623
	      skip_term(lex_comma),
624
	      read_exp();
625
	      skip_term(lex_crd)
626
	     )
627
	    return;
628
}
629
 
630
void
631
c_div2(void)
632
{
633
	    skip_term(lex_ord);
634
	o_div2(
635
	      read_error_treatment();
636
	      skip_term(lex_comma),
637
	      read_error_treatment();
638
	      skip_term(lex_comma),
639
	      read_exp();
640
	      skip_term(lex_comma),
641
	      read_exp();
642
	      skip_term(lex_crd)
643
	     )
644
	    return;
645
}
646
 
647
void
648
c_env_offset(void)
649
{
650
	    skip_term(lex_ord);
651
	o_env_offset(
652
	      read_alignment();
653
	      skip_term(lex_comma),
654
	      read_alignment();
655
	      skip_term(lex_comma),
656
	      read_tag();
657
	      skip_term(lex_crd)
658
	     )
659
	    return;
660
}
661
 
662
void
663
c_env_size(void)
664
{
665
	    skip_term(lex_ord);
666
	o_env_size(
667
	      read_tag();
668
	      skip_term(lex_crd)
669
	     )
670
	    return;
671
}
672
 
673
void
674
c_fail_installer(void)
675
{
676
	    skip_term(lex_ord);
677
	o_fail_installer(
678
	      read_string();
679
	      skip_term(lex_crd)
680
	     )
681
	    return;
682
}
683
 
684
void
685
c_float_int(void)
686
{
687
	    skip_term(lex_ord);
688
	o_float_int(
689
	      read_error_treatment();
690
	      skip_term(lex_comma),
691
	      read_floating_variety();
692
	      skip_term(lex_comma),
693
	      read_exp();
694
	      skip_term(lex_crd)
695
	     )
696
	    return;
697
}
698
 
699
void
700
c_floating_abs(void)
701
{
702
	    skip_term(lex_ord);
703
	o_floating_abs(
704
	      read_error_treatment();
705
	      skip_term(lex_comma),
706
	      read_exp();
707
	      skip_term(lex_crd)
708
	     )
709
	    return;
710
}
711
 
712
void
713
c_floating_div(void)
714
{
715
	    skip_term(lex_ord);
716
	o_floating_div(
717
	      read_error_treatment();
718
	      skip_term(lex_comma),
719
	      read_exp();
720
	      skip_term(lex_comma),
721
	      read_exp();
722
	      skip_term(lex_crd)
723
	     )
724
	    return;
725
}
726
 
727
void
728
c_floating_minus(void)
729
{
730
	    skip_term(lex_ord);
731
	o_floating_minus(
732
	      read_error_treatment();
733
	      skip_term(lex_comma),
734
	      read_exp();
735
	      skip_term(lex_comma),
736
	      read_exp();
737
	      skip_term(lex_crd)
738
	     )
739
	    return;
740
}
741
 
742
void
743
c_floating_maximum(void)
744
{
745
	    skip_term(lex_ord);
746
	o_floating_maximum(
747
	      read_error_treatment();
748
	      skip_term(lex_comma),
749
	      read_exp();
750
	      skip_term(lex_comma),
751
	      read_exp();
752
	      skip_term(lex_crd)
753
	     )
754
	    return;
755
}
756
 
757
void
758
c_floating_minimum(void)
759
{
760
	    skip_term(lex_ord);
761
	o_floating_minimum(
762
	      read_error_treatment();
763
	      skip_term(lex_comma),
764
	      read_exp();
765
	      skip_term(lex_comma),
766
	      read_exp();
767
	      skip_term(lex_crd)
768
	     )
769
	    return;
770
}
771
 
772
void
773
c_floating_mult(void)
774
{
775
	    skip_term(lex_ord);
776
	o_floating_mult(
777
	      read_error_treatment();
778
	      skip_term(lex_comma),
779
	      read_exp_list();
780
	      skip_term(lex_crd)
781
	     )
782
	    return;
783
}
784
 
785
void
786
c_floating_negate(void)
787
{
788
	    skip_term(lex_ord);
789
	o_floating_negate(
790
	      read_error_treatment();
791
	      skip_term(lex_comma),
792
	      read_exp();
793
	      skip_term(lex_crd)
794
	     )
795
	    return;
796
}
797
 
798
void
799
c_floating_plus(void)
800
{
801
	    skip_term(lex_ord);
802
	o_floating_plus(
803
	      read_error_treatment();
804
	      skip_term(lex_comma),
805
	      read_exp_list();
806
	      skip_term(lex_crd)
807
	     )
808
	    return;
809
}
810
 
811
void
812
c_floating_power(void)
813
{
814
	    skip_term(lex_ord);
815
	o_floating_power(
816
	      read_error_treatment();
817
	      skip_term(lex_comma),
818
	      read_exp();
819
	      skip_term(lex_comma),
820
	      read_exp();
821
	      skip_term(lex_crd)
822
	     )
823
	    return;
824
}
825
 
826
void
827
c_floating_test(void)
828
{
829
	    skip_term(lex_ord);
830
	o_floating_test(
831
	      read_nat_option();
832
	      skip_term(lex_comma),
833
	      read_error_treatment();
834
	      skip_term(lex_comma),
835
	      read_ntest();
836
	      skip_term(lex_comma),
837
	      read_label();
838
	      skip_term(lex_comma),
839
	      read_exp();
840
	      skip_term(lex_comma),
841
	      read_exp();
842
	      skip_term(lex_crd)
843
	     )
844
	    return;
845
}
846
 
847
void
848
c_goto(void)
849
{
850
	    skip_term(lex_ord);
851
	o_goto(
852
	      read_label();
853
	      skip_term(lex_crd)
854
	     )
855
	    return;
856
}
857
 
858
void
859
c_goto_local_lv(void)
860
{
861
	    skip_term(lex_ord);
862
	o_goto_local_lv(
863
	      read_exp();
864
	      skip_term(lex_crd)
865
	     )
866
	    return;
867
}
868
 
869
void
870
c_ignorable(void)
871
{
872
	    skip_term(lex_ord);
873
	o_ignorable(
874
	      read_exp();
875
	      skip_term(lex_crd)
876
	     )
877
	    return;
878
}
879
 
880
void
881
c_imaginary_part(void)
882
{
883
	    skip_term(lex_ord);
884
	o_imaginary_part(
885
	      read_exp();
886
	      skip_term(lex_crd)
887
	     )
888
	    return;
889
}
890
 
891
void
892
c_initial_value(void)
893
{
894
	    skip_term(lex_ord);
895
	o_initial_value(
896
	      read_exp();
897
	      skip_term(lex_crd)
898
	     )
899
	    return;
900
}
901
 
902
void
903
c_integer_test(void)
904
{
905
	    skip_term(lex_ord);
906
	o_integer_test(
907
	      read_nat_option();
908
	      skip_term(lex_comma),
909
	      read_ntest();
910
	      skip_term(lex_comma),
911
	      read_label();
912
	      skip_term(lex_comma),
913
	      read_exp();
914
	      skip_term(lex_comma),
915
	      read_exp();
916
	      skip_term(lex_crd)
917
	     )
918
	    return;
919
}
920
 
921
void
922
c_last_local(void)
923
{
924
	    skip_term(lex_ord);
925
	o_last_local(
926
	      read_exp();
927
	      skip_term(lex_crd)
928
	     )
929
	    return;
930
}
931
 
932
void
933
c_local_alloc(void)
934
{
935
	    skip_term(lex_ord);
936
	o_local_alloc(
937
	      read_exp();
938
	      skip_term(lex_crd)
939
	     )
940
	    return;
941
}
942
 
943
void
944
c_local_alloc_check(void)
945
{
946
	    skip_term(lex_ord);
947
	o_local_alloc_check(
948
	      read_exp();
949
	      skip_term(lex_crd)
950
	     )
951
	    return;
952
}
953
 
954
void
955
c_local_free(void)
956
{
957
	    skip_term(lex_ord);
958
	o_local_free(
959
	      read_exp();
960
	      skip_term(lex_comma),
961
	      read_exp();
962
	      skip_term(lex_crd)
963
	     )
964
	    return;
965
}
966
 
967
void
968
c_local_free_all(void)
969
{
970
	    o_local_free_all;
971
	    return;
972
}
973
 
974
void
975
c_long_jump(void)
976
{
977
	    skip_term(lex_ord);
978
	o_long_jump(
979
	      read_exp();
980
	      skip_term(lex_comma),
981
	      read_exp();
982
	      skip_term(lex_crd)
983
	     )
984
	    return;
985
}
986
 
987
void
988
c_make_complex(void)
989
{
990
	    skip_term(lex_ord);
991
	o_make_complex(
992
	      read_floating_variety();
993
	      skip_term(lex_comma),
994
	      read_exp();
995
	      skip_term(lex_comma),
996
	      read_exp();
997
	      skip_term(lex_crd)
998
	     )
999
	    return;
1000
}
1001
 
1002
void
1003
c_make_compound(void)
1004
{
1005
	    skip_term(lex_ord);
1006
	o_make_compound(
1007
	      read_exp();
1008
	      skip_term(lex_comma),
1009
	      read_exp_list();
1010
	      skip_term(lex_crd)
1011
	     )
1012
	    return;
1013
}
1014
 
1015
void
1016
c_make_local_lv(void)
1017
{
1018
	    skip_term(lex_ord);
1019
	o_make_local_lv(
1020
	      read_label();
1021
	      skip_term(lex_crd)
1022
	     )
1023
	    return;
1024
}
1025
 
1026
void
1027
c_make_nof(void)
1028
{
1029
	    skip_term(lex_ord);
1030
	o_make_nof(
1031
	      read_exp_list();
1032
	      skip_term(lex_crd)
1033
	     )
1034
	    return;
1035
}
1036
 
1037
void
1038
c_make_nof_int(void)
1039
{
1040
	    skip_term(lex_ord);
1041
	o_make_nof_int(
1042
	      read_variety();
1043
	      skip_term(lex_comma),
1044
	      read_string();
1045
	      skip_term(lex_crd)
1046
	     )
1047
	    return;
1048
}
1049
 
1050
void
1051
c_make_null_local_lv(void)
1052
{
1053
	    o_make_null_local_lv;
1054
	    return;
1055
}
1056
 
1057
void
1058
c_make_null_proc(void)
1059
{
1060
	    o_make_null_proc;
1061
	    return;
1062
}
1063
 
1064
void
1065
c_make_null_ptr(void)
1066
{
1067
	    skip_term(lex_ord);
1068
	o_make_null_ptr(
1069
	      read_alignment();
1070
	      skip_term(lex_crd)
1071
	     )
1072
	    return;
1073
}
1074
 
1075
void
1076
c_make_stack_limit(void)
1077
{
1078
	    skip_term(lex_ord);
1079
	o_make_stack_limit(
1080
	      read_exp();
1081
	      skip_term(lex_comma),
1082
	      read_exp();
1083
	      skip_term(lex_comma),
1084
	      read_exp();
1085
	      skip_term(lex_crd)
1086
	     )
1087
	    return;
1088
}
1089
 
1090
void
1091
c_make_top(void)
1092
{
1093
	    o_make_top;
1094
	    return;
1095
}
1096
 
1097
void
1098
c_make_value(void)
1099
{
1100
	    skip_term(lex_ord);
1101
	o_make_value(
1102
	      read_shape();
1103
	      skip_term(lex_crd)
1104
	     )
1105
	    return;
1106
}
1107
 
1108
void
1109
c_maximum(void)
1110
{
1111
	    skip_term(lex_ord);
1112
	o_maximum(
1113
	      read_exp();
1114
	      skip_term(lex_comma),
1115
	      read_exp();
1116
	      skip_term(lex_crd)
1117
	     )
1118
	    return;
1119
}
1120
 
1121
void
1122
c_minimum(void)
1123
{
1124
	    skip_term(lex_ord);
1125
	o_minimum(
1126
	      read_exp();
1127
	      skip_term(lex_comma),
1128
	      read_exp();
1129
	      skip_term(lex_crd)
1130
	     )
1131
	    return;
1132
}
1133
 
1134
void
1135
c_minus(void)
1136
{
1137
	    skip_term(lex_ord);
1138
	o_minus(
1139
	      read_error_treatment();
1140
	      skip_term(lex_comma),
1141
	      read_exp();
1142
	      skip_term(lex_comma),
1143
	      read_exp();
1144
	      skip_term(lex_crd)
1145
	     )
1146
	    return;
1147
}
1148
 
1149
void
1150
c_move_some(void)
1151
{
1152
	    skip_term(lex_ord);
1153
	o_move_some(
1154
	      read_transfer_mode();
1155
	      skip_term(lex_comma),
1156
	      read_exp();
1157
	      skip_term(lex_comma),
1158
	      read_exp();
1159
	      skip_term(lex_comma),
1160
	      read_exp();
1161
	      skip_term(lex_crd)
1162
	     )
1163
	    return;
1164
}
1165
 
1166
void
1167
c_mult(void)
1168
{
1169
	    skip_term(lex_ord);
1170
	o_mult(
1171
	      read_error_treatment();
1172
	      skip_term(lex_comma),
1173
	      read_exp();
1174
	      skip_term(lex_comma),
1175
	      read_exp();
1176
	      skip_term(lex_crd)
1177
	     )
1178
	    return;
1179
}
1180
 
1181
void
1182
c_n_copies(void)
1183
{
1184
	    skip_term(lex_ord);
1185
	o_n_copies(
1186
	      read_nat();
1187
	      skip_term(lex_comma),
1188
	      read_exp();
1189
	      skip_term(lex_crd)
1190
	     )
1191
	    return;
1192
}
1193
 
1194
void
1195
c_negate(void)
1196
{
1197
	    skip_term(lex_ord);
1198
	o_negate(
1199
	      read_error_treatment();
1200
	      skip_term(lex_comma),
1201
	      read_exp();
1202
	      skip_term(lex_crd)
1203
	     )
1204
	    return;
1205
}
1206
 
1207
void
1208
c_not(void)
1209
{
1210
	    skip_term(lex_ord);
1211
	o_not(
1212
	      read_exp();
1213
	      skip_term(lex_crd)
1214
	     )
1215
	    return;
1216
}
1217
 
1218
void
1219
c_offset_add(void)
1220
{
1221
	    skip_term(lex_ord);
1222
	o_offset_add(
1223
	      read_exp();
1224
	      skip_term(lex_comma),
1225
	      read_exp();
1226
	      skip_term(lex_crd)
1227
	     )
1228
	    return;
1229
}
1230
 
1231
void
1232
c_offset_div(void)
1233
{
1234
	    skip_term(lex_ord);
1235
	o_offset_div(
1236
	      read_variety();
1237
	      skip_term(lex_comma),
1238
	      read_exp();
1239
	      skip_term(lex_comma),
1240
	      read_exp();
1241
	      skip_term(lex_crd)
1242
	     )
1243
	    return;
1244
}
1245
 
1246
void
1247
c_offset_div_by_int(void)
1248
{
1249
	    skip_term(lex_ord);
1250
	o_offset_div_by_int(
1251
	      read_exp();
1252
	      skip_term(lex_comma),
1253
	      read_exp();
1254
	      skip_term(lex_crd)
1255
	     )
1256
	    return;
1257
}
1258
 
1259
void
1260
c_offset_max(void)
1261
{
1262
	    skip_term(lex_ord);
1263
	o_offset_max(
1264
	      read_exp();
1265
	      skip_term(lex_comma),
1266
	      read_exp();
1267
	      skip_term(lex_crd)
1268
	     )
1269
	    return;
1270
}
1271
 
1272
void
1273
c_offset_mult(void)
1274
{
1275
	    skip_term(lex_ord);
1276
	o_offset_mult(
1277
	      read_exp();
1278
	      skip_term(lex_comma),
1279
	      read_exp();
1280
	      skip_term(lex_crd)
1281
	     )
1282
	    return;
1283
}
1284
 
1285
void
1286
c_offset_negate(void)
1287
{
1288
	    skip_term(lex_ord);
1289
	o_offset_negate(
1290
	      read_exp();
1291
	      skip_term(lex_crd)
1292
	     )
1293
	    return;
1294
}
1295
 
1296
void
1297
c_offset_pad(void)
1298
{
1299
	    skip_term(lex_ord);
1300
	o_offset_pad(
1301
	      read_alignment();
1302
	      skip_term(lex_comma),
1303
	      read_exp();
1304
	      skip_term(lex_crd)
1305
	     )
1306
	    return;
1307
}
1308
 
1309
void
1310
c_offset_subtract(void)
1311
{
1312
	    skip_term(lex_ord);
1313
	o_offset_subtract(
1314
	      read_exp();
1315
	      skip_term(lex_comma),
1316
	      read_exp();
1317
	      skip_term(lex_crd)
1318
	     )
1319
	    return;
1320
}
1321
 
1322
void
1323
c_offset_test(void)
1324
{
1325
	    skip_term(lex_ord);
1326
	o_offset_test(
1327
	      read_nat_option();
1328
	      skip_term(lex_comma),
1329
	      read_ntest();
1330
	      skip_term(lex_comma),
1331
	      read_label();
1332
	      skip_term(lex_comma),
1333
	      read_exp();
1334
	      skip_term(lex_comma),
1335
	      read_exp();
1336
	      skip_term(lex_crd)
1337
	     )
1338
	    return;
1339
}
1340
 
1341
void
1342
c_offset_zero(void)
1343
{
1344
	    skip_term(lex_ord);
1345
	o_offset_zero(
1346
	      read_alignment();
1347
	      skip_term(lex_crd)
1348
	     )
1349
	    return;
1350
}
1351
 
1352
void
1353
c_or(void)
1354
{
1355
	    skip_term(lex_ord);
1356
	o_or(
1357
	      read_exp();
1358
	      skip_term(lex_comma),
1359
	      read_exp();
1360
	      skip_term(lex_crd)
1361
	     )
1362
	    return;
1363
}
1364
 
1365
void
1366
c_plus(void)
1367
{
1368
	    skip_term(lex_ord);
1369
	o_plus(
1370
	      read_error_treatment();
1371
	      skip_term(lex_comma),
1372
	      read_exp();
1373
	      skip_term(lex_comma),
1374
	      read_exp();
1375
	      skip_term(lex_crd)
1376
	     )
1377
	    return;
1378
}
1379
 
1380
void
1381
c_pointer_test(void)
1382
{
1383
	    skip_term(lex_ord);
1384
	o_pointer_test(
1385
	      read_nat_option();
1386
	      skip_term(lex_comma),
1387
	      read_ntest();
1388
	      skip_term(lex_comma),
1389
	      read_label();
1390
	      skip_term(lex_comma),
1391
	      read_exp();
1392
	      skip_term(lex_comma),
1393
	      read_exp();
1394
	      skip_term(lex_crd)
1395
	     )
1396
	    return;
1397
}
1398
 
1399
void
1400
c_power(void)
1401
{
1402
	    skip_term(lex_ord);
1403
	o_power(
1404
	      read_error_treatment();
1405
	      skip_term(lex_comma),
1406
	      read_exp();
1407
	      skip_term(lex_comma),
1408
	      read_exp();
1409
	      skip_term(lex_crd)
1410
	     )
1411
	    return;
1412
}
1413
 
1414
void
1415
c_proc_test(void)
1416
{
1417
	    skip_term(lex_ord);
1418
	o_proc_test(
1419
	      read_nat_option();
1420
	      skip_term(lex_comma),
1421
	      read_ntest();
1422
	      skip_term(lex_comma),
1423
	      read_label();
1424
	      skip_term(lex_comma),
1425
	      read_exp();
1426
	      skip_term(lex_comma),
1427
	      read_exp();
1428
	      skip_term(lex_crd)
1429
	     )
1430
	    return;
1431
}
1432
 
1433
void
1434
c_profile(void)
1435
{
1436
	    skip_term(lex_ord);
1437
	o_profile(
1438
	      read_nat();
1439
	      skip_term(lex_crd)
1440
	     )
1441
	    return;
1442
}
1443
 
1444
void
1445
c_real_part(void)
1446
{
1447
	    skip_term(lex_ord);
1448
	o_real_part(
1449
	      read_exp();
1450
	      skip_term(lex_crd)
1451
	     )
1452
	    return;
1453
}
1454
 
1455
void
1456
c_rem0(void)
1457
{
1458
	    skip_term(lex_ord);
1459
	o_rem0(
1460
	      read_error_treatment();
1461
	      skip_term(lex_comma),
1462
	      read_error_treatment();
1463
	      skip_term(lex_comma),
1464
	      read_exp();
1465
	      skip_term(lex_comma),
1466
	      read_exp();
1467
	      skip_term(lex_crd)
1468
	     )
1469
	    return;
1470
}
1471
 
1472
void
1473
c_rem1(void)
1474
{
1475
	    skip_term(lex_ord);
1476
	o_rem1(
1477
	      read_error_treatment();
1478
	      skip_term(lex_comma),
1479
	      read_error_treatment();
1480
	      skip_term(lex_comma),
1481
	      read_exp();
1482
	      skip_term(lex_comma),
1483
	      read_exp();
1484
	      skip_term(lex_crd)
1485
	     )
1486
	    return;
1487
}
1488
 
1489
void
1490
c_rem2(void)
1491
{
1492
	    skip_term(lex_ord);
1493
	o_rem2(
1494
	      read_error_treatment();
1495
	      skip_term(lex_comma),
1496
	      read_error_treatment();
1497
	      skip_term(lex_comma),
1498
	      read_exp();
1499
	      skip_term(lex_comma),
1500
	      read_exp();
1501
	      skip_term(lex_crd)
1502
	     )
1503
	    return;
1504
}
1505
 
1506
void
1507
c_repeat(void)
1508
{
1509
	    skip_term(lex_ord);
1510
	o_repeat(
1511
	      read_label();
1512
	      skip_term(lex_comma),
1513
	      read_exp();
1514
	      skip_term(lex_comma),
1515
	      read_exp();
1516
	      skip_term(lex_crd)
1517
	     )
1518
	    return;
1519
}
1520
 
1521
void
1522
c_return(void)
1523
{
1524
	    skip_term(lex_ord);
1525
	o_return(
1526
	      read_exp();
1527
	      skip_term(lex_crd)
1528
	     )
1529
	    return;
1530
}
1531
 
1532
void
1533
c_return_to_label(void)
1534
{
1535
	    skip_term(lex_ord);
1536
	o_return_to_label(
1537
	      read_exp();
1538
	      skip_term(lex_crd)
1539
	     )
1540
	    return;
1541
}
1542
 
1543
void
1544
c_round_with_mode(void)
1545
{
1546
	    skip_term(lex_ord);
1547
	o_round_with_mode(
1548
	      read_error_treatment();
1549
	      skip_term(lex_comma),
1550
	      read_rounding_mode();
1551
	      skip_term(lex_comma),
1552
	      read_variety();
1553
	      skip_term(lex_comma),
1554
	      read_exp();
1555
	      skip_term(lex_crd)
1556
	     )
1557
	    return;
1558
}
1559
 
1560
void
1561
c_rotate_left(void)
1562
{
1563
	    skip_term(lex_ord);
1564
	o_rotate_left(
1565
	      read_exp();
1566
	      skip_term(lex_comma),
1567
	      read_exp();
1568
	      skip_term(lex_crd)
1569
	     )
1570
	    return;
1571
}
1572
 
1573
void
1574
c_rotate_right(void)
1575
{
1576
	    skip_term(lex_ord);
1577
	o_rotate_right(
1578
	      read_exp();
1579
	      skip_term(lex_comma),
1580
	      read_exp();
1581
	      skip_term(lex_crd)
1582
	     )
1583
	    return;
1584
}
1585
 
1586
void
1587
c_set_stack_limit(void)
1588
{
1589
	    skip_term(lex_ord);
1590
	o_set_stack_limit(
1591
	      read_exp();
1592
	      skip_term(lex_crd)
1593
	     )
1594
	    return;
1595
}
1596
 
1597
void
1598
c_shape_offset(void)
1599
{
1600
	    skip_term(lex_ord);
1601
	o_shape_offset(
1602
	      read_shape();
1603
	      skip_term(lex_crd)
1604
	     )
1605
	    return;
1606
}
1607
 
1608
void
1609
c_shift_left(void)
1610
{
1611
	    skip_term(lex_ord);
1612
	o_shift_left(
1613
	      read_error_treatment();
1614
	      skip_term(lex_comma),
1615
	      read_exp();
1616
	      skip_term(lex_comma),
1617
	      read_exp();
1618
	      skip_term(lex_crd)
1619
	     )
1620
	    return;
1621
}
1622
 
1623
void
1624
c_shift_right(void)
1625
{
1626
	    skip_term(lex_ord);
1627
	o_shift_right(
1628
	      read_exp();
1629
	      skip_term(lex_comma),
1630
	      read_exp();
1631
	      skip_term(lex_crd)
1632
	     )
1633
	    return;
1634
}
1635
 
1636
void
1637
c_subtract_ptrs(void)
1638
{
1639
	    skip_term(lex_ord);
1640
	o_subtract_ptrs(
1641
	      read_exp();
1642
	      skip_term(lex_comma),
1643
	      read_exp();
1644
	      skip_term(lex_crd)
1645
	     )
1646
	    return;
1647
}
1648
 
1649
void
1650
c_untidy_return(void)
1651
{
1652
	    skip_term(lex_ord);
1653
	o_untidy_return(
1654
	      read_exp();
1655
	      skip_term(lex_crd)
1656
	     )
1657
	    return;
1658
}
1659
 
1660
void
1661
c_xor(void)
1662
{
1663
	    skip_term(lex_ord);
1664
	o_xor(
1665
	      read_exp();
1666
	      skip_term(lex_comma),
1667
	      read_exp();
1668
	      skip_term(lex_crd)
1669
	     )
1670
	    return;
1671
}
1672
 
1673
void
1674
c_flvar_parms(void)
1675
{
1676
	    skip_term(lex_ord);
1677
	o_flvar_parms(
1678
	      read_nat();
1679
	      skip_term(lex_comma),
1680
	      read_nat();
1681
	      skip_term(lex_comma),
1682
	      read_nat();
1683
	      skip_term(lex_comma),
1684
	      read_nat();
1685
	      skip_term(lex_crd)
1686
	     )
1687
	    return;
1688
}
1689
 
1690
void
1691
c_complex_parms(void)
1692
{
1693
	    skip_term(lex_ord);
1694
	o_complex_parms(
1695
	      read_nat();
1696
	      skip_term(lex_comma),
1697
	      read_nat();
1698
	      skip_term(lex_comma),
1699
	      read_nat();
1700
	      skip_term(lex_comma),
1701
	      read_nat();
1702
	      skip_term(lex_crd)
1703
	     )
1704
	    return;
1705
}
1706
 
1707
void
1708
c_float_of_complex(void)
1709
{
1710
	    skip_term(lex_ord);
1711
	o_float_of_complex(
1712
	      read_shape();
1713
	      skip_term(lex_crd)
1714
	     )
1715
	    return;
1716
}
1717
 
1718
void
1719
c_complex_of_float(void)
1720
{
1721
	    skip_term(lex_ord);
1722
	o_complex_of_float(
1723
	      read_shape();
1724
	      skip_term(lex_crd)
1725
	     )
1726
	    return;
1727
}
1728
 
1729
void
1730
c_computed_nat(void)
1731
{
1732
	    skip_term(lex_ord);
1733
	o_computed_nat(
1734
	      read_exp();
1735
	      skip_term(lex_crd)
1736
	     )
1737
	    return;
1738
}
1739
 
1740
void
1741
c_error_val(void)
1742
{
1743
	    skip_term(lex_ord);
1744
	o_error_val(
1745
	      read_error_code();
1746
	      skip_term(lex_crd)
1747
	     )
1748
	    return;
1749
}
1750
 
1751
void
1752
c_equal(void)
1753
{
1754
	    o_equal;
1755
	    return;
1756
}
1757
 
1758
void
1759
c_greater_than(void)
1760
{
1761
	    o_greater_than;
1762
	    return;
1763
}
1764
 
1765
void
1766
c_greater_than_or_equal(void)
1767
{
1768
	    o_greater_than_or_equal;
1769
	    return;
1770
}
1771
 
1772
void
1773
c_less_than(void)
1774
{
1775
	    o_less_than;
1776
	    return;
1777
}
1778
 
1779
void
1780
c_less_than_or_equal(void)
1781
{
1782
	    o_less_than_or_equal;
1783
	    return;
1784
}
1785
 
1786
void
1787
c_not_equal(void)
1788
{
1789
	    o_not_equal;
1790
	    return;
1791
}
1792
 
1793
void
1794
c_not_greater_than(void)
1795
{
1796
	    o_not_greater_than;
1797
	    return;
1798
}
1799
 
1800
void
1801
c_not_greater_than_or_equal(void)
1802
{
1803
	    o_not_greater_than_or_equal;
1804
	    return;
1805
}
1806
 
1807
void
1808
c_not_less_than(void)
1809
{
1810
	    o_not_less_than;
1811
	    return;
1812
}
1813
 
1814
void
1815
c_not_less_than_or_equal(void)
1816
{
1817
	    o_not_less_than_or_equal;
1818
	    return;
1819
}
1820
 
1821
void
1822
c_less_than_or_greater_than(void)
1823
{
1824
	    o_less_than_or_greater_than;
1825
	    return;
1826
}
1827
 
1828
void
1829
c_not_less_than_and_not_greater_than(void)
1830
{
1831
	    o_not_less_than_and_not_greater_than;
1832
	    return;
1833
}
1834
 
1835
void
1836
c_comparable(void)
1837
{
1838
	    o_comparable;
1839
	    return;
1840
}
1841
 
1842
void
1843
c_not_comparable(void)
1844
{
1845
	    o_not_comparable;
1846
	    return;
1847
}
1848
 
1849
void
1850
c_round_as_state(void)
1851
{
1852
	    o_round_as_state;
1853
	    return;
1854
}
1855
 
1856
void
1857
c_to_nearest(void)
1858
{
1859
	    o_to_nearest;
1860
	    return;
1861
}
1862
 
1863
void
1864
c_toward_larger(void)
1865
{
1866
	    o_toward_larger;
1867
	    return;
1868
}
1869
 
1870
void
1871
c_toward_smaller(void)
1872
{
1873
	    o_toward_smaller;
1874
	    return;
1875
}
1876
 
1877
void
1878
c_toward_zero(void)
1879
{
1880
	    o_toward_zero;
1881
	    return;
1882
}
1883
 
1884
void
1885
c_bitfield(void)
1886
{
1887
	    skip_term(lex_ord);
1888
	o_bitfield(
1889
	      read_bitfield_variety();
1890
	      skip_term(lex_crd)
1891
	     )
1892
	    return;
1893
}
1894
 
1895
void
1896
c_bottom(void)
1897
{
1898
	    o_bottom;
1899
	    return;
1900
}
1901
 
1902
void
1903
c_compound(void)
1904
{
1905
	    skip_term(lex_ord);
1906
	o_compound(
1907
	      read_exp();
1908
	      skip_term(lex_crd)
1909
	     )
1910
	    return;
1911
}
1912
 
1913
void
1914
c_floating(void)
1915
{
1916
	    skip_term(lex_ord);
1917
	o_floating(
1918
	      read_floating_variety();
1919
	      skip_term(lex_crd)
1920
	     )
1921
	    return;
1922
}
1923
 
1924
void
1925
c_integer(void)
1926
{
1927
	    skip_term(lex_ord);
1928
	o_integer(
1929
	      read_variety();
1930
	      skip_term(lex_crd)
1931
	     )
1932
	    return;
1933
}
1934
 
1935
void
1936
c_nof(void)
1937
{
1938
	    skip_term(lex_ord);
1939
	o_nof(
1940
	      read_nat();
1941
	      skip_term(lex_comma),
1942
	      read_shape();
1943
	      skip_term(lex_crd)
1944
	     )
1945
	    return;
1946
}
1947
 
1948
void
1949
c_offset(void)
1950
{
1951
	    skip_term(lex_ord);
1952
	o_offset(
1953
	      read_alignment();
1954
	      skip_term(lex_comma),
1955
	      read_alignment();
1956
	      skip_term(lex_crd)
1957
	     )
1958
	    return;
1959
}
1960
 
1961
void
1962
c_pointer(void)
1963
{
1964
	    skip_term(lex_ord);
1965
	o_pointer(
1966
	      read_alignment();
1967
	      skip_term(lex_crd)
1968
	     )
1969
	    return;
1970
}
1971
 
1972
void
1973
c_proc(void)
1974
{
1975
	    o_proc;
1976
	    return;
1977
}
1978
 
1979
void
1980
c_top(void)
1981
{
1982
	    o_top;
1983
	    return;
1984
}
1985
 
1986
void
1987
c_computed_signed_nat(void)
1988
{
1989
	    skip_term(lex_ord);
1990
	o_computed_signed_nat(
1991
	      read_exp();
1992
	      skip_term(lex_crd)
1993
	     )
1994
	    return;
1995
}
1996
 
1997
void
1998
c_make_signed_nat(void)
1999
{
2000
	    skip_term(lex_ord);
2001
	o_make_signed_nat(
2002
	      read_tdfbool();
2003
	      skip_term(lex_comma),
2004
	      read_tdfint();
2005
	      skip_term(lex_crd)
2006
	     )
2007
	    return;
2008
}
2009
 
2010
void
2011
c_snat_from_nat(void)
2012
{
2013
	    skip_term(lex_ord);
2014
	o_snat_from_nat(
2015
	      read_bool();
2016
	      skip_term(lex_comma),
2017
	      read_nat();
2018
	      skip_term(lex_crd)
2019
	     )
2020
	    return;
2021
}
2022
 
2023
void
2024
c_add_modes(void)
2025
{
2026
	    skip_term(lex_ord);
2027
	o_add_modes(
2028
	      read_transfer_mode();
2029
	      skip_term(lex_comma),
2030
	      read_transfer_mode();
2031
	      skip_term(lex_crd)
2032
	     )
2033
	    return;
2034
}
2035
 
2036
void
2037
c_overlap(void)
2038
{
2039
	    o_overlap;
2040
	    return;
2041
}
2042
 
2043
void
2044
c_standard_transfer_mode(void)
2045
{
2046
	    o_standard_transfer_mode;
2047
	    return;
2048
}
2049
 
2050
void
2051
c_trap_on_nil(void)
2052
{
2053
	    o_trap_on_nil;
2054
	    return;
2055
}
2056
 
2057
void
2058
c_volatile(void)
2059
{
2060
	    o_volatile;
2061
	    return;
2062
}
2063
 
2064
void
2065
c_complete(void)
2066
{
2067
	    o_complete;
2068
	    return;
2069
}
2070
 
2071
void
2072
c_var_limits(void)
2073
{
2074
	    skip_term(lex_ord);
2075
	o_var_limits(
2076
	      read_signed_nat();
2077
	      skip_term(lex_comma),
2078
	      read_signed_nat();
2079
	      skip_term(lex_crd)
2080
	     )
2081
	    return;
2082
}
2083
 
2084
void
2085
c_var_width(void)
2086
{
2087
	    skip_term(lex_ord);
2088
	o_var_width(
2089
	      read_bool();
2090
	      skip_term(lex_comma),
2091
	      read_nat();
2092
	      skip_term(lex_crd)
2093
	     )
2094
	    return;
2095
}