ghc/compiler/parser/printtree.c

   1 /**********************************************************************
   2 *                                                                     *
   3 *                                                                     *
   4 *      Syntax Tree Printing Routines                                  *
   5 *                                                                     *
   6 *                                                                     *
   7 **********************************************************************/
   8
   9
  10 #define COMPACT TRUE    /* No spaces in output -- #undef this for debugging */
  11
  12
  13 #include <stdio.h>
  14
  15 #include "hspincl.h"
  16 #include "constants.h"
  17 #include "utils.h"
  18
  19 /* fwd decls, necessary and otherwise */
  20 static void pbool   PROTO( (BOOLEAN) );
  21 static void pconstr PROTO( (constr) );
  22 /* static void pcoresyn PROTO((coresyn)); */
  23 static void pentid  PROTO( (entidt) );
  24 static void pgrhses PROTO( (list) );
  25 static void pid     PROTO( (id) );
  26 static void plist   PROTO( (void (*)(/*NOT WORTH IT: void * */), list) );
  27 static void pmaybe  PROTO( (void (*)(), maybe) );
  28 static void pmaybe_list  PROTO( (void (*)(), maybe) );
  29 static void ppbinding PROTO((pbinding));
  30 /* static void ppragma PROTO( (hpragma) ); */
  31 static void pqid    PROTO( (qid) );
  32 static void prbind  PROTO( (binding) );
  33 static void pstr    PROTO( (char *) );
  34 static void ptree   PROTO( (tree) );
  35 static void pttype  PROTO( (ttype) );
  36 static void plineno PROTO( (long) );
  37
  38 extern char *input_filename;
  39 extern BOOLEAN hashIds;
  40
  41 /*      How to print tags       */
  42
  43 #if COMPACT
  44 #define PUTTAG(c)       putchar(c);
  45 #define PUTTAGSTR(s)    printf("%s",(s));
  46 #else
  47 #define PUTTAG(c)       putchar(c); \
  48                         putchar(' ');
  49 #define PUTTAGSTR(s)    printf("%s",(s)); \
  50                         putchar(' ');
  51 #endif
  52
  53
  54 /*      Performs a post order walk of the tree
  55         to print it.
  56 */
  57
  58 void
  59 pprogram(t)
  60   tree t;
  61 {
  62     print_hash_table();
  63     ptree(t);
  64 }
  65
  66 /* print_string: we must escape \t and \\, as described in
  67    char/string lexer comments.  (WDP 94/11)
  68 */
  69 static void
  70 print_string(hstring str)
  71 {
  72     char *gs;
  73     char c;
  74     int i, str_length;
  75
  76     putchar('#');
  77     str_length = str->len;
  78     gs = str->bytes;
  79
  80     for (i = 0; i < str_length; i++) {
  81         c = gs[i];
  82         if ( c == '\t' ) {
  83             putchar('\\');
  84             putchar('t');
  85         } else if ( c == '\\' ) {
  86             putchar('\\');
  87             putchar('\\');
  88         } else {
  89             putchar(gs[i]);
  90         }
  91     }
  92     putchar('\t');
  93 }
  94
  95 static void
  96 plineno (l)
  97 long l;
  98 {
  99  printf("#%lu\t",l);
 100  return;
 101 }
 102
 103
 104 static int
 105 get_character(hstring str)
 106 {
 107     int c = (int)((str->bytes)[0]);
 108
 109     if (str->len != 1) { /* ToDo: assert */
 110         fprintf(stderr, "get_character: length != 1? (%ld: %s)\n", str->len, str->bytes);
 111     }
 112
 113     if (c < 0) {
 114         c += 256;       /* "This is not a hack" -- KH */
 115     }
 116
 117     return(c);
 118 }
 119
 120 static void
 121 pliteral(literal t)
 122 {
 123     switch(tliteral(t)) {
 124       case integer:
 125                       PUTTAG('4');
 126                       pstr(ginteger(t));
 127                       break;
 128       case intprim:
 129                       PUTTAG('H');
 130                       pstr(gintprim(t));
 131                       break;
 132       case floatr:
 133                       PUTTAG('F');
 134                       pstr(gfloatr(t));
 135                       break;
 136       case doubleprim:
 137                       PUTTAG('J');
 138                       pstr(gdoubleprim(t));
 139                       break;
 140       case floatprim:
 141                       PUTTAG('K');
 142                       pstr(gfloatprim(t));
 143                       break;
 144       case charr:
 145                       PUTTAG('C');
 146                       /* Changed %d to %u, since negative chars
 147                          make little sense -- KH @ 16/4/91
 148                       */
 149                       printf("#%u\t", get_character(gchar(t)));
 150                       break;
 151       case charprim:
 152                       PUTTAG('P');
 153                       printf("#%u\t", get_character(gcharprim(t)));
 154                       break;
 155       case string:
 156                       PUTTAG('S');
 157                       print_string(gstring(t));
 158                       break;
 159       case stringprim:
 160                       PUTTAG('V');
 161                       print_string(gstringprim(t));
 162                       break;
 163       case clitlit:
 164                       PUTTAG('Y');
 165                       pstr(gclitlit(t));
 166                       /* pstr(gclitlit_kind(t)); */
 167                       break;
 168       default:
 169                       error("Bad pliteral");
 170     }
 171 }
 172
 173 static void
 174 ptree(t)
 175   tree t;
 176 {
 177 again:
 178     switch(ttree(t)) {
 179       case hmodule:
 180                       PUTTAG('M');
 181                       plineno(ghmodline(t));
 182                       pid(ghname(t));
 183                       printf("#%lu\t",ghversion(t));
 184                       pstr(input_filename);
 185                       prbind(ghmodlist(t));
 186                       /* pfixes(); */
 187                       plist(prbind, ghimplist(t));
 188                       pmaybe_list(pentid, ghexplist(t));
 189                       break;
 190       case fixop:
 191                       PUTTAG('I');
 192                       pqid(gfixop(t));
 193                       printf("%lu\t%lu",gfixinfx(t),gfixprec(t));
 194                       break;
 195       case ident:
 196                       PUTTAG('i');
 197                       pqid(gident(t));
 198                       break;
 199       case lit:
 200                       PUTTAG('C');
 201                       pliteral(glit(t));
 202                       break;
 203
 204       case ap:
 205                       PUTTAG('a');
 206                       ptree(gfun(t));
 207                       ptree(garg(t));
 208                       break;
 209       case infixap:
 210                       PUTTAG('@');
 211                       pqid(ginffun(t));
 212                       ptree(ginfarg1(t));
 213                       ptree(ginfarg2(t));
 214                       break;
 215       case negate:
 216                       PUTTAG('-');
 217                       ptree(gnexp(t));
 218                       break;
 219       case lambda:
 220                       PUTTAG('l');
 221                       plineno(glamline(t));
 222                       plist(ptree,glampats(t));
 223                       ptree(glamexpr(t));
 224                       break;
 225
 226       case let:
 227                       PUTTAG('E');
 228                       prbind(gletvdefs(t));
 229                       ptree(gletvexpr(t));
 230                       break;
 231       case casee:
 232                       PUTTAG('c');
 233                       plineno(gcaseline(t));
 234                       ptree(gcaseexpr(t));
 235                       plist(ppbinding, gcasebody(t));
 236                       break;
 237       case ife:
 238                       PUTTAG('b');
 239                       ptree(gifpred(t));
 240                       ptree(gifthen(t));
 241                       ptree(gifelse(t));
 242                       break;
 243       case doe:
 244                       PUTTAG('O');
 245                       plineno(gdoline(t));
 246                       plist(ptree, gdo(t));
 247                       break;
 248       case dobind:
 249                       PUTTAG('Q');
 250                       plineno(gdobindline(t));
 251                       ptree(gdobindpat(t));
 252                       ptree(gdobindexp(t));
 253                       break;
 254       case doexp:
 255                       PUTTAG('R');
 256                       plineno(gdoexpline(t));
 257                       ptree(gdoexp(t));
 258                       break;
 259       case seqlet:
 260                       PUTTAG('U');
 261                       prbind(gseqlet(t));
 262                       break;
 263       case record:
 264                       PUTTAG('d');
 265                       pqid(grcon(t));
 266                       plist(prbind,grbinds(t));
 267                       break;
 268
 269       case rupdate:
 270                       PUTTAG('h');
 271                       ptree(gupdexp(t));
 272                       plist(prbind,gupdbinds(t));
 273                       break;
 274
 275       case rbind:
 276                       PUTTAG('o');
 277                       pqid(grbindvar(t));
 278                       pmaybe(ptree,grbindexp(t));
 279                       break;
 280
 281       case par:       t = gpare(t); goto again;
 282
 283       case as:
 284                       PUTTAG('s');
 285                       pqid(gasid(t));
 286                       ptree(gase(t));
 287                       break;
 288       case lazyp:
 289                       PUTTAG('~');
 290                       ptree(glazyp(t));
 291                       break;
 292       case wildp:
 293                       PUTTAG('_');
 294                       break;
 295
 296       case restr:
 297                       PUTTAG('R');
 298                       ptree(grestre(t));
 299                       pttype(grestrt(t));
 300                       break;
 301       case tuple:
 302                       PUTTAG(',');
 303                       plist(ptree,gtuplelist(t));
 304                       break;
 305       case llist:
 306                       PUTTAG(':');
 307                       plist(ptree,gllist(t));
 308                       break;
 309       case eenum:
 310                       PUTTAG('.');
 311                       ptree(gefrom(t));
 312                       pmaybe(ptree,gestep(t));
 313                       pmaybe(ptree,geto(t));
 314                       break;
 315       case comprh:
 316                       PUTTAG('Z');
 317                       ptree(gcexp(t));
 318                       plist(ptree,gcquals(t));
 319                       break;
 320       case qual:
 321                       PUTTAG('G');
 322                       ptree(gqpat(t));
 323                       ptree(gqexp(t));
 324                       break;
 325       case guard:
 326                       PUTTAG('g');
 327                       ptree(ggexp(t));
 328                       break;
 329       case lsection:
 330                       PUTTAG('(');
 331                       ptree(glsexp(t));
 332                       pqid(glsop(t));
 333                       break;
 334       case rsection:
 335                       PUTTAG(')');
 336                       pqid(grsop(t));
 337                       ptree(grsexp(t));
 338                       break;
 339       case ccall:
 340                       PUTTAG('j');
 341                       pstr(gccid(t));
 342                       pstr(gccinfo(t));
 343                       plist(ptree,gccargs(t));
 344                       break;
 345       case scc:
 346                       PUTTAG('k');
 347                       print_string(gsccid(t));
 348                       ptree(gsccexp(t));
 349                       break;
 350       default:
 351                       error("Bad ptree");
 352     }
 353 }
 354
 355 static void
 356 plist(fun, l)
 357   void (*fun)(/* NOT WORTH IT: void * */);
 358   list l;
 359 {
 360     if (tlist(l) == lnil) {
 361         PUTTAG('N');
 362     } else  {
 363         PUTTAG('L');
 364         (*fun)(lhd(l));
 365         plist(fun, ltl(l));
 366     }
 367 }
 368
 369 static void
 370 pmaybe(fun, m)
 371   void (*fun)(/* NOT WORTH IT: void * */);
 372   maybe m;
 373 {
 374     if (tmaybe(m) == nothing) {
 375         PUTTAG('N');
 376     } else  {
 377         PUTTAG('J');
 378         (*fun)(gthing(m));
 379     }
 380 }
 381
 382 static void
 383 pmaybe_list(fun, m)
 384   void (*fun)(/* NOT WORTH IT: void * */);
 385   maybe m;
 386 {
 387     if (tmaybe(m) == nothing) {
 388         PUTTAG('N');
 389     } else  {
 390         PUTTAG('J');
 391         plist(fun, gthing(m));
 392     }
 393 }
 394
 395 static void
 396 pid(i)
 397   id i;
 398 {
 399   if(hashIds)
 400         printf("!%lu\t", hash_index(i));
 401   else
 402         printf("#%s\t", id_to_string(i));
 403 }
 404
 405 static void
 406 pqid(i)
 407   qid i;
 408 {
 409   if(hashIds)
 410         printf("!%lu\t", hash_index(qid_to_id(i)));
 411   else
 412         printf("#%s\t", qid_to_string(i));
 413 }
 414
 415 static void
 416 pstr(i)
 417   char *i;
 418 {
 419         printf("#%s\t", i);
 420 }
 421
 422 static void
 423 prbind(b)
 424   binding b;
 425 {
 426         switch(tbinding(b)) {
 427         case tbind:
 428                           PUTTAG('t');
 429                           plineno(gtline(b));
 430                           plist(pttype, gtbindc(b));
 431                           pmaybe_list(pid, gtbindd(b));
 432                           pttype(gtbindid(b));
 433                           plist(pconstr, gtbindl(b));
 434                           break;
 435         case ntbind:
 436                           PUTTAG('q');
 437                           plineno(gntline(b));
 438                           plist(pttype,gntbindcty(b));
 439                           pmaybe_list(pid, gntbindd(b));
 440                           pttype(gntbindid(b));
 441                           plist(pconstr, gntbindcty(b));
 442                           break;
 443         case nbind      :
 444                           PUTTAG('n');
 445                           plineno(gnline(b));
 446                           pttype(gnbindid(b));
 447                           pttype(gnbindas(b));
 448                           break;
 449         case pbind      :
 450                           PUTTAG('p');
 451                           plineno(gpline(b));
 452                           plist(ppbinding, gpbindl(b));
 453                           break;
 454         case fbind      :
 455                           PUTTAG('f');
 456                           plineno(gfline(b));
 457                           plist(ppbinding, gfbindl(b));
 458                           break;
 459         case abind      :
 460                           PUTTAG('A');
 461                           prbind(gabindfst(b));
 462                           prbind(gabindsnd(b));
 463                           break;
 464         case ibind      :
 465                           PUTTAG('%');
 466                           plineno(giline(b));
 467                           plist(pttype,gibindc(b));
 468                           pqid(gibindid(b));
 469                           pttype(gibindi(b));
 470                           prbind(gibindw(b));
 471                           /* ppragma(gipragma(b)); */
 472                           break;
 473         case dbind      :
 474                           PUTTAG('D');
 475                           plineno(gdline(b));
 476                           plist(pttype,gdbindts(b));
 477                           break;
 478
 479         case cbind      :
 480                           PUTTAG('$');
 481                           plineno(gcline(b));
 482                           plist(pttype,gcbindc(b));
 483                           pttype(gcbindid(b));
 484                           prbind(gcbindw(b));
 485                           break;
 486
 487         /* signature(-like) things, including user pragmas */
 488         case sbind      :
 489                           PUTTAG('r');
 490                           plineno(gsline(b));
 491                           plist(pqid,gsbindids(b));
 492                           pttype(gsbindid(b));
 493                           break;
 494
 495         case nullbind   :
 496                           PUTTAG('B');
 497                           break;
 498
 499         case import:
 500                           PUTTAG('e');
 501                           plineno(gibindline(b));
 502                           /* pid(gibindfile(b)); */
 503                           pid(gibindimod(b));
 504                           printf("#%lu\t",gibindqual(b)); /* 1 -- qualified */
 505                           printf("#%lu\t",gibindsource(b)); /* 1 -- from source */
 506                           pmaybe(pid, gibindas(b));
 507                           pmaybe(pconstr, gibindspec(b));
 508                           /* plist(pentid,giebindexp(b)); ??? */
 509                           /* prbind(giebinddef(b)); ???? */
 510                           break;
 511
 512          /* User pragmas till the end */
 513
 514         case vspec_uprag:
 515                           PUTTAGSTR("Ss");
 516                           plineno(gvspec_line(b));
 517                           pqid(gvspec_id(b));
 518                           plist(pttype,gvspec_tys(b));
 519                           break;
 520         case vspec_ty_and_id:
 521                           PUTTAGSTR("St");
 522                           pttype(gvspec_ty(b));
 523                           pmaybe(pttype,gvspec_tyid(b));
 524                           break;
 525
 526         case ispec_uprag:
 527                           PUTTAGSTR("SS");
 528                           plineno(gispec_line(b));
 529                           pqid(gispec_clas(b));
 530                           pttype(gispec_ty(b));
 531                           break;
 532         case inline_uprag:
 533                           PUTTAGSTR("Si");
 534                           plineno(ginline_line(b));
 535                           pqid(ginline_id(b));
 536                           break;
 537         case magicuf_uprag:
 538                           PUTTAGSTR("Su");
 539                           plineno(gmagicuf_line(b));
 540                           pqid(gmagicuf_id(b));
 541                           pid(gmagicuf_str(b));
 542                           break;
 543         case dspec_uprag:
 544                           PUTTAGSTR("Sd");
 545                           plineno(gdspec_line(b));
 546                           pqid(gdspec_id(b));
 547                           plist(pttype,gdspec_tys(b));
 548                           break;
 549
 550         /* end of signature(-like) things */
 551 /* not used:
 552         case mbind:
 553                           PUTTAG('7');
 554                           plineno(gmline(b));
 555                           pid(gmbindmodn(b));
 556                           plist(pentid,gmbindimp(b));
 557                           break;
 558 */
 559         default         : error("Bad prbind");
 560                           break;
 561         }
 562 }
 563
 564 static void
 565 pttype(t)
 566   ttype t;
 567 {
 568         switch (tttype(t)) {
 569         case tname      : PUTTAG('T');
 570                           pqid(gtypeid(t));
 571                           break;
 572         case namedtvar  : PUTTAG('y');
 573                           pqid(gnamedtvar(t));
 574                           break;
 575         case tllist     : PUTTAG(':');
 576                           pttype(gtlist(t));
 577                           break;
 578         case ttuple     : PUTTAG(',');
 579                           plist(pttype,gttuple(t));
 580                           break;
 581         case tfun       : PUTTAG('>');
 582                           pttype(gtin(t));
 583                           pttype(gtout(t));
 584                           break;
 585         case tapp       : PUTTAG('@');
 586                           pttype(gtapp(t));
 587                           pttype(gtarg(t));
 588                           break;
 589         case tbang      : PUTTAG('!');
 590                           pttype(gtbang(t));
 591                           break;
 592         case context    : PUTTAG('3');
 593                           plist(pttype,gtcontextl(t));
 594                           pttype(gtcontextt(t));
 595                           break;
 596         default         : error("bad pttype");
 597         }
 598 }
 599
 600 static void
 601 pconstr(a)
 602   constr a;
 603 {
 604         switch (tconstr(a)) {
 605         case constrpre  :
 606                           PUTTAG('1');
 607                           plineno(gconcline(a));
 608                           pqid(gconcid(a));
 609                           plist(pttype, gconctypel(a));
 610                           break;
 611         case constrinf  :
 612                           PUTTAG('2');
 613                           plineno(gconiline(a));
 614                           pqid(gconiop(a));
 615                           pttype(gconity1(a));
 616                           pttype(gconity2(a));
 617                           break;
 618
 619         case constrrec  :
 620                           PUTTAG('u');
 621                           plineno(gconrline(a));
 622                           pqid(gconrid(a));
 623                           plist(pqid,gconrfieldl(a));
 624                           break;
 625         case constrnew  :
 626                           PUTTAG('v');
 627                           plineno(gconnline(a));
 628                           pqid(gconnid(a));
 629                           pttype(gconnty(a));
 630                           break;
 631         case field      :
 632                           PUTTAG('5');
 633                           plist(pqid,gfieldn(a));
 634                           pttype(gfieldt(a));
 635                           break;
 636         default         : fprintf(stderr, "Bad tag in abstree %d\n", tconstr(a));
 637                           exit(1);
 638         }
 639 }
 640
 641
 642 static void
 643 pentid(i)
 644   entidt i;
 645 {
 646         switch (tentidt(i)) {
 647         case entid      : PUTTAG('x');
 648                           pqid(gentid(i));
 649                           break;
 650         case enttype    : PUTTAG('X');
 651                           pqid(gtentid(i));
 652                           break;
 653         case enttypeall : PUTTAG('z');
 654                           pqid(gaentid(i));
 655                           break;
 656         case enttypenamed:PUTTAG('8');
 657                           pqid(gnentid(i));
 658                           plist(pqid,gnentnames(i));
 659                           break;
 660         case entmod     : PUTTAG('m');
 661                           pid(gmentid(i));
 662                           break;
 663         default         :
 664                           error("Bad pentid");
 665         }
 666 }
 667
 668
 669 static void
 670 ppbinding(p)
 671   pbinding p;
 672 {
 673         switch(tpbinding(p)) {
 674         case pgrhs      : PUTTAG('W');
 675                           plineno(ggline(p));
 676                           pqid(ggfuncname(p));
 677                           ptree(ggpat(p));
 678                           ppbinding(ggdexprs(p));
 679                           prbind(ggbind(p));
 680                           break;
 681         case pnoguards  :
 682                           PUTTAG('6');
 683                           ptree(gpnoguard(p));
 684                           break;
 685         case pguards    :
 686                           PUTTAG('9');
 687                           plist(ptree, gpguards(p));
 688                           break;
 689         case pgdexp     :
 690                           PUTTAG('&');
 691                           plist(ptree, gpguard(p)); /* Experimental: pattern guards */
 692                           ptree(gpexp(p));
 693                           break;
 694         default         :
 695                           error("Bad pbinding");
 696         }
 697 }
 698
 699
 700 static void
 701 pgrhses(l)
 702   list l;
 703 {
 704   ptree(lhd(l));                /* Guard */
 705   ptree(lhd(ltl(l)));           /* Expression */
 706 }
 707 /*
 708 static void
 709 ppragma(p)
 710   hpragma p;
 711 {
 712     switch(thpragma(p)) {
 713       case no_pragma:           PUTTAGSTR("PN");
 714                                 break;
 715       case idata_pragma:        PUTTAGSTR("Pd");
 716                                 plist(pconstr, gprag_data_constrs(p));
 717                                 plist(ppragma, gprag_data_specs(p));
 718                                 break;
 719       case itype_pragma:        PUTTAGSTR("Pt");
 720                                 break;
 721       case iclas_pragma:        PUTTAGSTR("Pc");
 722                                 plist(ppragma, gprag_clas(p));
 723                                 break;
 724       case iclasop_pragma:      PUTTAGSTR("Po");
 725                                 ppragma(gprag_dsel(p));
 726                                 ppragma(gprag_defm(p));
 727                                 break;
 728
 729       case iinst_simpl_pragma:  PUTTAGSTR("Pis");
 730 / *                             pid(gprag_imod_simpl(p));
 731 * /                             ppragma(gprag_dfun_simpl(p));
 732                                 break;
 733       case iinst_const_pragma:  PUTTAGSTR("Pic");
 734 / *                             pid(gprag_imod_const(p));
 735 * /                             ppragma(gprag_dfun_const(p));
 736                                 plist(ppragma, gprag_constms(p));
 737                                 break;
 738
 739       case igen_pragma:         PUTTAGSTR("Pg");
 740                                 ppragma(gprag_arity(p));
 741                                 ppragma(gprag_update(p));
 742                                 ppragma(gprag_strictness(p));
 743                                 ppragma(gprag_unfolding(p));
 744                                 plist(ppragma, gprag_specs(p));
 745                                 break;
 746       case iarity_pragma:       PUTTAGSTR("PA");
 747                                 pid(gprag_arity_val(p));
 748                                 break;
 749       case iupdate_pragma:      PUTTAGSTR("Pu");
 750                                 pid(gprag_update_val(p));
 751                                 break;
 752       case istrictness_pragma:  PUTTAGSTR("PS");
 753                                 print_string(gprag_strict_spec(p));
 754                                 ppragma(gprag_strict_wrkr(p));
 755                                 break;
 756       case imagic_unfolding_pragma: PUTTAGSTR("PM");
 757                                 pid(gprag_magic_str(p));
 758                                 break;
 759
 760       case iunfolding_pragma:   PUTTAGSTR("PU");
 761                                 ppragma(gprag_unfold_guide(p));
 762                                 pcoresyn(gprag_unfold_core(p));
 763                                 break;
 764
 765       case iunfold_always:      PUTTAGSTR("Px");
 766                                 break;
 767       case iunfold_if_args:     PUTTAGSTR("Py");
 768                                 pid(gprag_unfold_if_t_args(p));
 769                                 pid(gprag_unfold_if_v_args(p));
 770                                 pid(gprag_unfold_if_con_args(p));
 771                                 pid(gprag_unfold_if_size(p));
 772                                 break;
 773
 774       case iname_pragma_pr:     PUTTAGSTR("P1");
 775                                 pid(gprag_name_pr1(p));
 776                                 ppragma(gprag_name_pr2(p));
 777                                 break;
 778       case itype_pragma_pr:     PUTTAGSTR("P2");
 779                                 plist(pttype, gprag_type_pr1(p));
 780                                 pid(gprag_type_pr2(p));
 781                                 ppragma(gprag_type_pr3(p));
 782                                 break;
 783
 784       case idata_pragma_4s:     PUTTAGSTR("P4");
 785                                 plist(pttype, gprag_data_spec(p));
 786                                 break;
 787
 788       default:                  error("Bad Pragma");
 789       }
 790 }
 791 */
 792
 793 static void
 794 pbool(b)
 795   BOOLEAN b;
 796 {
 797     if (b) {
 798       putchar('T');
 799     } else {
 800       putchar('F');
 801     }
 802 }
 803