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(void)
  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(void)
  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 /************** igen_pragma ******************/
 204
 205 hpragma mkigen_pragma(PPgprag_arity, PPgprag_update, PPgprag_deforest, PPgprag_strictness, PPgprag_unfolding, PPgprag_specs)
 206  hpragma PPgprag_arity;
 207  hpragma PPgprag_update;
 208  hpragma PPgprag_deforest;
 209  hpragma PPgprag_strictness;
 210  hpragma PPgprag_unfolding;
 211  list PPgprag_specs;
 212 {
 213         register struct Sigen_pragma *pp =
 214                 (struct Sigen_pragma *) malloc(sizeof(struct Sigen_pragma));
 215         pp -> tag = igen_pragma;
 216         pp -> Xgprag_arity = PPgprag_arity;
 217         pp -> Xgprag_update = PPgprag_update;
 218         pp -> Xgprag_deforest = PPgprag_deforest;
 219         pp -> Xgprag_strictness = PPgprag_strictness;
 220         pp -> Xgprag_unfolding = PPgprag_unfolding;
 221         pp -> Xgprag_specs = PPgprag_specs;
 222         return((hpragma)pp);
 223 }
 224
 225 hpragma *Rgprag_arity(t)
 226  struct Sigen_pragma *t;
 227 {
 228 #ifdef UGEN_DEBUG
 229         if(t -> tag != igen_pragma)
 230                 fprintf(stderr,"gprag_arity: illegal selection; was %d\n", t -> tag);
 231 #endif /* UGEN_DEBUG */
 232         return(& t -> Xgprag_arity);
 233 }
 234
 235 hpragma *Rgprag_update(t)
 236  struct Sigen_pragma *t;
 237 {
 238 #ifdef UGEN_DEBUG
 239         if(t -> tag != igen_pragma)
 240                 fprintf(stderr,"gprag_update: illegal selection; was %d\n", t -> tag);
 241 #endif /* UGEN_DEBUG */
 242         return(& t -> Xgprag_update);
 243 }
 244
 245 hpragma *Rgprag_deforest(t)
 246  struct Sigen_pragma *t;
 247 {
 248 #ifdef UGEN_DEBUG
 249         if(t -> tag != igen_pragma)
 250                 fprintf(stderr,"gprag_deforest: illegal selection; was %d\n", t -> tag);
 251 #endif /* UGEN_DEBUG */
 252         return(& t -> Xgprag_deforest);
 253 }
 254
 255 hpragma *Rgprag_strictness(t)
 256  struct Sigen_pragma *t;
 257 {
 258 #ifdef UGEN_DEBUG
 259         if(t -> tag != igen_pragma)
 260                 fprintf(stderr,"gprag_strictness: illegal selection; was %d\n", t -> tag);
 261 #endif /* UGEN_DEBUG */
 262         return(& t -> Xgprag_strictness);
 263 }
 264
 265 hpragma *Rgprag_unfolding(t)
 266  struct Sigen_pragma *t;
 267 {
 268 #ifdef UGEN_DEBUG
 269         if(t -> tag != igen_pragma)
 270                 fprintf(stderr,"gprag_unfolding: illegal selection; was %d\n", t -> tag);
 271 #endif /* UGEN_DEBUG */
 272         return(& t -> Xgprag_unfolding);
 273 }
 274
 275 list *Rgprag_specs(t)
 276  struct Sigen_pragma *t;
 277 {
 278 #ifdef UGEN_DEBUG
 279         if(t -> tag != igen_pragma)
 280                 fprintf(stderr,"gprag_specs: illegal selection; was %d\n", t -> tag);
 281 #endif /* UGEN_DEBUG */
 282         return(& t -> Xgprag_specs);
 283 }
 284
 285 /************** iarity_pragma ******************/
 286
 287 hpragma mkiarity_pragma(PPgprag_arity_val)
 288  numId PPgprag_arity_val;
 289 {
 290         register struct Siarity_pragma *pp =
 291                 (struct Siarity_pragma *) malloc(sizeof(struct Siarity_pragma));
 292         pp -> tag = iarity_pragma;
 293         pp -> Xgprag_arity_val = PPgprag_arity_val;
 294         return((hpragma)pp);
 295 }
 296
 297 numId *Rgprag_arity_val(t)
 298  struct Siarity_pragma *t;
 299 {
 300 #ifdef UGEN_DEBUG
 301         if(t -> tag != iarity_pragma)
 302                 fprintf(stderr,"gprag_arity_val: illegal selection; was %d\n", t -> tag);
 303 #endif /* UGEN_DEBUG */
 304         return(& t -> Xgprag_arity_val);
 305 }
 306
 307 /************** iupdate_pragma ******************/
 308
 309 hpragma mkiupdate_pragma(PPgprag_update_val)
 310  stringId PPgprag_update_val;
 311 {
 312         register struct Siupdate_pragma *pp =
 313                 (struct Siupdate_pragma *) malloc(sizeof(struct Siupdate_pragma));
 314         pp -> tag = iupdate_pragma;
 315         pp -> Xgprag_update_val = PPgprag_update_val;
 316         return((hpragma)pp);
 317 }
 318
 319 stringId *Rgprag_update_val(t)
 320  struct Siupdate_pragma *t;
 321 {
 322 #ifdef UGEN_DEBUG
 323         if(t -> tag != iupdate_pragma)
 324                 fprintf(stderr,"gprag_update_val: illegal selection; was %d\n", t -> tag);
 325 #endif /* UGEN_DEBUG */
 326         return(& t -> Xgprag_update_val);
 327 }
 328
 329 /************** ideforest_pragma ******************/
 330
 331 hpragma mkideforest_pragma(void)
 332 {
 333         register struct Sideforest_pragma *pp =
 334                 (struct Sideforest_pragma *) malloc(sizeof(struct Sideforest_pragma));
 335         pp -> tag = ideforest_pragma;
 336         return((hpragma)pp);
 337 }
 338
 339 /************** istrictness_pragma ******************/
 340
 341 hpragma mkistrictness_pragma(PPgprag_strict_spec, PPgprag_strict_wrkr)
 342  hstring PPgprag_strict_spec;
 343  hpragma PPgprag_strict_wrkr;
 344 {
 345         register struct Sistrictness_pragma *pp =
 346                 (struct Sistrictness_pragma *) malloc(sizeof(struct Sistrictness_pragma));
 347         pp -> tag = istrictness_pragma;
 348         pp -> Xgprag_strict_spec = PPgprag_strict_spec;
 349         pp -> Xgprag_strict_wrkr = PPgprag_strict_wrkr;
 350         return((hpragma)pp);
 351 }
 352
 353 hstring *Rgprag_strict_spec(t)
 354  struct Sistrictness_pragma *t;
 355 {
 356 #ifdef UGEN_DEBUG
 357         if(t -> tag != istrictness_pragma)
 358                 fprintf(stderr,"gprag_strict_spec: illegal selection; was %d\n", t -> tag);
 359 #endif /* UGEN_DEBUG */
 360         return(& t -> Xgprag_strict_spec);
 361 }
 362
 363 hpragma *Rgprag_strict_wrkr(t)
 364  struct Sistrictness_pragma *t;
 365 {
 366 #ifdef UGEN_DEBUG
 367         if(t -> tag != istrictness_pragma)
 368                 fprintf(stderr,"gprag_strict_wrkr: illegal selection; was %d\n", t -> tag);
 369 #endif /* UGEN_DEBUG */
 370         return(& t -> Xgprag_strict_wrkr);
 371 }
 372
 373 /************** imagic_unfolding_pragma ******************/
 374
 375 hpragma mkimagic_unfolding_pragma(PPgprag_magic_str)
 376  stringId PPgprag_magic_str;
 377 {
 378         register struct Simagic_unfolding_pragma *pp =
 379                 (struct Simagic_unfolding_pragma *) malloc(sizeof(struct Simagic_unfolding_pragma));
 380         pp -> tag = imagic_unfolding_pragma;
 381         pp -> Xgprag_magic_str = PPgprag_magic_str;
 382         return((hpragma)pp);
 383 }
 384
 385 stringId *Rgprag_magic_str(t)
 386  struct Simagic_unfolding_pragma *t;
 387 {
 388 #ifdef UGEN_DEBUG
 389         if(t -> tag != imagic_unfolding_pragma)
 390                 fprintf(stderr,"gprag_magic_str: illegal selection; was %d\n", t -> tag);
 391 #endif /* UGEN_DEBUG */
 392         return(& t -> Xgprag_magic_str);
 393 }
 394
 395 /************** iunfolding_pragma ******************/
 396
 397 hpragma mkiunfolding_pragma(PPgprag_unfold_guide, PPgprag_unfold_core)
 398  hpragma PPgprag_unfold_guide;
 399  coresyn PPgprag_unfold_core;
 400 {
 401         register struct Siunfolding_pragma *pp =
 402                 (struct Siunfolding_pragma *) malloc(sizeof(struct Siunfolding_pragma));
 403         pp -> tag = iunfolding_pragma;
 404         pp -> Xgprag_unfold_guide = PPgprag_unfold_guide;
 405         pp -> Xgprag_unfold_core = PPgprag_unfold_core;
 406         return((hpragma)pp);
 407 }
 408
 409 hpragma *Rgprag_unfold_guide(t)
 410  struct Siunfolding_pragma *t;
 411 {
 412 #ifdef UGEN_DEBUG
 413         if(t -> tag != iunfolding_pragma)
 414                 fprintf(stderr,"gprag_unfold_guide: illegal selection; was %d\n", t -> tag);
 415 #endif /* UGEN_DEBUG */
 416         return(& t -> Xgprag_unfold_guide);
 417 }
 418
 419 coresyn *Rgprag_unfold_core(t)
 420  struct Siunfolding_pragma *t;
 421 {
 422 #ifdef UGEN_DEBUG
 423         if(t -> tag != iunfolding_pragma)
 424                 fprintf(stderr,"gprag_unfold_core: illegal selection; was %d\n", t -> tag);
 425 #endif /* UGEN_DEBUG */
 426         return(& t -> Xgprag_unfold_core);
 427 }
 428
 429 /************** iunfold_always ******************/
 430
 431 hpragma mkiunfold_always(void)
 432 {
 433         register struct Siunfold_always *pp =
 434                 (struct Siunfold_always *) malloc(sizeof(struct Siunfold_always));
 435         pp -> tag = iunfold_always;
 436         return((hpragma)pp);
 437 }
 438
 439 /************** iunfold_if_args ******************/
 440
 441 hpragma mkiunfold_if_args(PPgprag_unfold_if_t_args, PPgprag_unfold_if_v_args, PPgprag_unfold_if_con_args, PPgprag_unfold_if_size)
 442  numId PPgprag_unfold_if_t_args;
 443  numId PPgprag_unfold_if_v_args;
 444  stringId PPgprag_unfold_if_con_args;
 445  numId PPgprag_unfold_if_size;
 446 {
 447         register struct Siunfold_if_args *pp =
 448                 (struct Siunfold_if_args *) malloc(sizeof(struct Siunfold_if_args));
 449         pp -> tag = iunfold_if_args;
 450         pp -> Xgprag_unfold_if_t_args = PPgprag_unfold_if_t_args;
 451         pp -> Xgprag_unfold_if_v_args = PPgprag_unfold_if_v_args;
 452         pp -> Xgprag_unfold_if_con_args = PPgprag_unfold_if_con_args;
 453         pp -> Xgprag_unfold_if_size = PPgprag_unfold_if_size;
 454         return((hpragma)pp);
 455 }
 456
 457 numId *Rgprag_unfold_if_t_args(t)
 458  struct Siunfold_if_args *t;
 459 {
 460 #ifdef UGEN_DEBUG
 461         if(t -> tag != iunfold_if_args)
 462                 fprintf(stderr,"gprag_unfold_if_t_args: illegal selection; was %d\n", t -> tag);
 463 #endif /* UGEN_DEBUG */
 464         return(& t -> Xgprag_unfold_if_t_args);
 465 }
 466
 467 numId *Rgprag_unfold_if_v_args(t)
 468  struct Siunfold_if_args *t;
 469 {
 470 #ifdef UGEN_DEBUG
 471         if(t -> tag != iunfold_if_args)
 472                 fprintf(stderr,"gprag_unfold_if_v_args: illegal selection; was %d\n", t -> tag);
 473 #endif /* UGEN_DEBUG */
 474         return(& t -> Xgprag_unfold_if_v_args);
 475 }
 476
 477 stringId *Rgprag_unfold_if_con_args(t)
 478  struct Siunfold_if_args *t;
 479 {
 480 #ifdef UGEN_DEBUG
 481         if(t -> tag != iunfold_if_args)
 482                 fprintf(stderr,"gprag_unfold_if_con_args: illegal selection; was %d\n", t -> tag);
 483 #endif /* UGEN_DEBUG */
 484         return(& t -> Xgprag_unfold_if_con_args);
 485 }
 486
 487 numId *Rgprag_unfold_if_size(t)
 488  struct Siunfold_if_args *t;
 489 {
 490 #ifdef UGEN_DEBUG
 491         if(t -> tag != iunfold_if_args)
 492                 fprintf(stderr,"gprag_unfold_if_size: illegal selection; was %d\n", t -> tag);
 493 #endif /* UGEN_DEBUG */
 494         return(& t -> Xgprag_unfold_if_size);
 495 }
 496
 497 /************** iname_pragma_pr ******************/
 498
 499 hpragma mkiname_pragma_pr(PPgprag_name_pr1, PPgprag_name_pr2)
 500  unkId PPgprag_name_pr1;
 501  hpragma PPgprag_name_pr2;
 502 {
 503         register struct Siname_pragma_pr *pp =
 504                 (struct Siname_pragma_pr *) malloc(sizeof(struct Siname_pragma_pr));
 505         pp -> tag = iname_pragma_pr;
 506         pp -> Xgprag_name_pr1 = PPgprag_name_pr1;
 507         pp -> Xgprag_name_pr2 = PPgprag_name_pr2;
 508         return((hpragma)pp);
 509 }
 510
 511 unkId *Rgprag_name_pr1(t)
 512  struct Siname_pragma_pr *t;
 513 {
 514 #ifdef UGEN_DEBUG
 515         if(t -> tag != iname_pragma_pr)
 516                 fprintf(stderr,"gprag_name_pr1: illegal selection; was %d\n", t -> tag);
 517 #endif /* UGEN_DEBUG */
 518         return(& t -> Xgprag_name_pr1);
 519 }
 520
 521 hpragma *Rgprag_name_pr2(t)
 522  struct Siname_pragma_pr *t;
 523 {
 524 #ifdef UGEN_DEBUG
 525         if(t -> tag != iname_pragma_pr)
 526                 fprintf(stderr,"gprag_name_pr2: illegal selection; was %d\n", t -> tag);
 527 #endif /* UGEN_DEBUG */
 528         return(& t -> Xgprag_name_pr2);
 529 }
 530
 531 /************** itype_pragma_pr ******************/
 532
 533 hpragma mkitype_pragma_pr(PPgprag_type_pr1, PPgprag_type_pr2, PPgprag_type_pr3)
 534  list PPgprag_type_pr1;
 535  numId PPgprag_type_pr2;
 536  hpragma PPgprag_type_pr3;
 537 {
 538         register struct Sitype_pragma_pr *pp =
 539                 (struct Sitype_pragma_pr *) malloc(sizeof(struct Sitype_pragma_pr));
 540         pp -> tag = itype_pragma_pr;
 541         pp -> Xgprag_type_pr1 = PPgprag_type_pr1;
 542         pp -> Xgprag_type_pr2 = PPgprag_type_pr2;
 543         pp -> Xgprag_type_pr3 = PPgprag_type_pr3;
 544         return((hpragma)pp);
 545 }
 546
 547 list *Rgprag_type_pr1(t)
 548  struct Sitype_pragma_pr *t;
 549 {
 550 #ifdef UGEN_DEBUG
 551         if(t -> tag != itype_pragma_pr)
 552                 fprintf(stderr,"gprag_type_pr1: illegal selection; was %d\n", t -> tag);
 553 #endif /* UGEN_DEBUG */
 554         return(& t -> Xgprag_type_pr1);
 555 }
 556
 557 numId *Rgprag_type_pr2(t)
 558  struct Sitype_pragma_pr *t;
 559 {
 560 #ifdef UGEN_DEBUG
 561         if(t -> tag != itype_pragma_pr)
 562                 fprintf(stderr,"gprag_type_pr2: illegal selection; was %d\n", t -> tag);
 563 #endif /* UGEN_DEBUG */
 564         return(& t -> Xgprag_type_pr2);
 565 }
 566
 567 hpragma *Rgprag_type_pr3(t)
 568  struct Sitype_pragma_pr *t;
 569 {
 570 #ifdef UGEN_DEBUG
 571         if(t -> tag != itype_pragma_pr)
 572                 fprintf(stderr,"gprag_type_pr3: illegal selection; was %d\n", t -> tag);
 573 #endif /* UGEN_DEBUG */
 574         return(& t -> Xgprag_type_pr3);
 575 }
 576
 577 /************** idata_pragma_4s ******************/
 578
 579 hpragma mkidata_pragma_4s(PPgprag_data_spec)
 580  list PPgprag_data_spec;
 581 {
 582         register struct Sidata_pragma_4s *pp =
 583                 (struct Sidata_pragma_4s *) malloc(sizeof(struct Sidata_pragma_4s));
 584         pp -> tag = idata_pragma_4s;
 585         pp -> Xgprag_data_spec = PPgprag_data_spec;
 586         return((hpragma)pp);
 587 }
 588
 589 list *Rgprag_data_spec(t)
 590  struct Sidata_pragma_4s *t;
 591 {
 592 #ifdef UGEN_DEBUG
 593         if(t -> tag != idata_pragma_4s)
 594                 fprintf(stderr,"gprag_data_spec: illegal selection; was %d\n", t -> tag);
 595 #endif /* UGEN_DEBUG */
 596         return(& t -> Xgprag_data_spec);
 597 }