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 /************** 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(void)
 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(void)
 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 }