ghc/compiler/yaccParser/binding.c

   1
   2
   3 #include "hspincl.h"
   4 #include "yaccParser/binding.h"
   5
   6 Tbinding tbinding(t)
   7  binding t;
   8 {
   9         return(t -> tag);
  10 }
  11
  12
  13 /************** tbind ******************/
  14
  15 binding mktbind(PPgtbindc, PPgtbindid, PPgtbindl, PPgtbindd, PPgtline, PPgtpragma)
  16  list PPgtbindc;
  17  ttype PPgtbindid;
  18  list PPgtbindl;
  19  list PPgtbindd;
  20  long PPgtline;
  21  hpragma PPgtpragma;
  22 {
  23         register struct Stbind *pp =
  24                 (struct Stbind *) malloc(sizeof(struct Stbind));
  25         pp -> tag = tbind;
  26         pp -> Xgtbindc = PPgtbindc;
  27         pp -> Xgtbindid = PPgtbindid;
  28         pp -> Xgtbindl = PPgtbindl;
  29         pp -> Xgtbindd = PPgtbindd;
  30         pp -> Xgtline = PPgtline;
  31         pp -> Xgtpragma = PPgtpragma;
  32         return((binding)pp);
  33 }
  34
  35 list *Rgtbindc(t)
  36  struct Stbind *t;
  37 {
  38 #ifdef UGEN_DEBUG
  39         if(t -> tag != tbind)
  40                 fprintf(stderr,"gtbindc: illegal selection; was %d\n", t -> tag);
  41 #endif /* UGEN_DEBUG */
  42         return(& t -> Xgtbindc);
  43 }
  44
  45 ttype *Rgtbindid(t)
  46  struct Stbind *t;
  47 {
  48 #ifdef UGEN_DEBUG
  49         if(t -> tag != tbind)
  50                 fprintf(stderr,"gtbindid: illegal selection; was %d\n", t -> tag);
  51 #endif /* UGEN_DEBUG */
  52         return(& t -> Xgtbindid);
  53 }
  54
  55 list *Rgtbindl(t)
  56  struct Stbind *t;
  57 {
  58 #ifdef UGEN_DEBUG
  59         if(t -> tag != tbind)
  60                 fprintf(stderr,"gtbindl: illegal selection; was %d\n", t -> tag);
  61 #endif /* UGEN_DEBUG */
  62         return(& t -> Xgtbindl);
  63 }
  64
  65 list *Rgtbindd(t)
  66  struct Stbind *t;
  67 {
  68 #ifdef UGEN_DEBUG
  69         if(t -> tag != tbind)
  70                 fprintf(stderr,"gtbindd: illegal selection; was %d\n", t -> tag);
  71 #endif /* UGEN_DEBUG */
  72         return(& t -> Xgtbindd);
  73 }
  74
  75 long *Rgtline(t)
  76  struct Stbind *t;
  77 {
  78 #ifdef UGEN_DEBUG
  79         if(t -> tag != tbind)
  80                 fprintf(stderr,"gtline: illegal selection; was %d\n", t -> tag);
  81 #endif /* UGEN_DEBUG */
  82         return(& t -> Xgtline);
  83 }
  84
  85 hpragma *Rgtpragma(t)
  86  struct Stbind *t;
  87 {
  88 #ifdef UGEN_DEBUG
  89         if(t -> tag != tbind)
  90                 fprintf(stderr,"gtpragma: illegal selection; was %d\n", t -> tag);
  91 #endif /* UGEN_DEBUG */
  92         return(& t -> Xgtpragma);
  93 }
  94
  95 /************** nbind ******************/
  96
  97 binding mknbind(PPgnbindid, PPgnbindas, PPgnline, PPgnpragma)
  98  ttype PPgnbindid;
  99  ttype PPgnbindas;
 100  long PPgnline;
 101  hpragma PPgnpragma;
 102 {
 103         register struct Snbind *pp =
 104                 (struct Snbind *) malloc(sizeof(struct Snbind));
 105         pp -> tag = nbind;
 106         pp -> Xgnbindid = PPgnbindid;
 107         pp -> Xgnbindas = PPgnbindas;
 108         pp -> Xgnline = PPgnline;
 109         pp -> Xgnpragma = PPgnpragma;
 110         return((binding)pp);
 111 }
 112
 113 ttype *Rgnbindid(t)
 114  struct Snbind *t;
 115 {
 116 #ifdef UGEN_DEBUG
 117         if(t -> tag != nbind)
 118                 fprintf(stderr,"gnbindid: illegal selection; was %d\n", t -> tag);
 119 #endif /* UGEN_DEBUG */
 120         return(& t -> Xgnbindid);
 121 }
 122
 123 ttype *Rgnbindas(t)
 124  struct Snbind *t;
 125 {
 126 #ifdef UGEN_DEBUG
 127         if(t -> tag != nbind)
 128                 fprintf(stderr,"gnbindas: illegal selection; was %d\n", t -> tag);
 129 #endif /* UGEN_DEBUG */
 130         return(& t -> Xgnbindas);
 131 }
 132
 133 long *Rgnline(t)
 134  struct Snbind *t;
 135 {
 136 #ifdef UGEN_DEBUG
 137         if(t -> tag != nbind)
 138                 fprintf(stderr,"gnline: illegal selection; was %d\n", t -> tag);
 139 #endif /* UGEN_DEBUG */
 140         return(& t -> Xgnline);
 141 }
 142
 143 hpragma *Rgnpragma(t)
 144  struct Snbind *t;
 145 {
 146 #ifdef UGEN_DEBUG
 147         if(t -> tag != nbind)
 148                 fprintf(stderr,"gnpragma: illegal selection; was %d\n", t -> tag);
 149 #endif /* UGEN_DEBUG */
 150         return(& t -> Xgnpragma);
 151 }
 152
 153 /************** pbind ******************/
 154
 155 binding mkpbind(PPgpbindl, PPgpline)
 156  list PPgpbindl;
 157  long PPgpline;
 158 {
 159         register struct Spbind *pp =
 160                 (struct Spbind *) malloc(sizeof(struct Spbind));
 161         pp -> tag = pbind;
 162         pp -> Xgpbindl = PPgpbindl;
 163         pp -> Xgpline = PPgpline;
 164         return((binding)pp);
 165 }
 166
 167 list *Rgpbindl(t)
 168  struct Spbind *t;
 169 {
 170 #ifdef UGEN_DEBUG
 171         if(t -> tag != pbind)
 172                 fprintf(stderr,"gpbindl: illegal selection; was %d\n", t -> tag);
 173 #endif /* UGEN_DEBUG */
 174         return(& t -> Xgpbindl);
 175 }
 176
 177 long *Rgpline(t)
 178  struct Spbind *t;
 179 {
 180 #ifdef UGEN_DEBUG
 181         if(t -> tag != pbind)
 182                 fprintf(stderr,"gpline: illegal selection; was %d\n", t -> tag);
 183 #endif /* UGEN_DEBUG */
 184         return(& t -> Xgpline);
 185 }
 186
 187 /************** fbind ******************/
 188
 189 binding mkfbind(PPgfbindl, PPgfline)
 190  list PPgfbindl;
 191  long PPgfline;
 192 {
 193         register struct Sfbind *pp =
 194                 (struct Sfbind *) malloc(sizeof(struct Sfbind));
 195         pp -> tag = fbind;
 196         pp -> Xgfbindl = PPgfbindl;
 197         pp -> Xgfline = PPgfline;
 198         return((binding)pp);
 199 }
 200
 201 list *Rgfbindl(t)
 202  struct Sfbind *t;
 203 {
 204 #ifdef UGEN_DEBUG
 205         if(t -> tag != fbind)
 206                 fprintf(stderr,"gfbindl: illegal selection; was %d\n", t -> tag);
 207 #endif /* UGEN_DEBUG */
 208         return(& t -> Xgfbindl);
 209 }
 210
 211 long *Rgfline(t)
 212  struct Sfbind *t;
 213 {
 214 #ifdef UGEN_DEBUG
 215         if(t -> tag != fbind)
 216                 fprintf(stderr,"gfline: illegal selection; was %d\n", t -> tag);
 217 #endif /* UGEN_DEBUG */
 218         return(& t -> Xgfline);
 219 }
 220
 221 /************** abind ******************/
 222
 223 binding mkabind(PPgabindfst, PPgabindsnd)
 224  binding PPgabindfst;
 225  binding PPgabindsnd;
 226 {
 227         register struct Sabind *pp =
 228                 (struct Sabind *) malloc(sizeof(struct Sabind));
 229         pp -> tag = abind;
 230         pp -> Xgabindfst = PPgabindfst;
 231         pp -> Xgabindsnd = PPgabindsnd;
 232         return((binding)pp);
 233 }
 234
 235 binding *Rgabindfst(t)
 236  struct Sabind *t;
 237 {
 238 #ifdef UGEN_DEBUG
 239         if(t -> tag != abind)
 240                 fprintf(stderr,"gabindfst: illegal selection; was %d\n", t -> tag);
 241 #endif /* UGEN_DEBUG */
 242         return(& t -> Xgabindfst);
 243 }
 244
 245 binding *Rgabindsnd(t)
 246  struct Sabind *t;
 247 {
 248 #ifdef UGEN_DEBUG
 249         if(t -> tag != abind)
 250                 fprintf(stderr,"gabindsnd: illegal selection; was %d\n", t -> tag);
 251 #endif /* UGEN_DEBUG */
 252         return(& t -> Xgabindsnd);
 253 }
 254
 255 /************** lbind ******************/
 256
 257 binding mklbind(PPglbindfst, PPglbindsnd)
 258  binding PPglbindfst;
 259  binding PPglbindsnd;
 260 {
 261         register struct Slbind *pp =
 262                 (struct Slbind *) malloc(sizeof(struct Slbind));
 263         pp -> tag = lbind;
 264         pp -> Xglbindfst = PPglbindfst;
 265         pp -> Xglbindsnd = PPglbindsnd;
 266         return((binding)pp);
 267 }
 268
 269 binding *Rglbindfst(t)
 270  struct Slbind *t;
 271 {
 272 #ifdef UGEN_DEBUG
 273         if(t -> tag != lbind)
 274                 fprintf(stderr,"glbindfst: illegal selection; was %d\n", t -> tag);
 275 #endif /* UGEN_DEBUG */
 276         return(& t -> Xglbindfst);
 277 }
 278
 279 binding *Rglbindsnd(t)
 280  struct Slbind *t;
 281 {
 282 #ifdef UGEN_DEBUG
 283         if(t -> tag != lbind)
 284                 fprintf(stderr,"glbindsnd: illegal selection; was %d\n", t -> tag);
 285 #endif /* UGEN_DEBUG */
 286         return(& t -> Xglbindsnd);
 287 }
 288
 289 /************** ebind ******************/
 290
 291 binding mkebind(PPgebindl, PPgebind, PPgeline)
 292  list PPgebindl;
 293  binding PPgebind;
 294  long PPgeline;
 295 {
 296         register struct Sebind *pp =
 297                 (struct Sebind *) malloc(sizeof(struct Sebind));
 298         pp -> tag = ebind;
 299         pp -> Xgebindl = PPgebindl;
 300         pp -> Xgebind = PPgebind;
 301         pp -> Xgeline = PPgeline;
 302         return((binding)pp);
 303 }
 304
 305 list *Rgebindl(t)
 306  struct Sebind *t;
 307 {
 308 #ifdef UGEN_DEBUG
 309         if(t -> tag != ebind)
 310                 fprintf(stderr,"gebindl: illegal selection; was %d\n", t -> tag);
 311 #endif /* UGEN_DEBUG */
 312         return(& t -> Xgebindl);
 313 }
 314
 315 binding *Rgebind(t)
 316  struct Sebind *t;
 317 {
 318 #ifdef UGEN_DEBUG
 319         if(t -> tag != ebind)
 320                 fprintf(stderr,"gebind: illegal selection; was %d\n", t -> tag);
 321 #endif /* UGEN_DEBUG */
 322         return(& t -> Xgebind);
 323 }
 324
 325 long *Rgeline(t)
 326  struct Sebind *t;
 327 {
 328 #ifdef UGEN_DEBUG
 329         if(t -> tag != ebind)
 330                 fprintf(stderr,"geline: illegal selection; was %d\n", t -> tag);
 331 #endif /* UGEN_DEBUG */
 332         return(& t -> Xgeline);
 333 }
 334
 335 /************** hbind ******************/
 336
 337 binding mkhbind(PPghbindl, PPghbind, PPghline)
 338  list PPghbindl;
 339  binding PPghbind;
 340  long PPghline;
 341 {
 342         register struct Shbind *pp =
 343                 (struct Shbind *) malloc(sizeof(struct Shbind));
 344         pp -> tag = hbind;
 345         pp -> Xghbindl = PPghbindl;
 346         pp -> Xghbind = PPghbind;
 347         pp -> Xghline = PPghline;
 348         return((binding)pp);
 349 }
 350
 351 list *Rghbindl(t)
 352  struct Shbind *t;
 353 {
 354 #ifdef UGEN_DEBUG
 355         if(t -> tag != hbind)
 356                 fprintf(stderr,"ghbindl: illegal selection; was %d\n", t -> tag);
 357 #endif /* UGEN_DEBUG */
 358         return(& t -> Xghbindl);
 359 }
 360
 361 binding *Rghbind(t)
 362  struct Shbind *t;
 363 {
 364 #ifdef UGEN_DEBUG
 365         if(t -> tag != hbind)
 366                 fprintf(stderr,"ghbind: illegal selection; was %d\n", t -> tag);
 367 #endif /* UGEN_DEBUG */
 368         return(& t -> Xghbind);
 369 }
 370
 371 long *Rghline(t)
 372  struct Shbind *t;
 373 {
 374 #ifdef UGEN_DEBUG
 375         if(t -> tag != hbind)
 376                 fprintf(stderr,"ghline: illegal selection; was %d\n", t -> tag);
 377 #endif /* UGEN_DEBUG */
 378         return(& t -> Xghline);
 379 }
 380
 381 /************** ibind ******************/
 382
 383 binding mkibind(PPgibindc, PPgibindid, PPgibindi, PPgibindw, PPgiline, PPgipragma)
 384  list PPgibindc;
 385  unkId PPgibindid;
 386  ttype PPgibindi;
 387  binding PPgibindw;
 388  long PPgiline;
 389  hpragma PPgipragma;
 390 {
 391         register struct Sibind *pp =
 392                 (struct Sibind *) malloc(sizeof(struct Sibind));
 393         pp -> tag = ibind;
 394         pp -> Xgibindc = PPgibindc;
 395         pp -> Xgibindid = PPgibindid;
 396         pp -> Xgibindi = PPgibindi;
 397         pp -> Xgibindw = PPgibindw;
 398         pp -> Xgiline = PPgiline;
 399         pp -> Xgipragma = PPgipragma;
 400         return((binding)pp);
 401 }
 402
 403 list *Rgibindc(t)
 404  struct Sibind *t;
 405 {
 406 #ifdef UGEN_DEBUG
 407         if(t -> tag != ibind)
 408                 fprintf(stderr,"gibindc: illegal selection; was %d\n", t -> tag);
 409 #endif /* UGEN_DEBUG */
 410         return(& t -> Xgibindc);
 411 }
 412
 413 unkId *Rgibindid(t)
 414  struct Sibind *t;
 415 {
 416 #ifdef UGEN_DEBUG
 417         if(t -> tag != ibind)
 418                 fprintf(stderr,"gibindid: illegal selection; was %d\n", t -> tag);
 419 #endif /* UGEN_DEBUG */
 420         return(& t -> Xgibindid);
 421 }
 422
 423 ttype *Rgibindi(t)
 424  struct Sibind *t;
 425 {
 426 #ifdef UGEN_DEBUG
 427         if(t -> tag != ibind)
 428                 fprintf(stderr,"gibindi: illegal selection; was %d\n", t -> tag);
 429 #endif /* UGEN_DEBUG */
 430         return(& t -> Xgibindi);
 431 }
 432
 433 binding *Rgibindw(t)
 434  struct Sibind *t;
 435 {
 436 #ifdef UGEN_DEBUG
 437         if(t -> tag != ibind)
 438                 fprintf(stderr,"gibindw: illegal selection; was %d\n", t -> tag);
 439 #endif /* UGEN_DEBUG */
 440         return(& t -> Xgibindw);
 441 }
 442
 443 long *Rgiline(t)
 444  struct Sibind *t;
 445 {
 446 #ifdef UGEN_DEBUG
 447         if(t -> tag != ibind)
 448                 fprintf(stderr,"giline: illegal selection; was %d\n", t -> tag);
 449 #endif /* UGEN_DEBUG */
 450         return(& t -> Xgiline);
 451 }
 452
 453 hpragma *Rgipragma(t)
 454  struct Sibind *t;
 455 {
 456 #ifdef UGEN_DEBUG
 457         if(t -> tag != ibind)
 458                 fprintf(stderr,"gipragma: illegal selection; was %d\n", t -> tag);
 459 #endif /* UGEN_DEBUG */
 460         return(& t -> Xgipragma);
 461 }
 462
 463 /************** dbind ******************/
 464
 465 binding mkdbind(PPgdbindts, PPgdline)
 466  list PPgdbindts;
 467  long PPgdline;
 468 {
 469         register struct Sdbind *pp =
 470                 (struct Sdbind *) malloc(sizeof(struct Sdbind));
 471         pp -> tag = dbind;
 472         pp -> Xgdbindts = PPgdbindts;
 473         pp -> Xgdline = PPgdline;
 474         return((binding)pp);
 475 }
 476
 477 list *Rgdbindts(t)
 478  struct Sdbind *t;
 479 {
 480 #ifdef UGEN_DEBUG
 481         if(t -> tag != dbind)
 482                 fprintf(stderr,"gdbindts: illegal selection; was %d\n", t -> tag);
 483 #endif /* UGEN_DEBUG */
 484         return(& t -> Xgdbindts);
 485 }
 486
 487 long *Rgdline(t)
 488  struct Sdbind *t;
 489 {
 490 #ifdef UGEN_DEBUG
 491         if(t -> tag != dbind)
 492                 fprintf(stderr,"gdline: illegal selection; was %d\n", t -> tag);
 493 #endif /* UGEN_DEBUG */
 494         return(& t -> Xgdline);
 495 }
 496
 497 /************** cbind ******************/
 498
 499 binding mkcbind(PPgcbindc, PPgcbindid, PPgcbindw, PPgcline, PPgcpragma)
 500  list PPgcbindc;
 501  ttype PPgcbindid;
 502  binding PPgcbindw;
 503  long PPgcline;
 504  hpragma PPgcpragma;
 505 {
 506         register struct Scbind *pp =
 507                 (struct Scbind *) malloc(sizeof(struct Scbind));
 508         pp -> tag = cbind;
 509         pp -> Xgcbindc = PPgcbindc;
 510         pp -> Xgcbindid = PPgcbindid;
 511         pp -> Xgcbindw = PPgcbindw;
 512         pp -> Xgcline = PPgcline;
 513         pp -> Xgcpragma = PPgcpragma;
 514         return((binding)pp);
 515 }
 516
 517 list *Rgcbindc(t)
 518  struct Scbind *t;
 519 {
 520 #ifdef UGEN_DEBUG
 521         if(t -> tag != cbind)
 522                 fprintf(stderr,"gcbindc: illegal selection; was %d\n", t -> tag);
 523 #endif /* UGEN_DEBUG */
 524         return(& t -> Xgcbindc);
 525 }
 526
 527 ttype *Rgcbindid(t)
 528  struct Scbind *t;
 529 {
 530 #ifdef UGEN_DEBUG
 531         if(t -> tag != cbind)
 532                 fprintf(stderr,"gcbindid: illegal selection; was %d\n", t -> tag);
 533 #endif /* UGEN_DEBUG */
 534         return(& t -> Xgcbindid);
 535 }
 536
 537 binding *Rgcbindw(t)
 538  struct Scbind *t;
 539 {
 540 #ifdef UGEN_DEBUG
 541         if(t -> tag != cbind)
 542                 fprintf(stderr,"gcbindw: illegal selection; was %d\n", t -> tag);
 543 #endif /* UGEN_DEBUG */
 544         return(& t -> Xgcbindw);
 545 }
 546
 547 long *Rgcline(t)
 548  struct Scbind *t;
 549 {
 550 #ifdef UGEN_DEBUG
 551         if(t -> tag != cbind)
 552                 fprintf(stderr,"gcline: illegal selection; was %d\n", t -> tag);
 553 #endif /* UGEN_DEBUG */
 554         return(& t -> Xgcline);
 555 }
 556
 557 hpragma *Rgcpragma(t)
 558  struct Scbind *t;
 559 {
 560 #ifdef UGEN_DEBUG
 561         if(t -> tag != cbind)
 562                 fprintf(stderr,"gcpragma: illegal selection; was %d\n", t -> tag);
 563 #endif /* UGEN_DEBUG */
 564         return(& t -> Xgcpragma);
 565 }
 566
 567 /************** sbind ******************/
 568
 569 binding mksbind(PPgsbindids, PPgsbindid, PPgsline, PPgspragma)
 570  list PPgsbindids;
 571  ttype PPgsbindid;
 572  long PPgsline;
 573  hpragma PPgspragma;
 574 {
 575         register struct Ssbind *pp =
 576                 (struct Ssbind *) malloc(sizeof(struct Ssbind));
 577         pp -> tag = sbind;
 578         pp -> Xgsbindids = PPgsbindids;
 579         pp -> Xgsbindid = PPgsbindid;
 580         pp -> Xgsline = PPgsline;
 581         pp -> Xgspragma = PPgspragma;
 582         return((binding)pp);
 583 }
 584
 585 list *Rgsbindids(t)
 586  struct Ssbind *t;
 587 {
 588 #ifdef UGEN_DEBUG
 589         if(t -> tag != sbind)
 590                 fprintf(stderr,"gsbindids: illegal selection; was %d\n", t -> tag);
 591 #endif /* UGEN_DEBUG */
 592         return(& t -> Xgsbindids);
 593 }
 594
 595 ttype *Rgsbindid(t)
 596  struct Ssbind *t;
 597 {
 598 #ifdef UGEN_DEBUG
 599         if(t -> tag != sbind)
 600                 fprintf(stderr,"gsbindid: illegal selection; was %d\n", t -> tag);
 601 #endif /* UGEN_DEBUG */
 602         return(& t -> Xgsbindid);
 603 }
 604
 605 long *Rgsline(t)
 606  struct Ssbind *t;
 607 {
 608 #ifdef UGEN_DEBUG
 609         if(t -> tag != sbind)
 610                 fprintf(stderr,"gsline: illegal selection; was %d\n", t -> tag);
 611 #endif /* UGEN_DEBUG */
 612         return(& t -> Xgsline);
 613 }
 614
 615 hpragma *Rgspragma(t)
 616  struct Ssbind *t;
 617 {
 618 #ifdef UGEN_DEBUG
 619         if(t -> tag != sbind)
 620                 fprintf(stderr,"gspragma: illegal selection; was %d\n", t -> tag);
 621 #endif /* UGEN_DEBUG */
 622         return(& t -> Xgspragma);
 623 }
 624
 625 /************** mbind ******************/
 626
 627 binding mkmbind(PPgmbindmodn, PPgmbindimp, PPgmbindren, PPgmline)
 628  stringId PPgmbindmodn;
 629  list PPgmbindimp;
 630  list PPgmbindren;
 631  long PPgmline;
 632 {
 633         register struct Smbind *pp =
 634                 (struct Smbind *) malloc(sizeof(struct Smbind));
 635         pp -> tag = mbind;
 636         pp -> Xgmbindmodn = PPgmbindmodn;
 637         pp -> Xgmbindimp = PPgmbindimp;
 638         pp -> Xgmbindren = PPgmbindren;
 639         pp -> Xgmline = PPgmline;
 640         return((binding)pp);
 641 }
 642
 643 stringId *Rgmbindmodn(t)
 644  struct Smbind *t;
 645 {
 646 #ifdef UGEN_DEBUG
 647         if(t -> tag != mbind)
 648                 fprintf(stderr,"gmbindmodn: illegal selection; was %d\n", t -> tag);
 649 #endif /* UGEN_DEBUG */
 650         return(& t -> Xgmbindmodn);
 651 }
 652
 653 list *Rgmbindimp(t)
 654  struct Smbind *t;
 655 {
 656 #ifdef UGEN_DEBUG
 657         if(t -> tag != mbind)
 658                 fprintf(stderr,"gmbindimp: illegal selection; was %d\n", t -> tag);
 659 #endif /* UGEN_DEBUG */
 660         return(& t -> Xgmbindimp);
 661 }
 662
 663 list *Rgmbindren(t)
 664  struct Smbind *t;
 665 {
 666 #ifdef UGEN_DEBUG
 667         if(t -> tag != mbind)
 668                 fprintf(stderr,"gmbindren: illegal selection; was %d\n", t -> tag);
 669 #endif /* UGEN_DEBUG */
 670         return(& t -> Xgmbindren);
 671 }
 672
 673 long *Rgmline(t)
 674  struct Smbind *t;
 675 {
 676 #ifdef UGEN_DEBUG
 677         if(t -> tag != mbind)
 678                 fprintf(stderr,"gmline: illegal selection; was %d\n", t -> tag);
 679 #endif /* UGEN_DEBUG */
 680         return(& t -> Xgmline);
 681 }
 682
 683 /************** nullbind ******************/
 684
 685 binding mknullbind()
 686 {
 687         register struct Snullbind *pp =
 688                 (struct Snullbind *) malloc(sizeof(struct Snullbind));
 689         pp -> tag = nullbind;
 690         return((binding)pp);
 691 }
 692
 693 /************** import ******************/
 694
 695 binding mkimport(PPgiebindmod, PPgiebindexp, PPgiebindren, PPgiebinddef, PPgiebindfile, PPgiebindline)
 696  stringId PPgiebindmod;
 697  list PPgiebindexp;
 698  list PPgiebindren;
 699  binding PPgiebinddef;
 700  stringId PPgiebindfile;
 701  long PPgiebindline;
 702 {
 703         register struct Simport *pp =
 704                 (struct Simport *) malloc(sizeof(struct Simport));
 705         pp -> tag = import;
 706         pp -> Xgiebindmod = PPgiebindmod;
 707         pp -> Xgiebindexp = PPgiebindexp;
 708         pp -> Xgiebindren = PPgiebindren;
 709         pp -> Xgiebinddef = PPgiebinddef;
 710         pp -> Xgiebindfile = PPgiebindfile;
 711         pp -> Xgiebindline = PPgiebindline;
 712         return((binding)pp);
 713 }
 714
 715 stringId *Rgiebindmod(t)
 716  struct Simport *t;
 717 {
 718 #ifdef UGEN_DEBUG
 719         if(t -> tag != import)
 720                 fprintf(stderr,"giebindmod: illegal selection; was %d\n", t -> tag);
 721 #endif /* UGEN_DEBUG */
 722         return(& t -> Xgiebindmod);
 723 }
 724
 725 list *Rgiebindexp(t)
 726  struct Simport *t;
 727 {
 728 #ifdef UGEN_DEBUG
 729         if(t -> tag != import)
 730                 fprintf(stderr,"giebindexp: illegal selection; was %d\n", t -> tag);
 731 #endif /* UGEN_DEBUG */
 732         return(& t -> Xgiebindexp);
 733 }
 734
 735 list *Rgiebindren(t)
 736  struct Simport *t;
 737 {
 738 #ifdef UGEN_DEBUG
 739         if(t -> tag != import)
 740                 fprintf(stderr,"giebindren: illegal selection; was %d\n", t -> tag);
 741 #endif /* UGEN_DEBUG */
 742         return(& t -> Xgiebindren);
 743 }
 744
 745 binding *Rgiebinddef(t)
 746  struct Simport *t;
 747 {
 748 #ifdef UGEN_DEBUG
 749         if(t -> tag != import)
 750                 fprintf(stderr,"giebinddef: illegal selection; was %d\n", t -> tag);
 751 #endif /* UGEN_DEBUG */
 752         return(& t -> Xgiebinddef);
 753 }
 754
 755 stringId *Rgiebindfile(t)
 756  struct Simport *t;
 757 {
 758 #ifdef UGEN_DEBUG
 759         if(t -> tag != import)
 760                 fprintf(stderr,"giebindfile: illegal selection; was %d\n", t -> tag);
 761 #endif /* UGEN_DEBUG */
 762         return(& t -> Xgiebindfile);
 763 }
 764
 765 long *Rgiebindline(t)
 766  struct Simport *t;
 767 {
 768 #ifdef UGEN_DEBUG
 769         if(t -> tag != import)
 770                 fprintf(stderr,"giebindline: illegal selection; was %d\n", t -> tag);
 771 #endif /* UGEN_DEBUG */
 772         return(& t -> Xgiebindline);
 773 }
 774
 775 /************** hiding ******************/
 776
 777 binding mkhiding(PPgihbindmod, PPgihbindexp, PPgihbindren, PPgihbinddef, PPgihbindfile, PPgihbindline)
 778  stringId PPgihbindmod;
 779  list PPgihbindexp;
 780  list PPgihbindren;
 781  binding PPgihbinddef;
 782  stringId PPgihbindfile;
 783  long PPgihbindline;
 784 {
 785         register struct Shiding *pp =
 786                 (struct Shiding *) malloc(sizeof(struct Shiding));
 787         pp -> tag = hiding;
 788         pp -> Xgihbindmod = PPgihbindmod;
 789         pp -> Xgihbindexp = PPgihbindexp;
 790         pp -> Xgihbindren = PPgihbindren;
 791         pp -> Xgihbinddef = PPgihbinddef;
 792         pp -> Xgihbindfile = PPgihbindfile;
 793         pp -> Xgihbindline = PPgihbindline;
 794         return((binding)pp);
 795 }
 796
 797 stringId *Rgihbindmod(t)
 798  struct Shiding *t;
 799 {
 800 #ifdef UGEN_DEBUG
 801         if(t -> tag != hiding)
 802                 fprintf(stderr,"gihbindmod: illegal selection; was %d\n", t -> tag);
 803 #endif /* UGEN_DEBUG */
 804         return(& t -> Xgihbindmod);
 805 }
 806
 807 list *Rgihbindexp(t)
 808  struct Shiding *t;
 809 {
 810 #ifdef UGEN_DEBUG
 811         if(t -> tag != hiding)
 812                 fprintf(stderr,"gihbindexp: illegal selection; was %d\n", t -> tag);
 813 #endif /* UGEN_DEBUG */
 814         return(& t -> Xgihbindexp);
 815 }
 816
 817 list *Rgihbindren(t)
 818  struct Shiding *t;
 819 {
 820 #ifdef UGEN_DEBUG
 821         if(t -> tag != hiding)
 822                 fprintf(stderr,"gihbindren: illegal selection; was %d\n", t -> tag);
 823 #endif /* UGEN_DEBUG */
 824         return(& t -> Xgihbindren);
 825 }
 826
 827 binding *Rgihbinddef(t)
 828  struct Shiding *t;
 829 {
 830 #ifdef UGEN_DEBUG
 831         if(t -> tag != hiding)
 832                 fprintf(stderr,"gihbinddef: illegal selection; was %d\n", t -> tag);
 833 #endif /* UGEN_DEBUG */
 834         return(& t -> Xgihbinddef);
 835 }
 836
 837 stringId *Rgihbindfile(t)
 838  struct Shiding *t;
 839 {
 840 #ifdef UGEN_DEBUG
 841         if(t -> tag != hiding)
 842                 fprintf(stderr,"gihbindfile: illegal selection; was %d\n", t -> tag);
 843 #endif /* UGEN_DEBUG */
 844         return(& t -> Xgihbindfile);
 845 }
 846
 847 long *Rgihbindline(t)
 848  struct Shiding *t;
 849 {
 850 #ifdef UGEN_DEBUG
 851         if(t -> tag != hiding)
 852                 fprintf(stderr,"gihbindline: illegal selection; was %d\n", t -> tag);
 853 #endif /* UGEN_DEBUG */
 854         return(& t -> Xgihbindline);
 855 }
 856
 857 /************** vspec_uprag ******************/
 858
 859 binding mkvspec_uprag(PPgvspec_id, PPgvspec_tys, PPgvspec_line)
 860  unkId PPgvspec_id;
 861  list PPgvspec_tys;
 862  long PPgvspec_line;
 863 {
 864         register struct Svspec_uprag *pp =
 865                 (struct Svspec_uprag *) malloc(sizeof(struct Svspec_uprag));
 866         pp -> tag = vspec_uprag;
 867         pp -> Xgvspec_id = PPgvspec_id;
 868         pp -> Xgvspec_tys = PPgvspec_tys;
 869         pp -> Xgvspec_line = PPgvspec_line;
 870         return((binding)pp);
 871 }
 872
 873 unkId *Rgvspec_id(t)
 874  struct Svspec_uprag *t;
 875 {
 876 #ifdef UGEN_DEBUG
 877         if(t -> tag != vspec_uprag)
 878                 fprintf(stderr,"gvspec_id: illegal selection; was %d\n", t -> tag);
 879 #endif /* UGEN_DEBUG */
 880         return(& t -> Xgvspec_id);
 881 }
 882
 883 list *Rgvspec_tys(t)
 884  struct Svspec_uprag *t;
 885 {
 886 #ifdef UGEN_DEBUG
 887         if(t -> tag != vspec_uprag)
 888                 fprintf(stderr,"gvspec_tys: illegal selection; was %d\n", t -> tag);
 889 #endif /* UGEN_DEBUG */
 890         return(& t -> Xgvspec_tys);
 891 }
 892
 893 long *Rgvspec_line(t)
 894  struct Svspec_uprag *t;
 895 {
 896 #ifdef UGEN_DEBUG
 897         if(t -> tag != vspec_uprag)
 898                 fprintf(stderr,"gvspec_line: illegal selection; was %d\n", t -> tag);
 899 #endif /* UGEN_DEBUG */
 900         return(& t -> Xgvspec_line);
 901 }
 902
 903 /************** vspec_ty_and_id ******************/
 904
 905 binding mkvspec_ty_and_id(PPgvspec_ty, PPgvspec_tyid)
 906  ttype PPgvspec_ty;
 907  list PPgvspec_tyid;
 908 {
 909         register struct Svspec_ty_and_id *pp =
 910                 (struct Svspec_ty_and_id *) malloc(sizeof(struct Svspec_ty_and_id));
 911         pp -> tag = vspec_ty_and_id;
 912         pp -> Xgvspec_ty = PPgvspec_ty;
 913         pp -> Xgvspec_tyid = PPgvspec_tyid;
 914         return((binding)pp);
 915 }
 916
 917 ttype *Rgvspec_ty(t)
 918  struct Svspec_ty_and_id *t;
 919 {
 920 #ifdef UGEN_DEBUG
 921         if(t -> tag != vspec_ty_and_id)
 922                 fprintf(stderr,"gvspec_ty: illegal selection; was %d\n", t -> tag);
 923 #endif /* UGEN_DEBUG */
 924         return(& t -> Xgvspec_ty);
 925 }
 926
 927 list *Rgvspec_tyid(t)
 928  struct Svspec_ty_and_id *t;
 929 {
 930 #ifdef UGEN_DEBUG
 931         if(t -> tag != vspec_ty_and_id)
 932                 fprintf(stderr,"gvspec_tyid: illegal selection; was %d\n", t -> tag);
 933 #endif /* UGEN_DEBUG */
 934         return(& t -> Xgvspec_tyid);
 935 }
 936
 937 /************** ispec_uprag ******************/
 938
 939 binding mkispec_uprag(PPgispec_clas, PPgispec_ty, PPgispec_line)
 940  unkId PPgispec_clas;
 941  ttype PPgispec_ty;
 942  long PPgispec_line;
 943 {
 944         register struct Sispec_uprag *pp =
 945                 (struct Sispec_uprag *) malloc(sizeof(struct Sispec_uprag));
 946         pp -> tag = ispec_uprag;
 947         pp -> Xgispec_clas = PPgispec_clas;
 948         pp -> Xgispec_ty = PPgispec_ty;
 949         pp -> Xgispec_line = PPgispec_line;
 950         return((binding)pp);
 951 }
 952
 953 unkId *Rgispec_clas(t)
 954  struct Sispec_uprag *t;
 955 {
 956 #ifdef UGEN_DEBUG
 957         if(t -> tag != ispec_uprag)
 958                 fprintf(stderr,"gispec_clas: illegal selection; was %d\n", t -> tag);
 959 #endif /* UGEN_DEBUG */
 960         return(& t -> Xgispec_clas);
 961 }
 962
 963 ttype *Rgispec_ty(t)
 964  struct Sispec_uprag *t;
 965 {
 966 #ifdef UGEN_DEBUG
 967         if(t -> tag != ispec_uprag)
 968                 fprintf(stderr,"gispec_ty: illegal selection; was %d\n", t -> tag);
 969 #endif /* UGEN_DEBUG */
 970         return(& t -> Xgispec_ty);
 971 }
 972
 973 long *Rgispec_line(t)
 974  struct Sispec_uprag *t;
 975 {
 976 #ifdef UGEN_DEBUG
 977         if(t -> tag != ispec_uprag)
 978                 fprintf(stderr,"gispec_line: illegal selection; was %d\n", t -> tag);
 979 #endif /* UGEN_DEBUG */
 980         return(& t -> Xgispec_line);
 981 }
 982
 983 /************** inline_uprag ******************/
 984
 985 binding mkinline_uprag(PPginline_id, PPginline_howto, PPginline_line)
 986  unkId PPginline_id;
 987  list PPginline_howto;
 988  long PPginline_line;
 989 {
 990         register struct Sinline_uprag *pp =
 991                 (struct Sinline_uprag *) malloc(sizeof(struct Sinline_uprag));
 992         pp -> tag = inline_uprag;
 993         pp -> Xginline_id = PPginline_id;
 994         pp -> Xginline_howto = PPginline_howto;
 995         pp -> Xginline_line = PPginline_line;
 996         return((binding)pp);
 997 }
 998
 999 unkId *Rginline_id(t)
