[project @ 1996-01-08 20:28:12 by partain]
[ghc.git] / ghc / compiler / yaccParser / hpragma.c
1
2
3 #include "hspincl.h"
4 #include "yaccParser/hpragma.h"
5
6 Thpragma thpragma(t)
7 hpragma t;
8 {
9 return(t -> tag);
10 }
11
12
13 /************** no_pragma ******************/
14
15 hpragma mkno_pragma()
16 {
17 register struct Sno_pragma *pp =
18 (struct Sno_pragma *) malloc(sizeof(struct Sno_pragma));
19 pp -> tag = no_pragma;
20 return((hpragma)pp);
21 }
22
23 /************** idata_pragma ******************/
24
25 hpragma mkidata_pragma(PPgprag_data_constrs, PPgprag_data_specs)
26 list PPgprag_data_constrs;
27 list PPgprag_data_specs;
28 {
29 register struct Sidata_pragma *pp =
30 (struct Sidata_pragma *) malloc(sizeof(struct Sidata_pragma));
31 pp -> tag = idata_pragma;
32 pp -> Xgprag_data_constrs = PPgprag_data_constrs;
33 pp -> Xgprag_data_specs = PPgprag_data_specs;
34 return((hpragma)pp);
35 }
36
37 list *Rgprag_data_constrs(t)
38 struct Sidata_pragma *t;
39 {
40 #ifdef UGEN_DEBUG
41 if(t -> tag != idata_pragma)
42 fprintf(stderr,"gprag_data_constrs: illegal selection; was %d\n", t -> tag);
43 #endif /* UGEN_DEBUG */
44 return(& t -> Xgprag_data_constrs);
45 }
46
47 list *Rgprag_data_specs(t)
48 struct Sidata_pragma *t;
49 {
50 #ifdef UGEN_DEBUG
51 if(t -> tag != idata_pragma)
52 fprintf(stderr,"gprag_data_specs: illegal selection; was %d\n", t -> tag);
53 #endif /* UGEN_DEBUG */
54 return(& t -> Xgprag_data_specs);
55 }
56
57 /************** itype_pragma ******************/
58
59 hpragma mkitype_pragma()
60 {
61 register struct Sitype_pragma *pp =
62 (struct Sitype_pragma *) malloc(sizeof(struct Sitype_pragma));
63 pp -> tag = itype_pragma;
64 return((hpragma)pp);
65 }
66
67 /************** iclas_pragma ******************/
68
69 hpragma mkiclas_pragma(PPgprag_clas)
70 list PPgprag_clas;
71 {
72 register struct Siclas_pragma *pp =
73 (struct Siclas_pragma *) malloc(sizeof(struct Siclas_pragma));
74 pp -> tag = iclas_pragma;
75 pp -> Xgprag_clas = PPgprag_clas;
76 return((hpragma)pp);
77 }
78
79 list *Rgprag_clas(t)
80 struct Siclas_pragma *t;
81 {
82 #ifdef UGEN_DEBUG
83 if(t -> tag != iclas_pragma)
84 fprintf(stderr,"gprag_clas: illegal selection; was %d\n", t -> tag);
85 #endif /* UGEN_DEBUG */
86 return(& t -> Xgprag_clas);
87 }
88
89 /************** iclasop_pragma ******************/
90
91 hpragma mkiclasop_pragma(PPgprag_dsel, PPgprag_defm)
92 hpragma PPgprag_dsel;
93 hpragma PPgprag_defm;
94 {
95 register struct Siclasop_pragma *pp =
96 (struct Siclasop_pragma *) malloc(sizeof(struct Siclasop_pragma));
97 pp -> tag = iclasop_pragma;
98 pp -> Xgprag_dsel = PPgprag_dsel;
99 pp -> Xgprag_defm = PPgprag_defm;
100 return((hpragma)pp);
101 }
102
103 hpragma *Rgprag_dsel(t)
104 struct Siclasop_pragma *t;
105 {
106 #ifdef UGEN_DEBUG
107 if(t -> tag != iclasop_pragma)
108 fprintf(stderr,"gprag_dsel: illegal selection; was %d\n", t -> tag);
109 #endif /* UGEN_DEBUG */
110 return(& t -> Xgprag_dsel);
111 }
112
113 hpragma *Rgprag_defm(t)
114 struct Siclasop_pragma *t;
115 {
116 #ifdef UGEN_DEBUG
117 if(t -> tag != iclasop_pragma)
118 fprintf(stderr,"gprag_defm: illegal selection; was %d\n", t -> tag);
119 #endif /* UGEN_DEBUG */
120 return(& t -> Xgprag_defm);
121 }
122
123 /************** iinst_simpl_pragma ******************/
124
125 hpragma mkiinst_simpl_pragma(PPgprag_imod_simpl, PPgprag_dfun_simpl)
126 stringId PPgprag_imod_simpl;
127 hpragma PPgprag_dfun_simpl;
128 {
129 register struct Siinst_simpl_pragma *pp =
130 (struct Siinst_simpl_pragma *) malloc(sizeof(struct Siinst_simpl_pragma));
131 pp -> tag = iinst_simpl_pragma;
132 pp -> Xgprag_imod_simpl = PPgprag_imod_simpl;
133 pp -> Xgprag_dfun_simpl = PPgprag_dfun_simpl;
134 return((hpragma)pp);
135 }
136
137 stringId *Rgprag_imod_simpl(t)
138 struct Siinst_simpl_pragma *t;
139 {
140 #ifdef UGEN_DEBUG
141 if(t -> tag != iinst_simpl_pragma)
142 fprintf(stderr,"gprag_imod_simpl: illegal selection; was %d\n", t -> tag);
143 #endif /* UGEN_DEBUG */
144 return(& t -> Xgprag_imod_simpl);
145 }
146
147 hpragma *Rgprag_dfun_simpl(t)
148 struct Siinst_simpl_pragma *t;
149 {
150 #ifdef UGEN_DEBUG
151 if(t -> tag != iinst_simpl_pragma)
152 fprintf(stderr,"gprag_dfun_simpl: illegal selection; was %d\n", t -> tag);
153 #endif /* UGEN_DEBUG */
154 return(& t -> Xgprag_dfun_simpl);
155 }
156
157 /************** iinst_const_pragma ******************/
158
159 hpragma mkiinst_const_pragma(PPgprag_imod_const, PPgprag_dfun_const, PPgprag_constms)
160 stringId PPgprag_imod_const;
161 hpragma PPgprag_dfun_const;
162 list PPgprag_constms;
163 {
164 register struct Siinst_const_pragma *pp =
165 (struct Siinst_const_pragma *) malloc(sizeof(struct Siinst_const_pragma));
166 pp -> tag = iinst_const_pragma;
167 pp -> Xgprag_imod_const = PPgprag_imod_const;
168 pp -> Xgprag_dfun_const = PPgprag_dfun_const;
169 pp -> Xgprag_constms = PPgprag_constms;
170 return((hpragma)pp);
171 }
172
173 stringId *Rgprag_imod_const(t)
174 struct Siinst_const_pragma *t;
175 {
176 #ifdef UGEN_DEBUG
177 if(t -> tag != iinst_const_pragma)
178 fprintf(stderr,"gprag_imod_const: illegal selection; was %d\n", t -> tag);
179 #endif /* UGEN_DEBUG */
180 return(& t -> Xgprag_imod_const);
181 }
182
183 hpragma *Rgprag_dfun_const(t)
184 struct Siinst_const_pragma *t;
185 {
186 #ifdef UGEN_DEBUG
187 if(t -> tag != iinst_const_pragma)
188 fprintf(stderr,"gprag_dfun_const: illegal selection; was %d\n", t -> tag);
189 #endif /* UGEN_DEBUG */
190 return(& t -> Xgprag_dfun_const);
191 }
192
193 list *Rgprag_constms(t)
194 struct Siinst_const_pragma *t;
195 {
196 #ifdef UGEN_DEBUG
197 if(t -> tag != iinst_const_pragma)
198 fprintf(stderr,"gprag_constms: illegal selection; was %d\n", t -> tag);
199 #endif /* UGEN_DEBUG */
200 return(& t -> Xgprag_constms);
201 }
202
203 /************** iinst_spec_pragma ******************/
204
205 hpragma mkiinst_spec_pragma(PPgprag_imod_spec, PPgprag_dfun_spec, PPgprag_inst_specs)
206 stringId PPgprag_imod_spec;
207 hpragma PPgprag_dfun_spec;
208 list PPgprag_inst_specs;
209 {
210 register struct Siinst_spec_pragma *pp =
211 (struct Siinst_spec_pragma *) malloc(sizeof(struct Siinst_spec_pragma));
212 pp -> tag = iinst_spec_pragma;
213 pp -> Xgprag_imod_spec = PPgprag_imod_spec;
214 pp -> Xgprag_dfun_spec = PPgprag_dfun_spec;
215 pp -> Xgprag_inst_specs = PPgprag_inst_specs;
216 return((hpragma)pp);
217 }
218
219 stringId *Rgprag_imod_spec(t)
220 struct Siinst_spec_pragma *t;
221 {
222 #ifdef UGEN_DEBUG
223 if(t -> tag != iinst_spec_pragma)
224 fprintf(stderr,"gprag_imod_spec: illegal selection; was %d\n", t -> tag);
225 #endif /* UGEN_DEBUG */
226 return(& t -> Xgprag_imod_spec);
227 }
228
229 hpragma *Rgprag_dfun_spec(t)
230 struct Siinst_spec_pragma *t;
231 {
232 #ifdef UGEN_DEBUG
233 if(t -> tag != iinst_spec_pragma)
234 fprintf(stderr,"gprag_dfun_spec: illegal selection; was %d\n", t -> tag);
235 #endif /* UGEN_DEBUG */
236 return(& t -> Xgprag_dfun_spec);
237 }
238
239 list *Rgprag_inst_specs(t)
240 struct Siinst_spec_pragma *t;
241 {
242 #ifdef UGEN_DEBUG
243 if(t -> tag != iinst_spec_pragma)
244 fprintf(stderr,"gprag_inst_specs: illegal selection; was %d\n", t -> tag);
245 #endif /* UGEN_DEBUG */
246 return(& t -> Xgprag_inst_specs);
247 }
248
249 /************** igen_pragma ******************/
250
251 hpragma mkigen_pragma(PPgprag_arity, PPgprag_update, PPgprag_deforest, PPgprag_strictness, PPgprag_unfolding, PPgprag_specs)
252 hpragma PPgprag_arity;
253 hpragma PPgprag_update;
254 hpragma PPgprag_deforest;
255 hpragma PPgprag_strictness;
256 hpragma PPgprag_unfolding;
257 list PPgprag_specs;
258 {
259 register struct Sigen_pragma *pp =
260 (struct Sigen_pragma *) malloc(sizeof(struct Sigen_pragma));
261 pp -> tag = igen_pragma;
262 pp -> Xgprag_arity = PPgprag_arity;
263 pp -> Xgprag_update = PPgprag_update;
264 pp -> Xgprag_deforest = PPgprag_deforest;
265 pp -> Xgprag_strictness = PPgprag_strictness;
266 pp -> Xgprag_unfolding = PPgprag_unfolding;
267 pp -> Xgprag_specs = PPgprag_specs;
268 return((hpragma)pp);
269 }
270
271 hpragma *Rgprag_arity(t)
272 struct Sigen_pragma *t;
273 {
274 #ifdef UGEN_DEBUG
275 if(t -> tag != igen_pragma)
276 fprintf(stderr,"gprag_arity: illegal selection; was %d\n", t -> tag);
277 #endif /* UGEN_DEBUG */
278 return(& t -> Xgprag_arity);
279 }
280
281 hpragma *Rgprag_update(t)
282 struct Sigen_pragma *t;
283 {
284 #ifdef UGEN_DEBUG
285 if(t -> tag != igen_pragma)
286 fprintf(stderr,"gprag_update: illegal selection; was %d\n", t -> tag);
287 #endif /* UGEN_DEBUG */
288 return(& t -> Xgprag_update);
289 }
290
291 hpragma *Rgprag_deforest(t)
292 struct Sigen_pragma *t;
293 {
294 #ifdef UGEN_DEBUG
295 if(t -> tag != igen_pragma)
296 fprintf(stderr,"gprag_deforest: illegal selection; was %d\n", t -> tag);
297 #endif /* UGEN_DEBUG */
298 return(& t -> Xgprag_deforest);
299 }
300
301 hpragma *Rgprag_strictness(t)
302 struct Sigen_pragma *t;
303 {
304 #ifdef UGEN_DEBUG
305 if(t -> tag != igen_pragma)
306 fprintf(stderr,"gprag_strictness: illegal selection; was %d\n", t -> tag);
307 #endif /* UGEN_DEBUG */
308 return(& t -> Xgprag_strictness);
309 }
310
311 hpragma *Rgprag_unfolding(t)
312 struct Sigen_pragma *t;
313 {
314 #ifdef UGEN_DEBUG
315 if(t -> tag != igen_pragma)
316 fprintf(stderr,"gprag_unfolding: illegal selection; was %d\n", t -> tag);
317 #endif /* UGEN_DEBUG */
318 return(& t -> Xgprag_unfolding);
319 }
320
321 list *Rgprag_specs(t)
322 struct Sigen_pragma *t;
323 {
324 #ifdef UGEN_DEBUG
325 if(t -> tag != igen_pragma)
326 fprintf(stderr,"gprag_specs: illegal selection; was %d\n", t -> tag);
327 #endif /* UGEN_DEBUG */
328 return(& t -> Xgprag_specs);
329 }
330
331 /************** iarity_pragma ******************/
332
333 hpragma mkiarity_pragma(PPgprag_arity_val)
334 numId PPgprag_arity_val;
335 {
336 register struct Siarity_pragma *pp =
337 (struct Siarity_pragma *) malloc(sizeof(struct Siarity_pragma));
338 pp -> tag = iarity_pragma;
339 pp -> Xgprag_arity_val = PPgprag_arity_val;
340 return((hpragma)pp);
341 }
342
343 numId *Rgprag_arity_val(t)
344 struct Siarity_pragma *t;
345 {
346 #ifdef UGEN_DEBUG
347 if(t -> tag != iarity_pragma)
348 fprintf(stderr,"gprag_arity_val: illegal selection; was %d\n", t -> tag);
349 #endif /* UGEN_DEBUG */
350 return(& t -> Xgprag_arity_val);
351 }
352
353 /************** iupdate_pragma ******************/
354
355 hpragma mkiupdate_pragma(PPgprag_update_val)
356 stringId PPgprag_update_val;
357 {
358 register struct Siupdate_pragma *pp =
359 (struct Siupdate_pragma *) malloc(sizeof(struct Siupdate_pragma));
360 pp -> tag = iupdate_pragma;
361 pp -> Xgprag_update_val = PPgprag_update_val;
362 return((hpragma)pp);
363 }
364
365 stringId *Rgprag_update_val(t)
366 struct Siupdate_pragma *t;
367 {
368 #ifdef UGEN_DEBUG
369 if(t -> tag != iupdate_pragma)
370 fprintf(stderr,"gprag_update_val: illegal selection; was %d\n", t -> tag);
371 #endif /* UGEN_DEBUG */
372 return(& t -> Xgprag_update_val);
373 }
374
375 /************** ideforest_pragma ******************/
376
377 hpragma mkideforest_pragma()
378 {
379 register struct Sideforest_pragma *pp =
380 (struct Sideforest_pragma *) malloc(sizeof(struct Sideforest_pragma));
381 pp -> tag = ideforest_pragma;
382 return((hpragma)pp);
383 }
384
385 /************** istrictness_pragma ******************/
386
387 hpragma mkistrictness_pragma(PPgprag_strict_spec, PPgprag_strict_wrkr)
388 hstring PPgprag_strict_spec;
389 hpragma PPgprag_strict_wrkr;
390 {
391 register struct Sistrictness_pragma *pp =
392 (struct Sistrictness_pragma *) malloc(sizeof(struct Sistrictness_pragma));
393 pp -> tag = istrictness_pragma;
394 pp -> Xgprag_strict_spec = PPgprag_strict_spec;
395 pp -> Xgprag_strict_wrkr = PPgprag_strict_wrkr;
396 return((hpragma)pp);
397 }
398
399 hstring *Rgprag_strict_spec(t)
400 struct Sistrictness_pragma *t;
401 {
402 #ifdef UGEN_DEBUG
403 if(t -> tag != istrictness_pragma)
404 fprintf(stderr,"gprag_strict_spec: illegal selection; was %d\n", t -> tag);
405 #endif /* UGEN_DEBUG */
406 return(& t -> Xgprag_strict_spec);
407 }
408
409 hpragma *Rgprag_strict_wrkr(t)
410 struct Sistrictness_pragma *t;
411 {
412 #ifdef UGEN_DEBUG
413 if(t -> tag != istrictness_pragma)
414 fprintf(stderr,"gprag_strict_wrkr: illegal selection; was %d\n", t -> tag);
415 #endif /* UGEN_DEBUG */
416 return(& t -> Xgprag_strict_wrkr);
417 }
418
419 /************** imagic_unfolding_pragma ******************/
420
421 hpragma mkimagic_unfolding_pragma(PPgprag_magic_str)
422 stringId PPgprag_magic_str;
423 {
424 register struct Simagic_unfolding_pragma *pp =
425 (struct Simagic_unfolding_pragma *) malloc(sizeof(struct Simagic_unfolding_pragma));
426 pp -> tag = imagic_unfolding_pragma;
427 pp -> Xgprag_magic_str = PPgprag_magic_str;
428 return((hpragma)pp);
429 }
430
431 stringId *Rgprag_magic_str(t)
432 struct Simagic_unfolding_pragma *t;
433 {
434 #ifdef UGEN_DEBUG
435 if(t -> tag != imagic_unfolding_pragma)
436 fprintf(stderr,"gprag_magic_str: illegal selection; was %d\n", t -> tag);
437 #endif /* UGEN_DEBUG */
438 return(& t -> Xgprag_magic_str);
439 }
440
441 /************** iunfolding_pragma ******************/
442
443 hpragma mkiunfolding_pragma(PPgprag_unfold_guide, PPgprag_unfold_core)
444 hpragma PPgprag_unfold_guide;
445 coresyn PPgprag_unfold_core;
446 {
447 register struct Siunfolding_pragma *pp =
448 (struct Siunfolding_pragma *) malloc(sizeof(struct Siunfolding_pragma));
449 pp -> tag = iunfolding_pragma;
450 pp -> Xgprag_unfold_guide = PPgprag_unfold_guide;
451 pp -> Xgprag_unfold_core = PPgprag_unfold_core;
452 return((hpragma)pp);
453 }
454
455 hpragma *Rgprag_unfold_guide(t)
456 struct Siunfolding_pragma *t;
457 {
458 #ifdef UGEN_DEBUG
459 if(t -> tag != iunfolding_pragma)
460 fprintf(stderr,"gprag_unfold_guide: illegal selection; was %d\n", t -> tag);
461 #endif /* UGEN_DEBUG */
462 return(& t -> Xgprag_unfold_guide);
463 }
464
465 coresyn *Rgprag_unfold_core(t)
466 struct Siunfolding_pragma *t;
467 {
468 #ifdef UGEN_DEBUG
469 if(t -> tag != iunfolding_pragma)
470 fprintf(stderr,"gprag_unfold_core: illegal selection; was %d\n", t -> tag);
471 #endif /* UGEN_DEBUG */
472 return(& t -> Xgprag_unfold_core);
473 }
474
475 /************** iunfold_always ******************/
476
477 hpragma mkiunfold_always()
478 {
479 register struct Siunfold_always *pp =
480 (struct Siunfold_always *) malloc(sizeof(struct Siunfold_always));
481 pp -> tag = iunfold_always;
482 return((hpragma)pp);
483 }
484
485 /************** iunfold_if_args ******************/
486
487 hpragma mkiunfold_if_args(PPgprag_unfold_if_t_args, PPgprag_unfold_if_v_args, PPgprag_unfold_if_con_args, PPgprag_unfold_if_size)
488 numId PPgprag_unfold_if_t_args;
489 numId PPgprag_unfold_if_v_args;
490 stringId PPgprag_unfold_if_con_args;
491 numId PPgprag_unfold_if_size;
492 {
493 register struct Siunfold_if_args *pp =
494 (struct Siunfold_if_args *) malloc(sizeof(struct Siunfold_if_args));
495 pp -> tag = iunfold_if_args;
496 pp -> Xgprag_unfold_if_t_args = PPgprag_unfold_if_t_args;
497 pp -> Xgprag_unfold_if_v_args = PPgprag_unfold_if_v_args;
498 pp -> Xgprag_unfold_if_con_args = PPgprag_unfold_if_con_args;
499 pp -> Xgprag_unfold_if_size = PPgprag_unfold_if_size;
500 return((hpragma)pp);
501 }
502
503 numId *Rgprag_unfold_if_t_args(t)
504 struct Siunfold_if_args *t;
505 {
506 #ifdef UGEN_DEBUG
507 if(t -> tag != iunfold_if_args)
508 fprintf(stderr,"gprag_unfold_if_t_args: illegal selection; was %d\n", t -> tag);
509 #endif /* UGEN_DEBUG */
510 return(& t -> Xgprag_unfold_if_t_args);
511 }
512
513 numId *Rgprag_unfold_if_v_args(t)
514 struct Siunfold_if_args *t;
515 {
516 #ifdef UGEN_DEBUG
517 if(t -> tag != iunfold_if_args)
518 fprintf(stderr,"gprag_unfold_if_v_args: illegal selection; was %d\n", t -> tag);
519 #endif /* UGEN_DEBUG */
520 return(& t -> Xgprag_unfold_if_v_args);
521 }
522
523 stringId *Rgprag_unfold_if_con_args(t)
524 struct Siunfold_if_args *t;
525 {
526 #ifdef UGEN_DEBUG
527 if(t -> tag != iunfold_if_args)
528 fprintf(stderr,"gprag_unfold_if_con_args: illegal selection; was %d\n", t -> tag);
529 #endif /* UGEN_DEBUG */
530 return(& t -> Xgprag_unfold_if_con_args);
531 }
532
533 numId *Rgprag_unfold_if_size(t)
534 struct Siunfold_if_args *t;
535 {
536 #ifdef UGEN_DEBUG
537 if(t -> tag != iunfold_if_args)
538 fprintf(stderr,"gprag_unfold_if_size: illegal selection; was %d\n", t -> tag);
539 #endif /* UGEN_DEBUG */
540 return(& t -> Xgprag_unfold_if_size);
541 }
542
543 /************** iname_pragma_pr ******************/
544
545 hpragma mkiname_pragma_pr(PPgprag_name_pr1, PPgprag_name_pr2)
546 unkId PPgprag_name_pr1;
547 hpragma PPgprag_name_pr2;
548 {
549 register struct Siname_pragma_pr *pp =
550 (struct Siname_pragma_pr *) malloc(sizeof(struct Siname_pragma_pr));
551 pp -> tag = iname_pragma_pr;
552 pp -> Xgprag_name_pr1 = PPgprag_name_pr1;
553 pp -> Xgprag_name_pr2 = PPgprag_name_pr2;
554 return((hpragma)pp);
555 }
556
557 unkId *Rgprag_name_pr1(t)
558 struct Siname_pragma_pr *t;
559 {
560 #ifdef UGEN_DEBUG
561 if(t -> tag != iname_pragma_pr)
562 fprintf(stderr,"gprag_name_pr1: illegal selection; was %d\n", t -> tag);
563 #endif /* UGEN_DEBUG */
564 return(& t -> Xgprag_name_pr1);
565 }
566
567 hpragma *Rgprag_name_pr2(t)
568 struct Siname_pragma_pr *t;
569 {
570 #ifdef UGEN_DEBUG
571 if(t -> tag != iname_pragma_pr)
572 fprintf(stderr,"gprag_name_pr2: illegal selection; was %d\n", t -> tag);
573 #endif /* UGEN_DEBUG */
574 return(& t -> Xgprag_name_pr2);
575 }
576
577 /************** itype_pragma_pr ******************/
578
579 hpragma mkitype_pragma_pr(PPgprag_type_pr1, PPgprag_type_pr2, PPgprag_type_pr3)
580 list PPgprag_type_pr1;
581 numId PPgprag_type_pr2;
582 hpragma PPgprag_type_pr3;
583 {
584 register struct Sitype_pragma_pr *pp =
585 (struct Sitype_pragma_pr *) malloc(sizeof(struct Sitype_pragma_pr));
586 pp -> tag = itype_pragma_pr;
587 pp -> Xgprag_type_pr1 = PPgprag_type_pr1;
588 pp -> Xgprag_type_pr2 = PPgprag_type_pr2;
589 pp -> Xgprag_type_pr3 = PPgprag_type_pr3;
590 return((hpragma)pp);
591 }
592
593 list *Rgprag_type_pr1(t)
594 struct Sitype_pragma_pr *t;
595 {
596 #ifdef UGEN_DEBUG
597 if(t -> tag != itype_pragma_pr)
598 fprintf(stderr,"gprag_type_pr1: illegal selection; was %d\n", t -> tag);
599 #endif /* UGEN_DEBUG */
600 return(& t -> Xgprag_type_pr1);
601 }
602
603 numId *Rgprag_type_pr2(t)
604 struct Sitype_pragma_pr *t;
605 {
606 #ifdef UGEN_DEBUG
607 if(t -> tag != itype_pragma_pr)
608 fprintf(stderr,"gprag_type_pr2: illegal selection; was %d\n", t -> tag);
609 #endif /* UGEN_DEBUG */
610 return(& t -> Xgprag_type_pr2);
611 }
612
613 hpragma *Rgprag_type_pr3(t)
614 struct Sitype_pragma_pr *t;
615 {
616 #ifdef UGEN_DEBUG
617 if(t -> tag != itype_pragma_pr)
618 fprintf(stderr,"gprag_type_pr3: illegal selection; was %d\n", t -> tag);
619 #endif /* UGEN_DEBUG */
620 return(& t -> Xgprag_type_pr3);
621 }
622
623 /************** iinst_pragma_3s ******************/
624
625 hpragma mkiinst_pragma_3s(PPgprag_inst_pt1, PPgprag_inst_pt2, PPgprag_inst_pt3, PPgprag_inst_pt4)
626 list PPgprag_inst_pt1;
627 numId PPgprag_inst_pt2;
628 hpragma PPgprag_inst_pt3;
629 list PPgprag_inst_pt4;
630 {
631 register struct Siinst_pragma_3s *pp =
632 (struct Siinst_pragma_3s *) malloc(sizeof(struct Siinst_pragma_3s));
633 pp -> tag = iinst_pragma_3s;
634 pp -> Xgprag_inst_pt1 = PPgprag_inst_pt1;
635 pp -> Xgprag_inst_pt2 = PPgprag_inst_pt2;
636 pp -> Xgprag_inst_pt3 = PPgprag_inst_pt3;
637 pp -> Xgprag_inst_pt4 = PPgprag_inst_pt4;
638 return((hpragma)pp);
639 }
640
641 list *Rgprag_inst_pt1(t)
642 struct Siinst_pragma_3s *t;
643 {
644 #ifdef UGEN_DEBUG
645 if(t -> tag != iinst_pragma_3s)
646 fprintf(stderr,"gprag_inst_pt1: illegal selection; was %d\n", t -> tag);
647 #endif /* UGEN_DEBUG */
648 return(& t -> Xgprag_inst_pt1);
649 }
650
651 numId *Rgprag_inst_pt2(t)
652 struct Siinst_pragma_3s *t;
653 {
654 #ifdef UGEN_DEBUG
655 if(t -> tag != iinst_pragma_3s)
656 fprintf(stderr,"gprag_inst_pt2: illegal selection; was %d\n", t -> tag);
657 #endif /* UGEN_DEBUG */
658 return(& t -> Xgprag_inst_pt2);
659 }
660
661 hpragma *Rgprag_inst_pt3(t)
662 struct Siinst_pragma_3s *t;
663 {
664 #ifdef UGEN_DEBUG
665 if(t -> tag != iinst_pragma_3s)
666 fprintf(stderr,"gprag_inst_pt3: illegal selection; was %d\n", t -> tag);
667 #endif /* UGEN_DEBUG */
668 return(& t -> Xgprag_inst_pt3);
669 }
670
671 list *Rgprag_inst_pt4(t)
672 struct Siinst_pragma_3s *t;
673 {
674 #ifdef UGEN_DEBUG
675 if(t -> tag != iinst_pragma_3s)
676 fprintf(stderr,"gprag_inst_pt4: illegal selection; was %d\n", t -> tag);
677 #endif /* UGEN_DEBUG */
678 return(& t -> Xgprag_inst_pt4);
679 }
680
681 /************** idata_pragma_4s ******************/
682
683 hpragma mkidata_pragma_4s(PPgprag_data_spec)
684 list PPgprag_data_spec;
685 {
686 register struct Sidata_pragma_4s *pp =
687 (struct Sidata_pragma_4s *) malloc(sizeof(struct Sidata_pragma_4s));
688 pp -> tag = idata_pragma_4s;
689 pp -> Xgprag_data_spec = PPgprag_data_spec;
690 return((hpragma)pp);
691 }
692
693 list *Rgprag_data_spec(t)
694 struct Sidata_pragma_4s *t;
695 {
696 #ifdef UGEN_DEBUG
697 if(t -> tag != idata_pragma_4s)
698 fprintf(stderr,"gprag_data_spec: illegal selection; was %d\n", t -> tag);
699 #endif /* UGEN_DEBUG */
700 return(& t -> Xgprag_data_spec);
701 }