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 /************** ibind ******************/
 256
 257 binding mkibind(PPgibindc, PPgibindid, PPgibindi, PPgibindw, PPgiline, PPgipragma)
 258  list PPgibindc;
 259  unkId PPgibindid;
 260  ttype PPgibindi;
 261  binding PPgibindw;
 262  long PPgiline;
 263  hpragma PPgipragma;
 264 {
 265         register struct Sibind *pp =
 266                 (struct Sibind *) malloc(sizeof(struct Sibind));
 267         pp -> tag = ibind;
 268         pp -> Xgibindc = PPgibindc;
 269         pp -> Xgibindid = PPgibindid;
 270         pp -> Xgibindi = PPgibindi;
 271         pp -> Xgibindw = PPgibindw;
 272         pp -> Xgiline = PPgiline;
 273         pp -> Xgipragma = PPgipragma;
 274         return((binding)pp);
 275 }
 276
 277 list *Rgibindc(t)
 278  struct Sibind *t;
 279 {
 280 #ifdef UGEN_DEBUG
 281         if(t -> tag != ibind)
 282                 fprintf(stderr,"gibindc: illegal selection; was %d\n", t -> tag);
 283 #endif /* UGEN_DEBUG */
 284         return(& t -> Xgibindc);
 285 }
 286
 287 unkId *Rgibindid(t)
 288  struct Sibind *t;
 289 {
 290 #ifdef UGEN_DEBUG
 291         if(t -> tag != ibind)
 292                 fprintf(stderr,"gibindid: illegal selection; was %d\n", t -> tag);
 293 #endif /* UGEN_DEBUG */
 294         return(& t -> Xgibindid);
 295 }
 296
 297 ttype *Rgibindi(t)
 298  struct Sibind *t;
 299 {
 300 #ifdef UGEN_DEBUG
 301         if(t -> tag != ibind)
 302                 fprintf(stderr,"gibindi: illegal selection; was %d\n", t -> tag);
 303 #endif /* UGEN_DEBUG */
 304         return(& t -> Xgibindi);
 305 }
 306
 307 binding *Rgibindw(t)
 308  struct Sibind *t;
 309 {
 310 #ifdef UGEN_DEBUG
 311         if(t -> tag != ibind)
 312                 fprintf(stderr,"gibindw: illegal selection; was %d\n", t -> tag);
 313 #endif /* UGEN_DEBUG */
 314         return(& t -> Xgibindw);
 315 }
 316
 317 long *Rgiline(t)
 318  struct Sibind *t;
 319 {
 320 #ifdef UGEN_DEBUG
 321         if(t -> tag != ibind)
 322                 fprintf(stderr,"giline: illegal selection; was %d\n", t -> tag);
 323 #endif /* UGEN_DEBUG */
 324         return(& t -> Xgiline);
 325 }
 326
 327 hpragma *Rgipragma(t)
 328  struct Sibind *t;
 329 {
 330 #ifdef UGEN_DEBUG
 331         if(t -> tag != ibind)
 332                 fprintf(stderr,"gipragma: illegal selection; was %d\n", t -> tag);
 333 #endif /* UGEN_DEBUG */
 334         return(& t -> Xgipragma);
 335 }
 336
 337 /************** dbind ******************/
 338
 339 binding mkdbind(PPgdbindts, PPgdline)
 340  list PPgdbindts;
 341  long PPgdline;
 342 {
 343         register struct Sdbind *pp =
 344                 (struct Sdbind *) malloc(sizeof(struct Sdbind));
 345         pp -> tag = dbind;
 346         pp -> Xgdbindts = PPgdbindts;
 347         pp -> Xgdline = PPgdline;
 348         return((binding)pp);
 349 }
 350
 351 list *Rgdbindts(t)
 352  struct Sdbind *t;
 353 {
 354 #ifdef UGEN_DEBUG
 355         if(t -> tag != dbind)
 356                 fprintf(stderr,"gdbindts: illegal selection; was %d\n", t -> tag);
 357 #endif /* UGEN_DEBUG */
 358         return(& t -> Xgdbindts);
 359 }
 360
 361 long *Rgdline(t)
 362  struct Sdbind *t;
 363 {
 364 #ifdef UGEN_DEBUG
 365         if(t -> tag != dbind)
 366                 fprintf(stderr,"gdline: illegal selection; was %d\n", t -> tag);
 367 #endif /* UGEN_DEBUG */
 368         return(& t -> Xgdline);
 369 }
 370
 371 /************** cbind ******************/
 372
 373 binding mkcbind(PPgcbindc, PPgcbindid, PPgcbindw, PPgcline, PPgcpragma)
 374  list PPgcbindc;
 375  ttype PPgcbindid;
 376  binding PPgcbindw;
 377  long PPgcline;
 378  hpragma PPgcpragma;
 379 {
 380         register struct Scbind *pp =
 381                 (struct Scbind *) malloc(sizeof(struct Scbind));
 382         pp -> tag = cbind;
 383         pp -> Xgcbindc = PPgcbindc;
 384         pp -> Xgcbindid = PPgcbindid;
 385         pp -> Xgcbindw = PPgcbindw;
 386         pp -> Xgcline = PPgcline;
 387         pp -> Xgcpragma = PPgcpragma;
 388         return((binding)pp);
 389 }
 390
 391 list *Rgcbindc(t)
 392  struct Scbind *t;
 393 {
 394 #ifdef UGEN_DEBUG
 395         if(t -> tag != cbind)
 396                 fprintf(stderr,"gcbindc: illegal selection; was %d\n", t -> tag);
 397 #endif /* UGEN_DEBUG */
 398         return(& t -> Xgcbindc);
 399 }
 400
 401 ttype *Rgcbindid(t)
 402  struct Scbind *t;
 403 {
 404 #ifdef UGEN_DEBUG
 405         if(t -> tag != cbind)
 406                 fprintf(stderr,"gcbindid: illegal selection; was %d\n", t -> tag);
 407 #endif /* UGEN_DEBUG */
 408         return(& t -> Xgcbindid);
 409 }
 410
 411 binding *Rgcbindw(t)
 412  struct Scbind *t;
 413 {
 414 #ifdef UGEN_DEBUG
 415         if(t -> tag != cbind)
 416                 fprintf(stderr,"gcbindw: illegal selection; was %d\n", t -> tag);
 417 #endif /* UGEN_DEBUG */
 418         return(& t -> Xgcbindw);
 419 }
 420
 421 long *Rgcline(t)
 422  struct Scbind *t;
 423 {
 424 #ifdef UGEN_DEBUG
 425         if(t -> tag != cbind)
 426                 fprintf(stderr,"gcline: illegal selection; was %d\n", t -> tag);
 427 #endif /* UGEN_DEBUG */
 428         return(& t -> Xgcline);
 429 }
 430
 431 hpragma *Rgcpragma(t)
 432  struct Scbind *t;
 433 {
 434 #ifdef UGEN_DEBUG
 435         if(t -> tag != cbind)
 436                 fprintf(stderr,"gcpragma: illegal selection; was %d\n", t -> tag);
 437 #endif /* UGEN_DEBUG */
 438         return(& t -> Xgcpragma);
 439 }
 440
 441 /************** sbind ******************/
 442
 443 binding mksbind(PPgsbindids, PPgsbindid, PPgsline, PPgspragma)
 444  list PPgsbindids;
 445  ttype PPgsbindid;
 446  long PPgsline;
 447  hpragma PPgspragma;
 448 {
 449         register struct Ssbind *pp =
 450                 (struct Ssbind *) malloc(sizeof(struct Ssbind));
 451         pp -> tag = sbind;
 452         pp -> Xgsbindids = PPgsbindids;
 453         pp -> Xgsbindid = PPgsbindid;
 454         pp -> Xgsline = PPgsline;
 455         pp -> Xgspragma = PPgspragma;
 456         return((binding)pp);
 457 }
 458
 459 list *Rgsbindids(t)
 460  struct Ssbind *t;
 461 {
 462 #ifdef UGEN_DEBUG
 463         if(t -> tag != sbind)
 464                 fprintf(stderr,"gsbindids: illegal selection; was %d\n", t -> tag);
 465 #endif /* UGEN_DEBUG */
 466         return(& t -> Xgsbindids);
 467 }
 468
 469 ttype *Rgsbindid(t)
 470  struct Ssbind *t;
 471 {
 472 #ifdef UGEN_DEBUG
 473         if(t -> tag != sbind)
 474                 fprintf(stderr,"gsbindid: illegal selection; was %d\n", t -> tag);
 475 #endif /* UGEN_DEBUG */
 476         return(& t -> Xgsbindid);
 477 }
 478
 479 long *Rgsline(t)
 480  struct Ssbind *t;
 481 {
 482 #ifdef UGEN_DEBUG
 483         if(t -> tag != sbind)
 484                 fprintf(stderr,"gsline: illegal selection; was %d\n", t -> tag);
 485 #endif /* UGEN_DEBUG */
 486         return(& t -> Xgsline);
 487 }
 488
 489 hpragma *Rgspragma(t)
 490  struct Ssbind *t;
 491 {
 492 #ifdef UGEN_DEBUG
 493         if(t -> tag != sbind)
 494                 fprintf(stderr,"gspragma: illegal selection; was %d\n", t -> tag);
 495 #endif /* UGEN_DEBUG */
 496         return(& t -> Xgspragma);
 497 }
 498
 499 /************** mbind ******************/
 500
 501 binding mkmbind(PPgmbindmodn, PPgmbindimp, PPgmbindren, PPgmline)
 502  stringId PPgmbindmodn;
 503  list PPgmbindimp;
 504  list PPgmbindren;
 505  long PPgmline;
 506 {
 507         register struct Smbind *pp =
 508                 (struct Smbind *) malloc(sizeof(struct Smbind));
 509         pp -> tag = mbind;
 510         pp -> Xgmbindmodn = PPgmbindmodn;
 511         pp -> Xgmbindimp = PPgmbindimp;
 512         pp -> Xgmbindren = PPgmbindren;
 513         pp -> Xgmline = PPgmline;
 514         return((binding)pp);
 515 }
 516
 517 stringId *Rgmbindmodn(t)
 518  struct Smbind *t;
 519 {
 520 #ifdef UGEN_DEBUG
 521         if(t -> tag != mbind)
 522                 fprintf(stderr,"gmbindmodn: illegal selection; was %d\n", t -> tag);
 523 #endif /* UGEN_DEBUG */
 524         return(& t -> Xgmbindmodn);
 525 }
 526
 527 list *Rgmbindimp(t)
 528  struct Smbind *t;
 529 {
 530 #ifdef UGEN_DEBUG
 531         if(t -> tag != mbind)
 532                 fprintf(stderr,"gmbindimp: illegal selection; was %d\n", t -> tag);
 533 #endif /* UGEN_DEBUG */
 534         return(& t -> Xgmbindimp);
 535 }
 536
 537 list *Rgmbindren(t)
 538  struct Smbind *t;
 539 {
 540 #ifdef UGEN_DEBUG
 541         if(t -> tag != mbind)
 542                 fprintf(stderr,"gmbindren: illegal selection; was %d\n", t -> tag);
 543 #endif /* UGEN_DEBUG */
 544         return(& t -> Xgmbindren);
 545 }
 546
 547 long *Rgmline(t)
 548  struct Smbind *t;
 549 {
 550 #ifdef UGEN_DEBUG
 551         if(t -> tag != mbind)
 552                 fprintf(stderr,"gmline: illegal selection; was %d\n", t -> tag);
 553 #endif /* UGEN_DEBUG */
 554         return(& t -> Xgmline);
 555 }
 556
 557 /************** nullbind ******************/
 558
 559 binding mknullbind(void)
 560 {
 561         register struct Snullbind *pp =
 562                 (struct Snullbind *) malloc(sizeof(struct Snullbind));
 563         pp -> tag = nullbind;
 564         return((binding)pp);
 565 }
 566
 567 /************** import ******************/
 568
 569 binding mkimport(PPgiebindmod, PPgiebindexp, PPgiebindren, PPgiebinddef, PPgiebindfile, PPgiebindline)
 570  stringId PPgiebindmod;
 571  list PPgiebindexp;
 572  list PPgiebindren;
 573  binding PPgiebinddef;
 574  stringId PPgiebindfile;
 575  long PPgiebindline;
 576 {
 577         register struct Simport *pp =
 578                 (struct Simport *) malloc(sizeof(struct Simport));
 579         pp -> tag = import;
 580         pp -> Xgiebindmod = PPgiebindmod;
 581         pp -> Xgiebindexp = PPgiebindexp;
 582         pp -> Xgiebindren = PPgiebindren;
 583         pp -> Xgiebinddef = PPgiebinddef;
 584         pp -> Xgiebindfile = PPgiebindfile;
 585         pp -> Xgiebindline = PPgiebindline;
 586         return((binding)pp);
 587 }
 588
 589 stringId *Rgiebindmod(t)
 590  struct Simport *t;
 591 {
 592 #ifdef UGEN_DEBUG
 593         if(t -> tag != import)
 594                 fprintf(stderr,"giebindmod: illegal selection; was %d\n", t -> tag);
 595 #endif /* UGEN_DEBUG */
 596         return(& t -> Xgiebindmod);
 597 }
 598
 599 list *Rgiebindexp(t)
 600  struct Simport *t;
 601 {
 602 #ifdef UGEN_DEBUG
 603         if(t -> tag != import)
 604                 fprintf(stderr,"giebindexp: illegal selection; was %d\n", t -> tag);
 605 #endif /* UGEN_DEBUG */
 606         return(& t -> Xgiebindexp);
 607 }
 608
 609 list *Rgiebindren(t)
 610  struct Simport *t;
 611 {
 612 #ifdef UGEN_DEBUG
 613         if(t -> tag != import)
 614                 fprintf(stderr,"giebindren: illegal selection; was %d\n", t -> tag);
 615 #endif /* UGEN_DEBUG */
 616         return(& t -> Xgiebindren);
 617 }
 618
 619 binding *Rgiebinddef(t)
 620  struct Simport *t;
 621 {
 622 #ifdef UGEN_DEBUG
 623         if(t -> tag != import)
 624                 fprintf(stderr,"giebinddef: illegal selection; was %d\n", t -> tag);
 625 #endif /* UGEN_DEBUG */
 626         return(& t -> Xgiebinddef);
 627 }
 628
 629 stringId *Rgiebindfile(t)
 630  struct Simport *t;
 631 {
 632 #ifdef UGEN_DEBUG
 633         if(t -> tag != import)
 634                 fprintf(stderr,"giebindfile: illegal selection; was %d\n", t -> tag);
 635 #endif /* UGEN_DEBUG */
 636         return(& t -> Xgiebindfile);
 637 }
 638
 639 long *Rgiebindline(t)
 640  struct Simport *t;
 641 {
 642 #ifdef UGEN_DEBUG
 643         if(t -> tag != import)
 644                 fprintf(stderr,"giebindline: illegal selection; was %d\n", t -> tag);
 645 #endif /* UGEN_DEBUG */
 646         return(& t -> Xgiebindline);
 647 }
 648
 649 /************** hiding ******************/
 650
 651 binding mkhiding(PPgihbindmod, PPgihbindexp, PPgihbindren, PPgihbinddef, PPgihbindfile, PPgihbindline)
 652  stringId PPgihbindmod;
 653  list PPgihbindexp;
 654  list PPgihbindren;
 655  binding PPgihbinddef;
 656  stringId PPgihbindfile;
 657  long PPgihbindline;
 658 {
 659         register struct Shiding *pp =
 660                 (struct Shiding *) malloc(sizeof(struct Shiding));
 661         pp -> tag = hiding;
 662         pp -> Xgihbindmod = PPgihbindmod;
 663         pp -> Xgihbindexp = PPgihbindexp;
 664         pp -> Xgihbindren = PPgihbindren;
 665         pp -> Xgihbinddef = PPgihbinddef;
 666         pp -> Xgihbindfile = PPgihbindfile;
 667         pp -> Xgihbindline = PPgihbindline;
 668         return((binding)pp);
 669 }
 670
 671 stringId *Rgihbindmod(t)
 672  struct Shiding *t;
 673 {
 674 #ifdef UGEN_DEBUG
 675         if(t -> tag != hiding)
 676                 fprintf(stderr,"gihbindmod: illegal selection; was %d\n", t -> tag);
 677 #endif /* UGEN_DEBUG */
 678         return(& t -> Xgihbindmod);
 679 }
 680
 681 list *Rgihbindexp(t)
 682  struct Shiding *t;
 683 {
 684 #ifdef UGEN_DEBUG
 685         if(t -> tag != hiding)
 686                 fprintf(stderr,"gihbindexp: illegal selection; was %d\n", t -> tag);
 687 #endif /* UGEN_DEBUG */
 688         return(& t -> Xgihbindexp);
 689 }
 690
 691 list *Rgihbindren(t)
 692  struct Shiding *t;
 693 {
 694 #ifdef UGEN_DEBUG
 695         if(t -> tag != hiding)
 696                 fprintf(stderr,"gihbindren: illegal selection; was %d\n", t -> tag);
 697 #endif /* UGEN_DEBUG */
 698         return(& t -> Xgihbindren);
 699 }
 700
 701 binding *Rgihbinddef(t)
 702  struct Shiding *t;
 703 {
 704 #ifdef UGEN_DEBUG
 705         if(t -> tag != hiding)
 706                 fprintf(stderr,"gihbinddef: illegal selection; was %d\n", t -> tag);
 707 #endif /* UGEN_DEBUG */
 708         return(& t -> Xgihbinddef);
 709 }
 710
 711 stringId *Rgihbindfile(t)
 712  struct Shiding *t;
 713 {
 714 #ifdef UGEN_DEBUG
 715         if(t -> tag != hiding)
 716                 fprintf(stderr,"gihbindfile: illegal selection; was %d\n", t -> tag);
 717 #endif /* UGEN_DEBUG */
 718         return(& t -> Xgihbindfile);
 719 }
 720
 721 long *Rgihbindline(t)
 722  struct Shiding *t;
 723 {
 724 #ifdef UGEN_DEBUG
 725         if(t -> tag != hiding)
 726                 fprintf(stderr,"gihbindline: illegal selection; was %d\n", t -> tag);
 727 #endif /* UGEN_DEBUG */
 728         return(& t -> Xgihbindline);
 729 }
 730
 731 /************** vspec_uprag ******************/
 732
 733 binding mkvspec_uprag(PPgvspec_id, PPgvspec_tys, PPgvspec_line)
 734  unkId PPgvspec_id;
 735  list PPgvspec_tys;
 736  long PPgvspec_line;
 737 {
 738         register struct Svspec_uprag *pp =
 739                 (struct Svspec_uprag *) malloc(sizeof(struct Svspec_uprag));
 740         pp -> tag = vspec_uprag;
 741         pp -> Xgvspec_id = PPgvspec_id;
 742         pp -> Xgvspec_tys = PPgvspec_tys;
 743         pp -> Xgvspec_line = PPgvspec_line;
 744         return((binding)pp);
 745 }
 746
 747 unkId *Rgvspec_id(t)
 748  struct Svspec_uprag *t;
 749 {
 750 #ifdef UGEN_DEBUG
 751         if(t -> tag != vspec_uprag)
 752                 fprintf(stderr,"gvspec_id: illegal selection; was %d\n", t -> tag);
 753 #endif /* UGEN_DEBUG */
 754         return(& t -> Xgvspec_id);
 755 }
 756
 757 list *Rgvspec_tys(t)
 758  struct Svspec_uprag *t;
 759 {
 760 #ifdef UGEN_DEBUG
 761         if(t -> tag != vspec_uprag)
 762                 fprintf(stderr,"gvspec_tys: illegal selection; was %d\n", t -> tag);
 763 #endif /* UGEN_DEBUG */
 764         return(& t -> Xgvspec_tys);
 765 }
 766
 767 long *Rgvspec_line(t)
 768  struct Svspec_uprag *t;
 769 {
 770 #ifdef UGEN_DEBUG
 771         if(t -> tag != vspec_uprag)
 772                 fprintf(stderr,"gvspec_line: illegal selection; was %d\n", t -> tag);
 773 #endif /* UGEN_DEBUG */
 774         return(& t -> Xgvspec_line);
 775 }
 776
 777 /************** vspec_ty_and_id ******************/
 778
 779 binding mkvspec_ty_and_id(PPgvspec_ty, PPgvspec_tyid)
 780  ttype PPgvspec_ty;
 781  list PPgvspec_tyid;
 782 {
 783         register struct Svspec_ty_and_id *pp =
 784                 (struct Svspec_ty_and_id *) malloc(sizeof(struct Svspec_ty_and_id));
 785         pp -> tag = vspec_ty_and_id;
 786         pp -> Xgvspec_ty = PPgvspec_ty;
 787         pp -> Xgvspec_tyid = PPgvspec_tyid;
 788         return((binding)pp);
 789 }
 790
 791 ttype *Rgvspec_ty(t)
 792  struct Svspec_ty_and_id *t;
 793 {
 794 #ifdef UGEN_DEBUG
 795         if(t -> tag != vspec_ty_and_id)
 796                 fprintf(stderr,"gvspec_ty: illegal selection; was %d\n", t -> tag);
 797 #endif /* UGEN_DEBUG */
 798         return(& t -> Xgvspec_ty);
 799 }
 800
 801 list *Rgvspec_tyid(t)
 802  struct Svspec_ty_and_id *t;
 803 {
 804 #ifdef UGEN_DEBUG
 805         if(t -> tag != vspec_ty_and_id)
 806                 fprintf(stderr,"gvspec_tyid: illegal selection; was %d\n", t -> tag);
 807 #endif /* UGEN_DEBUG */
 808         return(& t -> Xgvspec_tyid);
 809 }
 810
 811 /************** ispec_uprag ******************/
 812
 813 binding mkispec_uprag(PPgispec_clas, PPgispec_ty, PPgispec_line)
 814  unkId PPgispec_clas;
 815  ttype PPgispec_ty;
 816  long PPgispec_line;
 817 {
 818         register struct Sispec_uprag *pp =
 819                 (struct Sispec_uprag *) malloc(sizeof(struct Sispec_uprag));
 820         pp -> tag = ispec_uprag;
 821         pp -> Xgispec_clas = PPgispec_clas;
 822         pp -> Xgispec_ty = PPgispec_ty;
 823         pp -> Xgispec_line = PPgispec_line;
 824         return((binding)pp);
 825 }
 826
 827 unkId *Rgispec_clas(t)
 828  struct Sispec_uprag *t;
 829 {
 830 #ifdef UGEN_DEBUG
 831         if(t -> tag != ispec_uprag)
 832                 fprintf(stderr,"gispec_clas: illegal selection; was %d\n", t -> tag);
 833 #endif /* UGEN_DEBUG */
 834         return(& t -> Xgispec_clas);
 835 }
 836
 837 ttype *Rgispec_ty(t)
 838  struct Sispec_uprag *t;
 839 {
 840 #ifdef UGEN_DEBUG
 841         if(t -> tag != ispec_uprag)
 842                 fprintf(stderr,"gispec_ty: illegal selection; was %d\n", t -> tag);
 843 #endif /* UGEN_DEBUG */
 844         return(& t -> Xgispec_ty);
 845 }
 846
 847 long *Rgispec_line(t)
 848  struct Sispec_uprag *t;
 849 {
 850 #ifdef UGEN_DEBUG
 851         if(t -> tag != ispec_uprag)
 852                 fprintf(stderr,"gispec_line: illegal selection; was %d\n", t -> tag);
 853 #endif /* UGEN_DEBUG */
 854         return(& t -> Xgispec_line);
 855 }
 856
 857 /************** inline_uprag ******************/
 858
 859 binding mkinline_uprag(PPginline_id, PPginline_howto, PPginline_line)
 860  unkId PPginline_id;
 861  list PPginline_howto;
 862  long PPginline_line;
 863 {
 864         register struct Sinline_uprag *pp =
 865                 (struct Sinline_uprag *) malloc(sizeof(struct Sinline_uprag));
 866         pp -> tag = inline_uprag;
 867         pp -> Xginline_id = PPginline_id;
 868         pp -> Xginline_howto = PPginline_howto;
 869         pp -> Xginline_line = PPginline_line;
 870         return((binding)pp);
 871 }
 872
 873 unkId *Rginline_id(t)
 874  struct Sinline_uprag *t;
 875 {
 876 #ifdef UGEN_DEBUG
 877         if(t -> tag != inline_uprag)
 878                 fprintf(stderr,"ginline_id: illegal selection; was %d\n", t -> tag);
 879 #endif /* UGEN_DEBUG */
 880         return(& t -> Xginline_id);
 881 }
 882
 883 list *Rginline_howto(t)
 884  struct Sinline_uprag *t;
 885 {
 886 #ifdef UGEN_DEBUG
 887         if(t -> tag != inline_uprag)
 888                 fprintf(stderr,"ginline_howto: illegal selection; was %d\n", t -> tag);
 889 #endif /* UGEN_DEBUG */
 890         return(& t -> Xginline_howto);
 891 }
 892
 893 long *Rginline_line(t)
 894  struct Sinline_uprag *t;
 895 {
 896 #ifdef UGEN_DEBUG
 897         if(t -> tag != inline_uprag)
 898                 fprintf(stderr,"ginline_line: illegal selection; was %d\n", t -> tag);
 899 #endif /* UGEN_DEBUG */
 900         return(& t -> Xginline_line);
 901 }
 902
 903 /************** deforest_uprag ******************/
 904
 905 binding mkdeforest_uprag(PPgdeforest_id, PPgdeforest_line)
 906  unkId PPgdeforest_id;
 907  long PPgdeforest_line;
 908 {
 909         register struct Sdeforest_uprag *pp =
 910                 (struct Sdeforest_uprag *) malloc(sizeof(struct Sdeforest_uprag));
 911         pp -> tag = deforest_uprag;
 912         pp -> Xgdeforest_id = PPgdeforest_id;
 913         pp -> Xgdeforest_line = PPgdeforest_line;
 914         return((binding)pp);
 915 }
 916
 917 unkId *Rgdeforest_id(t)
 918  struct Sdeforest_uprag *t;
 919 {
 920 #ifdef UGEN_DEBUG
 921         if(t -> tag != deforest_uprag)
 922                 fprintf(stderr,"gdeforest_id: illegal selection; was %d\n", t -> tag);
 923 #endif /* UGEN_DEBUG */
 924         return(& t -> Xgdeforest_id);
 925 }
 926
 927 long *Rgdeforest_line(t)
 928  struct Sdeforest_uprag *t;
 929 {
 930 #ifdef UGEN_DEBUG
 931         if(t -> tag != deforest_uprag)
 932                 fprintf(stderr,"gdeforest_line: illegal selection; was %d\n", t -> tag);
 933 #endif /* UGEN_DEBUG */
 934         return(& t -> Xgdeforest_line);
 935 }
 936
 937 /************** magicuf_uprag ******************/
 938
 939 binding mkmagicuf_uprag(PPgmagicuf_id, PPgmagicuf_str, PPgmagicuf_line)
 940  unkId PPgmagicuf_id;
 941  stringId PPgmagicuf_str;
 942  long PPgmagicuf_line;
 943 {
 944         register struct Smagicuf_uprag *pp =
 945                 (struct Smagicuf_uprag *) malloc(sizeof(struct Smagicuf_uprag));
 946         pp -> tag = magicuf_uprag;
 947         pp -> Xgmagicuf_id = PPgmagicuf_id;
 948         pp -> Xgmagicuf_str = PPgmagicuf_str;
 949         pp -> Xgmagicuf_line = PPgmagicuf_line;
 950         return((binding)pp);
 951 }
 952
 953 unkId *Rgmagicuf_id(t)
 954  struct Smagicuf_uprag *t;
 955 {
 956 #ifdef UGEN_DEBUG
 957         if(t -> tag != magicuf_uprag)
 958                 fprintf(stderr,"gmagicuf_id: illegal selection; was %d\n", t -> tag);
 959 #endif /* UGEN_DEBUG */
 960         return(& t -> Xgmagicuf_id);
 961 }
 962
 963 stringId *Rgmagicuf_str(t)
 964  struct Smagicuf_uprag *t;
 965 {
 966 #ifdef UGEN_DEBUG
 967         if(t -> tag != magicuf_uprag)
 968                 fprintf(stderr,"gmagicuf_str: illegal selection; was %d\n", t -> tag);
 969 #endif /* UGEN_DEBUG */
 970         return(& t -> Xgmagicuf_str);
 971 }
 972
 973 long *Rgmagicuf_line(t)
 974  struct Smagicuf_uprag *t;
 975 {
 976 #ifdef UGEN_DEBUG
 977         if(t -> tag != magicuf_uprag)
 978                 fprintf(stderr,"gmagicuf_line: illegal selection; was %d\n", t -> tag);
 979 #endif /* UGEN_DEBUG */
 980         return(& t -> Xgmagicuf_line);
 981 }
 982
 983 /************** abstract_uprag ******************/
 984
 985 binding mkabstract_uprag(PPgabstract_id, PPgabstract_line)
 986  unkId PPgabstract_id;
 987  long PPgabstract_line;
 988 {
 989         register struct Sabstract_uprag *pp =
 990                 (struct Sabstract_uprag *) malloc(sizeof(struct Sabstract_uprag));
 991         pp -> tag = abstract_uprag;
 992         pp -> Xgabstract_id = PPgabstract_id;
 993         pp -> Xgabstract_line = PPgabstract_line;
 994         return((binding)pp);
 995 }
 996
 997 unkId *Rgabstract_id(t)
 998  struct Sabstract_uprag *t;
 999 {
1000 #ifdef UGEN_DEBUG
1001         if(t -> tag != abstract_uprag)
1002                 fprintf(stderr,"gabstract_id: illegal selection; was %d\n", t -> tag);
1003 #endif /* UGEN_DEBUG */
1004         return(& t -> Xgabstract_id);
1005 }
1006
1007 long *Rgabstract_line(t)
1008  struct Sabstract_uprag *t;
1009 {
1010 #ifdef UGEN_DEBUG
1011         if(t -> tag != abstract_uprag)
1012                 fprintf(stderr,"gabstract_line: illegal selection; was %d\n", t -> tag);
1013 #endif /* UGEN_DEBUG */
1014         return(& t -> Xgabstract_line);
1015 }
1016
1017 /************** dspec_uprag ******************/
1018
1019 binding mkdspec_uprag(PPgdspec_id, PPgdspec_tys, PPgdspec_line)
1020  unkId PPgdspec_id;
1021  list PPgdspec_tys;
1022  long PPgdspec_line;
1023 {
1024         register struct Sdspec_uprag *pp =
1025                 (struct Sdspec_uprag *) malloc(sizeof(struct Sdspec_uprag));
1026         pp -> tag = dspec_uprag;
1027         pp -> Xgdspec_id = PPgdspec_id;
1028         pp -> Xgdspec_tys = PPgdspec_tys;
1029         pp -> Xgdspec_line = PPgdspec_line;
1030         return((binding)pp);
1031 }
1032
1033 unkId *Rgdspec_id(t)
1034  struct Sdspec_uprag *t;
1035 {
1036 #ifdef UGEN_DEBUG
1037         if(t -> tag != dspec_uprag)
1038                 fprintf(stderr,"gdspec_id: illegal selection; was %d\n", t -> tag);
1039 #endif /* UGEN_DEBUG */
1040         return(& t -> Xgdspec_id);
1041 }
1042
1043 list *Rgdspec_tys(t)
1044  struct Sdspec_uprag *t;
1045 {
1046 #ifdef UGEN_DEBUG
1047         if(t -> tag != dspec_uprag)
1048                 fprintf(stderr,"gdspec_tys: illegal selection; was %d\n", t -> tag);
1049 #endif /* UGEN_DEBUG */
1050         return(& t -> Xgdspec_tys);
1051 }
1052
1053 long *Rgdspec_line(t)
1054  struct Sdspec_uprag *t;
1055 {
1056 #ifdef UGEN_DEBUG
1057         if(t -> tag != dspec_uprag)
1058                 fprintf(stderr,"gdspec_line: illegal selection; was %d\n", t -> tag);
1059 #endif /* UGEN_DEBUG */
1060         return(& t -> Xgdspec_line);
1061 }