1000  struct Sinline_uprag *t;
1001 {
1002 #ifdef UGEN_DEBUG
1003         if(t -> tag != inline_uprag)
1004                 fprintf(stderr,"ginline_id: illegal selection; was %d\n", t -> tag);
1005 #endif /* UGEN_DEBUG */
1006         return(& t -> Xginline_id);
1007 }
1008
1009 list *Rginline_howto(t)
1010  struct Sinline_uprag *t;
1011 {
1012 #ifdef UGEN_DEBUG
1013         if(t -> tag != inline_uprag)
1014                 fprintf(stderr,"ginline_howto: illegal selection; was %d\n", t -> tag);
1015 #endif /* UGEN_DEBUG */
1016         return(& t -> Xginline_howto);
1017 }
1018
1019 long *Rginline_line(t)
1020  struct Sinline_uprag *t;
1021 {
1022 #ifdef UGEN_DEBUG
1023         if(t -> tag != inline_uprag)
1024                 fprintf(stderr,"ginline_line: illegal selection; was %d\n", t -> tag);
1025 #endif /* UGEN_DEBUG */
1026         return(& t -> Xginline_line);
1027 }
1028
1029 /************** deforest_uprag ******************/
1030
1031 binding mkdeforest_uprag(PPgdeforest_id, PPgdeforest_line)
1032  unkId PPgdeforest_id;
1033  long PPgdeforest_line;
1034 {
1035         register struct Sdeforest_uprag *pp =
1036                 (struct Sdeforest_uprag *) malloc(sizeof(struct Sdeforest_uprag));
1037         pp -> tag = deforest_uprag;
1038         pp -> Xgdeforest_id = PPgdeforest_id;
1039         pp -> Xgdeforest_line = PPgdeforest_line;
1040         return((binding)pp);
1041 }
1042
1043 unkId *Rgdeforest_id(t)
1044  struct Sdeforest_uprag *t;
1045 {
1046 #ifdef UGEN_DEBUG
1047         if(t -> tag != deforest_uprag)
1048                 fprintf(stderr,"gdeforest_id: illegal selection; was %d\n", t -> tag);
1049 #endif /* UGEN_DEBUG */
1050         return(& t -> Xgdeforest_id);
1051 }
1052
1053 long *Rgdeforest_line(t)
1054  struct Sdeforest_uprag *t;
1055 {
1056 #ifdef UGEN_DEBUG
1057         if(t -> tag != deforest_uprag)
1058                 fprintf(stderr,"gdeforest_line: illegal selection; was %d\n", t -> tag);
1059 #endif /* UGEN_DEBUG */
1060         return(& t -> Xgdeforest_line);
1061 }
1062
1063 /************** magicuf_uprag ******************/
1064
1065 binding mkmagicuf_uprag(PPgmagicuf_id, PPgmagicuf_str, PPgmagicuf_line)
1066  unkId PPgmagicuf_id;
1067  stringId PPgmagicuf_str;
1068  long PPgmagicuf_line;
1069 {
1070         register struct Smagicuf_uprag *pp =
1071                 (struct Smagicuf_uprag *) malloc(sizeof(struct Smagicuf_uprag));
1072         pp -> tag = magicuf_uprag;
1073         pp -> Xgmagicuf_id = PPgmagicuf_id;
1074         pp -> Xgmagicuf_str = PPgmagicuf_str;
1075         pp -> Xgmagicuf_line = PPgmagicuf_line;
1076         return((binding)pp);
1077 }
1078
1079 unkId *Rgmagicuf_id(t)
1080  struct Smagicuf_uprag *t;
1081 {
1082 #ifdef UGEN_DEBUG
1083         if(t -> tag != magicuf_uprag)
1084                 fprintf(stderr,"gmagicuf_id: illegal selection; was %d\n", t -> tag);
1085 #endif /* UGEN_DEBUG */
1086         return(& t -> Xgmagicuf_id);
1087 }
1088
1089 stringId *Rgmagicuf_str(t)
1090  struct Smagicuf_uprag *t;
1091 {
1092 #ifdef UGEN_DEBUG
1093         if(t -> tag != magicuf_uprag)
1094                 fprintf(stderr,"gmagicuf_str: illegal selection; was %d\n", t -> tag);
1095 #endif /* UGEN_DEBUG */
1096         return(& t -> Xgmagicuf_str);
1097 }
1098
1099 long *Rgmagicuf_line(t)
1100  struct Smagicuf_uprag *t;
1101 {
1102 #ifdef UGEN_DEBUG
1103         if(t -> tag != magicuf_uprag)
1104                 fprintf(stderr,"gmagicuf_line: illegal selection; was %d\n", t -> tag);
1105 #endif /* UGEN_DEBUG */
1106         return(& t -> Xgmagicuf_line);
1107 }
1108
1109 /************** abstract_uprag ******************/
1110
1111 binding mkabstract_uprag(PPgabstract_id, PPgabstract_line)
1112  unkId PPgabstract_id;
1113  long PPgabstract_line;
1114 {
1115         register struct Sabstract_uprag *pp =
1116                 (struct Sabstract_uprag *) malloc(sizeof(struct Sabstract_uprag));
1117         pp -> tag = abstract_uprag;
1118         pp -> Xgabstract_id = PPgabstract_id;
1119         pp -> Xgabstract_line = PPgabstract_line;
1120         return((binding)pp);
1121 }
1122
1123 unkId *Rgabstract_id(t)
1124  struct Sabstract_uprag *t;
1125 {
1126 #ifdef UGEN_DEBUG
1127         if(t -> tag != abstract_uprag)
1128                 fprintf(stderr,"gabstract_id: illegal selection; was %d\n", t -> tag);
1129 #endif /* UGEN_DEBUG */
1130         return(& t -> Xgabstract_id);
1131 }
1132
1133 long *Rgabstract_line(t)
1134  struct Sabstract_uprag *t;
1135 {
1136 #ifdef UGEN_DEBUG
1137         if(t -> tag != abstract_uprag)
1138                 fprintf(stderr,"gabstract_line: illegal selection; was %d\n", t -> tag);
1139 #endif /* UGEN_DEBUG */
1140         return(& t -> Xgabstract_line);
1141 }
1142
1143 /************** dspec_uprag ******************/
1144
1145 binding mkdspec_uprag(PPgdspec_id, PPgdspec_tys, PPgdspec_line)
1146  unkId PPgdspec_id;
1147  list PPgdspec_tys;
1148  long PPgdspec_line;
1149 {
1150         register struct Sdspec_uprag *pp =
1151                 (struct Sdspec_uprag *) malloc(sizeof(struct Sdspec_uprag));
1152         pp -> tag = dspec_uprag;
1153         pp -> Xgdspec_id = PPgdspec_id;
1154         pp -> Xgdspec_tys = PPgdspec_tys;
1155         pp -> Xgdspec_line = PPgdspec_line;
1156         return((binding)pp);
1157 }
1158
1159 unkId *Rgdspec_id(t)
1160  struct Sdspec_uprag *t;
1161 {
1162 #ifdef UGEN_DEBUG
1163         if(t -> tag != dspec_uprag)
1164                 fprintf(stderr,"gdspec_id: illegal selection; was %d\n", t -> tag);
1165 #endif /* UGEN_DEBUG */
1166         return(& t -> Xgdspec_id);
1167 }
1168
1169 list *Rgdspec_tys(t)
1170  struct Sdspec_uprag *t;
1171 {
1172 #ifdef UGEN_DEBUG
1173         if(t -> tag != dspec_uprag)
1174                 fprintf(stderr,"gdspec_tys: illegal selection; was %d\n", t -> tag);
1175 #endif /* UGEN_DEBUG */
1176         return(& t -> Xgdspec_tys);
1177 }
1178
1179 long *Rgdspec_line(t)
1180  struct Sdspec_uprag *t;
1181 {
1182 #ifdef UGEN_DEBUG
1183         if(t -> tag != dspec_uprag)
1184                 fprintf(stderr,"gdspec_line: illegal selection; was %d\n", t -> tag);
1185 #endif /* UGEN_DEBUG */
1186         return(& t -> Xgdspec_line);
1187 }