ghc/compiler/yaccParser/coresyn.c

   1
   2
   3 #include "hspincl.h"
   4 #include "yaccParser/coresyn.h"
   5
   6 Tcoresyn tcoresyn(t)
   7  coresyn t;
   8 {
   9         return(t -> tag);
  10 }
  11
  12
  13 /************** cobinder ******************/
  14
  15 coresyn mkcobinder(PPgcobinder_v, PPgcobinder_ty)
  16  unkId PPgcobinder_v;
  17  ttype PPgcobinder_ty;
  18 {
  19         register struct Scobinder *pp =
  20                 (struct Scobinder *) malloc(sizeof(struct Scobinder));
  21         pp -> tag = cobinder;
  22         pp -> Xgcobinder_v = PPgcobinder_v;
  23         pp -> Xgcobinder_ty = PPgcobinder_ty;
  24         return((coresyn)pp);
  25 }
  26
  27 unkId *Rgcobinder_v(t)
  28  struct Scobinder *t;
  29 {
  30 #ifdef UGEN_DEBUG
  31         if(t -> tag != cobinder)
  32                 fprintf(stderr,"gcobinder_v: illegal selection; was %d\n", t -> tag);
  33 #endif /* UGEN_DEBUG */
  34         return(& t -> Xgcobinder_v);
  35 }
  36
  37 ttype *Rgcobinder_ty(t)
  38  struct Scobinder *t;
  39 {
  40 #ifdef UGEN_DEBUG
  41         if(t -> tag != cobinder)
  42                 fprintf(stderr,"gcobinder_ty: illegal selection; was %d\n", t -> tag);
  43 #endif /* UGEN_DEBUG */
  44         return(& t -> Xgcobinder_ty);
  45 }
  46
  47 /************** colit ******************/
  48
  49 coresyn mkcolit(PPgcolit)
  50  literal PPgcolit;
  51 {
  52         register struct Scolit *pp =
  53                 (struct Scolit *) malloc(sizeof(struct Scolit));
  54         pp -> tag = colit;
  55         pp -> Xgcolit = PPgcolit;
  56         return((coresyn)pp);
  57 }
  58
  59 literal *Rgcolit(t)
  60  struct Scolit *t;
  61 {
  62 #ifdef UGEN_DEBUG
  63         if(t -> tag != colit)
  64                 fprintf(stderr,"gcolit: illegal selection; was %d\n", t -> tag);
  65 #endif /* UGEN_DEBUG */
  66         return(& t -> Xgcolit);
  67 }
  68
  69 /************** colocal ******************/
  70
  71 coresyn mkcolocal(PPgcolocal_v)
  72  coresyn PPgcolocal_v;
  73 {
  74         register struct Scolocal *pp =
  75                 (struct Scolocal *) malloc(sizeof(struct Scolocal));
  76         pp -> tag = colocal;
  77         pp -> Xgcolocal_v = PPgcolocal_v;
  78         return((coresyn)pp);
  79 }
  80
  81 coresyn *Rgcolocal_v(t)
  82  struct Scolocal *t;
  83 {
  84 #ifdef UGEN_DEBUG
  85         if(t -> tag != colocal)
  86                 fprintf(stderr,"gcolocal_v: illegal selection; was %d\n", t -> tag);
  87 #endif /* UGEN_DEBUG */
  88         return(& t -> Xgcolocal_v);
  89 }
  90
  91 /************** cononrec ******************/
  92
  93 coresyn mkcononrec(PPgcononrec_b, PPgcononrec_rhs)
  94  coresyn PPgcononrec_b;
  95  coresyn PPgcononrec_rhs;
  96 {
  97         register struct Scononrec *pp =
  98                 (struct Scononrec *) malloc(sizeof(struct Scononrec));
  99         pp -> tag = cononrec;
 100         pp -> Xgcononrec_b = PPgcononrec_b;
 101         pp -> Xgcononrec_rhs = PPgcononrec_rhs;
 102         return((coresyn)pp);
 103 }
 104
 105 coresyn *Rgcononrec_b(t)
 106  struct Scononrec *t;
 107 {
 108 #ifdef UGEN_DEBUG
 109         if(t -> tag != cononrec)
 110                 fprintf(stderr,"gcononrec_b: illegal selection; was %d\n", t -> tag);
 111 #endif /* UGEN_DEBUG */
 112         return(& t -> Xgcononrec_b);
 113 }
 114
 115 coresyn *Rgcononrec_rhs(t)
 116  struct Scononrec *t;
 117 {
 118 #ifdef UGEN_DEBUG
 119         if(t -> tag != cononrec)
 120                 fprintf(stderr,"gcononrec_rhs: illegal selection; was %d\n", t -> tag);
 121 #endif /* UGEN_DEBUG */
 122         return(& t -> Xgcononrec_rhs);
 123 }
 124
 125 /************** corec ******************/
 126
 127 coresyn mkcorec(PPgcorec)
 128  list PPgcorec;
 129 {
 130         register struct Scorec *pp =
 131                 (struct Scorec *) malloc(sizeof(struct Scorec));
 132         pp -> tag = corec;
 133         pp -> Xgcorec = PPgcorec;
 134         return((coresyn)pp);
 135 }
 136
 137 list *Rgcorec(t)
 138  struct Scorec *t;
 139 {
 140 #ifdef UGEN_DEBUG
 141         if(t -> tag != corec)
 142                 fprintf(stderr,"gcorec: illegal selection; was %d\n", t -> tag);
 143 #endif /* UGEN_DEBUG */
 144         return(& t -> Xgcorec);
 145 }
 146
 147 /************** corec_pair ******************/
 148
 149 coresyn mkcorec_pair(PPgcorec_b, PPgcorec_rhs)
 150  coresyn PPgcorec_b;
 151  coresyn PPgcorec_rhs;
 152 {
 153         register struct Scorec_pair *pp =
 154                 (struct Scorec_pair *) malloc(sizeof(struct Scorec_pair));
 155         pp -> tag = corec_pair;
 156         pp -> Xgcorec_b = PPgcorec_b;
 157         pp -> Xgcorec_rhs = PPgcorec_rhs;
 158         return((coresyn)pp);
 159 }
 160
 161 coresyn *Rgcorec_b(t)
 162  struct Scorec_pair *t;
 163 {
 164 #ifdef UGEN_DEBUG
 165         if(t -> tag != corec_pair)
 166                 fprintf(stderr,"gcorec_b: illegal selection; was %d\n", t -> tag);
 167 #endif /* UGEN_DEBUG */
 168         return(& t -> Xgcorec_b);
 169 }
 170
 171 coresyn *Rgcorec_rhs(t)
 172  struct Scorec_pair *t;
 173 {
 174 #ifdef UGEN_DEBUG
 175         if(t -> tag != corec_pair)
 176                 fprintf(stderr,"gcorec_rhs: illegal selection; was %d\n", t -> tag);
 177 #endif /* UGEN_DEBUG */
 178         return(& t -> Xgcorec_rhs);
 179 }
 180
 181 /************** covar ******************/
 182
 183 coresyn mkcovar(PPgcovar)
 184  coresyn PPgcovar;
 185 {
 186         register struct Scovar *pp =
 187                 (struct Scovar *) malloc(sizeof(struct Scovar));
 188         pp -> tag = covar;
 189         pp -> Xgcovar = PPgcovar;
 190         return((coresyn)pp);
 191 }
 192
 193 coresyn *Rgcovar(t)
 194  struct Scovar *t;
 195 {
 196 #ifdef UGEN_DEBUG
 197         if(t -> tag != covar)
 198                 fprintf(stderr,"gcovar: illegal selection; was %d\n", t -> tag);
 199 #endif /* UGEN_DEBUG */
 200         return(& t -> Xgcovar);
 201 }
 202
 203 /************** coliteral ******************/
 204
 205 coresyn mkcoliteral(PPgcoliteral)
 206  literal PPgcoliteral;
 207 {
 208         register struct Scoliteral *pp =
 209                 (struct Scoliteral *) malloc(sizeof(struct Scoliteral));
 210         pp -> tag = coliteral;
 211         pp -> Xgcoliteral = PPgcoliteral;
 212         return((coresyn)pp);
 213 }
 214
 215 literal *Rgcoliteral(t)
 216  struct Scoliteral *t;
 217 {
 218 #ifdef UGEN_DEBUG
 219         if(t -> tag != coliteral)
 220                 fprintf(stderr,"gcoliteral: illegal selection; was %d\n", t -> tag);
 221 #endif /* UGEN_DEBUG */
 222         return(& t -> Xgcoliteral);
 223 }
 224
 225 /************** cocon ******************/
 226
 227 coresyn mkcocon(PPgcocon_con, PPgcocon_tys, PPgcocon_args)
 228  coresyn PPgcocon_con;
 229  list PPgcocon_tys;
 230  list PPgcocon_args;
 231 {
 232         register struct Scocon *pp =
 233                 (struct Scocon *) malloc(sizeof(struct Scocon));
 234         pp -> tag = cocon;
 235         pp -> Xgcocon_con = PPgcocon_con;
 236         pp -> Xgcocon_tys = PPgcocon_tys;
 237         pp -> Xgcocon_args = PPgcocon_args;
 238         return((coresyn)pp);
 239 }
 240
 241 coresyn *Rgcocon_con(t)
 242  struct Scocon *t;
 243 {
 244 #ifdef UGEN_DEBUG
 245         if(t -> tag != cocon)
 246                 fprintf(stderr,"gcocon_con: illegal selection; was %d\n", t -> tag);
 247 #endif /* UGEN_DEBUG */
 248         return(& t -> Xgcocon_con);
 249 }
 250
 251 list *Rgcocon_tys(t)
 252  struct Scocon *t;
 253 {
 254 #ifdef UGEN_DEBUG
 255         if(t -> tag != cocon)
 256                 fprintf(stderr,"gcocon_tys: illegal selection; was %d\n", t -> tag);
 257 #endif /* UGEN_DEBUG */
 258         return(& t -> Xgcocon_tys);
 259 }
 260
 261 list *Rgcocon_args(t)
 262  struct Scocon *t;
 263 {
 264 #ifdef UGEN_DEBUG
 265         if(t -> tag != cocon)
 266                 fprintf(stderr,"gcocon_args: illegal selection; was %d\n", t -> tag);
 267 #endif /* UGEN_DEBUG */
 268         return(& t -> Xgcocon_args);
 269 }
 270
 271 /************** coprim ******************/
 272
 273 coresyn mkcoprim(PPgcoprim_op, PPgcoprim_tys, PPgcoprim_args)
 274  coresyn PPgcoprim_op;
 275  list PPgcoprim_tys;
 276  list PPgcoprim_args;
 277 {
 278         register struct Scoprim *pp =
 279                 (struct Scoprim *) malloc(sizeof(struct Scoprim));
 280         pp -> tag = coprim;
 281         pp -> Xgcoprim_op = PPgcoprim_op;
 282         pp -> Xgcoprim_tys = PPgcoprim_tys;
 283         pp -> Xgcoprim_args = PPgcoprim_args;
 284         return((coresyn)pp);
 285 }
 286
 287 coresyn *Rgcoprim_op(t)
 288  struct Scoprim *t;
 289 {
 290 #ifdef UGEN_DEBUG
 291         if(t -> tag != coprim)
 292                 fprintf(stderr,"gcoprim_op: illegal selection; was %d\n", t -> tag);
 293 #endif /* UGEN_DEBUG */
 294         return(& t -> Xgcoprim_op);
 295 }
 296
 297 list *Rgcoprim_tys(t)
 298  struct Scoprim *t;
 299 {
 300 #ifdef UGEN_DEBUG
 301         if(t -> tag != coprim)
 302                 fprintf(stderr,"gcoprim_tys: illegal selection; was %d\n", t -> tag);
 303 #endif /* UGEN_DEBUG */
 304         return(& t -> Xgcoprim_tys);
 305 }
 306
 307 list *Rgcoprim_args(t)
 308  struct Scoprim *t;
 309 {
 310 #ifdef UGEN_DEBUG
 311         if(t -> tag != coprim)
 312                 fprintf(stderr,"gcoprim_args: illegal selection; was %d\n", t -> tag);
 313 #endif /* UGEN_DEBUG */
 314         return(& t -> Xgcoprim_args);
 315 }
 316
 317 /************** colam ******************/
 318
 319 coresyn mkcolam(PPgcolam_vars, PPgcolam_body)
 320  list PPgcolam_vars;
 321  coresyn PPgcolam_body;
 322 {
 323         register struct Scolam *pp =
 324                 (struct Scolam *) malloc(sizeof(struct Scolam));
 325         pp -> tag = colam;
 326         pp -> Xgcolam_vars = PPgcolam_vars;
 327         pp -> Xgcolam_body = PPgcolam_body;
 328         return((coresyn)pp);
 329 }
 330
 331 list *Rgcolam_vars(t)
 332  struct Scolam *t;
 333 {
 334 #ifdef UGEN_DEBUG
 335         if(t -> tag != colam)
 336                 fprintf(stderr,"gcolam_vars: illegal selection; was %d\n", t -> tag);
 337 #endif /* UGEN_DEBUG */
 338         return(& t -> Xgcolam_vars);
 339 }
 340
 341 coresyn *Rgcolam_body(t)
 342  struct Scolam *t;
 343 {
 344 #ifdef UGEN_DEBUG
 345         if(t -> tag != colam)
 346                 fprintf(stderr,"gcolam_body: illegal selection; was %d\n", t -> tag);
 347 #endif /* UGEN_DEBUG */
 348         return(& t -> Xgcolam_body);
 349 }
 350
 351 /************** cotylam ******************/
 352
 353 coresyn mkcotylam(PPgcotylam_tvs, PPgcotylam_body)
 354  list PPgcotylam_tvs;
 355  coresyn PPgcotylam_body;
 356 {
 357         register struct Scotylam *pp =
 358                 (struct Scotylam *) malloc(sizeof(struct Scotylam));
 359         pp -> tag = cotylam;
 360         pp -> Xgcotylam_tvs = PPgcotylam_tvs;
 361         pp -> Xgcotylam_body = PPgcotylam_body;
 362         return((coresyn)pp);
 363 }
 364
 365 list *Rgcotylam_tvs(t)
 366  struct Scotylam *t;
 367 {
 368 #ifdef UGEN_DEBUG
 369         if(t -> tag != cotylam)
 370                 fprintf(stderr,"gcotylam_tvs: illegal selection; was %d\n", t -> tag);
 371 #endif /* UGEN_DEBUG */
 372         return(& t -> Xgcotylam_tvs);
 373 }
 374
 375 coresyn *Rgcotylam_body(t)
 376  struct Scotylam *t;
 377 {
 378 #ifdef UGEN_DEBUG
 379         if(t -> tag != cotylam)
 380                 fprintf(stderr,"gcotylam_body: illegal selection; was %d\n", t -> tag);
 381 #endif /* UGEN_DEBUG */
 382         return(& t -> Xgcotylam_body);
 383 }
 384
 385 /************** coapp ******************/
 386
 387 coresyn mkcoapp(PPgcoapp_fun, PPgcoapp_args)
 388  coresyn PPgcoapp_fun;
 389  list PPgcoapp_args;
 390 {
 391         register struct Scoapp *pp =
 392                 (struct Scoapp *) malloc(sizeof(struct Scoapp));
 393         pp -> tag = coapp;
 394         pp -> Xgcoapp_fun = PPgcoapp_fun;
 395         pp -> Xgcoapp_args = PPgcoapp_args;
 396         return((coresyn)pp);
 397 }
 398
 399 coresyn *Rgcoapp_fun(t)
 400  struct Scoapp *t;
 401 {
 402 #ifdef UGEN_DEBUG
 403         if(t -> tag != coapp)
 404                 fprintf(stderr,"gcoapp_fun: illegal selection; was %d\n", t -> tag);
 405 #endif /* UGEN_DEBUG */
 406         return(& t -> Xgcoapp_fun);
 407 }
 408
 409 list *Rgcoapp_args(t)
 410  struct Scoapp *t;
 411 {
 412 #ifdef UGEN_DEBUG
 413         if(t -> tag != coapp)
 414                 fprintf(stderr,"gcoapp_args: illegal selection; was %d\n", t -> tag);
 415 #endif /* UGEN_DEBUG */
 416         return(& t -> Xgcoapp_args);
 417 }
 418
 419 /************** cotyapp ******************/
 420
 421 coresyn mkcotyapp(PPgcotyapp_e, PPgcotyapp_t)
 422  coresyn PPgcotyapp_e;
 423  ttype PPgcotyapp_t;
 424 {
 425         register struct Scotyapp *pp =
 426                 (struct Scotyapp *) malloc(sizeof(struct Scotyapp));
 427         pp -> tag = cotyapp;
 428         pp -> Xgcotyapp_e = PPgcotyapp_e;
 429         pp -> Xgcotyapp_t = PPgcotyapp_t;
 430         return((coresyn)pp);
 431 }
 432
 433 coresyn *Rgcotyapp_e(t)
 434  struct Scotyapp *t;
 435 {
 436 #ifdef UGEN_DEBUG
 437         if(t -> tag != cotyapp)
 438                 fprintf(stderr,"gcotyapp_e: illegal selection; was %d\n", t -> tag);
 439 #endif /* UGEN_DEBUG */
 440         return(& t -> Xgcotyapp_e);
 441 }
 442
 443 ttype *Rgcotyapp_t(t)
 444  struct Scotyapp *t;
 445 {
 446 #ifdef UGEN_DEBUG
 447         if(t -> tag != cotyapp)
 448                 fprintf(stderr,"gcotyapp_t: illegal selection; was %d\n", t -> tag);
 449 #endif /* UGEN_DEBUG */
 450         return(& t -> Xgcotyapp_t);
 451 }
 452
 453 /************** cocase ******************/
 454
 455 coresyn mkcocase(PPgcocase_s, PPgcocase_alts)
 456  coresyn PPgcocase_s;
 457  coresyn PPgcocase_alts;
 458 {
 459         register struct Scocase *pp =
 460                 (struct Scocase *) malloc(sizeof(struct Scocase));
 461         pp -> tag = cocase;
 462         pp -> Xgcocase_s = PPgcocase_s;
 463         pp -> Xgcocase_alts = PPgcocase_alts;
 464         return((coresyn)pp);
 465 }
 466
 467 coresyn *Rgcocase_s(t)
 468  struct Scocase *t;
 469 {
 470 #ifdef UGEN_DEBUG
 471         if(t -> tag != cocase)
 472                 fprintf(stderr,"gcocase_s: illegal selection; was %d\n", t -> tag);
 473 #endif /* UGEN_DEBUG */
 474         return(& t -> Xgcocase_s);
 475 }
 476
 477 coresyn *Rgcocase_alts(t)
 478  struct Scocase *t;
 479 {
 480 #ifdef UGEN_DEBUG
 481         if(t -> tag != cocase)
 482                 fprintf(stderr,"gcocase_alts: illegal selection; was %d\n", t -> tag);
 483 #endif /* UGEN_DEBUG */
 484         return(& t -> Xgcocase_alts);
 485 }
 486
 487 /************** colet ******************/
 488
 489 coresyn mkcolet(PPgcolet_bind, PPgcolet_body)
 490  coresyn PPgcolet_bind;
 491  coresyn PPgcolet_body;
 492 {
 493         register struct Scolet *pp =
 494                 (struct Scolet *) malloc(sizeof(struct Scolet));
 495         pp -> tag = colet;
 496         pp -> Xgcolet_bind = PPgcolet_bind;
 497         pp -> Xgcolet_body = PPgcolet_body;
 498         return((coresyn)pp);
 499 }
 500
 501 coresyn *Rgcolet_bind(t)
 502  struct Scolet *t;
 503 {
 504 #ifdef UGEN_DEBUG
 505         if(t -> tag != colet)
 506                 fprintf(stderr,"gcolet_bind: illegal selection; was %d\n", t -> tag);
 507 #endif /* UGEN_DEBUG */
 508         return(& t -> Xgcolet_bind);
 509 }
 510
 511 coresyn *Rgcolet_body(t)
 512  struct Scolet *t;
 513 {
 514 #ifdef UGEN_DEBUG
 515         if(t -> tag != colet)
 516                 fprintf(stderr,"gcolet_body: illegal selection; was %d\n", t -> tag);
 517 #endif /* UGEN_DEBUG */
 518         return(& t -> Xgcolet_body);
 519 }
 520
 521 /************** coscc ******************/
 522
 523 coresyn mkcoscc(PPgcoscc_scc, PPgcoscc_body)
 524  coresyn PPgcoscc_scc;
 525  coresyn PPgcoscc_body;
 526 {
 527         register struct Scoscc *pp =
 528                 (struct Scoscc *) malloc(sizeof(struct Scoscc));
 529         pp -> tag = coscc;
 530         pp -> Xgcoscc_scc = PPgcoscc_scc;
 531         pp -> Xgcoscc_body = PPgcoscc_body;
 532         return((coresyn)pp);
 533 }
 534
 535 coresyn *Rgcoscc_scc(t)
 536  struct Scoscc *t;
 537 {
 538 #ifdef UGEN_DEBUG
 539         if(t -> tag != coscc)
 540                 fprintf(stderr,"gcoscc_scc: illegal selection; was %d\n", t -> tag);
 541 #endif /* UGEN_DEBUG */
 542         return(& t -> Xgcoscc_scc);
 543 }
 544
 545 coresyn *Rgcoscc_body(t)
 546  struct Scoscc *t;
 547 {
 548 #ifdef UGEN_DEBUG
 549         if(t -> tag != coscc)
 550                 fprintf(stderr,"gcoscc_body: illegal selection; was %d\n", t -> tag);
 551 #endif /* UGEN_DEBUG */
 552         return(& t -> Xgcoscc_body);
 553 }
 554
 555 /************** coalg_alts ******************/
 556
 557 coresyn mkcoalg_alts(PPgcoalg_alts, PPgcoalg_deflt)
 558  list PPgcoalg_alts;
 559  coresyn PPgcoalg_deflt;
 560 {
 561         register struct Scoalg_alts *pp =
 562                 (struct Scoalg_alts *) malloc(sizeof(struct Scoalg_alts));
 563         pp -> tag = coalg_alts;
 564         pp -> Xgcoalg_alts = PPgcoalg_alts;
 565         pp -> Xgcoalg_deflt = PPgcoalg_deflt;
 566         return((coresyn)pp);
 567 }
 568
 569 list *Rgcoalg_alts(t)
 570  struct Scoalg_alts *t;
 571 {
 572 #ifdef UGEN_DEBUG
 573         if(t -> tag != coalg_alts)
 574                 fprintf(stderr,"gcoalg_alts: illegal selection; was %d\n", t -> tag);
 575 #endif /* UGEN_DEBUG */
 576         return(& t -> Xgcoalg_alts);
 577 }
 578
 579 coresyn *Rgcoalg_deflt(t)
 580  struct Scoalg_alts *t;
 581 {
 582 #ifdef UGEN_DEBUG
 583         if(t -> tag != coalg_alts)
 584                 fprintf(stderr,"gcoalg_deflt: illegal selection; was %d\n", t -> tag);
 585 #endif /* UGEN_DEBUG */
 586         return(& t -> Xgcoalg_deflt);
 587 }
 588
 589 /************** coalg_alt ******************/
 590
 591 coresyn mkcoalg_alt(PPgcoalg_con, PPgcoalg_bs, PPgcoalg_rhs)
 592  coresyn PPgcoalg_con;
 593  list PPgcoalg_bs;
 594  coresyn PPgcoalg_rhs;
 595 {
 596         register struct Scoalg_alt *pp =
 597                 (struct Scoalg_alt *) malloc(sizeof(struct Scoalg_alt));
 598         pp -> tag = coalg_alt;
 599         pp -> Xgcoalg_con = PPgcoalg_con;
 600         pp -> Xgcoalg_bs = PPgcoalg_bs;
 601         pp -> Xgcoalg_rhs = PPgcoalg_rhs;
 602         return((coresyn)pp);
 603 }
 604
 605 coresyn *Rgcoalg_con(t)
 606  struct Scoalg_alt *t;
 607 {
 608 #ifdef UGEN_DEBUG
 609         if(t -> tag != coalg_alt)
 610                 fprintf(stderr,"gcoalg_con: illegal selection; was %d\n", t -> tag);
 611 #endif /* UGEN_DEBUG */
 612         return(& t -> Xgcoalg_con);
 613 }
 614
 615 list *Rgcoalg_bs(t)
 616  struct Scoalg_alt *t;
 617 {
 618 #ifdef UGEN_DEBUG
 619         if(t -> tag != coalg_alt)
 620                 fprintf(stderr,"gcoalg_bs: illegal selection; was %d\n", t -> tag);
 621 #endif /* UGEN_DEBUG */
 622         return(& t -> Xgcoalg_bs);
 623 }
 624
 625 coresyn *Rgcoalg_rhs(t)
 626  struct Scoalg_alt *t;
 627 {
 628 #ifdef UGEN_DEBUG
 629         if(t -> tag != coalg_alt)
 630                 fprintf(stderr,"gcoalg_rhs: illegal selection; was %d\n", t -> tag);
 631 #endif /* UGEN_DEBUG */
 632         return(& t -> Xgcoalg_rhs);
 633 }
 634
 635 /************** coprim_alts ******************/
 636
 637 coresyn mkcoprim_alts(PPgcoprim_alts, PPgcoprim_deflt)
 638  list PPgcoprim_alts;
 639  coresyn PPgcoprim_deflt;
 640 {
 641         register struct Scoprim_alts *pp =
 642                 (struct Scoprim_alts *) malloc(sizeof(struct Scoprim_alts));
 643         pp -> tag = coprim_alts;
 644         pp -> Xgcoprim_alts = PPgcoprim_alts;
 645         pp -> Xgcoprim_deflt = PPgcoprim_deflt;
 646         return((coresyn)pp);
 647 }
 648
 649 list *Rgcoprim_alts(t)
 650  struct Scoprim_alts *t;
 651 {
 652 #ifdef UGEN_DEBUG
 653         if(t -> tag != coprim_alts)
 654                 fprintf(stderr,"gcoprim_alts: illegal selection; was %d\n", t -> tag);
 655 #endif /* UGEN_DEBUG */
 656         return(& t -> Xgcoprim_alts);
 657 }
 658
 659 coresyn *Rgcoprim_deflt(t)
 660  struct Scoprim_alts *t;
 661 {
 662 #ifdef UGEN_DEBUG
 663         if(t -> tag != coprim_alts)
 664                 fprintf(stderr,"gcoprim_deflt: illegal selection; was %d\n", t -> tag);
 665 #endif /* UGEN_DEBUG */
 666         return(& t -> Xgcoprim_deflt);
 667 }
 668
 669 /************** coprim_alt ******************/
 670
 671 coresyn mkcoprim_alt(PPgcoprim_lit, PPgcoprim_rhs)
 672  literal PPgcoprim_lit;
 673  coresyn PPgcoprim_rhs;
 674 {
 675         register struct Scoprim_alt *pp =
 676                 (struct Scoprim_alt *) malloc(sizeof(struct Scoprim_alt));
 677         pp -> tag = coprim_alt;
 678         pp -> Xgcoprim_lit = PPgcoprim_lit;
 679         pp -> Xgcoprim_rhs = PPgcoprim_rhs;
 680         return((coresyn)pp);
 681 }
 682
 683 literal *Rgcoprim_lit(t)
 684  struct Scoprim_alt *t;
 685 {
 686 #ifdef UGEN_DEBUG
 687         if(t -> tag != coprim_alt)
 688                 fprintf(stderr,"gcoprim_lit: illegal selection; was %d\n", t -> tag);
 689 #endif /* UGEN_DEBUG */
 690         return(& t -> Xgcoprim_lit);
 691 }
 692
 693 coresyn *Rgcoprim_rhs(t)
 694  struct Scoprim_alt *t;
 695 {
 696 #ifdef UGEN_DEBUG
 697         if(t -> tag != coprim_alt)
 698                 fprintf(stderr,"gcoprim_rhs: illegal selection; was %d\n", t -> tag);
 699 #endif /* UGEN_DEBUG */
 700         return(& t -> Xgcoprim_rhs);
 701 }
 702
 703 /************** conodeflt ******************/
 704
 705 coresyn mkconodeflt()
 706 {
 707         register struct Sconodeflt *pp =
 708                 (struct Sconodeflt *) malloc(sizeof(struct Sconodeflt));
 709         pp -> tag = conodeflt;
 710         return((coresyn)pp);
 711 }
 712
 713 /************** cobinddeflt ******************/
 714
 715 coresyn mkcobinddeflt(PPgcobinddeflt_v, PPgcobinddeflt_rhs)
 716  coresyn PPgcobinddeflt_v;
 717  coresyn PPgcobinddeflt_rhs;
 718 {
 719         register struct Scobinddeflt *pp =
 720                 (struct Scobinddeflt *) malloc(sizeof(struct Scobinddeflt));
 721         pp -> tag = cobinddeflt;
 722         pp -> Xgcobinddeflt_v = PPgcobinddeflt_v;
 723         pp -> Xgcobinddeflt_rhs = PPgcobinddeflt_rhs;
 724         return((coresyn)pp);
 725 }
 726
 727 coresyn *Rgcobinddeflt_v(t)
 728  struct Scobinddeflt *t;
 729 {
 730 #ifdef UGEN_DEBUG
 731         if(t -> tag != cobinddeflt)
 732                 fprintf(stderr,"gcobinddeflt_v: illegal selection; was %d\n", t -> tag);
 733 #endif /* UGEN_DEBUG */
 734         return(& t -> Xgcobinddeflt_v);
 735 }
 736
 737 coresyn *Rgcobinddeflt_rhs(t)
 738  struct Scobinddeflt *t;
 739 {
 740 #ifdef UGEN_DEBUG
 741         if(t -> tag != cobinddeflt)
 742                 fprintf(stderr,"gcobinddeflt_rhs: illegal selection; was %d\n", t -> tag);
 743 #endif /* UGEN_DEBUG */
 744         return(& t -> Xgcobinddeflt_rhs);
 745 }
 746
 747 /************** co_primop ******************/
 748
 749 coresyn mkco_primop(PPgco_primop)
 750  stringId PPgco_primop;
 751 {
 752         register struct Sco_primop *pp =
 753                 (struct Sco_primop *) malloc(sizeof(struct Sco_primop));
 754         pp -> tag = co_primop;
 755         pp -> Xgco_primop = PPgco_primop;
 756         return((coresyn)pp);
 757 }
 758
 759 stringId *Rgco_primop(t)
 760  struct Sco_primop *t;
 761 {
 762 #ifdef UGEN_DEBUG
 763         if(t -> tag != co_primop)
 764                 fprintf(stderr,"gco_primop: illegal selection; was %d\n", t -> tag);
 765 #endif /* UGEN_DEBUG */
 766         return(& t -> Xgco_primop);
 767 }
 768
 769 /************** co_ccall ******************/
 770
 771 coresyn mkco_ccall(PPgco_ccall, PPgco_ccall_may_gc, PPgco_ccall_arg_tys, PPgco_ccall_res_ty)
 772  stringId PPgco_ccall;
 773  long PPgco_ccall_may_gc;
 774  list PPgco_ccall_arg_tys;
 775  ttype PPgco_ccall_res_ty;
 776 {
 777         register struct Sco_ccall *pp =
 778                 (struct Sco_ccall *) malloc(sizeof(struct Sco_ccall));
 779         pp -> tag = co_ccall;
 780         pp -> Xgco_ccall = PPgco_ccall;
 781         pp -> Xgco_ccall_may_gc = PPgco_ccall_may_gc;
 782         pp -> Xgco_ccall_arg_tys = PPgco_ccall_arg_tys;
 783         pp -> Xgco_ccall_res_ty = PPgco_ccall_res_ty;
 784         return((coresyn)pp);
 785 }
 786
 787 stringId *Rgco_ccall(t)
 788  struct Sco_ccall *t;
 789 {
 790 #ifdef UGEN_DEBUG
 791         if(t -> tag != co_ccall)
 792                 fprintf(stderr,"gco_ccall: illegal selection; was %d\n", t -> tag);
 793 #endif /* UGEN_DEBUG */
 794         return(& t -> Xgco_ccall);
 795 }
 796
 797 long *Rgco_ccall_may_gc(t)
 798  struct Sco_ccall *t;
 799 {
 800 #ifdef UGEN_DEBUG
 801         if(t -> tag != co_ccall)
 802                 fprintf(stderr,"gco_ccall_may_gc: illegal selection; was %d\n", t -> tag);
 803 #endif /* UGEN_DEBUG */
 804         return(& t -> Xgco_ccall_may_gc);
 805 }
 806
 807 list *Rgco_ccall_arg_tys(t)
 808  struct Sco_ccall *t;
 809 {
 810 #ifdef UGEN_DEBUG
 811         if(t -> tag != co_ccall)
 812                 fprintf(stderr,"gco_ccall_arg_tys: illegal selection; was %d\n", t -> tag);
 813 #endif /* UGEN_DEBUG */
 814         return(& t -> Xgco_ccall_arg_tys);
 815 }
 816
 817 ttype *Rgco_ccall_res_ty(t)
 818  struct Sco_ccall *t;
 819 {
 820 #ifdef UGEN_DEBUG
 821         if(t -> tag != co_ccall)
 822                 fprintf(stderr,"gco_ccall_res_ty: illegal selection; was %d\n", t -> tag);
 823 #endif /* UGEN_DEBUG */
 824         return(& t -> Xgco_ccall_res_ty);
 825 }
 826
 827 /************** co_casm ******************/
 828
 829 coresyn mkco_casm(PPgco_casm, PPgco_casm_may_gc, PPgco_casm_arg_tys, PPgco_casm_res_ty)
 830  literal PPgco_casm;
 831  long PPgco_casm_may_gc;
 832  list PPgco_casm_arg_tys;
 833  ttype PPgco_casm_res_ty;
 834 {
 835         register struct Sco_casm *pp =
 836                 (struct Sco_casm *) malloc(sizeof(struct Sco_casm));
 837         pp -> tag = co_casm;
 838         pp -> Xgco_casm = PPgco_casm;
 839         pp -> Xgco_casm_may_gc = PPgco_casm_may_gc;
 840         pp -> Xgco_casm_arg_tys = PPgco_casm_arg_tys;
 841         pp -> Xgco_casm_res_ty = PPgco_casm_res_ty;
 842         return((coresyn)pp);
 843 }
 844
 845 literal *Rgco_casm(t)
 846  struct Sco_casm *t;
 847 {
 848 #ifdef UGEN_DEBUG
 849         if(t -> tag != co_casm)
 850                 fprintf(stderr,"gco_casm: illegal selection; was %d\n", t -> tag);
 851 #endif /* UGEN_DEBUG */
 852         return(& t -> Xgco_casm);
 853 }
 854
 855 long *Rgco_casm_may_gc(t)
 856  struct Sco_casm *t;
 857 {
 858 #ifdef UGEN_DEBUG
 859         if(t -> tag != co_casm)
 860                 fprintf(stderr,"gco_casm_may_gc: illegal selection; was %d\n", t -> tag);
 861 #endif /* UGEN_DEBUG */
 862         return(& t -> Xgco_casm_may_gc);
 863 }
 864
 865 list *Rgco_casm_arg_tys(t)
 866  struct Sco_casm *t;
 867 {
 868 #ifdef UGEN_DEBUG
 869         if(t -> tag != co_casm)
 870                 fprintf(stderr,"gco_casm_arg_tys: illegal selection; was %d\n", t -> tag);
 871 #endif /* UGEN_DEBUG */
 872         return(& t -> Xgco_casm_arg_tys);
 873 }
 874
 875 ttype *Rgco_casm_res_ty(t)
 876  struct Sco_casm *t;
 877 {
 878 #ifdef UGEN_DEBUG
 879         if(t -> tag != co_casm)
 880                 fprintf(stderr,"gco_casm_res_ty: illegal selection; was %d\n", t -> tag);
 881 #endif /* UGEN_DEBUG */
 882         return(& t -> Xgco_casm_res_ty);
 883 }
 884
 885 /************** co_preludedictscc ******************/
 886
 887 coresyn mkco_preludedictscc(PPgco_preludedictscc_dupd)
 888  coresyn PPgco_preludedictscc_dupd;
 889 {
 890         register struct Sco_preludedictscc *pp =
 891                 (struct Sco_preludedictscc *) malloc(sizeof(struct Sco_preludedictscc));
 892         pp -> tag = co_preludedictscc;
 893         pp -> Xgco_preludedictscc_dupd = PPgco_preludedictscc_dupd;
 894         return((coresyn)pp);
 895 }
 896
 897 coresyn *Rgco_preludedictscc_dupd(t)
 898  struct Sco_preludedictscc *t;
 899 {
 900 #ifdef UGEN_DEBUG
 901         if(t -> tag != co_preludedictscc)
 902                 fprintf(stderr,"gco_preludedictscc_dupd: illegal selection; was %d\n", t -> tag);
 903 #endif /* UGEN_DEBUG */
 904         return(& t -> Xgco_preludedictscc_dupd);
 905 }
 906
 907 /************** co_alldictscc ******************/
 908
 909 coresyn mkco_alldictscc(PPgco_alldictscc_m, PPgco_alldictscc_g, PPgco_alldictscc_dupd)
 910  hstring PPgco_alldictscc_m;
 911  hstring PPgco_alldictscc_g;
 912  coresyn PPgco_alldictscc_dupd;
 913 {
 914         register struct Sco_alldictscc *pp =
 915                 (struct Sco_alldictscc *) malloc(sizeof(struct Sco_alldictscc));
 916         pp -> tag = co_alldictscc;
 917         pp -> Xgco_alldictscc_m = PPgco_alldictscc_m;
 918         pp -> Xgco_alldictscc_g = PPgco_alldictscc_g;
 919         pp -> Xgco_alldictscc_dupd = PPgco_alldictscc_dupd;
 920         return((coresyn)pp);
 921 }
 922
 923 hstring *Rgco_alldictscc_m(t)
 924  struct Sco_alldictscc *t;
 925 {
 926 #ifdef UGEN_DEBUG
 927         if(t -> tag != co_alldictscc)
 928                 fprintf(stderr,"gco_alldictscc_m: illegal selection; was %d\n", t -> tag);
 929 #endif /* UGEN_DEBUG */
 930         return(& t -> Xgco_alldictscc_m);
 931 }
 932
 933 hstring *Rgco_alldictscc_g(t)
 934  struct Sco_alldictscc *t;
 935 {
 936 #ifdef UGEN_DEBUG
 937         if(t -> tag != co_alldictscc)
 938                 fprintf(stderr,"gco_alldictscc_g: illegal selection; was %d\n", t -> tag);
 939 #endif /* UGEN_DEBUG */
 940         return(& t -> Xgco_alldictscc_g);
 941 }
 942
 943 coresyn *Rgco_alldictscc_dupd(t)
 944  struct Sco_alldictscc *t;
 945 {
 946 #ifdef UGEN_DEBUG
 947         if(t -> tag != co_alldictscc)
 948                 fprintf(stderr,"gco_alldictscc_dupd: illegal selection; was %d\n", t -> tag);
 949 #endif /* UGEN_DEBUG */
 950         return(& t -> Xgco_alldictscc_dupd);
 951 }
 952
 953 /************** co_usercc ******************/
 954
 955 coresyn mkco_usercc(PPgco_usercc_n, PPgco_usercc_m, PPgco_usercc_g, PPgco_usercc_dupd, PPgco_usercc_cafd)
 956  hstring PPgco_usercc_n;
 957  hstring PPgco_usercc_m;
 958  hstring PPgco_usercc_g;
 959  coresyn PPgco_usercc_dupd;
 960  coresyn PPgco_usercc_cafd;
 961 {
 962         register struct Sco_usercc *pp =
 963                 (struct Sco_usercc *) malloc(sizeof(struct Sco_usercc));
 964         pp -> tag = co_usercc;
 965         pp -> Xgco_usercc_n = PPgco_usercc_n;
 966         pp -> Xgco_usercc_m = PPgco_usercc_m;
 967         pp -> Xgco_usercc_g = PPgco_usercc_g;
 968         pp -> Xgco_usercc_dupd = PPgco_usercc_dupd;
 969         pp -> Xgco_usercc_cafd = PPgco_usercc_cafd;
 970         return((coresyn)pp);
 971 }
 972
 973 hstring *Rgco_usercc_n(t)
 974  struct Sco_usercc *t;
 975 {
 976 #ifdef UGEN_DEBUG
 977         if(t -> tag != co_usercc)
 978                 fprintf(stderr,"gco_usercc_n: illegal selection; was %d\n", t -> tag);
 979 #endif /* UGEN_DEBUG */
 980         return(& t -> Xgco_usercc_n);
 981 }
 982
 983 hstring *Rgco_usercc_m(t)
 984  struct Sco_usercc *t;
 985 {
 986 #ifdef UGEN_DEBUG
 987         if(t -> tag != co_usercc)
 988                 fprintf(stderr,"gco_usercc_m: illegal selection; was %d\n", t -> tag);
 989 #endif /* UGEN_DEBUG */
 990         return(& t -> Xgco_usercc_m);
 991 }
 992
 993 hstring *Rgco_usercc_g(t)
 994  struct Sco_usercc *t;
 995 {
 996 #ifdef UGEN_DEBUG
 997         if(t -> tag != co_usercc)
 998                 fprintf(stderr,"gco_usercc_g: illegal selection; was %d\n", t -> tag);
 999 #endif /* UGEN_DEBUG */
1000         return(& t -> Xgco_usercc_g);
1001 }
1002
1003 coresyn *Rgco_usercc_dupd(t)
1004  struct Sco_usercc *t;
1005 {
1006 #ifdef UGEN_DEBUG
1007         if(t -> tag != co_usercc)
1008                 fprintf(stderr,"gco_usercc_dupd: illegal selection; was %d\n", t -> tag);
1009 #endif /* UGEN_DEBUG */
1010         return(& t -> Xgco_usercc_dupd);
1011 }
1012
1013 coresyn *Rgco_usercc_cafd(t)
1014  struct Sco_usercc *t;
1015 {
1016 #ifdef UGEN_DEBUG
1017         if(t -> tag != co_usercc)
1018                 fprintf(stderr,"gco_usercc_cafd: illegal selection; was %d\n", t -> tag);
1019 #endif /* UGEN_DEBUG */
1020         return(& t -> Xgco_usercc_cafd);
1021 }
1022
1023 /************** co_autocc ******************/
1024
1025 coresyn mkco_autocc(PPgco_autocc_i, PPgco_autocc_m, PPgco_autocc_g, PPgco_autocc_dupd, PPgco_autocc_cafd)
1026  coresyn PPgco_autocc_i;
1027  hstring PPgco_autocc_m;
1028  hstring PPgco_autocc_g;
1029  coresyn PPgco_autocc_dupd;
1030  coresyn PPgco_autocc_cafd;
1031 {
1032         register struct Sco_autocc *pp =
1033                 (struct Sco_autocc *) malloc(sizeof(struct Sco_autocc));
1034         pp -> tag = co_autocc;
1035         pp -> Xgco_autocc_i = PPgco_autocc_i;
1036         pp -> Xgco_autocc_m = PPgco_autocc_m;
1037         pp -> Xgco_autocc_g = PPgco_autocc_g;
1038         pp -> Xgco_autocc_dupd = PPgco_autocc_dupd;
1039         pp -> Xgco_autocc_cafd = PPgco_autocc_cafd;
1040         return((coresyn)pp);
1041 }
1042
1043 coresyn *Rgco_autocc_i(t)
1044  struct Sco_autocc *t;
1045 {
1046 #ifdef UGEN_DEBUG
1047         if(t -> tag != co_autocc)
1048                 fprintf(stderr,"gco_autocc_i: illegal selection; was %d\n", t -> tag);
1049 #endif /* UGEN_DEBUG */
1050         return(& t -> Xgco_autocc_i);
1051 }
1052
1053 hstring *Rgco_autocc_m(t)
1054  struct Sco_autocc *t;
1055 {
1056 #ifdef UGEN_DEBUG
1057         if(t -> tag != co_autocc)
1058                 fprintf(stderr,"gco_autocc_m: illegal selection; was %d\n", t -> tag);
1059 #endif /* UGEN_DEBUG */
1060         return(& t -> Xgco_autocc_m);
1061 }
1062
1063 hstring *Rgco_autocc_g(t)
1064  struct Sco_autocc *t;
1065 {
1066 #ifdef UGEN_DEBUG
1067         if(t -> tag != co_autocc)
1068                 fprintf(stderr,"gco_autocc_g: illegal selection; was %d\n", t -> tag);
1069 #endif /* UGEN_DEBUG */
1070         return(& t -> Xgco_autocc_g);
1071 }
1072
1073 coresyn *Rgco_autocc_dupd(t)
1074  struct Sco_autocc *t;
1075 {
1076 #ifdef UGEN_DEBUG
1077         if(t -> tag != co_autocc)
1078                 fprintf(stderr,"gco_autocc_dupd: illegal selection; was %d\n", t -> tag);
1079 #endif /* UGEN_DEBUG */
1080         return(& t -> Xgco_autocc_dupd);
1081 }
1082
1083 coresyn *Rgco_autocc_cafd(t)
1084  struct Sco_autocc *t;
1085 {
1086 #ifdef UGEN_DEBUG
1087         if(t -> tag != co_autocc)
1088                 fprintf(stderr,"gco_autocc_cafd: illegal selection; was %d\n", t -> tag);
1089 #endif /* UGEN_DEBUG */
1090         return(& t -> Xgco_autocc_cafd);
1091 }
1092
1093 /************** co_dictcc ******************/
1094
1095 coresyn mkco_dictcc(PPgco_dictcc_i, PPgco_dictcc_m, PPgco_dictcc_g, PPgco_dictcc_dupd, PPgco_dictcc_cafd)
1096  coresyn PPgco_dictcc_i;
1097  hstring PPgco_dictcc_m;
1098  hstring PPgco_dictcc_g;
1099  coresyn PPgco_dictcc_dupd;
1100  coresyn PPgco_dictcc_cafd;
1101 {
1102         register struct Sco_dictcc *pp =
1103                 (struct Sco_dictcc *) malloc(sizeof(struct Sco_dictcc));
1104         pp -> tag = co_dictcc;
1105         pp -> Xgco_dictcc_i = PPgco_dictcc_i;
1106         pp -> Xgco_dictcc_m = PPgco_dictcc_m;
1107         pp -> Xgco_dictcc_g = PPgco_dictcc_g;
1108         pp -> Xgco_dictcc_dupd = PPgco_dictcc_dupd;
1109         pp -> Xgco_dictcc_cafd = PPgco_dictcc_cafd;
1110         return((coresyn)pp);
1111 }
1112
1113 coresyn *Rgco_dictcc_i(t)
1114  struct Sco_dictcc *t;
1115 {
1116 #ifdef UGEN_DEBUG
1117         if(t -> tag != co_dictcc)
1118                 fprintf(stderr,"gco_dictcc_i: illegal selection; was %d\n", t -> tag);
1119 #endif /* UGEN_DEBUG */
1120         return(& t -> Xgco_dictcc_i);
1121 }
1122
1123 hstring *Rgco_dictcc_m(t)
1124  struct Sco_dictcc *t;
1125 {
1126 #ifdef UGEN_DEBUG
1127         if(t -> tag != co_dictcc)
1128                 fprintf(stderr,"gco_dictcc_m: illegal selection; was %d\n", t -> tag);
1129 #endif /* UGEN_DEBUG */
1130         return(& t -> Xgco_dictcc_m);
1131 }
1132
1133 hstring *Rgco_dictcc_g(t)
1134  struct Sco_dictcc *t;
1135 {
1136 #ifdef UGEN_DEBUG
1137         if(t -> tag != co_dictcc)
1138                 fprintf(stderr,"gco_dictcc_g: illegal selection; was %d\n", t -> tag);
1139 #endif /* UGEN_DEBUG */
1140         return(& t -> Xgco_dictcc_g);
1141 }
1142
1143 coresyn *Rgco_dictcc_dupd(t)
1144  struct Sco_dictcc *t;
1145 {
1146 #ifdef UGEN_DEBUG
1147         if(t -> tag != co_dictcc)
1148                 fprintf(stderr,"gco_dictcc_dupd: illegal selection; was %d\n", t -> tag);
1149 #endif /* UGEN_DEBUG */
1150         return(& t -> Xgco_dictcc_dupd);
1151 }
1152
1153 coresyn *Rgco_dictcc_cafd(t)
1154  struct Sco_dictcc *t;
1155 {
1156 #ifdef UGEN_DEBUG
1157         if(t -> tag != co_dictcc)
1158                 fprintf(stderr,"gco_dictcc_cafd: illegal selection; was %d\n", t -> tag);
1159 #endif /* UGEN_DEBUG */
1160         return(& t -> Xgco_dictcc_cafd);
1161 }
1162
1163 /************** co_scc_noncaf ******************/
1164
1165 coresyn mkco_scc_noncaf()
1166 {
1167         register struct Sco_scc_noncaf *pp =
1168                 (struct Sco_scc_noncaf *) malloc(sizeof(struct Sco_scc_noncaf));
1169         pp -> tag = co_scc_noncaf;
1170         return((coresyn)pp);
1171 }
1172
1173 /************** co_scc_caf ******************/
1174
1175 coresyn mkco_scc_caf()
1176 {
1177         register struct Sco_scc_caf *pp =
1178                 (struct Sco_scc_caf *) malloc(sizeof(struct Sco_scc_caf));
1179         pp -> tag = co_scc_caf;
1180         return((coresyn)pp);
1181 }
1182
1183 /************** co_scc_nondupd ******************/
1184
1185 coresyn mkco_scc_nondupd()
1186 {
1187         register struct Sco_scc_nondupd *pp =
1188                 (struct Sco_scc_nondupd *) malloc(sizeof(struct Sco_scc_nondupd));
1189         pp -> tag = co_scc_nondupd;
1190         return((coresyn)pp);
1191 }
1192
1193 /************** co_scc_dupd ******************/
1194
1195 coresyn mkco_scc_dupd()
1196 {
1197         register struct Sco_scc_dupd *pp =
1198                 (struct Sco_scc_dupd *) malloc(sizeof(struct Sco_scc_dupd));
1199         pp -> tag = co_scc_dupd;
1200         return((coresyn)pp);
1201 }
1202
1203 /************** co_id ******************/
1204
1205 coresyn mkco_id(PPgco_id)
1206  stringId PPgco_id;
1207 {
1208         register struct Sco_id *pp =
1209                 (struct Sco_id *) malloc(sizeof(struct Sco_id));
1210         pp -> tag = co_id;
1211         pp -> Xgco_id = PPgco_id;
1212         return((coresyn)pp);
1213 }
1214
1215 stringId *Rgco_id(t)
1216  struct Sco_id *t;
1217 {
1218 #ifdef UGEN_DEBUG
1219         if(t -> tag != co_id)
1220                 fprintf(stderr,"gco_id: illegal selection; was %d\n", t -> tag);
1221 #endif /* UGEN_DEBUG */
1222         return(& t -> Xgco_id);
1223 }
1224
1225 /************** co_orig_id ******************/
1226
1227 coresyn mkco_orig_id(PPgco_orig_id_m, PPgco_orig_id_n)
1228  stringId PPgco_orig_id_m;
1229  stringId PPgco_orig_id_n;
1230 {
1231         register struct Sco_orig_id *pp =
1232                 (struct Sco_orig_id *) malloc(sizeof(struct Sco_orig_id));
1233         pp -> tag = co_orig_id;
1234         pp -> Xgco_orig_id_m = PPgco_orig_id_m;
1235         pp -> Xgco_orig_id_n = PPgco_orig_id_n;
1236         return((coresyn)pp);
1237 }
1238
1239 stringId *Rgco_orig_id_m(t)
1240  struct Sco_orig_id *t;
1241 {
1242 #ifdef UGEN_DEBUG
1243         if(t -> tag != co_orig_id)
1244                 fprintf(stderr,"gco_orig_id_m: illegal selection; was %d\n", t -> tag);
1245 #endif /* UGEN_DEBUG */
1246         return(& t -> Xgco_orig_id_m);
1247 }
1248
1249 stringId *Rgco_orig_id_n(t)
1250  struct Sco_orig_id *t;
1251 {
1252 #ifdef UGEN_DEBUG
1253         if(t -> tag != co_orig_id)
1254                 fprintf(stderr,"gco_orig_id_n: illegal selection; was %d\n", t -> tag);
1255 #endif /* UGEN_DEBUG */
1256         return(& t -> Xgco_orig_id_n);
1257 }
1258
1259 /************** co_sdselid ******************/
1260
1261 coresyn mkco_sdselid(PPgco_sdselid_c, PPgco_sdselid_sc)
1262  unkId PPgco_sdselid_c;
1263  unkId PPgco_sdselid_sc;
1264 {
1265         register struct Sco_sdselid *pp =
1266                 (struct Sco_sdselid *) malloc(sizeof(struct Sco_sdselid));
1267         pp -> tag = co_sdselid;
1268         pp -> Xgco_sdselid_c = PPgco_sdselid_c;
1269         pp -> Xgco_sdselid_sc = PPgco_sdselid_sc;
1270         return((coresyn)pp);
1271 }
1272
1273 unkId *Rgco_sdselid_c(t)
1274  struct Sco_sdselid *t;
1275 {
1276 #ifdef UGEN_DEBUG
1277         if(t -> tag != co_sdselid)
1278                 fprintf(stderr,"gco_sdselid_c: illegal selection; was %d\n", t -> tag);
1279 #endif /* UGEN_DEBUG */
1280         return(& t -> Xgco_sdselid_c);
1281 }
1282
1283 unkId *Rgco_sdselid_sc(t)
1284  struct Sco_sdselid *t;
1285 {
1286 #ifdef UGEN_DEBUG
1287         if(t -> tag != co_sdselid)
1288                 fprintf(stderr,"gco_sdselid_sc: illegal selection; was %d\n", t -> tag);
1289 #endif /* UGEN_DEBUG */
1290         return(& t -> Xgco_sdselid_sc);
1291 }
1292
1293 /************** co_classopid ******************/
1294
1295 coresyn mkco_classopid(PPgco_classopid_c, PPgco_classopid_o)
1296  unkId PPgco_classopid_c;
1297  unkId PPgco_classopid_o;
1298 {
1299         register struct Sco_classopid *pp =
1300                 (struct Sco_classopid *) malloc(sizeof(struct Sco_classopid));
1301         pp -> tag = co_classopid;
1302         pp -> Xgco_classopid_c = PPgco_classopid_c;
1303         pp -> Xgco_classopid_o = PPgco_classopid_o;
1304         return((coresyn)pp);
1305 }
1306
1307 unkId *Rgco_classopid_c(t)
1308  struct Sco_classopid *t;
1309 {
1310 #ifdef UGEN_DEBUG
1311         if(t -> tag != co_classopid)
1312                 fprintf(stderr,"gco_classopid_c: illegal selection; was %d\n", t -> tag);
1313 #endif /* UGEN_DEBUG */
1314         return(& t -> Xgco_classopid_c);
1315 }
1316
1317 unkId *Rgco_classopid_o(t)
1318  struct Sco_classopid *t;
1319 {
1320 #ifdef UGEN_DEBUG
1321         if(t -> tag != co_classopid)
1322                 fprintf(stderr,"gco_classopid_o: illegal selection; was %d\n", t -> tag);
1323 #endif /* UGEN_DEBUG */
1324         return(& t -> Xgco_classopid_o);
1325 }
1326
1327 /************** co_defmid ******************/
1328
1329 coresyn mkco_defmid(PPgco_defmid_c, PPgco_defmid_op)
1330  unkId PPgco_defmid_c;
1331  unkId PPgco_defmid_op;
1332 {
1333         register struct Sco_defmid *pp =
1334                 (struct Sco_defmid *) malloc(sizeof(struct Sco_defmid));
1335         pp -> tag = co_defmid;
1336         pp -> Xgco_defmid_c = PPgco_defmid_c;
1337         pp -> Xgco_defmid_op = PPgco_defmid_op;
1338         return((coresyn)pp);
1339 }
1340
1341 unkId *Rgco_defmid_c(t)
1342  struct Sco_defmid *t;
1343 {
1344 #ifdef UGEN_DEBUG
1345         if(t -> tag != co_defmid)
1346                 fprintf(stderr,"gco_defmid_c: illegal selection; was %d\n", t -> tag);
1347 #endif /* UGEN_DEBUG */
1348         return(& t -> Xgco_defmid_c);
1349 }
1350
1351 unkId *Rgco_defmid_op(t)
1352  struct Sco_defmid *t;
1353 {
1354 #ifdef UGEN_DEBUG
1355         if(t -> tag != co_defmid)
1356                 fprintf(stderr,"gco_defmid_op: illegal selection; was %d\n", t -> tag);
1357 #endif /* UGEN_DEBUG */
1358         return(& t -> Xgco_defmid_op);
1359 }
1360
1361 /************** co_dfunid ******************/
1362
1363 coresyn mkco_dfunid(PPgco_dfunid_c, PPgco_dfunid_ty)
1364  unkId PPgco_dfunid_c;
1365  ttype PPgco_dfunid_ty;
1366 {
1367         register struct Sco_dfunid *pp =
1368                 (struct Sco_dfunid *) malloc(sizeof(struct Sco_dfunid));
1369         pp -> tag = co_dfunid;
1370         pp -> Xgco_dfunid_c = PPgco_dfunid_c;
1371         pp -> Xgco_dfunid_ty = PPgco_dfunid_ty;
1372         return((coresyn)pp);
1373 }
1374
1375 unkId *Rgco_dfunid_c(t)
1376  struct Sco_dfunid *t;
1377 {
1378 #ifdef UGEN_DEBUG
1379         if(t -> tag != co_dfunid)
1380                 fprintf(stderr,"gco_dfunid_c: illegal selection; was %d\n", t -> tag);
1381 #endif /* UGEN_DEBUG */
1382         return(& t -> Xgco_dfunid_c);
1383 }
1384
1385 ttype *Rgco_dfunid_ty(t)
1386  struct Sco_dfunid *t;
1387 {
1388 #ifdef UGEN_DEBUG
1389         if(t -> tag != co_dfunid)
1390                 fprintf(stderr,"gco_dfunid_ty: illegal selection; was %d\n", t -> tag);
1391 #endif /* UGEN_DEBUG */
1392         return(& t -> Xgco_dfunid_ty);
1393 }
1394
1395 /************** co_constmid ******************/
1396
1397 coresyn mkco_constmid(PPgco_constmid_c, PPgco_constmid_op, PPgco_constmid_ty)
1398  unkId PPgco_constmid_c;
1399  unkId PPgco_constmid_op;
1400  ttype PPgco_constmid_ty;
1401 {
1402         register struct Sco_constmid *pp =
1403                 (struct Sco_constmid *) malloc(sizeof(struct Sco_constmid));
1404         pp -> tag = co_constmid;
1405         pp -> Xgco_constmid_c = PPgco_constmid_c;
1406         pp -> Xgco_constmid_op = PPgco_constmid_op;
1407         pp -> Xgco_constmid_ty = PPgco_constmid_ty;
1408         return((coresyn)pp);
1409 }
1410
1411 unkId *Rgco_constmid_c(t)
1412  struct Sco_constmid *t;
1413 {
1414 #ifdef UGEN_DEBUG
1415         if(t -> tag != co_constmid)
1416                 fprintf(stderr,"gco_constmid_c: illegal selection; was %d\n", t -> tag);
1417 #endif /* UGEN_DEBUG */
1418         return(& t -> Xgco_constmid_c);
1419 }
1420
1421 unkId *Rgco_constmid_op(t)
1422  struct Sco_constmid *t;
1423 {
1424 #ifdef UGEN_DEBUG
1425         if(t -> tag != co_constmid)
1426                 fprintf(stderr,"gco_constmid_op: illegal selection; was %d\n", t -> tag);
1427 #endif /* UGEN_DEBUG */
1428         return(& t -> Xgco_constmid_op);
1429 }
1430
1431 ttype *Rgco_constmid_ty(t)
1432  struct Sco_constmid *t;
1433 {
1434 #ifdef UGEN_DEBUG
1435         if(t -> tag != co_constmid)
1436                 fprintf(stderr,"gco_constmid_ty: illegal selection; was %d\n", t -> tag);
1437 #endif /* UGEN_DEBUG */
1438         return(& t -> Xgco_constmid_ty);
1439 }
1440
1441 /************** co_specid ******************/
1442
1443 coresyn mkco_specid(PPgco_specid_un, PPgco_specid_tys)
1444  coresyn PPgco_specid_un;
1445  list PPgco_specid_tys;
1446 {
1447         register struct Sco_specid *pp =
1448                 (struct Sco_specid *) malloc(sizeof(struct Sco_specid));
1449         pp -> tag = co_specid;
1450         pp -> Xgco_specid_un = PPgco_specid_un;
1451         pp -> Xgco_specid_tys = PPgco_specid_tys;
1452         return((coresyn)pp);
1453 }
1454
1455 coresyn *Rgco_specid_un(t)
1456  struct Sco_specid *t;
1457 {
1458 #ifdef UGEN_DEBUG
1459         if(t -> tag != co_specid)
1460                 fprintf(stderr,"gco_specid_un: illegal selection; was %d\n", t -> tag);
1461 #endif /* UGEN_DEBUG */
1462         return(& t -> Xgco_specid_un);
1463 }
1464
1465 list *Rgco_specid_tys(t)
1466  struct Sco_specid *t;
1467 {
1468 #ifdef UGEN_DEBUG
1469         if(t -> tag != co_specid)
1470                 fprintf(stderr,"gco_specid_tys: illegal selection; was %d\n", t -> tag);
1471 #endif /* UGEN_DEBUG */
1472         return(& t -> Xgco_specid_tys);
1473 }
1474
1475 /************** co_wrkrid ******************/
1476
1477 coresyn mkco_wrkrid(PPgco_wrkrid_un)
1478  coresyn PPgco_wrkrid_un;
1479 {
1480         register struct Sco_wrkrid *pp =
1481                 (struct Sco_wrkrid *) malloc(sizeof(struct Sco_wrkrid));
1482         pp -> tag = co_wrkrid;
1483         pp -> Xgco_wrkrid_un = PPgco_wrkrid_un;
1484         return((coresyn)pp);
1485 }
1486
1487 coresyn *Rgco_wrkrid_un(t)
1488  struct Sco_wrkrid *t;
1489 {
1490 #ifdef UGEN_DEBUG
1491         if(t -> tag != co_wrkrid)
1492                 fprintf(stderr,"gco_wrkrid_un: illegal selection; was %d\n", t -> tag);
1493 #endif /* UGEN_DEBUG */
1494         return(& t -> Xgco_wrkrid_un);
1495 }