![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pepsy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy|
Return to pepsy.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 ! root 1: /* pepsy.c - table driven posy/pepy replacement system */ ! 2: ! 3: /* OPEN QUESTIONS: ! 4: ! 5: How to do smarter DEFAULT determination for the other types and NULLs ! 6: ! 7: Perhaps pull-up primitive IDentifiers ! 8: ! 9: Abort a CHOICE encoding if the structure is empty ! 10: ! 11: ! 12: HEURISTICS ! 13: ! 14: 1. LANGUAGE SIMPLIFICATIONS: ! 15: ! 16: ! 17: Pull-up uni-member SEQUENCEs/SETs/CHOICEs ! 18: ! 19: ! 20: 2. LANGUAGE ASSUMPTIONS: ! 21: ! 22: Unique tags to avoid conflicts for internal structures (-h1 option) ! 23: ! 24: ! 25: 3. STYLE ISSUES: ! 26: ! 27: SEQUENCE/SET OF Type should have Type be an ID for nicer naming ! 28: */ ! 29: ! 30: #ifndef lint ! 31: static char *rcsid = "$Header: /f/osi/pepsy/RCS/pepsy.c,v 7.1 90/07/09 14:52:50 mrose Exp $"; ! 32: #endif ! 33: ! 34: /* ! 35: * $Header: /f/osi/pepsy/RCS/pepsy.c,v 7.1 90/07/09 14:52:50 mrose Exp $ ! 36: * ! 37: * ! 38: * $Log: pepsy.c,v $ ! 39: * Revision 7.1 90/07/09 14:52:50 mrose ! 40: * sync ! 41: * ! 42: * Revision 7.0 90/07/01 19:54:25 mrose ! 43: * *** empty log message *** ! 44: * ! 45: * Revision 7.3 90/02/23 17:50:09 mrose ! 46: * update ! 47: * ! 48: * Revision 7.2 90/02/19 13:09:35 mrose ! 49: * update ! 50: * ! 51: * Revision 7.1 90/01/11 18:37:05 mrose ! 52: * real-sync ! 53: * ! 54: * Revision 7.0 89/11/23 22:11:59 mrose ! 55: * Release 6.0 ! 56: * ! 57: */ ! 58: ! 59: /* ! 60: * NOTICE ! 61: * ! 62: * Acquisition, use, and distribution of this module and related ! 63: * materials are subject to the restrictions of a license agreement. ! 64: * Consult the Preface in the User's Manual for the full terms of ! 65: * this agreement. ! 66: * ! 67: */ ! 68: ! 69: ! 70: #include <ctype.h> ! 71: #include <stdio.h> ! 72: #include <varargs.h> ! 73: #include "pepsydefs.h" ! 74: #include "pass2.h" ! 75: ! 76: ! 77: #define SVAL(s) ((s) ? (s) : "") ! 78: #define PARVAL(s) ((s) ? (s) : "parm") ! 79: ! 80: /* DATA */ ! 81: ! 82: static int aflag = 0; ! 83: int Aflag = 0; /* Don't so all modes by default */ ! 84: int Cflag = 0; /* posy */ ! 85: int dflag = 0; ! 86: int Pflag = 0; /* pepy compat ... */ ! 87: char *bflag = NULL; /* .. */ ! 88: char *module_actions = NULL; ! 89: int pepydebug = 0; ! 90: int doexternals = 1; ! 91: static int fflag = 0; ! 92: static int linepos = 0; ! 93: static int mflag = 0; ! 94: int sflag = 0; ! 95: ! 96: int p_debug = 3; ! 97: int options[NOPTIONS]; ! 98: ! 99: char *eval = NULLCP; ! 100: ! 101: char *mymodule = ""; ! 102: OID mymoduleid = NULLOID; ! 103: static char modulename[BUFSIZ]; ! 104: ! 105: int yysection = YP_DECODER; ! 106: char *yyencpref = "encode"; ! 107: char *yydecpref = "decode"; ! 108: char *yyprfpref = "print"; ! 109: char *yyencdflt = "encode"; ! 110: char *yydecdflt = "decode"; ! 111: char *yyprfdflt = "print"; ! 112: ! 113: static char *classes[] = { ! 114: "UNIVERSAL ", ! 115: "APPLICATION ", ! 116: "", ! 117: "PRIVATE " ! 118: }; ! 119: ! 120: static char *tags[] = { ! 121: "", "BOOLEAN", "INTEGER", "INTEGER", "BIT STRING", "BIT STRING", ! 122: "OCTET STRING", "NULL", "SEQUENCE", "SEQUENCE OF", "SEQUENCE", "SET", ! 123: "SET OF", "SET", "CHOICE", "ANY", "OBJECT IDENTIFIER", "", ! 124: ! 125: NULL ! 126: }; ! 127: ! 128: struct tuple tuples[] = { ! 129: YP_BOOL, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_BOOL", ! 130: PE_CLASS_UNIV, PE_PRIM_BOOL, ! 131: YP_INT, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_INT", ! 132: PE_CLASS_UNIV, PE_PRIM_INT, ! 133: YP_INTLIST, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_INT", ! 134: PE_CLASS_UNIV, PE_PRIM_INT, ! 135: YP_BIT, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_BITS", ! 136: PE_CLASS_UNIV, PE_PRIM_BITS, ! 137: YP_BITLIST, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_BITS", ! 138: PE_CLASS_UNIV, PE_PRIM_BITS, ! 139: YP_OCT, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_OCTS", ! 140: PE_CLASS_UNIV, PE_PRIM_OCTS, ! 141: YP_NULL, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_NULL", ! 142: PE_CLASS_UNIV, PE_PRIM_NULL, ! 143: YP_OID, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_OID", ! 144: PE_CLASS_UNIV, PE_PRIM_OID, ! 145: YP_SEQ, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ", ! 146: PE_CLASS_UNIV, PE_CONS_SEQ, ! 147: YP_SEQTYPE, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ", ! 148: PE_CLASS_UNIV, PE_CONS_SEQ, ! 149: YP_SEQLIST, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ", ! 150: PE_CLASS_UNIV, PE_CONS_SEQ, ! 151: YP_SET, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET", ! 152: PE_CLASS_UNIV, PE_CONS_SET, ! 153: YP_SETTYPE, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET", ! 154: PE_CLASS_UNIV, PE_CONS_SET, ! 155: YP_SETLIST, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET", ! 156: PE_CLASS_UNIV, PE_CONS_SET, ! 157: YP_ENUMLIST, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_ENUM", ! 158: PE_CLASS_UNIV, PE_PRIM_ENUM, ! 159: YP_REAL, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_REAL", ! 160: PE_CLASS_UNIV, PE_PRIM_REAL, ! 161: ! 162: YP_UNDF ! 163: }; ! 164: ! 165: ! 166: static char autogen[BUFSIZ]; ! 167: ! 168: char *sysin = NULLCP; ! 169: static char sysout[BUFSIZ]; ! 170: static char sysdef[BUFSIZ]; ! 171: static char sysact[BUFSIZ]; ! 172: ! 173: #if 0 ! 174: static FILE *fact; ! 175: #endif ! 176: static FILE *fdef; ! 177: ! 178: typedef struct modlist { ! 179: char *md_module; ! 180: OID md_oid; ! 181: int md_flags; ! 182: #define MDF_SEEN 1 /* Seen this module */ ! 183: ! 184: struct modlist *md_next; ! 185: } modlist, *MD; ! 186: #define NULLMD ((MD) 0) ! 187: ! 188: static MD mymodules = NULLMD; ! 189: ! 190: typedef struct symlist { ! 191: char *sy_encpref; ! 192: char *sy_decpref; ! 193: char *sy_prfpref; ! 194: char *sy_module; ! 195: char *sy_name; ! 196: ! 197: YP sy_type; ! 198: ! 199: struct symlist *sy_next; ! 200: } symlist, *SY; ! 201: #define NULLSY ((SY) 0) ! 202: ! 203: SY mysymbols = NULLSY; ! 204: ! 205: ! 206: char *gensym (), *modsym (), *array (); ! 207: extern char *my_strcat(), *gfree(), *concat(), *my_new_str(); ! 208: MD lookup_module (); ! 209: SY new_symbol (), add_symbol (); ! 210: static double val2real (); ! 211: static void prime_default (); ! 212: ! 213: FILE *open_ph_file (); ! 214: ! 215: YP lookup_type (); ! 216: ! 217: YT lookup_tag (); ! 218: ! 219: /* MAIN */ ! 220: ! 221: /* ARGSUSED */ ! 222: ! 223: main (argc, argv, envp) ! 224: int argc; ! 225: char **argv, ! 226: **envp; ! 227: { ! 228: int i; ! 229: register char *cp, ! 230: *dp; ! 231: ! 232: dp = pepsyversion + strlen ("pepsy "); ! 233: (void) fprintf (stderr, "pepsy %s\n", dp); ! 234: ! 235: sysout[0] = sysdef[0] = sysact[0] = NULL; ! 236: for (argc--, argv++; argc > 0; argc--, argv++) { ! 237: cp = *argv; ! 238: ! 239: if (strcmp (cp, "-A") == 0) { ! 240: Aflag++; ! 241: continue; ! 242: } ! 243: if (strcmp (cp, "-a") == 0) { ! 244: aflag++; ! 245: continue; ! 246: } ! 247: if (strcmp (cp, "-d") == 0) { ! 248: dflag++; ! 249: continue; ! 250: } ! 251: if (strcmp (cp, "-f") == 0) { ! 252: dflag++, fflag++; ! 253: continue; ! 254: } ! 255: if (strncmp (cp, "-h", 2) == 0) { ! 256: if (cp[2] == NULL) { ! 257: hflag++; ! 258: continue; ! 259: } ! 260: if (sscanf (cp + 2, "%d", &i) != 1 || i >= NOPTIONS) ! 261: goto usage; ! 262: hflag++, options[i]++; ! 263: continue; ! 264: } ! 265: if (strcmp (cp, "-m") == 0) { ! 266: mflag++; ! 267: continue; ! 268: } ! 269: if (strcmp (cp, "-s") == 0) { ! 270: sflag++; ! 271: continue; ! 272: } ! 273: ! 274: if (sysin) { ! 275: usage: ; ! 276: (void) fprintf (stderr, ! 277: "usage: pepsy [-A] [-a] [-d] [-f] [-h] [-s] module.py\n"); ! 278: exit (1); ! 279: } ! 280: ! 281: if (*cp == '-') { ! 282: if (*++cp != NULL) ! 283: goto usage; ! 284: sysin = ""; ! 285: } ! 286: sysin = cp; ! 287: } ! 288: ! 289: switch (pepydebug = (cp = getenv ("PEPSYTEST")) && *cp ? atoi (cp) : 0) { ! 290: case 2: ! 291: yydebug++; /* fall */ ! 292: case 1: ! 293: sflag++; /* .. */ ! 294: case 0: ! 295: break; ! 296: } ! 297: ! 298: if (sysin == NULLCP) ! 299: sysin = ""; ! 300: ! 301: if (*sysin && freopen (sysin, "r", stdin) == NULL) { ! 302: (void) fprintf (stderr, "unable to read "), perror (sysin); ! 303: exit (1); ! 304: } ! 305: ! 306: if (strcmp (sysout, "-") == 0) ! 307: sysout[0] = NULL; ! 308: if (*sysout && freopen (sysout, "w", stdout) == NULL) { ! 309: (void) fprintf (stderr, "unable to write "), perror (sysout); ! 310: exit (1); ! 311: } ! 312: ! 313: if (cp = index (dp, ')')) { ! 314: for (cp++; *cp != ' '; cp++) ! 315: if (*cp == NULL) ! 316: break; ! 317: if (*cp == NULL) ! 318: cp = NULL; ! 319: } ! 320: if (cp == NULL) ! 321: cp = dp + strlen (dp); ! 322: (void) sprintf (autogen, "pepsy %*.*s", cp - dp, cp - dp, dp); ! 323: ! 324: initoidtbl (); ! 325: ! 326: exit (yyparse ()); /* NOTREACHED */ ! 327: } ! 328: ! 329: /* ERRORS */ ! 330: ! 331: yyerror (s) ! 332: register char *s; ! 333: { ! 334: yyerror_aux (s); ! 335: ! 336: if (*sysout) ! 337: (void) unlink (sysout); ! 338: if (*sysdef) ! 339: (void) unlink (sysdef); ! 340: if (*sysact) ! 341: (void) unlink (sysact); ! 342: ! 343: exit (1); ! 344: } ! 345: ! 346: #ifndef lint ! 347: warning (va_alist) ! 348: va_dcl ! 349: { ! 350: char buffer[BUFSIZ]; ! 351: char buffer2[BUFSIZ]; ! 352: char *cp; ! 353: va_list ap; ! 354: ! 355: va_start (ap); ! 356: ! 357: _asprintf (buffer, NULLCP, ap); ! 358: ! 359: va_end (ap); ! 360: ! 361: (void) sprintf (buffer2, "Warning: %s", buffer); ! 362: yyerror_aux (buffer2); ! 363: } ! 364: ! 365: #else ! 366: ! 367: /* VARARGS1 */ ! 368: warning (fmt) ! 369: char *fmt; ! 370: { ! 371: warning (fmt); ! 372: } ! 373: #endif ! 374: ! 375: static yyerror_aux (s) ! 376: register char *s; ! 377: { ! 378: if (linepos) ! 379: (void) fprintf (stderr, "\n"), linepos = 0; ! 380: ! 381: if (eval) ! 382: (void) fprintf (stderr, "type %s: ", eval); ! 383: else ! 384: (void) fprintf (stderr, "line %d: ", yylineno); ! 385: (void) fprintf (stderr, "%s\n", s); ! 386: if (!eval) ! 387: (void) fprintf (stderr, "last token read was \"%s\"\n", yytext); ! 388: } ! 389: ! 390: /* */ ! 391: ! 392: #ifndef lint ! 393: myyerror (va_alist) ! 394: va_dcl ! 395: { ! 396: char buffer[BUFSIZ]; ! 397: va_list ap; ! 398: ! 399: va_start (ap); ! 400: ! 401: _asprintf (buffer, NULLCP, ap); ! 402: ! 403: va_end (ap); ! 404: ! 405: yyerror (buffer); ! 406: } ! 407: #else ! 408: /* VARARGS */ ! 409: ! 410: myyerror (fmt) ! 411: char *fmt; ! 412: { ! 413: myyerror (fmt); ! 414: } ! 415: #endif ! 416: ! 417: ! 418: #ifndef lint ! 419: static pyyerror (va_alist) ! 420: va_dcl ! 421: { ! 422: char buffer[BUFSIZ]; ! 423: register YP yp; ! 424: va_list ap; ! 425: ! 426: va_start (ap); ! 427: ! 428: yp = va_arg (ap, YP); ! 429: ! 430: _asprintf (buffer, NULLCP, ap); ! 431: ! 432: va_end (ap); ! 433: ! 434: yyerror_aux (buffer); ! 435: print_type (yp, 0); ! 436: ! 437: ! 438: if (*sysout) ! 439: (void) unlink (sysout); ! 440: if (*sysdef) ! 441: (void) unlink (sysdef); ! 442: if (*sysact) ! 443: (void) unlink (sysact); ! 444: ! 445: exit (1); ! 446: } ! 447: #else ! 448: /* VARARGS */ ! 449: ! 450: static pyyerror (yp, fmt) ! 451: YP yp; ! 452: char *fmt; ! 453: { ! 454: pyyerror (yp, fmt); ! 455: } ! 456: #endif ! 457: ! 458: /* */ ! 459: ! 460: yywrap () { ! 461: if (linepos) ! 462: (void) fprintf (stderr, "\n"), linepos = 0; ! 463: ! 464: return 1; ! 465: } ! 466: ! 467: /* */ ! 468: ! 469: /* ARGSUSED */ ! 470: ! 471: yyprint (s, f, top) ! 472: char *s; ! 473: int f; ! 474: int top; ! 475: { ! 476: int len; ! 477: static int nameoutput = 0; ! 478: static int outputlinelen = 79; ! 479: ! 480: if (sflag || !s) ! 481: return; ! 482: ! 483: if (!nameoutput) { ! 484: if (linepos) ! 485: (void) fprintf (stderr, "\n\n"); ! 486: ! 487: (void) fprintf (stderr, "%s", mymodule); ! 488: nameoutput = (linepos = strlen (mymodule)) + 1; ! 489: ! 490: (void) fprintf (stderr, " types:"); ! 491: linepos += 7; ! 492: ! 493: if (top) ! 494: return; ! 495: } ! 496: ! 497: len = strlen (s); ! 498: if (linepos != nameoutput) ! 499: if (len + linepos + 1 > outputlinelen) ! 500: (void) fprintf (stderr, "\n%*s", linepos = nameoutput, ""); ! 501: else ! 502: (void) fprintf (stderr, " "), linepos++; ! 503: (void) fprintf (stderr, "%s", s); ! 504: linepos += len; ! 505: } ! 506: ! 507: /* PASS1 */ ! 508: ! 509: pass1 () ! 510: { ! 511: #if 0 ! 512: (void) printf ("%s ", mymodule); ! 513: if (mymoduleid) { ! 514: (void) printf ("%s ", oidprint(mymoduleid)); ! 515: } ! 516: (void) printf ("DEFINITIONS ::=\n\n"); ! 517: #endif ! 518: } ! 519: ! 520: /* */ ! 521: ! 522: pass1_type (encpref, decpref, prfpref, mod, id, yp) ! 523: register char *encpref, ! 524: *decpref, ! 525: *prfpref, ! 526: *mod, ! 527: *id; ! 528: register YP yp; ! 529: { ! 530: register SY sy; ! 531: ! 532: if (lookup_type (mod, id)) /* no duplicate entries, please... */ ! 533: return; ! 534: ! 535: if (pepydebug) { ! 536: if (linepos) ! 537: (void) fprintf (stderr, "\n"), linepos = 0; ! 538: ! 539: (void) fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id); ! 540: print_type (yp, 0); ! 541: (void) fprintf (stderr, "--------\n"); ! 542: } ! 543: else ! 544: if (!(yp -> yp_flags & YP_IMPORTED)) ! 545: yyprint (id, 0, 0); ! 546: ! 547: sy = new_symbol (encpref, decpref, prfpref, mod, id, yp); ! 548: mysymbols = add_symbol (mysymbols, sy); ! 549: } ! 550: ! 551: /* PASS2 */ ! 552: ! 553: pass2 () { ! 554: register SY sy; ! 555: register YP yp; ! 556: ! 557: if (!sflag) ! 558: (void) fflush (stderr); ! 559: ! 560: modsym_aux (mymodule, modulename); ! 561: ! 562: (void) sprintf (sysdef, "%s-types.h", mymodule); ! 563: if ((fdef = fopen (sysdef, "w")) == NULL) ! 564: myyerror ("unable to write %s", sysdef); ! 565: (void) fprintf (fdef, "/* automatically generated by %s, do not edit! */\n\n", ! 566: autogen); ! 567: (void) fprintf (fdef, "#ifndef\t_module_%s_defined_\n", modulename); ! 568: (void) fprintf (fdef, "#define\t_module_%s_defined_\n\n", modulename); ! 569: ! 570: (void) fprintf (fdef, "#ifndef\tPEPSY_VERSION\n"); ! 571: (void) fprintf (fdef, "#define\tPEPSY_VERSION\t\t%d\n", PEPSY_VERSION_NUMBER); ! 572: (void) fprintf (fdef, "#endif\n\n"); ! 573: ! 574: { ! 575: #define NFILES 5 ! 576: char *files[NFILES]; ! 577: /* { "psap.h", "pepsy.h", "UNIV-types.h", (char *)0 }; */ ! 578: ! 579: int last = 0; /* last slot available in files */ ! 580: ! 581: files[last++] = "psap.h"; ! 582: files[last++] = "pepsy.h"; ! 583: ! 584: if (strcmp (mymodule, "UNIV")) { ! 585: files[last++] = "pepsy/UNIV-types.h"; ! 586: } ! 587: ! 588: files[last++] = (char *)0; ! 589: ! 590: doincl(fdef, files); ! 591: ! 592: #undef NFILES ! 593: } ! 594: ! 595: (void) fprintf (fdef, "#ifndef\tPEPYPATH\n"); ! 596: (void) fprintf (fdef, "#include <isode/pepsy/%s%s>\n", mymodule, HFILE1); ! 597: (void) fprintf (fdef, "#else\n"); ! 598: (void) fprintf (fdef, "#include \"%s%s\"\n", mymodule, HFILE1); ! 599: (void) fprintf (fdef, "#endif\n"); ! 600: ! 601: #if 0 ! 602: if (fflag) { ! 603: (void) sprintf (sysact, "%s-types.tmp", mymodule); ! 604: if ((fact = fopen (sysact, "w+")) == NULL) ! 605: myyerror ("unable to write %s", sysact); ! 606: } ! 607: #endif ! 608: ! 609: for (sy = mysymbols; sy; sy = sy -> sy_next) { ! 610: eval = sy -> sy_name; ! 611: yp = sy -> sy_type; ! 612: if (sy -> sy_module == NULLCP) ! 613: yyerror ("no module name associated with symbol"); ! 614: if (yp -> yp_flags & YP_IMPORTED) ! 615: continue; ! 616: ! 617: do_struct0 (yp, eval); ! 618: #if 0 ! 619: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact))) ! 620: myyerror ("write error - %s", sys_errname (errno)); ! 621: #endif ! 622: if (ferror (stdout) || ferror (fdef)) ! 623: myyerror ("write error - %s", sys_errname (errno)); ! 624: } ! 625: /* dump out the references to the external types */ ! 626: proc_extmod(fdef); ! 627: ! 628: for (sy = mysymbols; sy; sy = sy -> sy_next) { ! 629: eval = sy -> sy_name; ! 630: yp = sy -> sy_type; ! 631: if (yp -> yp_flags & YP_IMPORTED) ! 632: continue; ! 633: ! 634: do_struct1 (yp, eval, NULLCP); ! 635: #if 0 ! 636: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact))) ! 637: myyerror ("write error - %s", sys_errname (errno)); ! 638: #endif ! 639: if (ferror (stdout) || ferror (fdef)) ! 640: myyerror ("write error - %s", sys_errname (errno)); ! 641: } ! 642: ! 643: for (sy = mysymbols; sy; sy = sy -> sy_next) { ! 644: eval = sy -> sy_name; ! 645: yp = sy -> sy_type; ! 646: if (yp -> yp_flags & YP_IMPORTED) ! 647: continue; ! 648: ! 649: do_struct2 (yp, eval, NULLCP); ! 650: #if 0 ! 651: if (ferror (stdout) || ferror (fdef) || (fflag && ferror (fact))) ! 652: myyerror ("write error - %s", sys_errname (errno)); ! 653: #endif ! 654: if (ferror (stdout) || ferror (fdef)) ! 655: myyerror ("write error - %s", sys_errname (errno)); ! 656: } ! 657: ! 658: peri_pass2(); ! 659: ! 660: #if 0 ! 661: if (fflag) { ! 662: register int c; ! 663: ! 664: (void) fflush (fact); ! 665: (void) fseek (fact, 0L, 0); ! 666: ! 667: (void) printf ("\n%%{\n"); ! 668: while ((c = getc (fact)) != EOF) ! 669: (void) putchar (c); ! 670: (void) printf ("\n%%}\n"); ! 671: ! 672: (void) fclose (fact); ! 673: if (*sysact) ! 674: (void) unlink (sysact); ! 675: } ! 676: #endif ! 677: ! 678: (void) fprintf (fdef, "#endif\n"); ! 679: (void) fflush (fdef); ! 680: (void) fflush (stdout); ! 681: if (ferror (stdout) || ferror (fdef)) ! 682: myyerror ("write error - %s", sys_errname (errno)); ! 683: (void) fclose (fdef); ! 684: ! 685: write_ph_file(); ! 686: } ! 687: ! 688: /* */ ! 689: ! 690: /* ARGSUSED */ ! 691: ! 692: static do_struct0 (yp, id) ! 693: register YP yp; ! 694: char *id; ! 695: { ! 696: register YP y; ! 697: MD md; ! 698: ! 699: switch (yp -> yp_code) { ! 700: case YP_SEQLIST: ! 701: case YP_SETLIST: ! 702: components_pullup (yp); ! 703: break; ! 704: ! 705: default: ! 706: break; ! 707: } ! 708: ! 709: switch (yp -> yp_code) { ! 710: case YP_SEQTYPE: ! 711: case YP_SETTYPE: ! 712: do_struct0 (yp -> yp_type, id); ! 713: break; ! 714: ! 715: case YP_CHOICE: ! 716: case YP_SETLIST: ! 717: choice_pullup (yp, yp -> yp_code == YP_CHOICE ? CH_FULLY ! 718: : CH_PARTIAL); ! 719: /* and fall */ ! 720: case YP_SEQLIST: ! 721: for (y = yp -> yp_type; y; y = y -> yp_next) ! 722: do_struct0 (y, id); ! 723: break; ! 724: ! 725: case YP_IDEFINED: ! 726: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) { ! 727: if ((md = lookup_module (yp -> yp_module, yp -> yp_modid)) ! 728: == NULLMD || (md->md_flags & MDF_SEEN) == 0) { ! 729: addextmod(yp -> yp_module); ! 730: #if 0 ! 731: (void) fprintf(fdef, "#include \"%s-types.h\"\n", ! 732: yp -> yp_module); ! 733: #endif ! 734: if (md) ! 735: md->md_flags |= MDF_SEEN; ! 736: } ! 737: } ! 738: break; ! 739: ! 740: default: ! 741: break; ! 742: } ! 743: } ! 744: ! 745: /* */ ! 746: ! 747: static do_struct1 (yp, id, pullup) ! 748: register YP yp; ! 749: char *id, ! 750: *pullup; ! 751: { ! 752: register int i, ! 753: j; ! 754: char buf1[BUFSIZ]; ! 755: register YP y; ! 756: register YV yv; ! 757: ! 758: switch (yp -> yp_code) { ! 759: case YP_BIT: ! 760: case YP_BITLIST: ! 761: case YP_SEQ: ! 762: case YP_SET: ! 763: case YP_ANY: ! 764: (void) fprintf (fdef, "\n"); ! 765: if (aflag) ! 766: printag (yp, 4, pullup); ! 767: (void) fprintf (fdef, "#define\t%s\tPElement\n", ! 768: modsym (mymodule, id, "type")); ! 769: if (yp -> yp_code == YP_BITLIST) { ! 770: i = -1; ! 771: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 772: if ((j = val2int (yv)) < 0) ! 773: pyyerror (yp, "invalid bit number in BIT STRING"); ! 774: else ! 775: if (j > i) ! 776: i = j; ! 777: if (i < sizeof (int) * 8) { /* NBBY */ ! 778: (void) fprintf (fdef, "#define\t%s\t\"\\020", ! 779: modsym (mymodule, eval, "bits")); ! 780: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 781: if (yv -> yv_flags & YV_NAMED) ! 782: (void) fprintf (fdef, "\\0%o%s", ! 783: val2int (yv) + 1, yv -> yv_named); ! 784: else ! 785: (void) fprintf (fdef, "\\0%oBIT%d", ! 786: val2int (yv) + 1, val2int (yv)); ! 787: (void) fprintf (fdef, "\"\n"); ! 788: } ! 789: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 790: modsym_aux (yv -> yv_named, buf1); ! 791: (void) fprintf (fdef, "#define\t%s_%s\t%d\n", ! 792: modsym (mymodule, eval, "bit"), ! 793: buf1, val2int (yv)); ! 794: } ! 795: } ! 796: if (fflag) ! 797: (void) fprintf (fdef, "#define\t%s\tpe_free\n", ! 798: modsym (mymodule, id, "free")); ! 799: break; ! 800: ! 801: case YP_OCT: ! 802: (void) fprintf (fdef, "\n"); ! 803: if (aflag) ! 804: printag (yp, 4, pullup); ! 805: (void) fprintf (fdef, "#define\t%s\tqbuf\n", ! 806: modsym (mymodule, id, "type")); ! 807: if (fflag) ! 808: (void) fprintf (fdef, "#define\t%s\tqb_free\n", ! 809: modsym (mymodule, id, "free")); ! 810: break; ! 811: ! 812: case YP_OID: ! 813: (void) fprintf (fdef, "\n"); ! 814: if (aflag) ! 815: printag (yp, 4, pullup); ! 816: (void) fprintf (fdef, "#define\t%s\tOIDentifier\n", ! 817: modsym (mymodule, id, "type")); ! 818: if (fflag) ! 819: (void) fprintf (fdef, "#define\t%s\toid_free\n", ! 820: modsym (mymodule, id, "free")); ! 821: break; ! 822: ! 823: case YP_IDEFINED: ! 824: (void) fprintf (fdef, "\n"); ! 825: if (aflag) ! 826: printag (yp, 4, pullup); ! 827: (void) fprintf (fdef, "#define\t%s\t", ! 828: modsym (mymodule, id, "type")); ! 829: (void) fprintf (fdef, "%s\n", ! 830: modsym (yp -> yp_module, yp -> yp_identifier, "type")); ! 831: if (fflag) { ! 832: (void) fprintf (fdef, "#define\t%s\t", ! 833: modsym (mymodule, id, "free")); ! 834: (void) fprintf (fdef, "%s\n", ! 835: modsym (yp -> yp_module, yp -> yp_identifier, "free")); ! 836: } ! 837: break; ! 838: ! 839: case YP_SEQLIST: ! 840: case YP_SETLIST: ! 841: case YP_CHOICE: ! 842: if (hflag && (y = yp -> yp_type) && !y -> yp_next) { ! 843: do_struct1 (y, id, tags[yp -> yp_code]); ! 844: break; ! 845: } ! 846: /* else fall */ ! 847: ! 848: default: ! 849: break; ! 850: } ! 851: } ! 852: ! 853: /* */ ! 854: ! 855: static do_struct2 (yp, id, pullup) ! 856: register YP yp; ! 857: char *id, ! 858: *pullup; ! 859: { ! 860: register YP y; ! 861: int flg = (yp -> yp_code == YP_SEQTYPE || yp -> yp_code == YP_SETTYPE); ! 862: ! 863: switch (yp -> yp_code) { ! 864: case YP_BIT: ! 865: case YP_BITLIST: ! 866: case YP_SEQ: ! 867: case YP_SET: ! 868: case YP_ANY: ! 869: case YP_OCT: ! 870: case YP_OID: ! 871: case YP_IDEFINED: ! 872: break; ! 873: ! 874: case YP_SEQLIST: ! 875: case YP_SETLIST: ! 876: case YP_CHOICE: ! 877: if (hflag && (y = yp -> yp_type) && !y -> yp_next) { ! 878: do_struct2 (y, id, tags[yp -> yp_code]); ! 879: break; ! 880: } ! 881: /* else fall */ ! 882: ! 883: default: ! 884: (void) fprintf (fdef, "\n"); ! 885: if (aflag) ! 886: printag (yp, 4, pullup); ! 887: (void) fprintf (fdef, "struct %s {\n", modsym (mymodule, id, "type")); ! 888: #if 0 ! 889: if (fflag) { ! 890: (void) fprintf (fact, "\n%s (arg)\n", modsym (mymodule, id, "free")); ! 891: (void) fprintf (fact, "struct %s *arg;\n{\n", ! 892: modsym (mymodule, id, "type")); ! 893: (void) fprintf (fact, " struct %s *parm = arg;\n", ! 894: modsym (mymodule, id, "type")); ! 895: if (h2flag && flg) ! 896: (void) fprintf (fact, " int\tn_parm;\n"); ! 897: (void) fprintf (fact, "\n if (parm == NULL)\n\treturn;\n\n"); ! 898: } ! 899: #endif ! 900: pepsy (yp, 1, 1, "parm", id, "parm", flg && h2flag); ! 901: (void) fprintf (fdef, "};\n"); ! 902: (void) fprintf (fdef, "#define\t%s(parm)\\\n\t%s\n", modsym (mymodule, id, "free"), gfree(mymodule, id, "parm")); ! 903: #if 0 ! 904: if (fflag) { ! 905: if (yp -> yp_code != YP_SEQTYPE && ! 906: yp -> yp_code != YP_SETTYPE) ! 907: (void) fprintf (fact, "\n free ((char *) arg);"); ! 908: (void) fprintf (fact, "\n}\n"); ! 909: } ! 910: #endif ! 911: ! 912: break; ! 913: } ! 914: } ! 915: ! 916: /* */ ! 917: ! 918: #if 0 ! 919: static int type0_brackets; ! 920: ! 921: static do_type0 (yp, direction) ! 922: register YP yp; ! 923: int direction; ! 924: { ! 925: type0_brackets = type0_bit = 0; ! 926: do_type0_aux (yp, direction); ! 927: if (type0_brackets) ! 928: (void) printf (" %%}\n "); ! 929: } ! 930: ! 931: static do_type0_aux (yp, direction) ! 932: register YP yp; ! 933: int direction; ! 934: { ! 935: register YP y; ! 936: ! 937: if (yp -> yp_declexp) { ! 938: if (type0_brackets++ == 0) ! 939: (void) printf ("\n %%{\n"); ! 940: (void) printf ("\tstruct %s *%s%s;\n", yp -> yp_declexp, ! 941: direction == YP_DECODER ? "*" : "", yp -> yp_declexp); ! 942: } ! 943: ! 944: switch (yp -> yp_code) { ! 945: case YP_SEQTYPE: ! 946: case YP_SETTYPE: ! 947: if (h2flag) { ! 948: if (type0_brackets++ == 0) ! 949: (void) printf ("\n %%{\n"); ! 950: (void) printf ("\tint n_%s = 0;\n", yp -> yp_declexp ? ! 951: yp -> yp_declexp : "parm"); ! 952: } ! 953: do_type0_aux (yp -> yp_type, direction); ! 954: break; ! 955: ! 956: case YP_SEQLIST: ! 957: case YP_SETLIST: ! 958: case YP_CHOICE: ! 959: for (y = yp -> yp_type; y; y = y -> yp_next) ! 960: do_type0_aux (y, direction); ! 961: break; ! 962: ! 963: case YP_BIT: ! 964: case YP_BITLIST: ! 965: if (direction == YP_ENCODER) { ! 966: if (type0_brackets++ == 0) ! 967: (void) printf ("\n %%{\n"); ! 968: if (type0_bit++ == 0) ! 969: (void) printf ("\tchar *bit_parm;\n"); ! 970: } ! 971: break; ! 972: ! 973: default: ! 974: break; ! 975: } ! 976: } ! 977: #endif ! 978: ! 979: /* */ ! 980: ! 981: /* ARGSUSED */ ! 982: ! 983: static do_type1 (yp, top, level, id, var, action2, direction) ! 984: register YP yp; ! 985: int top, ! 986: level; ! 987: char *id, ! 988: *var, ! 989: *action2; ! 990: int direction; ! 991: { ! 992: int i; ! 993: char *cp, ! 994: *ep, ! 995: buffer[BUFSIZ], ! 996: varbuf[BUFSIZ]; ! 997: register YP y; ! 998: register YV yv; ! 999: register YT yt; ! 1000: ! 1001: (void) printf ("%*s", level * 4, ""); ! 1002: ! 1003: if (yp -> yp_flags & YP_ID) { ! 1004: (void) printf ("%s", yp -> yp_id); ! 1005: if (!(yp -> yp_flags & YP_TAG)) ! 1006: (void) printf ("\n%*s", ++level * 4, ""); ! 1007: } ! 1008: ! 1009: if (yp -> yp_flags & YP_TAG) { ! 1010: yt = yp -> yp_tag; ! 1011: (void) printf ("[%s%d]\n", classes[yt -> yt_class], val2int (yt -> yt_value)); ! 1012: level++; ! 1013: (void) printf ("%*s", level * 4, ""); ! 1014: } ! 1015: if (yp -> yp_flags & YP_OPTIONAL && yp -> yp_varexp) { ! 1016: if ((ep = index (yp -> yp_varexp, ' ')) == NULL) ! 1017: yyerror ("Bug in varexp!"); ! 1018: ! 1019: (void) sprintf (varbuf, "%*.*s", ep - yp -> yp_varexp, ! 1020: ep - yp -> yp_varexp, yp -> yp_varexp); ! 1021: } ! 1022: ! 1023: switch (yp -> yp_code) { ! 1024: case YP_BOOL: ! 1025: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) && ! 1026: direction == YP_DECODER) { ! 1027: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG))) ! 1028: (void) printf ("dummy-for-default\n%*s", ++level * 4, ""); ! 1029: if (yp -> yp_flags & YP_OPTIONAL) ! 1030: (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s", ! 1031: varbuf, yp -> yp_optcontrol, level * 4, ""); ! 1032: else ! 1033: (void) printf ("%%{ %s%s = %d; %%}\n%*s", ! 1034: var, SVAL (yp -> yp_varexp), ! 1035: val2int (yp -> yp_default) ? 1 : 0, level * 4, ""); ! 1036: } ! 1037: break; ! 1038: ! 1039: case YP_INT: ! 1040: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) && ! 1041: direction == YP_DECODER) { ! 1042: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG))) ! 1043: (void) printf ("dummy-for-default\n%*s", ++level * 4, ""); ! 1044: if (yp -> yp_flags & YP_OPTIONAL) ! 1045: (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s", ! 1046: varbuf, yp -> yp_optcontrol, level * 4, ""); ! 1047: else ! 1048: (void) printf ("%%{ %s%s = %d; %%}\n%*s", ! 1049: var, SVAL (yp -> yp_varexp), ! 1050: val2int (yp -> yp_default), level * 4, ""); ! 1051: } ! 1052: break; ! 1053: ! 1054: case YP_INTLIST: ! 1055: case YP_ENUMLIST: ! 1056: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) && ! 1057: direction == YP_DECODER) { ! 1058: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG))) ! 1059: (void) printf ("dummy-for-default\n%*s", ++level * 4, ""); ! 1060: if (yp -> yp_flags & YP_OPTIONAL) ! 1061: (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s", ! 1062: varbuf, yp -> yp_optcontrol, level * 4, ""); ! 1063: else ! 1064: (void) printf ("%%{ %s%s = %d; %%}\n%*s", ! 1065: var, SVAL (yp -> yp_varexp), dfl2int (yp), ! 1066: level * 4, ""); ! 1067: } ! 1068: break; ! 1069: ! 1070: case YP_REAL: ! 1071: if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) && ! 1072: direction == YP_DECODER) { ! 1073: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG))) ! 1074: (void) printf ("dummy-for-default\n%*s", ++level * 4, ""); ! 1075: if (yp -> yp_flags & YP_OPTIONAL) ! 1076: (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s", ! 1077: varbuf, yp -> yp_optcontrol, level * 4, ""); ! 1078: else ! 1079: (void) printf ("%%{ %s%s = %g; %%}\n%*s", ! 1080: var, SVAL (yp -> yp_varexp), ! 1081: val2real (yp -> yp_default), level * 4, ""); ! 1082: } ! 1083: break; ! 1084: ! 1085: case YP_NULL: ! 1086: if ((yp -> yp_flags & YP_OPTIONAL) && direction == YP_DECODER) { ! 1087: if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG))) ! 1088: (void) printf ("dummy-for-default\n%*s", ++level * 4, ""); ! 1089: (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s", ! 1090: varbuf, yp -> yp_optcontrol, level * 4, ""); ! 1091: } ! 1092: break; ! 1093: } ! 1094: ! 1095: if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == (YP_TAG | YP_IMPLICIT)) ! 1096: (void) printf ("IMPLICIT "); ! 1097: if (yp -> yp_flags & YP_BOUND) ! 1098: (void) printf ("%s < ", yp -> yp_bound); ! 1099: if (yp -> yp_flags & YP_COMPONENTS) ! 1100: (void) printf ("COMPONENTS OF "); ! 1101: if (yp -> yp_flags & YP_ENCRYPTED) ! 1102: (void) printf ("ENCRYPTED "); ! 1103: ! 1104: switch (yp -> yp_code) { ! 1105: case YP_BOOL: ! 1106: (void) printf ("BOOLEAN"); ! 1107: switch (direction) { ! 1108: case YP_ENCODER: ! 1109: case YP_DECODER: ! 1110: (void) printf (top ? "\n%*s[[b %s -> %s ]]" : "\n%*s[[b %s%s ]]", ! 1111: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1112: break; ! 1113: } ! 1114: break; ! 1115: ! 1116: case YP_INT: ! 1117: (void) printf ("INTEGER"); ! 1118: switch (direction) { ! 1119: case YP_ENCODER: ! 1120: case YP_DECODER: ! 1121: (void) printf (top ? "\n%*s[[i %s -> %s ]]" : "\n%*s[[i %s%s ]]", ! 1122: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1123: break; ! 1124: } ! 1125: break; ! 1126: ! 1127: case YP_INTLIST: ! 1128: case YP_ENUMLIST: ! 1129: if (yp -> yp_code == YP_ENUMLIST) ! 1130: (void) printf ("ENUMERATED"); ! 1131: else ! 1132: (void) printf ("INTEGER"); ! 1133: switch (direction) { ! 1134: case YP_ENCODER: ! 1135: case YP_DECODER: ! 1136: (void) printf (top ? "\n%*s[[i %s -> %s ]]\n%*s{\n" ! 1137: : "\n%*s[[i %s%s ]]\n%*s{\n", ! 1138: level * 4, "", var, SVAL (yp -> yp_varexp), ! 1139: level * 4, ""); ! 1140: break; ! 1141: ! 1142: default: ! 1143: (void) printf (" {\n"); ! 1144: break; ! 1145: } ! 1146: level++; ! 1147: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 1148: (void) printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named, ! 1149: val2int (yv), yv -> yv_next ? "," : ""); ! 1150: level--; ! 1151: (void) printf ("%*s}", level * 4, ""); ! 1152: break; ! 1153: ! 1154: case YP_BIT: ! 1155: (void) printf ("BIT STRING"); ! 1156: switch (direction) { ! 1157: case YP_ENCODER: ! 1158: (void) printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]", ! 1159: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1160: (void) printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "", ! 1161: (level + 1) * 4, ""); ! 1162: if (action2) ! 1163: (void) printf ("%*s%s\n", (level + 1) * 4, "", action2); ! 1164: (void) printf ("%*s%%}\n", level * 4, ""); ! 1165: break; ! 1166: ! 1167: case YP_DECODER: ! 1168: balloc (yp, var, action2, level); ! 1169: break; ! 1170: } ! 1171: break; ! 1172: ! 1173: case YP_BITLIST: ! 1174: (void) printf ("BIT STRING"); ! 1175: switch (direction) { ! 1176: case YP_ENCODER: ! 1177: (void) printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]\n%*s{\n", ! 1178: level * 4, "", var, SVAL (yp -> yp_varexp), ! 1179: level * 4, ""); ! 1180: break; ! 1181: ! 1182: case YP_DECODER: ! 1183: default: ! 1184: (void) printf (" {\n"); ! 1185: break; ! 1186: } ! 1187: level++; ! 1188: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 1189: (void) printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named, ! 1190: val2int (yv), yv -> yv_next ? "," : ""); ! 1191: level--; ! 1192: (void) printf ("%*s}", level * 4, ""); ! 1193: switch (direction) { ! 1194: case YP_DECODER: ! 1195: balloc (yp, var, action2, level); ! 1196: break; ! 1197: ! 1198: case YP_ENCODER: ! 1199: (void) printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "", ! 1200: (level + 1) * 4, ""); ! 1201: if (action2) ! 1202: (void) printf ("%*s%s\n", (level + 1) * 4, "", action2); ! 1203: (void) printf ("%*s%%}\n", level * 4, ""); ! 1204: break; ! 1205: } ! 1206: break; ! 1207: ! 1208: case YP_OCT: ! 1209: (void) printf ("OCTET STRING"); ! 1210: switch (direction) { ! 1211: case YP_ENCODER: ! 1212: (void) printf ("\n%*s[[q %s%s ]]", level * 4, "", ! 1213: var, SVAL (yp -> yp_varexp)); ! 1214: break; ! 1215: ! 1216: case YP_DECODER: ! 1217: (void) printf ("\n%*s[[q %s%s ]]", level * 4, "", ! 1218: var, SVAL (yp -> yp_varexp)); ! 1219: break; ! 1220: } ! 1221: break; ! 1222: ! 1223: case YP_REAL: ! 1224: (void) printf ("REAL"); ! 1225: (void) printf (top ? "\n%*s[[r %s -> %s ]]" : "\n%*s[[r %s%s ]]", ! 1226: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1227: break; ! 1228: ! 1229: case YP_NULL: ! 1230: (void) printf ("NULL"); ! 1231: break; ! 1232: ! 1233: case YP_SEQ: ! 1234: case YP_SET: ! 1235: case YP_ANY: ! 1236: (void) printf ("%s", tags[yp -> yp_code]); ! 1237: switch (direction) { ! 1238: case YP_ENCODER: ! 1239: case YP_DECODER: ! 1240: (void) printf ("\n%*s[[a %s%s ]]", ! 1241: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1242: break; ! 1243: } ! 1244: break; ! 1245: ! 1246: case YP_SEQTYPE: ! 1247: case YP_SETTYPE: ! 1248: ep = yp -> yp_code != YP_SETTYPE ? "element" : "member"; ! 1249: (void) printf ("%s\n", tags [yp -> yp_code]); ! 1250: switch (direction) { ! 1251: case YP_ENCODER: ! 1252: if ((y = yp -> yp_type) -> yp_declexp) { ! 1253: (void) printf ("%*s%%{ %s = %s; %%}\n", ! 1254: (level + 1) * 4, "", y -> yp_declexp, ! 1255: SVAL (y -> yp_varexp)); ! 1256: } ! 1257: if (h2flag) { ! 1258: if (top) { ! 1259: (void) printf ("%*s<<n_parm = 0; ", (level + 1) * 4, ""); ! 1260: (void) printf ("n_parm < parm -> nelem; n_parm++>>\n"); ! 1261: } ! 1262: else { ! 1263: (void) printf ("%*s<<n_%s = 0;\n%*sn_%s < %s -> nelem;\n", ! 1264: (level + 1) * 4, "", yp -> yp_declexp, ! 1265: (level + 3) * 4, "", yp -> yp_declexp, ! 1266: yp -> yp_declexp); ! 1267: (void) printf ("%*sn_%s++>>\n", ! 1268: (level + 3) * 4, "", yp -> yp_declexp); ! 1269: } ! 1270: } ! 1271: else { ! 1272: if (top) ! 1273: (void) printf ("%*s<<; parm; parm = parm -> next>>\n", ! 1274: (level + 1) * 4, ""); ! 1275: else ! 1276: (void) printf ("%*s<<%s = %s%s;\n%*s%s;\n%*s%s = %s -> next>>\n", ! 1277: (level + 1) * 4, "", yp -> yp_declexp, ! 1278: var, SVAL (yp -> yp_varexp), ! 1279: (level + 3) * 4, "", yp -> yp_declexp, ! 1280: (level + 3) * 4, "", yp -> yp_declexp, ! 1281: yp -> yp_declexp); ! 1282: } ! 1283: break; ! 1284: ! 1285: case YP_DECODER: ! 1286: if (h2flag) { ! 1287: y = yp -> yp_type; ! 1288: xalloc (y, 0, level + 2, y -> yp_declexp, ! 1289: y -> yp_declexp, 1); ! 1290: } ! 1291: else ! 1292: xalloc (yp, 0, level + 1, ! 1293: top ? "parm" : yp -> yp_declexp, ! 1294: top ? modsym (mymodule, eval, "type") ! 1295: : yp -> yp_declexp, 1); ! 1296: break; ! 1297: } ! 1298: do_type1 (yp -> yp_type, 0, level + 1, ep, "", NULLCP, direction); ! 1299: switch (direction) { ! 1300: case YP_DECODER: ! 1301: (void) printf ("\n%*s%%{ ", (level + 1) * 4, ""); ! 1302: if (h2flag) ! 1303: (void) printf ("n_%s++;", top ? "parm" : yp -> yp_declexp); ! 1304: else ! 1305: if (top) ! 1306: (void) printf ("parm = &((*parm) -> next);"); ! 1307: else ! 1308: (void) printf ("%s = &((*%s) -> next);", ! 1309: yp -> yp_declexp, yp -> yp_declexp); ! 1310: if (action2) ! 1311: (void) printf (" %s", action2); ! 1312: (void) printf (" %%}"); ! 1313: break; ! 1314: } ! 1315: break; ! 1316: ! 1317: case YP_SEQLIST: ! 1318: case YP_SETLIST: ! 1319: ep = yp -> yp_code != YP_SETLIST ? "element" : "member"; ! 1320: (void) printf ("%s", tags [yp -> yp_code]); ! 1321: (void) printf ("\n%*s%%{\n", (level + 1) * 4, ""); ! 1322: if (direction == YP_DECODER) ! 1323: xalloc (yp, 1, level + 2, yp -> yp_declexp, ! 1324: yp -> yp_declexp, 0); ! 1325: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 1326: if (y -> yp_declexp) ! 1327: switch (direction) { ! 1328: case YP_ENCODER: ! 1329: (void) printf ("%*s%s = %s;\n", ! 1330: (level + 2) * 4, "", ! 1331: y -> yp_declexp, y -> yp_varexp); ! 1332: break; ! 1333: ! 1334: case YP_DECODER: ! 1335: (void) printf ("%*s%s = &(%s);\n", ! 1336: (level + 2) * 4, "", ! 1337: y -> yp_declexp, y -> yp_varexp); ! 1338: break; ! 1339: } ! 1340: if (direction == YP_DECODER && ! 1341: y -> yp_flags & YP_DEFAULT) { ! 1342: prime_default (y, level + 2); ! 1343: } ! 1344: } ! 1345: (void) printf ("%*s%%}\n%*s{\n", (level + 1) * 4, "", ! 1346: level * 4, ""); ! 1347: ! 1348: if (!hflag || !(y = yp -> yp_type) || y -> yp_next) { ! 1349: var = ""; ! 1350: top = 0; ! 1351: } ! 1352: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 1353: do_type1 (y, top, ! 1354: level + ((y -> yp_flags & (YP_ID | YP_TAG)) ? 1 : 2), ! 1355: ep, var, NULLCP, direction); ! 1356: (void) printf ("%s\n", y -> yp_next ? ",\n" : ""); ! 1357: } ! 1358: (void) printf ("%*s}", level * 4, ""); ! 1359: break; ! 1360: ! 1361: case YP_CHOICE: ! 1362: (void) printf ("CHOICE"); ! 1363: if (!hflag || !(y = yp -> yp_type) || y -> yp_next) ! 1364: var = ""; ! 1365: i = 0; ! 1366: for (y = yp -> yp_type; y; y = y -> yp_next) ! 1367: if (y -> yp_declexp) ! 1368: i++; ! 1369: switch (direction) { ! 1370: case YP_ENCODER: ! 1371: if (i) { ! 1372: (void) printf ("\n%*s%%{\n", (level + 1) * 4, ""); ! 1373: for (y = yp -> yp_type; y; y = y -> yp_next) ! 1374: if (y -> yp_declexp) ! 1375: (void) printf ("%*s%s = %s;\n", (level + 2) * 4, "", ! 1376: y -> yp_declexp, y -> yp_varexp); ! 1377: (void) printf ("%*s%%}\n%*s", (level + 1) * 4, "", ! 1378: (level + 1) * 4 - 1, "" ); ! 1379: } ! 1380: if (*var) ! 1381: (void) printf (" <<1>>"); ! 1382: else ! 1383: if (top) ! 1384: (void) printf (" <<parm -> offset>>"); ! 1385: else ! 1386: (void) printf (" <<%s -> offset>>", ! 1387: yp -> yp_declexp); ! 1388: (void) printf (i ? "\n%*s{\n" : " {\n", level * 4, ""); ! 1389: break; ! 1390: ! 1391: case YP_DECODER: ! 1392: (void) printf ("\n"); ! 1393: xalloc (yp, 0, level + 1, yp -> yp_declexp, ! 1394: yp -> yp_declexp, 1); ! 1395: (void) printf ("%*s{\n", level * 4, ""); ! 1396: break; ! 1397: ! 1398: default: ! 1399: (void) printf (" {\n"); ! 1400: break; ! 1401: } ! 1402: if (direction == YP_DECODER) { ! 1403: (void) sprintf (cp = buffer, "(*(%s)) -> offset = ", ! 1404: top ? "parm" : yp -> yp_declexp); ! 1405: cp += strlen (cp); ! 1406: } ! 1407: else ! 1408: cp = NULL; ! 1409: if (!hflag || !(y = yp -> yp_type) || y -> yp_next) ! 1410: top = 0; ! 1411: else ! 1412: if (top) ! 1413: cp = NULL; ! 1414: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 1415: if (cp) ! 1416: (void) sprintf (cp, "%s;", y -> yp_offset); ! 1417: do_type1 (y, top, level + 1, "choice", var, ! 1418: cp ? buffer : NULLCP, direction); ! 1419: (void) printf ("%s\n", y -> yp_next ? ",\n" : ""); ! 1420: } ! 1421: (void) printf ("%*s}", level * 4, ""); ! 1422: break; ! 1423: ! 1424: case YP_OID: ! 1425: (void) printf ("OBJECT IDENTIFIER"); ! 1426: switch (direction) { ! 1427: case YP_ENCODER: ! 1428: case YP_DECODER: ! 1429: (void) printf ("\n%*s[[O %s%s ]]", ! 1430: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1431: break; ! 1432: } ! 1433: break; ! 1434: ! 1435: case YP_IDEFINED: ! 1436: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) ! 1437: (void) printf ("%s.", yp -> yp_module); ! 1438: (void) printf ("%s", yp -> yp_identifier); ! 1439: switch (direction) { ! 1440: case YP_ENCODER: ! 1441: (void) printf ("\n%*s[[p %s%s ]]", ! 1442: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1443: break; ! 1444: ! 1445: case YP_DECODER: ! 1446: (void) printf ("\n%*s[[p &(%s%s)]]", ! 1447: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 1448: break; ! 1449: } ! 1450: break; ! 1451: ! 1452: default: ! 1453: myyerror ("unknown type: %d", yp -> yp_code); ! 1454: } ! 1455: ! 1456: if (action2) ! 1457: switch (yp -> yp_code) { ! 1458: case YP_BIT: ! 1459: case YP_BITLIST: ! 1460: if (direction == YP_ENCODER) ! 1461: break; ! 1462: case YP_SEQTYPE: ! 1463: case YP_SETTYPE: ! 1464: if (direction == YP_DECODER) ! 1465: break; ! 1466: /* else fall */ ! 1467: ! 1468: default: ! 1469: (void) printf ("\n%*s%%{ %s %%}", level * 4, "", action2); ! 1470: break; ! 1471: } ! 1472: ! 1473: if (yp -> yp_flags & YP_OPTIONAL) { ! 1474: (void) printf ("\n%*sOPTIONAL", level * 4, ""); ! 1475: ! 1476: if (direction == YP_ENCODER) ! 1477: switch (yp -> yp_code) { ! 1478: case YP_BOOL: ! 1479: case YP_INT: ! 1480: case YP_INTLIST: ! 1481: case YP_ENUMLIST: ! 1482: case YP_NULL: ! 1483: case YP_REAL: ! 1484: (void) printf (" <<%s -> optionals & %s >>", ! 1485: varbuf, yp -> yp_optcontrol); ! 1486: default: ! 1487: break; ! 1488: ! 1489: case YP_BIT: ! 1490: case YP_BITLIST: ! 1491: case YP_OCT: ! 1492: case YP_SEQ: ! 1493: case YP_SEQTYPE: ! 1494: case YP_SEQLIST: ! 1495: case YP_SET: ! 1496: case YP_SETTYPE: ! 1497: case YP_SETLIST: ! 1498: case YP_CHOICE: ! 1499: case YP_ANY: ! 1500: case YP_OID: ! 1501: case YP_IDEFINED: ! 1502: (void) printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp)); ! 1503: break; ! 1504: } ! 1505: } ! 1506: else ! 1507: if (yp -> yp_flags & YP_DEFAULT) { ! 1508: (void) printf ("\n%*sDEFAULT ", level * 4, ""); ! 1509: val2prf (yp -> yp_default, level + 2); ! 1510: ! 1511: if (direction == YP_ENCODER) ! 1512: switch (yp -> yp_code) { ! 1513: case YP_BOOL: ! 1514: (void) printf (" <<%s%s%s>>", ! 1515: val2int (yp -> yp_default) ? "!" : "", ! 1516: var, SVAL (yp -> yp_varexp)); ! 1517: break; ! 1518: ! 1519: case YP_INT: ! 1520: case YP_INTLIST: ! 1521: case YP_ENUMLIST: ! 1522: (void) printf (" <<%s%s != %d>>", var, SVAL (yp -> yp_varexp), ! 1523: dfl2int (yp)); ! 1524: break; ! 1525: ! 1526: case YP_REAL: ! 1527: (void) printf (" << %s%s != %g >>", ! 1528: var, SVAL (yp -> yp_varexp), ! 1529: val2real (yp -> yp_default)); ! 1530: break; ! 1531: ! 1532: case YP_NULL: ! 1533: default: ! 1534: break; ! 1535: ! 1536: case YP_BIT: ! 1537: case YP_BITLIST: ! 1538: case YP_OCT: ! 1539: case YP_SEQ: ! 1540: case YP_SEQTYPE: ! 1541: case YP_SEQLIST: ! 1542: case YP_SET: ! 1543: case YP_SETTYPE: ! 1544: case YP_SETLIST: ! 1545: case YP_CHOICE: ! 1546: case YP_ANY: ! 1547: case YP_OID: ! 1548: case YP_IDEFINED: ! 1549: (void) printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp)); ! 1550: break; ! 1551: } ! 1552: } ! 1553: ! 1554: if (direction == YP_ENCODER ! 1555: && yp -> yp_varexp ! 1556: && (cp = index (yp -> yp_varexp, ' ')) ! 1557: && strncmp (cp + 1, "-> ", 3) == 0) { ! 1558: *cp = NULL; ! 1559: (void) sprintf (buffer, "(*%s) -> %s", yp -> yp_varexp, cp + 4); ! 1560: yp -> yp_varexp = new_string (buffer); ! 1561: } ! 1562: } ! 1563: ! 1564: /* TYPE HANDLING */ ! 1565: ! 1566: static YP lookup_type (mod, id) ! 1567: register char *mod, ! 1568: *id; ! 1569: { ! 1570: register SY sy; ! 1571: ! 1572: for (sy = mysymbols; sy; sy = sy -> sy_next) { ! 1573: if (mod) { ! 1574: if (strcmp (sy -> sy_module, mod)) ! 1575: continue; ! 1576: } ! 1577: else ! 1578: if (strcmp (sy -> sy_module, mymodule) ! 1579: && strcmp (sy -> sy_module, "UNIV")) ! 1580: continue; ! 1581: ! 1582: if (strcmp (sy -> sy_name, id) == 0) ! 1583: return sy -> sy_type; ! 1584: } ! 1585: ! 1586: return NULLYP; ! 1587: } ! 1588: ! 1589: /* */ ! 1590: ! 1591: pepsy (yp, top, level, id, val, var, arrayflg) ! 1592: register YP yp; ! 1593: int top, ! 1594: level, ! 1595: arrayflg; ! 1596: char *id, ! 1597: *val, ! 1598: *var; ! 1599: { ! 1600: register int i, ! 1601: j; ! 1602: register char *bp; ! 1603: char *cp, ! 1604: *dp, ! 1605: *ep, ! 1606: *newid, ! 1607: buf1[BUFSIZ], ! 1608: buf2[BUFSIZ], ! 1609: buf3[BUFSIZ]; ! 1610: register YP y; ! 1611: register YV yv; ! 1612: ! 1613: (void) strcpy (bp = buf2, var); ! 1614: bp += strlen (bp); ! 1615: /* Preserve the name of the field */ ! 1616: yp->yp_varexp = new_string(yp -> yp_ptrname ? yp -> yp_ptrname : id); ! 1617: ! 1618: switch (yp -> yp_code) { ! 1619: case YP_BOOL: ! 1620: if (aflag) ! 1621: printag (yp, level + 4, NULLCP); ! 1622: (void) fprintf (fdef, "%*schar %s;\n", level * 4, "", ! 1623: array(id, arrayflg)); ! 1624: break; ! 1625: ! 1626: case YP_INT: ! 1627: case YP_INTLIST: ! 1628: case YP_ENUMLIST: ! 1629: if (aflag) ! 1630: printag (yp, level + 4, NULLCP); ! 1631: (void) fprintf (fdef, "%*sint %s;\n", level * 4, "", ! 1632: array(id, arrayflg)); ! 1633: if (yp -> yp_code == YP_INT) ! 1634: break; ! 1635: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 1636: modsym_aux (yv -> yv_named, buf1); ! 1637: (void) fprintf (fdef, "#define\t%s_%s\t%d\n", ! 1638: modsym (mymodule, top ? eval : id, "int"), ! 1639: buf1, val2int (yv)); ! 1640: } ! 1641: break; ! 1642: ! 1643: case YP_BIT: ! 1644: case YP_BITLIST: ! 1645: if (!top) { ! 1646: if (aflag) ! 1647: printag (yp, level + 4, NULLCP); ! 1648: (void) fprintf (fdef, "%*sPE %s;\n", level * 4, "", ! 1649: array(id, arrayflg)); ! 1650: } ! 1651: #if 0 ! 1652: if (fflag) { ! 1653: (void) fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2); ! 1654: (void) fprintf (fact, ! 1655: "%*spe_free (%s),\n%*s%s = NULLPE;\n", ! 1656: (level + 1) * 4, "", buf2, ! 1657: (level + 2) * 4, "", buf2); ! 1658: } ! 1659: #endif ! 1660: if (yp -> yp_code != YP_BITLIST) ! 1661: break; ! 1662: i = -1; ! 1663: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 1664: if ((j = val2int (yv)) < 0) ! 1665: pyyerror (yp, "invalid bit number in BIT STRING"); ! 1666: else ! 1667: if (j > i) ! 1668: i = j; ! 1669: if (i < sizeof (int) * 8) { /* NBBY */ ! 1670: (void) fprintf (fdef, "#define\t%s\t\"\\020", ! 1671: modsym (mymodule, top ? eval : id, "bits")); ! 1672: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) ! 1673: if (yv -> yv_flags & YV_NAMED) ! 1674: (void) fprintf (fdef, "\\0%o%s", ! 1675: val2int (yv) + 1, yv -> yv_named); ! 1676: else ! 1677: (void) fprintf (fdef, "\\0%oBIT%d", ! 1678: val2int (yv) + 1, val2int (yv)); ! 1679: (void) fprintf (fdef, "\"\n"); ! 1680: } ! 1681: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 1682: modsym_aux (yv -> yv_named, buf1); ! 1683: (void) fprintf (fdef, "#define\t%s_%s\t%d\n", ! 1684: modsym (mymodule, top ? eval : id, "bit"), ! 1685: buf1, val2int (yv)); ! 1686: } ! 1687: break; ! 1688: ! 1689: case YP_REAL: ! 1690: if (aflag) ! 1691: printag (yp, level + 4, NULLCP); ! 1692: (void) fprintf (fdef, "%*sdouble %s;\n", level * 4, "", ! 1693: array(id, arrayflg)); ! 1694: yp -> yp_varexp = new_string (buf2); ! 1695: break; ! 1696: ! 1697: case YP_OCT: ! 1698: if (!top) { ! 1699: if (aflag) ! 1700: printag (yp, level + 4, NULLCP); ! 1701: (void) fprintf (fdef, "%*sstruct qbuf *%s;\n", level * 4, "", ! 1702: array(id, arrayflg)); ! 1703: } ! 1704: #if 0 ! 1705: if (fflag) { ! 1706: (void) fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2); ! 1707: (void) fprintf (fact, ! 1708: "%*sqb_free (%s),\n%*s%s = NULL;\n", ! 1709: (level + 1) * 4, "", buf2, ! 1710: (level + 2) * 4, "", buf2); ! 1711: } ! 1712: #endif ! 1713: break; ! 1714: ! 1715: case YP_NULL: ! 1716: if (aflag) ! 1717: printag (yp, level + 4, NULLCP); ! 1718: (void) fprintf (fdef, "%*schar %s;\n", level * 4, "", ! 1719: array(id, arrayflg)); ! 1720: break; ! 1721: ! 1722: case YP_SEQ: ! 1723: case YP_SET: ! 1724: case YP_ANY: ! 1725: if (!top) { ! 1726: if (aflag) ! 1727: printag (yp, level + 4, NULLCP); ! 1728: (void) fprintf (fdef, "%*sPE %s;\n", level * 4, "", ! 1729: array(id, arrayflg)); ! 1730: } ! 1731: #if 0 ! 1732: if (fflag) { ! 1733: (void) fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2); ! 1734: (void) fprintf (fact, ! 1735: "%*spe_free (%s),\n%*s%s = NULLPE;\n", ! 1736: (level + 1) * 4, "", buf2, ! 1737: (level + 2) * 4, "", buf2); ! 1738: } ! 1739: #endif ! 1740: break; ! 1741: ! 1742: case YP_SEQTYPE: ! 1743: case YP_SETTYPE: ! 1744: ep = yp -> yp_code != YP_SETTYPE ? "element" : "member"; ! 1745: if ((cp = rindex (buf2, ' ')) && *++cp) { ! 1746: if ((dp = rindex (cp, '.')) && *++dp) ! 1747: cp = dp; ! 1748: (void) sprintf (dp = buf1, "%*.*s", ! 1749: cp - buf2, cp - buf2, buf2); ! 1750: dp += strlen (dp); ! 1751: } ! 1752: else { ! 1753: (void) strcpy (buf1, buf2); ! 1754: dp = NULL; ! 1755: } ! 1756: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id; ! 1757: if (h2flag && top) ! 1758: (void) fprintf (fdef, "%*sint\tnelem;\n", level * 4, ""); ! 1759: if (!top) { ! 1760: if (yp -> yp_structname) ! 1761: id = yp -> yp_structname; ! 1762: else if (!Hflag) ! 1763: id = gensym (ep, NULLCP); ! 1764: if (aflag) ! 1765: printag (yp, level + 4, NULLCP); ! 1766: (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id); ! 1767: if (h2flag) ! 1768: (void) fprintf (fdef, "%*sint\tnelem;\n", (level + 1) * 4, ""); ! 1769: } ! 1770: if (dp) ! 1771: (void) strcpy (dp, newid); ! 1772: (void) strcpy (bp = buf2, id); ! 1773: bp += strlen (bp); ! 1774: ! 1775: if (!top) ! 1776: yp -> yp_declexp = new_string (id); ! 1777: ! 1778: if (dp) ! 1779: (void) strcpy (dp, newid); ! 1780: if ((y = yp -> yp_type) -> yp_code == YP_IDEFINED && hflag) { ! 1781: modsym_aux (y -> yp_identifier, cp = buf3); ! 1782: if (h2flag) { ! 1783: cp += strlen(cp); ! 1784: (void) sprintf (cp, "[n_%s]", PARVAL (yp->yp_declexp)); ! 1785: cp = buf3; ! 1786: } ! 1787: } ! 1788: else { ! 1789: switch (y -> yp_code) { ! 1790: case YP_SEQLIST: ! 1791: case YP_SETLIST: ! 1792: case YP_SETTYPE: ! 1793: case YP_SEQTYPE: ! 1794: case YP_CHOICE: ! 1795: case YP_IDEFINED: ! 1796: cp = gensym (ep, h2flag ? PARVAL(yp->yp_declexp) : NULLCP); ! 1797: break; ! 1798: default: ! 1799: cp = gensym (ep, NULLCP); ! 1800: break; ! 1801: } ! 1802: } ! 1803: (void) sprintf (bp, " -> %s", cp); ! 1804: #if 0 ! 1805: if (fflag) { ! 1806: if (!top) { ! 1807: (void) fprintf (fact, "%*s{\n", level * 4, ""); ! 1808: level++; ! 1809: if (h2flag) { ! 1810: (void) fprintf (fact, "%*sint n_%s;\n", ! 1811: level * 4, "", PARVAL (yp->yp_declexp)); ! 1812: (void) fprintf (fact, "%*sstruct %s *%s = %s;\n\n", ! 1813: level * 4, "", id, id, var); ! 1814: } ! 1815: else ! 1816: (void) fprintf (fact, "%*sstruct %s *%s;\n\n", ! 1817: level * 4, "", id, id); ! 1818: } ! 1819: if (h2flag) { ! 1820: (void) fprintf (fact, "%*sfor (n_%s = 0;\n", ! 1821: level * 4, "", PARVAL(yp -> yp_declexp)); ! 1822: (void) fprintf (fact, "%*sn_%s < %s -> nelem;\n", ! 1823: (level + 2) * 4, "", PARVAL(yp->yp_declexp), id); ! 1824: (void) fprintf (fact, "%*sn_%s++) {\n", ! 1825: (level + 2) * 4, "", PARVAL(yp->yp_declexp)); ! 1826: } ! 1827: else { ! 1828: (void) fprintf (fact, ! 1829: "%*sfor (%s = %s; %s;) {\n", ! 1830: level * 4, "", id, buf1, id); ! 1831: (void) fprintf (fact, "%*sstruct %s *f_%s = %s -> next;\n\n", ! 1832: (level + 1) * 4, "", ! 1833: top ? modsym (mymodule, val, "type") : id, ! 1834: id, id); ! 1835: } ! 1836: } ! 1837: #endif ! 1838: level++; ! 1839: pepsy (y, 0, level, cp, ep, buf2, h2flag); ! 1840: *bp = NULL; ! 1841: if (y -> yp_code != YP_IDEFINED) ! 1842: free (cp); ! 1843: if (!h2flag) ! 1844: (void) fprintf (fdef, "\n%*sstruct %s *next;\n", level * 4, "", ! 1845: top ? modsym (mymodule, val, "type") : id); ! 1846: ! 1847: level--; ! 1848: ! 1849: (void) strcpy (bp = buf2, var); ! 1850: bp += strlen (bp); ! 1851: #if 0 ! 1852: if (fflag) { ! 1853: if (!h2flag) { ! 1854: (void) fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);", ! 1855: (level + 1) * 4, "", id, ! 1856: (level + 2) * 4, "", id); ! 1857: (void) fprintf (fact, "\n%*s%s = f_%s;", (level + 1) * 4, "", ! 1858: id, id); ! 1859: } ! 1860: (void) fprintf (fact, "\n%*s}\n", level * 4, ""); ! 1861: ! 1862: if (!top) { ! 1863: if (h2flag) ! 1864: (void) fprintf (fact, "\n%*s%s = NULL;\n", ! 1865: level * 4, "", var); ! 1866: else ! 1867: (void) fprintf (fact, "\n%*s%s = NULL;\n", ! 1868: level * 4, "", yp -> yp_varexp); ! 1869: ! 1870: level--; ! 1871: (void) fprintf (fact, "%*s}\n", level * 4, ""); ! 1872: } ! 1873: } ! 1874: #endif ! 1875: ! 1876: if (!top) { ! 1877: (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "", ! 1878: array(newid, arrayflg)); ! 1879: if (!Hflag) ! 1880: free (id); ! 1881: } ! 1882: break; ! 1883: ! 1884: case YP_SEQLIST: ! 1885: case YP_SETLIST: ! 1886: ep = yp -> yp_code != YP_SETLIST ? "element" : "member"; ! 1887: if ((cp = rindex (buf2, ' ')) && *++cp) { ! 1888: if ((dp = rindex (cp, '.')) && *++dp) ! 1889: cp = dp; ! 1890: (void) sprintf (dp = buf1, "%*.*s", ! 1891: cp - buf2, cp - buf2, buf2); ! 1892: dp += strlen (dp); ! 1893: } ! 1894: else { ! 1895: (void) strcpy (buf1, buf2); ! 1896: dp = NULL; ! 1897: } ! 1898: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id; ! 1899: if (!top) { ! 1900: if (yp -> yp_structname) ! 1901: id = yp -> yp_structname; ! 1902: else if (!Hflag) ! 1903: id = gensym (ep, NULLCP); ! 1904: if (aflag) ! 1905: printag (yp, level + 4, NULLCP); ! 1906: (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id); ! 1907: ! 1908: if (dp) ! 1909: (void) strcpy (dp, newid); ! 1910: ! 1911: #if 0 ! 1912: if (fflag) { ! 1913: (void) fprintf (fact, "%*sif (%s) {\n", ! 1914: level * 4, "", buf1); ! 1915: i = 0; ! 1916: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 1917: switch (y -> yp_code) { ! 1918: case YP_BOOL: ! 1919: case YP_INT: ! 1920: case YP_INTLIST: ! 1921: case YP_ENUMLIST: ! 1922: case YP_REAL: ! 1923: case YP_NULL: ! 1924: continue; ! 1925: ! 1926: default: ! 1927: i = 1; ! 1928: break; ! 1929: } ! 1930: break; ! 1931: } ! 1932: if (i) ! 1933: (void) fprintf (fact, "%*sstruct %s *%s = %s;\n\n", ! 1934: (level + 1) * 4, "", id, id, buf1); ! 1935: } ! 1936: #endif ! 1937: (void) strcpy (bp = buf2, id); ! 1938: bp += strlen (bp); ! 1939: yp -> yp_declexp = new_string (id); ! 1940: ! 1941: level++; ! 1942: } ! 1943: if (dp) ! 1944: (void) strcpy (dp, newid); ! 1945: for (y = yp -> yp_type, i = 0; y; y = y -> yp_next) { ! 1946: if (y -> yp_flags & YP_OPTIONAL) ! 1947: switch (y -> yp_code) { ! 1948: case YP_BOOL: ! 1949: case YP_INT: ! 1950: case YP_INTLIST: ! 1951: case YP_ENUMLIST: ! 1952: case YP_REAL: ! 1953: case YP_NULL: ! 1954: { ! 1955: char obuf[BUFSIZ]; ! 1956: ! 1957: if (i == 0) ! 1958: (void) fprintf (fdef, "%*sint optionals;\n", ! 1959: level * 4, ""); ! 1960: if (y -> yp_flags & YP_ID) ! 1961: modsym_aux (y -> yp_id, cp = buf1); ! 1962: else { ! 1963: cp = gensym (ep, NULLCP); ! 1964: (void) strcpy (buf1, cp); ! 1965: free (cp); ! 1966: cp = buf1; ! 1967: } ! 1968: (void) sprintf (obuf, "%s_%s", ! 1969: modsym (mymodule, ! 1970: top ? eval : id, ! 1971: "opt"), cp); ! 1972: (void) fprintf (fdef, "#define\t%s (0%08o)\n", obuf, ! 1973: 1 << i); ! 1974: y -> yp_optcontrol = new_string (obuf); ! 1975: y -> yp_flags |= YP_OPTCONTROL; ! 1976: ! 1977: i ++; ! 1978: if (i >= 8 * sizeof (int)) ! 1979: yyerror ("too many optionals in structure"); ! 1980: } ! 1981: break; ! 1982: } ! 1983: } ! 1984: if (i > 0) (void) fprintf (fdef, "\n"); ! 1985: ! 1986: for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) { ! 1987: if (y -> yp_flags & YP_ID) ! 1988: modsym_aux (y -> yp_id, cp = buf1); ! 1989: else ! 1990: cp = gensym (ep, NULLCP); ! 1991: (void) sprintf (bp, " -> %s", cp); ! 1992: pepsy (y, 0, level, cp, ep, buf2, 0); ! 1993: *bp = NULL; ! 1994: if (!(y -> yp_flags & YP_ID)) ! 1995: free (cp); ! 1996: if (y -> yp_next) ! 1997: (void) fprintf (fdef, "\n"); ! 1998: } ! 1999: if (i == 1) ! 2000: (void) fprintf (fdef, "%*schar dummy;\n", level * 4, ""); ! 2001: if (!top) { ! 2002: level--; ! 2003: ! 2004: (void) strcpy (bp = buf2, var); ! 2005: bp += strlen (bp); ! 2006: #if 0 ! 2007: if (fflag) { ! 2008: (void) fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);\n%*s%s = NULL;\n", ! 2009: (level + 1) * 4, "", yp -> yp_varexp, ! 2010: (level + 2) * 4, "", yp -> yp_varexp, ! 2011: (level + 1) * 4, "", yp -> yp_varexp); ! 2012: (void) fprintf (fact, "%*s}\n", level * 4, ""); ! 2013: } ! 2014: #endif ! 2015: ! 2016: (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "", ! 2017: array(newid, arrayflg)); ! 2018: if (!Hflag) ! 2019: free (id); ! 2020: } ! 2021: break; ! 2022: ! 2023: case YP_CHOICE: ! 2024: if ((cp = rindex (buf2, ' ')) && *++cp) { ! 2025: if ((dp = rindex (cp, '.')) && *++dp) ! 2026: cp = dp; ! 2027: (void) sprintf (dp = buf1, "%*.*s", ! 2028: cp - buf2, cp - buf2, buf2); ! 2029: dp += strlen (dp); ! 2030: } ! 2031: else { ! 2032: (void) strcpy (buf1, buf2); ! 2033: dp = NULL; ! 2034: } ! 2035: newid = yp -> yp_ptrname ? yp -> yp_ptrname : id; ! 2036: if (!top) { ! 2037: if (yp -> yp_structname) ! 2038: id = yp -> yp_structname; ! 2039: else if (!Hflag) ! 2040: id = gensym ("choice", NULLCP); ! 2041: if (aflag) ! 2042: printag (yp, level + 4, NULLCP); ! 2043: (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id); ! 2044: ! 2045: if (dp) ! 2046: (void) strcpy (dp, newid); ! 2047: #if 0 ! 2048: if (fflag) { ! 2049: (void) fprintf (fact, "%*sif (%s) {\n%*sstruct %s *%s = %s;\n\n", ! 2050: level * 4, "", buf1, ! 2051: (level + 1) * 4, "", id, id, buf1); ! 2052: } ! 2053: #endif ! 2054: (void) strcpy (bp = buf2, id); ! 2055: bp += strlen (bp); ! 2056: yp -> yp_declexp = new_string (id); ! 2057: ! 2058: level++; ! 2059: } ! 2060: if (dp) ! 2061: (void) strcpy (dp, newid); ! 2062: (void) fprintf (fdef, "%*sint offset;\n", level * 4, ""); ! 2063: #if 0 ! 2064: if (fflag) ! 2065: (void) fprintf (fact, "%*sswitch (%s -> offset) {\n", ! 2066: level * 4, "", id); ! 2067: #endif ! 2068: if (top) ! 2069: cp = modsym (mymodule, val, "type"); ! 2070: else ! 2071: cp = id; ! 2072: (void) sprintf (ep = buf1, "%s_", cp); ! 2073: ep += strlen (ep); ! 2074: for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) { ! 2075: if (y -> yp_flags & YP_ID) ! 2076: modsym_aux (y -> yp_id, ep); ! 2077: else ! 2078: (void) sprintf (ep, "%d", i); ! 2079: y -> yp_offset = new_string (buf1); ! 2080: (void) fprintf (fdef, "#define\t%s\t%d\n", y -> yp_offset, i); ! 2081: } ! 2082: (void) fprintf (fdef, "\n%*sunion {\n", level * 4, ""); ! 2083: level++; ! 2084: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 2085: char *t; ! 2086: ! 2087: if (y -> yp_flags & YP_ID) ! 2088: modsym_aux (y -> yp_id, cp = buf1); ! 2089: else ! 2090: cp = gensym ("choice", NULLCP); ! 2091: #if 0 ! 2092: if (fflag) { ! 2093: (void) fprintf (fact, "%*scase %s:\n", level * 4, "", ! 2094: y -> yp_offset); ! 2095: level++; ! 2096: } ! 2097: #endif ! 2098: (void) sprintf (bp, " -> un.%s", cp); ! 2099: pepsy (y, 0, level, cp, "choice", buf2, 0); ! 2100: /* prefix yp_varexp (field name) with un. so we will generate offsets that ! 2101: * allow for the union all the CHOICE fields are imbedded in ! 2102: */ ! 2103: t = y->yp_varexp; ! 2104: y->yp_varexp = my_strcat("un.", t); ! 2105: free(t); ! 2106: ! 2107: *bp = NULL; ! 2108: #if 0 ! 2109: if (fflag) { ! 2110: (void) fprintf (fact, "%*sbreak;\n", level * 4, ""); ! 2111: if (y -> yp_next) ! 2112: (void) fprintf (fact, "\n"); ! 2113: level--; ! 2114: } ! 2115: #endif ! 2116: if (!(y -> yp_flags & YP_ID)) ! 2117: free (cp); ! 2118: if (y -> yp_next) ! 2119: (void) fprintf (fdef, "\n"); ! 2120: } ! 2121: level--; ! 2122: (void) fprintf (fdef, "%*s} un;\n", level * 4, ""); ! 2123: #if 0 ! 2124: if (fflag) ! 2125: (void) fprintf (fact, "%*s}\n", level * 4, ""); ! 2126: #endif ! 2127: if (!top) { ! 2128: level--; ! 2129: ! 2130: (void) strcpy (bp = buf2, var); ! 2131: bp += strlen (bp); ! 2132: #if 0 ! 2133: if (fflag) { ! 2134: (void) fprintf (fact, "\n%*sif (%s)\n%*sfree ((char *) %s);\n%*s%s = NULL;\n", ! 2135: (level + 1) * 4, "", yp -> yp_varexp, ! 2136: (level + 2) * 4, "", yp -> yp_varexp, ! 2137: (level + 1) * 4, "", yp -> yp_varexp); ! 2138: (void) fprintf (fact, "%*s}\n", level * 4, ""); ! 2139: } ! 2140: #endif ! 2141: ! 2142: (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "", ! 2143: array(newid, arrayflg)); ! 2144: if (!Hflag) ! 2145: free (id); ! 2146: } ! 2147: break; ! 2148: ! 2149: case YP_OID: ! 2150: if (!top) { ! 2151: if (aflag) ! 2152: printag (yp, level + 4, NULLCP); ! 2153: (void) fprintf (fdef, "%*sOID %s;\n", level * 4, "", ! 2154: array(id, arrayflg)); ! 2155: } ! 2156: #if 0 ! 2157: if (fflag) { ! 2158: (void) fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2); ! 2159: (void) fprintf (fact, ! 2160: "%*soid_free (%s),\n%*s%s = NULLOID;\n", ! 2161: (level + 1) * 4, "", buf2, ! 2162: (level + 2) * 4, "", buf2); ! 2163: } ! 2164: #endif ! 2165: break; ! 2166: ! 2167: case YP_IDEFINED: ! 2168: if (aflag) ! 2169: printag (yp, level + 4, NULLCP); ! 2170: { ! 2171: /* Predefined Universal Type */ ! 2172: struct univ_typ *p; ! 2173: if ((p = univtyp(yp->yp_identifier))) { ! 2174: (void) fprintf (fdef, "%*s%s%s;\n", level * 4, "", ! 2175: p->univ_data, array(id, arrayflg)); ! 2176: /* ! 2177: if (fflag) ! 2178: ferr(1, "pepsy:YP_IDEFINED:fflag not implemented\n"); ! 2179: */ ! 2180: break; ! 2181: } ! 2182: } ! 2183: (void) fprintf (fdef, "%*sstruct %s *%s;\n", level * 4, "", ! 2184: modsym (yp -> yp_module, yp -> yp_identifier, "type"), ! 2185: array(id, arrayflg)); ! 2186: #if 0 ! 2187: if (fflag) { ! 2188: (void) fprintf (fact, "%*sif (%s)\n", level * 4, "", buf2); ! 2189: (void) fprintf (fact, ! 2190: "%*s%s (%s),\n%*s%s = NULL;\n", ! 2191: (level + 1) * 4, "", ! 2192: modsym (yp -> yp_module, yp -> yp_identifier, "free"), ! 2193: buf2, (level + 2) * 4, "", buf2); ! 2194: } ! 2195: #endif ! 2196: break; ! 2197: ! 2198: default: ! 2199: myyerror ("unknown type: %d", yp -> yp_code); ! 2200: } ! 2201: } ! 2202: ! 2203: /* */ ! 2204: ! 2205: static printag (yp, level, pullup) ! 2206: register YP yp; ! 2207: int level; ! 2208: char *pullup; ! 2209: { ! 2210: (void) fprintf (fdef, "%*s/* ", level * 4, ""); ! 2211: switch (yp -> yp_code) { ! 2212: case YP_IDEFINED: ! 2213: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) ! 2214: (void) fprintf (fdef, "%s.", yp -> yp_module); ! 2215: (void) fprintf (fdef, "%s", yp -> yp_identifier); ! 2216: break; ! 2217: ! 2218: default: ! 2219: (void) fprintf (fdef, "%s", tags[yp -> yp_code]); ! 2220: break; ! 2221: } ! 2222: if (pullup) ! 2223: (void) fprintf (fdef, " pulled up from %s", pullup); ! 2224: (void) fprintf (fdef, " */\n"); ! 2225: } ! 2226: ! 2227: /* */ ! 2228: ! 2229: static xalloc (yp, top, level, arg, type, brackets) ! 2230: register YP yp; ! 2231: int top, ! 2232: level, ! 2233: brackets; ! 2234: char *arg, ! 2235: *type; ! 2236: { ! 2237: int didone; ! 2238: register YP y; ! 2239: ! 2240: if (hflag && !arg && !type) ! 2241: return; ! 2242: ! 2243: didone = 0; ! 2244: ! 2245: if (arg && type) { ! 2246: if (brackets && !didone) { ! 2247: (void) printf ("%*s%%{\n", level * 4, ""); ! 2248: level++, didone++; ! 2249: } ! 2250: ! 2251: if (h2flag && (yp -> yp_code == YP_SEQTYPE || ! 2252: yp -> yp_code == YP_SETTYPE)) { ! 2253: (void) printf ("%*s{\n%*sPE xx_pe = prim2%s ($$);\n\n", ! 2254: level * 4, "", (level +1) * 4, "", ! 2255: yp -> yp_code == YP_SEQTYPE ? "seq" : "set"); ! 2256: (void) printf ("%*sn_%s = xx_pe -> pe_cardinal > 0 ", ! 2257: (level + 1) * 4, "", arg); ! 2258: (void) printf ("? xx_pe -> pe_cardinal : 0;\n%*s}\n", level * 4, ""); ! 2259: (void) printf ("%*sif ((*(%s) = (struct %s *)\n", ! 2260: level * 4, "", arg, type); ! 2261: (void) printf ("%*scalloc (1 + (unsigned) n_%s, sizeof **(%s)", ! 2262: (level + 2) * 4, "", arg, arg); ! 2263: (void) printf (")) == ((struct %s *) 0)) {\n", type); ! 2264: (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", ! 2265: (level + 1) * 4, ""); ! 2266: (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 2267: level * 4, ""); ! 2268: (void) printf ("%*s(*%s) -> nelem = n_%s;\n", level * 4, "", arg, arg); ! 2269: (void) printf ("%*sn_%s = 0;\n", level * 4, "", arg); ! 2270: } else { ! 2271: (void) printf ("%*sif ((*(%s) = (struct %s *)\n", ! 2272: level * 4, "", arg, type); ! 2273: (void) printf ("%*scalloc (1, sizeof **(%s))) == ((struct %s *) 0)) {\n", ! 2274: (level + 2) * 4, "", arg, type); ! 2275: (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", ! 2276: (level + 1) * 4, ""); ! 2277: (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", ! 2278: level * 4, ""); ! 2279: } ! 2280: } ! 2281: switch (yp -> yp_code) { ! 2282: case YP_SEQTYPE: ! 2283: case YP_SETTYPE: ! 2284: if (top) break; ! 2285: case YP_CHOICE: ! 2286: case YP_SEQLIST: ! 2287: case YP_SETLIST: ! 2288: for (y = yp -> yp_type; y; y = y -> yp_next) ! 2289: switch (y -> yp_code) { ! 2290: case YP_SEQTYPE: ! 2291: case YP_SETTYPE: ! 2292: if (h2flag && (yp -> yp_code == YP_SETLIST || ! 2293: yp -> yp_code == YP_SEQLIST)) { ! 2294: /* include allocation here - no chance later */ ! 2295: if (brackets && !didone) { ! 2296: (void) printf ("%*s%%{\n", level * 4, ""); ! 2297: level++, didone++; ! 2298: } ! 2299: if (y -> yp_declexp) ! 2300: (void) printf ("%*s%s = &(%s);\n", level * 4, "", ! 2301: y -> yp_declexp, ! 2302: y -> yp_varexp); ! 2303: xalloc (y, top, level, y -> yp_declexp, ! 2304: y -> yp_declexp, 0); ! 2305: } ! 2306: /* and continue ... */ ! 2307: case YP_SEQLIST: ! 2308: case YP_SETLIST: ! 2309: case YP_CHOICE: ! 2310: if (brackets && !didone) { ! 2311: (void) printf ("%*s%%{\n", level * 4, ""); ! 2312: level++, didone++; ! 2313: } ! 2314: (void) printf ("%*s%s = &(%s);\n", ! 2315: level * 4, "", y -> yp_declexp, ! 2316: y -> yp_varexp); ! 2317: break; ! 2318: } ! 2319: break; ! 2320: } ! 2321: ! 2322: if (brackets && didone) { ! 2323: level--; ! 2324: (void) printf ("%*s%%}\n", level * 4, ""); ! 2325: } ! 2326: } ! 2327: ! 2328: ! 2329: static balloc (yp, var, action2, level) ! 2330: register YP yp; ! 2331: char *var, *action2; ! 2332: int level; ! 2333: { ! 2334: (void) printf ("\n%*s%%{\n", level * 4, ""); ! 2335: level++; ! 2336: ! 2337: (void) printf ("%*sif ((%s%s = prim2bit (pe_cpy ($$))) == NULLPE) {\n", ! 2338: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 2339: (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, ""); ! 2340: (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, ""); ! 2341: ! 2342: if (action2) ! 2343: (void) printf ("\n%*s%s\n", level * 4, "", action2); ! 2344: ! 2345: level--; ! 2346: (void) printf ("%*s%%}", level * 4, ""); ! 2347: } ! 2348: ! 2349: #ifdef notdef ! 2350: static qalloc (yp, var, action2, level) ! 2351: register YP yp; ! 2352: char *var, ! 2353: *action2; ! 2354: int level; ! 2355: { ! 2356: (void) printf ("\n%*s%%{\n", level * 4, ""); ! 2357: level++; ! 2358: ! 2359: (void) printf ("%*sif ((%s%s = str2qb ($$, $$_len, 1)) == ((struct qbuf *) 0)) {\n", ! 2360: level * 4, "", var, SVAL (yp -> yp_varexp)); ! 2361: (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, ""); ! 2362: (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, ""); ! 2363: ! 2364: if (action2) ! 2365: (void) printf ("\n%*s%s\n", level * 4, "", action2); ! 2366: ! 2367: level--; ! 2368: (void) printf ("%*s%%}", level * 4, ""); ! 2369: } ! 2370: #endif ! 2371: ! 2372: /* */ ! 2373: ! 2374: static choice_pullup (yp, partial) ! 2375: register YP yp; ! 2376: int partial; ! 2377: { ! 2378: register YP *x, ! 2379: y, ! 2380: z, ! 2381: *z1, ! 2382: z2, ! 2383: z3; ! 2384: ! 2385: for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) { ! 2386: if (y -> yp_flags & (YP_TAG | YP_BOUND)) ! 2387: continue; ! 2388: ! 2389: switch (y -> yp_code) { ! 2390: case YP_IDEFINED: ! 2391: if ((z = lookup_type (y -> yp_module, y -> yp_identifier)) ! 2392: == NULLYP ! 2393: || z -> yp_code != YP_CHOICE) ! 2394: continue; ! 2395: choice_pullup (z2 = copy_type (z), CH_FULLY); ! 2396: goto patch; ! 2397: ! 2398: case YP_CHOICE: ! 2399: choice_pullup (z2 = copy_type (y), CH_FULLY); ! 2400: patch: ; ! 2401: if (partial) { ! 2402: *x = z2; ! 2403: z2 -> yp_next = y -> yp_next; ! 2404: continue; ! 2405: } ! 2406: break; ! 2407: ! 2408: default: ! 2409: continue; ! 2410: } ! 2411: z = z3 = z2 -> yp_type; ! 2412: for (z1 = &z -> yp_next; z2 = *z1; z1 = &z2 -> yp_next) ! 2413: z3 = z2; ! 2414: *z1 = y -> yp_next; ! 2415: *x = z; ! 2416: y = z3; ! 2417: } ! 2418: } ! 2419: ! 2420: /* */ ! 2421: ! 2422: static components_pullup (yp) ! 2423: register YP yp; ! 2424: { ! 2425: register YP *x, ! 2426: y, ! 2427: z, ! 2428: z1, ! 2429: z2; ! 2430: ! 2431: for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) { ! 2432: if (!(y -> yp_flags & YP_COMPONENTS)) ! 2433: continue; ! 2434: ! 2435: switch (y -> yp_code) { ! 2436: case YP_SEQLIST: ! 2437: case YP_SETLIST: ! 2438: z = y; ! 2439: break; ! 2440: ! 2441: case YP_IDEFINED: ! 2442: if ((z = lookup_type (y -> yp_module, y -> yp_identifier)) ! 2443: == NULLYP) { ! 2444: warning ("COMPONENTS OF target \"%s\" is undefined", ! 2445: y -> yp_identifier); ! 2446: continue; ! 2447: } ! 2448: break; ! 2449: } ! 2450: if (yp -> yp_code != z -> yp_code) { ! 2451: warning ("COMPONENTS OF target \"%s\" is wrong type, should be %s", ! 2452: y -> yp_code == YP_IDEFINED ? y -> yp_identifier ! 2453: : y -> yp_id ? y -> yp_id ! 2454: : "", ! 2455: yp -> yp_code == YP_SEQLIST ? "SEQUENCE" : "SET"); ! 2456: continue; ! 2457: } ! 2458: if (z -> yp_type == NULLYP) ! 2459: continue; ! 2460: components_pullup (z = copy_type (z)); ! 2461: *x = z2 = z -> yp_type; ! 2462: for (x = &z -> yp_type; z1 = *x; x = &z1 -> yp_next) ! 2463: z2 = z1; ! 2464: *x = y -> yp_next; ! 2465: y = z2; ! 2466: } ! 2467: } ! 2468: ! 2469: /* VALUE HANDLING */ ! 2470: ! 2471: static int val2int (yv) ! 2472: register YV yv; ! 2473: { ! 2474: switch (yv -> yv_code) { ! 2475: case YV_BOOL: ! 2476: case YV_NUMBER: ! 2477: return yv -> yv_number; ! 2478: ! 2479: case YV_STRING: ! 2480: yyerror ("need an integer, not a string"); ! 2481: ! 2482: case YV_IDEFINED: ! 2483: case YV_IDLIST: ! 2484: yyerror ("haven't written symbol table for values yet"); ! 2485: ! 2486: case YV_NULL: ! 2487: yyerror ("need an integer, not NULL"); ! 2488: ! 2489: default: ! 2490: myyerror ("unknown value: %d", yv -> yv_code); ! 2491: } ! 2492: /* NOTREACHED */ ! 2493: } ! 2494: ! 2495: static double val2real (yv) ! 2496: register YV yv; ! 2497: { ! 2498: switch (yv -> yv_code) { ! 2499: case YV_NUMBER: ! 2500: return yv -> yv_number; ! 2501: ! 2502: case YV_REAL: ! 2503: return yv -> yv_real; ! 2504: ! 2505: case YV_STRING: ! 2506: yyerror ("need an integer, not a string"); ! 2507: ! 2508: case YV_IDEFINED: ! 2509: case YV_IDLIST: ! 2510: yyerror ("haven't written symbol table for values yet"); ! 2511: ! 2512: case YV_NULL: ! 2513: yyerror ("need an integer, not NULL"); ! 2514: ! 2515: default: ! 2516: myyerror ("unknown value: %d", yv -> yv_code); ! 2517: } ! 2518: /* NOTREACHED */ ! 2519: } ! 2520: ! 2521: /* */ ! 2522: ! 2523: static val2prf (yv, level) ! 2524: register YV yv; ! 2525: int level; ! 2526: { ! 2527: register YV y; ! 2528: ! 2529: if (yv -> yv_flags & YV_ID) ! 2530: (void) printf ("%s ", yv -> yv_id); ! 2531: ! 2532: if (yv -> yv_flags & YV_TYPE) /* will this REALLY work??? */ ! 2533: do_type1 (yv -> yv_type, 0, level, NULLCP, NULLCP, NULLCP, NULL); ! 2534: ! 2535: switch (yv -> yv_code) { ! 2536: case YV_BOOL: ! 2537: (void) printf (yv -> yv_number ? "TRUE" : "FALSE"); ! 2538: break; ! 2539: ! 2540: case YV_NUMBER: ! 2541: if (yv -> yv_named) ! 2542: (void) printf ("%s", yv -> yv_named); ! 2543: else ! 2544: (void) printf ("%d", yv -> yv_number); ! 2545: break; ! 2546: ! 2547: case YV_REAL: ! 2548: dump_real (yv -> yv_real); ! 2549: break; ! 2550: ! 2551: case YV_STRING: ! 2552: (void) printf ("\"%s\"", yv -> yv_string); ! 2553: break; ! 2554: ! 2555: case YV_IDEFINED: ! 2556: if (yv -> yv_module) ! 2557: (void) printf ("%s.", yv -> yv_module); ! 2558: (void) printf ("%s", yv -> yv_identifier); ! 2559: break; ! 2560: ! 2561: case YV_IDLIST: ! 2562: case YV_VALIST: ! 2563: (void) printf ("{"); ! 2564: for (y = yv -> yv_idlist; y; y = y -> yv_next) { ! 2565: (void) printf (" "); ! 2566: val2prf (y, level + 1); ! 2567: (void) printf (y -> yv_next ? ", " : " "); ! 2568: } ! 2569: (void) printf ("}"); ! 2570: break; ! 2571: ! 2572: case YV_NULL: ! 2573: (void) printf ("NULL"); ! 2574: break; ! 2575: ! 2576: default: ! 2577: myyerror ("unknown value: %d", yv -> yv_code); ! 2578: /* NOTREACHED */ ! 2579: } ! 2580: } ! 2581: static dump_real (r) ! 2582: double r; ! 2583: { ! 2584: #ifndef BSD44 ! 2585: extern char *ecvt (); ! 2586: char *cp; ! 2587: char sbuf[128]; ! 2588: int decpt, sign; ! 2589: ! 2590: cp = ecvt (r, 20, &decpt, &sign); ! 2591: (void) strcpy (sbuf, cp); /* cp gets overwritten by printf */ ! 2592: (void) printf ("{ %s%s, 10, %d }", sign ? "-" : "", sbuf, ! 2593: decpt - strlen (sbuf)); ! 2594: #else ! 2595: register char *cp, ! 2596: *dp, ! 2597: *sp; ! 2598: char sbuf[128]; ! 2599: ! 2600: (void) sprintf (sbuf, "%.19e", r); ! 2601: if (*(dp = sbuf) == '-') ! 2602: sp = "-", dp++; ! 2603: else ! 2604: sp = ""; ! 2605: ! 2606: if (dp[1] != '.' || (cp = index (dp, 'e')) == NULL) { ! 2607: (void) printf ("{ 0, 10, 0 } -- %s --", sbuf); ! 2608: return; ! 2609: } ! 2610: *cp++ = NULL; ! 2611: (void) printf ("{ %s%c%s, 10, %d }", ! 2612: sp, *dp, dp + 2, atoi (cp) - strlen (dp + 2)); ! 2613: #endif ! 2614: } ! 2615: ! 2616: /* */ ! 2617: ! 2618: static int dfl2int (yp) ! 2619: register YP yp; ! 2620: { ! 2621: register YV yv, ! 2622: y; ! 2623: ! 2624: yv = yp -> yp_default; ! 2625: switch (yv -> yv_code) { ! 2626: case YV_BOOL: ! 2627: case YV_NUMBER: ! 2628: return yv -> yv_number; ! 2629: ! 2630: case YV_STRING: ! 2631: yyerror ("need an integer, not a string"); ! 2632: ! 2633: case YV_REAL: ! 2634: yyerror ("need an integer, not a real"); ! 2635: ! 2636: case YV_IDEFINED: ! 2637: for (y = yp -> yp_value; y; y = y -> yv_next) ! 2638: if (y -> yv_code == YV_NUMBER ! 2639: && (y -> yv_flags & YV_NAMED) ! 2640: && strcmp (yv -> yv_identifier, y -> yv_named) == 0) ! 2641: return y -> yv_number; ! 2642: /* and fall */ ! 2643: ! 2644: case YV_IDLIST: ! 2645: yyerror ("haven't written symbol table for values yet"); ! 2646: ! 2647: case YV_NULL: ! 2648: yyerror ("need an integer, not NULL"); ! 2649: ! 2650: default: ! 2651: myyerror ("unknown value: %d", yv -> yv_code); ! 2652: } ! 2653: /* NOTREACHED */ ! 2654: } ! 2655: ! 2656: /* DEBUG */ ! 2657: ! 2658: print_type (yp, level) ! 2659: register YP yp; ! 2660: register int level; ! 2661: { ! 2662: register YP y; ! 2663: register YV yv; ! 2664: ! 2665: if (yp == NULLYP) ! 2666: return; ! 2667: ! 2668: (void) fprintf (stderr, "%*scode=0x%x flags=%s direction=0x%x\n", level * 4, "", ! 2669: yp -> yp_code, sprintb (yp -> yp_flags, YPBITS), ! 2670: yp -> yp_direction); ! 2671: (void) fprintf (stderr, ! 2672: "%*sintexp=\"%s\" strexp=\"%s\" prfexp=0%o declexp=\"%s\" varexp=\"%s\"\n", ! 2673: level * 4, "", yp -> yp_intexp, yp -> yp_strexp, yp -> yp_prfexp, ! 2674: yp -> yp_declexp, yp -> yp_varexp); ! 2675: if (yp -> yp_param_type) ! 2676: (void) fprintf (stderr, "%*sparameter type=\"%s\"\n", level * 4, "", ! 2677: yp -> yp_param_type); ! 2678: if (yp -> yp_action0) ! 2679: (void) fprintf (stderr, "%*saction0 at line %d=\"%s\"\n", level * 4, "", ! 2680: yp -> yp_act0_lineno, yp -> yp_action0); ! 2681: if (yp -> yp_action05) ! 2682: (void) fprintf (stderr, "%*saction05 at line %d=\"%s\"\n", level * 4, "", ! 2683: yp -> yp_act05_lineno, yp -> yp_action05); ! 2684: if (yp -> yp_action1) ! 2685: (void) fprintf (stderr, "%*saction1 at line %d=\"%s\"\n", level * 4, "", ! 2686: yp -> yp_act1_lineno, yp -> yp_action1); ! 2687: if (yp -> yp_action2) ! 2688: (void) fprintf (stderr, "%*saction2 at line %d=\"%s\"\n", level * 4, "", ! 2689: yp -> yp_act2_lineno, yp -> yp_action2); ! 2690: if (yp -> yp_action3) ! 2691: (void) fprintf (stderr, "%*saction3 at line %d=\"%s\"\n", level * 4, "", ! 2692: yp -> yp_act3_lineno, yp -> yp_action3); ! 2693: ! 2694: if (yp -> yp_flags & YP_TAG) { ! 2695: (void) fprintf (stderr, "%*stag class=0x%x value=0x%x\n", level * 4, "", ! 2696: yp -> yp_tag -> yt_class, yp -> yp_tag -> yt_value); ! 2697: print_value (yp -> yp_tag -> yt_value, level + 1); ! 2698: } ! 2699: ! 2700: if (yp -> yp_flags & YP_DEFAULT) { ! 2701: (void) fprintf (stderr, "%*sdefault=0x%x\n", level * 4, "", yp -> yp_default); ! 2702: print_value (yp -> yp_default, level + 1); ! 2703: } ! 2704: ! 2705: if (yp -> yp_flags & YP_ID) ! 2706: (void) fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yp -> yp_id); ! 2707: ! 2708: if (yp -> yp_flags & YP_BOUND) ! 2709: (void) fprintf (stderr, "%*sbound=\"%s\"\n", level * 4, "", yp -> yp_bound); ! 2710: ! 2711: if (yp -> yp_offset) ! 2712: (void) fprintf (stderr, "%*soffset=\"%s\"\n", level * 4, "", yp -> yp_offset); ! 2713: ! 2714: switch (yp -> yp_code) { ! 2715: case YP_INTLIST: ! 2716: case YP_ENUMLIST: ! 2717: case YP_BITLIST: ! 2718: (void) fprintf (stderr, "%*svalue=0x%x\n", level * 4, "", yp -> yp_value); ! 2719: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 2720: print_value (yv, level + 1); ! 2721: (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 2722: } ! 2723: break; ! 2724: ! 2725: case YP_SEQTYPE: ! 2726: case YP_SEQLIST: ! 2727: case YP_SETTYPE: ! 2728: case YP_SETLIST: ! 2729: case YP_CHOICE: ! 2730: (void) fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yp -> yp_type); ! 2731: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 2732: print_type (y, level + 1); ! 2733: (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 2734: } ! 2735: break; ! 2736: ! 2737: case YP_IDEFINED: ! 2738: (void) fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n", ! 2739: level * 4, "", yp -> yp_module ? yp -> yp_module : "", ! 2740: yp -> yp_identifier); ! 2741: break; ! 2742: ! 2743: default: ! 2744: break; ! 2745: } ! 2746: } ! 2747: ! 2748: /* */ ! 2749: ! 2750: static print_value (yv, level) ! 2751: register YV yv; ! 2752: register int level; ! 2753: { ! 2754: register YV y; ! 2755: ! 2756: if (yv == NULLYV) ! 2757: return; ! 2758: ! 2759: (void) fprintf (stderr, "%*scode=0x%x flags=%s\n", level * 4, "", ! 2760: yv -> yv_code, sprintb (yv -> yv_flags, YVBITS)); ! 2761: ! 2762: if (yv -> yv_action) ! 2763: (void) fprintf (stderr, "%*saction at line %d=\"%s\"\n", level * 4, "", ! 2764: yv -> yv_act_lineno, yv -> yv_action); ! 2765: ! 2766: if (yv -> yv_flags & YV_ID) ! 2767: (void) fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yv -> yv_id); ! 2768: ! 2769: if (yv -> yv_flags & YV_NAMED) ! 2770: (void) fprintf (stderr, "%*snamed=\"%s\"\n", level * 4, "", yv -> yv_named); ! 2771: ! 2772: if (yv -> yv_flags & YV_TYPE) { ! 2773: (void) fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yv -> yv_type); ! 2774: print_type (yv -> yv_type, level + 1); ! 2775: } ! 2776: ! 2777: switch (yv -> yv_code) { ! 2778: case YV_NUMBER: ! 2779: case YV_BOOL: ! 2780: (void) fprintf (stderr, "%*snumber=0x%x\n", level * 4, "", ! 2781: yv -> yv_number); ! 2782: break; ! 2783: ! 2784: case YV_STRING: ! 2785: (void) fprintf (stderr, "%*sstring=0x%x\n", level * 4, "", ! 2786: yv -> yv_string); ! 2787: break; ! 2788: ! 2789: case YV_IDEFINED: ! 2790: if (yv -> yv_flags & YV_BOUND) ! 2791: (void) fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n", ! 2792: level * 4, "", yv -> yv_module, yv -> yv_identifier); ! 2793: else ! 2794: (void) fprintf (stderr, "%*sbound identifier=\"%s\"\n", ! 2795: level * 4, "", yv -> yv_identifier); ! 2796: break; ! 2797: ! 2798: case YV_IDLIST: ! 2799: case YV_VALIST: ! 2800: for (y = yv -> yv_idlist; y; y = y -> yv_next) { ! 2801: print_value (y, level + 1); ! 2802: (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 2803: } ! 2804: break; ! 2805: ! 2806: default: ! 2807: break; ! 2808: } ! 2809: } ! 2810: ! 2811: /* SYMBOLS */ ! 2812: ! 2813: static SY new_symbol (encpref, decpref, prfpref, mod, id, type) ! 2814: register char *encpref, ! 2815: *decpref, ! 2816: *prfpref, ! 2817: *mod, ! 2818: *id; ! 2819: register YP type; ! 2820: { ! 2821: register SY sy; ! 2822: ! 2823: if ((sy = (SY) calloc (1, sizeof *sy)) == NULLSY) ! 2824: yyerror ("out of memory"); ! 2825: sy -> sy_encpref = encpref; ! 2826: sy -> sy_decpref = decpref; ! 2827: sy -> sy_prfpref = prfpref; ! 2828: sy -> sy_module = mod; ! 2829: sy -> sy_name = id; ! 2830: sy -> sy_type = type; ! 2831: ! 2832: return sy; ! 2833: } ! 2834: ! 2835: ! 2836: static SY add_symbol (s1, s2) ! 2837: register SY s1, ! 2838: s2; ! 2839: { ! 2840: register SY sy; ! 2841: ! 2842: if (s1 == NULLSY) ! 2843: return s2; ! 2844: ! 2845: for (sy = s1; sy -> sy_next; sy = sy -> sy_next) ! 2846: continue; ! 2847: sy -> sy_next = s2; ! 2848: ! 2849: return s1; ! 2850: } ! 2851: ! 2852: /* MODULES */ ! 2853: ! 2854: MD lookup_module (module, oid) ! 2855: char *module; ! 2856: OID oid; ! 2857: { ! 2858: register MD md; ! 2859: ! 2860: for (md = mymodules; md; md = md -> md_next) { ! 2861: if (module && md -> md_module && strcmp (md -> md_module, module) == 0) ! 2862: return md; ! 2863: if (oid && md -> md_oid && oid_cmp(oid, md->md_oid) == 0) ! 2864: return md; ! 2865: } ! 2866: ! 2867: read_ph_file (module, oid); ! 2868: ! 2869: if ((md = (MD) calloc (1, sizeof *md)) == NULLMD) ! 2870: yyerror ("out of memory"); ! 2871: md -> md_module = new_string (module); ! 2872: if (oid) ! 2873: md -> md_oid = oid_cpy(oid); ! 2874: else ! 2875: md -> md_oid = NULLOID; ! 2876: ! 2877: if (mymodules != NULLMD) ! 2878: md -> md_next = mymodules; ! 2879: ! 2880: return (mymodules = md); ! 2881: } ! 2882: ! 2883: /* TYPES */ ! 2884: ! 2885: YP new_type (code) ! 2886: int code; ! 2887: { ! 2888: register YP yp; ! 2889: ! 2890: if ((yp = (YP) calloc (1, sizeof *yp)) == NULLYP) ! 2891: yyerror ("out of memory"); ! 2892: yp -> yp_code = code; ! 2893: ! 2894: return yp; ! 2895: } ! 2896: ! 2897: ! 2898: YP add_type (y, z) ! 2899: register YP y, ! 2900: z; ! 2901: { ! 2902: register YP yp; ! 2903: ! 2904: for (yp = y; yp -> yp_next; yp = yp -> yp_next) ! 2905: continue; ! 2906: yp -> yp_next = z; ! 2907: ! 2908: return y; ! 2909: } ! 2910: ! 2911: /* */ ! 2912: ! 2913: YP copy_type (yp) ! 2914: register YP yp; ! 2915: { ! 2916: register YP y; ! 2917: ! 2918: if (yp == NULLYP) ! 2919: return NULLYP; ! 2920: ! 2921: y = new_type (yp -> yp_code); ! 2922: y -> yp_direction = yp -> yp_direction; ! 2923: ! 2924: switch (yp -> yp_code) { ! 2925: case YP_IDEFINED: ! 2926: if (yp -> yp_module) ! 2927: y -> yp_module = new_string (yp -> yp_module); ! 2928: y -> yp_identifier = new_string (yp -> yp_identifier); ! 2929: y -> yp_modid = oid_cpy (yp -> yp_modid); ! 2930: break; ! 2931: ! 2932: case YP_SEQTYPE: ! 2933: case YP_SEQLIST: ! 2934: case YP_SETTYPE: ! 2935: case YP_SETLIST: ! 2936: case YP_CHOICE: ! 2937: y -> yp_type = copy_type (yp -> yp_type); ! 2938: break; ! 2939: ! 2940: case YP_INTLIST: ! 2941: case YP_ENUMLIST: ! 2942: case YP_BITLIST: ! 2943: y -> yp_value = copy_value (yp -> yp_value); ! 2944: break; ! 2945: ! 2946: default: ! 2947: break; ! 2948: } ! 2949: ! 2950: y -> yp_intexp = yp -> yp_intexp; ! 2951: y -> yp_strexp = yp -> yp_strexp; ! 2952: y -> yp_prfexp = yp -> yp_prfexp; ! 2953: ! 2954: y -> yp_declexp = yp -> yp_declexp; ! 2955: y -> yp_varexp = yp -> yp_varexp; ! 2956: ! 2957: if (yp -> yp_structname) ! 2958: y -> yp_structname = new_string (yp -> yp_structname); ! 2959: if (yp -> yp_ptrname) ! 2960: y -> yp_ptrname = new_string (yp -> yp_ptrname); ! 2961: ! 2962: if (yp -> yp_param_type) ! 2963: y -> yp_param_type = new_string (yp -> yp_param_type); ! 2964: ! 2965: if (yp -> yp_action0) { ! 2966: y -> yp_action0 = new_string (yp -> yp_action0); ! 2967: y -> yp_act0_lineno = yp -> yp_act0_lineno; ! 2968: } ! 2969: ! 2970: if (yp -> yp_action05) { ! 2971: y -> yp_action05 = new_string (yp -> yp_action05); ! 2972: y -> yp_act05_lineno = yp -> yp_act05_lineno; ! 2973: } ! 2974: ! 2975: if (yp -> yp_action1) { ! 2976: y -> yp_action1 = new_string (yp -> yp_action1); ! 2977: y -> yp_act1_lineno = yp -> yp_act1_lineno; ! 2978: } ! 2979: ! 2980: if (yp -> yp_action2) { ! 2981: y -> yp_action2 = new_string (yp -> yp_action2); ! 2982: y -> yp_act2_lineno = yp -> yp_act2_lineno; ! 2983: } ! 2984: ! 2985: if (yp -> yp_action3) { ! 2986: y -> yp_action3 = new_string (yp -> yp_action3); ! 2987: y -> yp_act3_lineno = yp -> yp_act3_lineno; ! 2988: } ! 2989: ! 2990: y -> yp_flags = yp -> yp_flags; ! 2991: ! 2992: if (yp -> yp_flags & YP_DEFAULT) ! 2993: y -> yp_default = copy_value (yp -> yp_default); ! 2994: ! 2995: if (yp -> yp_flags & YP_ID) ! 2996: y -> yp_id = new_string (yp -> yp_id); ! 2997: ! 2998: if (yp -> yp_flags & YP_TAG) ! 2999: y -> yp_tag = copy_tag (yp -> yp_tag); ! 3000: ! 3001: if (yp -> yp_flags & YP_BOUND) ! 3002: y -> yp_bound = new_string (yp -> yp_bound); ! 3003: ! 3004: if (yp -> yp_flags & YP_PARMVAL) ! 3005: y -> yp_parm = new_string (yp -> yp_parm); ! 3006: ! 3007: if (yp -> yp_flags & YP_CONTROLLED) ! 3008: y -> yp_control = new_string (yp -> yp_control); ! 3009: ! 3010: if (yp -> yp_flags & YP_OPTCONTROL) ! 3011: y -> yp_optcontrol = new_string (yp -> yp_optcontrol); ! 3012: ! 3013: if (yp -> yp_offset) ! 3014: y -> yp_offset = new_string (yp -> yp_offset); ! 3015: ! 3016: if (yp -> yp_next) ! 3017: y -> yp_next = copy_type (yp -> yp_next); ! 3018: ! 3019: return y; ! 3020: } ! 3021: ! 3022: /* VALUES */ ! 3023: ! 3024: YV new_value (code) ! 3025: int code; ! 3026: { ! 3027: register YV yv; ! 3028: ! 3029: if ((yv = (YV) calloc (1, sizeof *yv)) == NULLYV) ! 3030: yyerror ("out of memory"); ! 3031: yv -> yv_code = code; ! 3032: ! 3033: return yv; ! 3034: } ! 3035: ! 3036: ! 3037: YV add_value (y, z) ! 3038: register YV y, ! 3039: z; ! 3040: { ! 3041: register YV yv; ! 3042: ! 3043: for (yv = y; yv -> yv_next; yv = yv -> yv_next) ! 3044: continue; ! 3045: yv -> yv_next = z; ! 3046: ! 3047: return y; ! 3048: } ! 3049: ! 3050: /* */ ! 3051: ! 3052: YV copy_value (yv) ! 3053: register YV yv; ! 3054: { ! 3055: register YV y; ! 3056: ! 3057: if (yv == NULLYV) ! 3058: return NULLYV; ! 3059: ! 3060: y = new_value (yv -> yv_code); ! 3061: y -> yv_flags = yv -> yv_flags; ! 3062: ! 3063: if (yv -> yv_action) { ! 3064: y -> yv_action = new_string (yv -> yv_action); ! 3065: y -> yv_act_lineno = yv -> yv_act_lineno; ! 3066: } ! 3067: ! 3068: if (yv -> yv_flags & YV_ID) ! 3069: y -> yv_id = new_string (yv -> yv_id); ! 3070: ! 3071: if (yv -> yv_flags & YV_NAMED) ! 3072: y -> yv_named = new_string (yv -> yv_named); ! 3073: ! 3074: if (yv -> yv_flags & YV_TYPE) ! 3075: y -> yv_type = copy_type (yv -> yv_type); ! 3076: ! 3077: switch (yv -> yv_code) { ! 3078: case YV_NUMBER: ! 3079: case YV_BOOL: ! 3080: y -> yv_number = yv -> yv_number; ! 3081: break; ! 3082: ! 3083: case YV_STRING: ! 3084: y -> yv_string = new_string (yv -> yv_string); ! 3085: break; ! 3086: ! 3087: case YV_IDEFINED: ! 3088: if (yv -> yv_module) ! 3089: y -> yv_module = new_string (yv -> yv_module); ! 3090: y -> yv_identifier = new_string (yv -> yv_identifier); ! 3091: break; ! 3092: ! 3093: case YV_IDLIST: ! 3094: case YV_VALIST: ! 3095: y -> yv_idlist = copy_value (yv -> yv_idlist); ! 3096: break; ! 3097: ! 3098: default: ! 3099: break; ! 3100: } ! 3101: ! 3102: if (yv -> yv_next) ! 3103: y -> yv_next = copy_value (yv -> yv_next); ! 3104: ! 3105: return y; ! 3106: } ! 3107: ! 3108: /* TAGS */ ! 3109: ! 3110: YT new_tag (class) ! 3111: PElementClass class; ! 3112: { ! 3113: register YT yt; ! 3114: ! 3115: if ((yt = (YT) calloc (1, sizeof *yt)) == NULLYT) ! 3116: yyerror ("out of memory"); ! 3117: yt -> yt_class = class; ! 3118: ! 3119: return yt; ! 3120: } ! 3121: ! 3122: /* */ ! 3123: ! 3124: YT copy_tag (yt) ! 3125: register YT yt; ! 3126: { ! 3127: register YT y; ! 3128: ! 3129: if (yt == NULLYT) ! 3130: return NULLYT; ! 3131: ! 3132: y = new_tag (yt -> yt_class); ! 3133: ! 3134: y -> yt_value = copy_value (yt -> yt_value); ! 3135: ! 3136: return y; ! 3137: } ! 3138: ! 3139: /* STRINGS */ ! 3140: ! 3141: char *new_string (s) ! 3142: register char *s; ! 3143: { ! 3144: register char *p; ! 3145: ! 3146: if ((p = malloc ((unsigned) (strlen (s) + 1))) == NULLCP) ! 3147: yyerror ("out of memory"); ! 3148: ! 3149: (void) strcpy (p, s); ! 3150: return p; ! 3151: } ! 3152: ! 3153: /* SYMBOLS */ ! 3154: ! 3155: static struct triple { ! 3156: char *t_name; ! 3157: PElementClass t_class; ! 3158: PElementID t_id; ! 3159: } triples[] = { ! 3160: "IA5String", PE_CLASS_UNIV, PE_DEFN_IA5S, ! 3161: "ISO646String", PE_CLASS_UNIV, PE_DEFN_IA5S, ! 3162: "NumericString", PE_CLASS_UNIV, PE_DEFN_NUMS, ! 3163: "PrintableString", PE_CLASS_UNIV, PE_DEFN_PRTS, ! 3164: "T61String", PE_CLASS_UNIV, PE_DEFN_T61S, ! 3165: "TeletexString", PE_CLASS_UNIV, PE_DEFN_T61S, ! 3166: "VideotexString", PE_CLASS_UNIV, PE_DEFN_VTXS, ! 3167: "GeneralizedTime", PE_CLASS_UNIV, PE_DEFN_GENT, ! 3168: "GeneralisedTime", PE_CLASS_UNIV, PE_DEFN_GENT, ! 3169: "UTCTime", PE_CLASS_UNIV, PE_DEFN_UTCT, ! 3170: "UniversalTime", PE_CLASS_UNIV, PE_DEFN_UTCT, ! 3171: "GraphicString", PE_CLASS_UNIV, PE_DEFN_GFXS, ! 3172: "VisibleString", PE_CLASS_UNIV, PE_DEFN_VISS, ! 3173: "GeneralString", PE_CLASS_UNIV, PE_DEFN_GENS, ! 3174: "EXTERNAL", PE_CLASS_UNIV, PE_CONS_EXTN, ! 3175: "ObjectDescriptor", PE_CLASS_UNIV, PE_PRIM_ODE, ! 3176: ! 3177: NULL ! 3178: }; ! 3179: ! 3180: /* */ ! 3181: ! 3182: char *modsym (module, id, prefix) ! 3183: register char *module, ! 3184: *id; ! 3185: char *prefix; ! 3186: { ! 3187: char buf1[BUFSIZ], ! 3188: buf2[BUFSIZ], ! 3189: buf3[BUFSIZ]; ! 3190: register struct triple *t; ! 3191: static char buffer[BUFSIZ]; ! 3192: ! 3193: if (module == NULLCP) ! 3194: for (t = triples; t -> t_name; t++) ! 3195: if (strcmp (t -> t_name, id) == 0) { ! 3196: module = "UNIV"; ! 3197: break; ! 3198: } ! 3199: ! 3200: if (prefix) ! 3201: modsym_aux (prefix, buf1); ! 3202: modsym_aux (module ? module : mymodule, buf2); ! 3203: modsym_aux (id, buf3); ! 3204: if (prefix) ! 3205: (void) sprintf (buffer, "%s_%s_%s", buf1, buf2, buf3); ! 3206: else ! 3207: (void) sprintf (buffer, "%s_%s", buf2, buf3); ! 3208: ! 3209: return buffer; ! 3210: } ! 3211: ! 3212: ! 3213: static modsym_aux (name, bp) ! 3214: register char *name, ! 3215: *bp; ! 3216: { ! 3217: register char c; ! 3218: ! 3219: while (c = *name++) ! 3220: switch (c) { ! 3221: case '-': ! 3222: *bp++ = '_'; ! 3223: *bp++ = '_'; ! 3224: break; ! 3225: ! 3226: default: ! 3227: *bp++ = c; ! 3228: break; ! 3229: } ! 3230: ! 3231: *bp = NULL; ! 3232: } ! 3233: ! 3234: /* */ ! 3235: ! 3236: static char *gensym (s, a) ! 3237: char *s, *a; ! 3238: { ! 3239: int i; ! 3240: register char *p; ! 3241: char buffer[BUFSIZ]; ! 3242: static int cP = 0; ! 3243: static int eP = 0; ! 3244: static int mP = 0; ! 3245: ! 3246: switch (*s) { ! 3247: case 'c': ! 3248: i = cP++; ! 3249: break; ! 3250: case 'e': ! 3251: i = eP++; ! 3252: break; ! 3253: case 'm': ! 3254: i = mP++; ! 3255: break; ! 3256: ! 3257: default: ! 3258: myyerror ("unknown gensym argument \"%s\"", s); ! 3259: /* NOTREACHED */ ! 3260: } ! 3261: if (a) ! 3262: (void) sprintf (buffer, "%s_%s_%d[n_%s]", s, modulename, i, a); ! 3263: else ! 3264: (void) sprintf (buffer, "%s_%s_%d", s, modulename, i); ! 3265: ! 3266: if ((p = malloc ((unsigned) (strlen (buffer) + 11))) == NULLCP) ! 3267: yyerror ("out of memory"); ! 3268: ! 3269: (void) strcpy (p, buffer); ! 3270: return p; ! 3271: } ! 3272: ! 3273: /* pepy compatible routines - you know how it is ... */ ! 3274: init_new_file () ! 3275: { ! 3276: ; ! 3277: } ! 3278: ! 3279: end_file () ! 3280: { ! 3281: ; ! 3282: } ! 3283: ! 3284: static char *array (s, flg) ! 3285: char *s; ! 3286: int flg; ! 3287: { ! 3288: static char buf[BUFSIZ]; ! 3289: char *p; ! 3290: ! 3291: if (!flg) return s; ! 3292: ! 3293: if (p = index (s, '[')) { ! 3294: (void) sprintf (buf, "%*.*s[1]", p - s, p - s, s); ! 3295: return buf; ! 3296: } ! 3297: return s; ! 3298: } ! 3299: ! 3300: static void prime_default (yp, level) ! 3301: YP yp; ! 3302: int level; ! 3303: { ! 3304: switch (yp -> yp_code) { ! 3305: case YP_BOOL: ! 3306: (void) printf ("%*s%s = %d;\n", level * 4, "", ! 3307: SVAL (yp->yp_varexp), ! 3308: val2int (yp -> yp_default) ? 1 : 0); ! 3309: break; ! 3310: ! 3311: case YP_INT: ! 3312: (void) printf ("%*s%s = %d;\n", level * 4, "", ! 3313: SVAL (yp -> yp_varexp), val2int (yp -> yp_default)); ! 3314: break; ! 3315: ! 3316: case YP_INTLIST: ! 3317: case YP_ENUMLIST: ! 3318: (void) printf ("%*s%s = %d;\n", level * 4, "", ! 3319: SVAL (yp -> yp_varexp), dfl2int (yp)); ! 3320: break; ! 3321: ! 3322: case YP_REAL: ! 3323: (void) printf ("%*s%s = %g;\n", level * 4, "", ! 3324: SVAL (yp -> yp_varexp), ! 3325: val2real (yp -> yp_default)); ! 3326: ! 3327: default: ! 3328: break; ! 3329: } ! 3330: } ! 3331: /* PH FILES */ ! 3332: ! 3333: /* really need much more information in the .ph file... */ ! 3334: ! 3335: static read_ph_file (module, oid) ! 3336: register char *module; ! 3337: OID oid; ! 3338: { ! 3339: int class, ! 3340: value, ! 3341: direction; ! 3342: char buffer[BUFSIZ], ! 3343: file[BUFSIZ], ! 3344: id[BUFSIZ], ! 3345: encpref[BUFSIZ], ! 3346: decpref[BUFSIZ], ! 3347: printpref[BUFSIZ]; ! 3348: char *p, *ep, *dp, *ppp; ! 3349: register FILE *fp; ! 3350: register YP yp; ! 3351: register YT yt; ! 3352: register YV yv; ! 3353: ! 3354: (void) sprintf (file, "%s.ph", module); ! 3355: if (oid) ! 3356: (void) sprintf (p = buffer, "%s.ph", sprintoid(oid)); ! 3357: else ! 3358: p = NULLCP; ! 3359: if ((fp = open_ph_file (file, p, "r")) == NULL) ! 3360: { ! 3361: warning ("Can't find file %s%s%s failed\n", ! 3362: file, p ? "/" : "", p ? p : ""); ! 3363: return; ! 3364: } ! 3365: ! 3366: if (strcmp (module, "UNIV")) ! 3367: yyprint (module, 1, 0); ! 3368: ! 3369: while (fgets (buffer, sizeof buffer, fp)) { ! 3370: if (sscanf (buffer, "%d/%d/%d: %s", ! 3371: &class, &value, &direction, id) !=4) { ! 3372: myyerror ("bad external definition in %s: %s", ! 3373: file, buffer); ! 3374: continue; ! 3375: } ! 3376: ppp = dp = ep = NULLCP; ! 3377: if (p = index(buffer, '|')) { ! 3378: if( sscanf (p+1, "%s %s %s\n", encpref, decpref, printpref) == 3) { ! 3379: ppp = new_string (printpref); ! 3380: dp = new_string (decpref); ! 3381: ep = new_string (encpref); ! 3382: } ! 3383: } ! 3384: ! 3385: yp = new_type (YP_ANY); ! 3386: yp -> yp_flags = YP_IMPORTED; ! 3387: if (class >= 0) { ! 3388: yp -> yp_flags |= YP_TAG; ! 3389: yp -> yp_tag = yt = new_tag ((PElementClass) class); ! 3390: yt -> yt_value = yv = new_value (YV_NUMBER); ! 3391: yv -> yv_number = value; ! 3392: } ! 3393: yp -> yp_direction = direction; ! 3394: pass1_type (ep, dp, ppp, new_string (module), ! 3395: new_string (id), yp); ! 3396: } ! 3397: ! 3398: (void) fclose (fp); ! 3399: } ! 3400: ! 3401: /* */ ! 3402: ! 3403: static write_ph_file () { ! 3404: int msave; ! 3405: char file[BUFSIZ]; ! 3406: char fileoid[BUFSIZ]; ! 3407: char *cp; ! 3408: register FILE *fp; ! 3409: register SY sy; ! 3410: register YT yt; ! 3411: register YP yp; ! 3412: ! 3413: (void) sprintf (file, "%s.ph", mymodule); ! 3414: if (mymoduleid) ! 3415: (void) sprintf (cp = fileoid, "%s.ph", sprintoid(mymoduleid)); ! 3416: else ! 3417: cp = NULLCP; ! 3418: msave = mflag, mflag = 0; ! 3419: if ((fp = open_ph_file (file, cp, "w")) == NULL) ! 3420: myyerror ("unable to write %s", file); ! 3421: mflag = msave; ! 3422: ! 3423: for (sy = mysymbols; sy; sy = sy -> sy_next) { ! 3424: yp = sy -> sy_type; ! 3425: if (yp -> yp_flags & YP_IMPORTED) ! 3426: continue; ! 3427: if (doexternals == 0 && (yp->yp_flags & YP_EXPORTED) == 0) ! 3428: continue; ! 3429: ! 3430: if (is_any_type (yp)) { ! 3431: (void) fprintf (fp, "-1/0/%d: %s", yp -> yp_direction, sy -> sy_name); ! 3432: (void) fprintf (fp, " |%s %s %s\n", yyencpref, yydecpref, yyprfpref); ! 3433: } ! 3434: else ! 3435: if ((yt = lookup_tag (yp)) && yt -> yt_class != PE_CLASS_CONT) { ! 3436: (void) fprintf (fp, "%d/%d/%d: %s", yt -> yt_class, ! 3437: val2int (yt -> yt_value), yp -> yp_direction, ! 3438: sy -> sy_name); ! 3439: (void) fprintf (fp, " |%s %s %s\n", yyencpref, yydecpref, yyprfpref); ! 3440: } ! 3441: } ! 3442: ! 3443: (void) fclose (fp); ! 3444: } ! 3445: ! 3446: /* */ ! 3447: ! 3448: #ifndef PEPSYPATH ! 3449: #define PEPSYPATH "" ! 3450: #endif ! 3451: ! 3452: ! 3453: static FILE *open_ph_file (fn, fnoid, mode) ! 3454: char *fn, ! 3455: *fnoid, ! 3456: *mode; ! 3457: { ! 3458: register char *dst, ! 3459: *path; ! 3460: char fnb[BUFSIZ]; ! 3461: register FILE *fp; ! 3462: static char *pepypath = NULL; ! 3463: ! 3464: if (*fn == '/') ! 3465: return fopen (fn, mode); ! 3466: ! 3467: if (mflag) { /* MOBY HACK */ ! 3468: if (fnoid && (fp = fopen (fnoid, mode)) != NULL) ! 3469: return fp; ! 3470: if ((fp = fopen (fn, mode)) != NULL) ! 3471: return fp; ! 3472: ! 3473: if (fnoid) { ! 3474: (void) sprintf (fnb, "../pepy/%s", fnoid); ! 3475: if ((fp = fopen (fnb, mode)) != NULL) ! 3476: return fp; ! 3477: } ! 3478: (void) sprintf (fnb, "../pepy/%s", fn); ! 3479: if ((fp = fopen (fnb, mode)) != NULL) ! 3480: return fp; ! 3481: ! 3482: if (fnoid) { ! 3483: (void) sprintf (fnb, "../../pepy/%s", fnoid); ! 3484: if ((fp = fopen (fnb, mode)) != NULL) ! 3485: return fp; ! 3486: } ! 3487: (void) sprintf (fnb, "../../pepy/%s", fn); ! 3488: return fopen (fnb, mode); ! 3489: } ! 3490: ! 3491: if (pepypath == NULL && (pepypath = getenv ("PEPSYPATH")) == NULL) ! 3492: pepypath = PEPSYPATH; ! 3493: path = pepypath; ! 3494: ! 3495: do { ! 3496: dst = fnb; ! 3497: while (*path && *path != ':') ! 3498: *dst++ = *path++; ! 3499: if (dst != fnb) ! 3500: *dst++ = '/'; ! 3501: if (fnoid) { ! 3502: (void) strcpy (dst, fnoid); ! 3503: if ((fp = fopen (fnb, mode)) != NULL) ! 3504: break; ! 3505: } ! 3506: (void) strcpy (dst, fn); ! 3507: if ((fp = fopen (fnb, mode)) != NULL) ! 3508: break; ! 3509: } while (*path++); ! 3510: ! 3511: return fp; ! 3512: } ! 3513: ! 3514: YT lookup_tag (yp) ! 3515: register YP yp; ! 3516: { ! 3517: register struct tuple *t; ! 3518: static struct ypt ypts; ! 3519: register YT yt = &ypts; ! 3520: static struct ypv ypvs; ! 3521: register YV yv = &ypvs; ! 3522: register YP z; ! 3523: ! 3524: if (yp -> yp_flags & YP_TAG) ! 3525: return yp -> yp_tag; ! 3526: ! 3527: while (yp -> yp_code == YP_IDEFINED) { ! 3528: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) ! 3529: (void) lookup_module (yp -> yp_module, yp -> yp_modid); ! 3530: ! 3531: if (z = lookup_type (yp -> yp_module, yp -> yp_identifier)) { ! 3532: yp = z; ! 3533: ! 3534: if (yp -> yp_flags & YP_TAG) ! 3535: return yp -> yp_tag; ! 3536: ! 3537: continue; ! 3538: } ! 3539: ! 3540: break; ! 3541: } ! 3542: ! 3543: for (t = tuples; t -> t_type != YP_UNDF; t++) ! 3544: if (t -> t_type == yp -> yp_code) { ! 3545: yt -> yt_class = t -> t_classnum; ! 3546: yt -> yt_value = yv; ! 3547: yv -> yv_code = YV_NUMBER; ! 3548: yv -> yv_number = t -> t_idnum; ! 3549: ! 3550: return yt; ! 3551: } ! 3552: ! 3553: return NULLYT; ! 3554: } ! 3555: ! 3556: int is_any_type (yp) ! 3557: register YP yp; ! 3558: { ! 3559: register YP z; ! 3560: ! 3561: while (yp -> yp_code == YP_IDEFINED) { ! 3562: if (yp -> yp_flags & YP_TAG) ! 3563: return 0; ! 3564: ! 3565: if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) ! 3566: (void) lookup_module (yp -> yp_module, yp -> yp_modid); ! 3567: ! 3568: if (z = lookup_type (yp -> yp_module, yp -> yp_identifier)) { ! 3569: yp = z; ! 3570: ! 3571: continue; ! 3572: } ! 3573: ! 3574: break; ! 3575: } ! 3576: ! 3577: return (yp -> yp_code == YP_ANY && !(yp -> yp_flags & YP_TAG)); ! 3578: } ! 3579: ! 3580: /* ! 3581: * return a string with the leading pathname stripped off ! 3582: */ ! 3583: char * ! 3584: pstrip(p) ! 3585: char *p; ! 3586: { ! 3587: char *p1; ! 3588: ! 3589: if (p1 = rindex(p, '/')) ! 3590: return (p1 + 1); ! 3591: return (p); ! 3592: } ! 3593: ! 3594: ! 3595: /* ! 3596: * produce a #include on the given file descriptor according to what ever ! 3597: * rules are in fashion today. Unfortunately these keep changing so to ! 3598: * minimise the effort involved in keeping up we put all the code to change ! 3599: * in the one place, here. -- amrw ! 3600: * ! 3601: * actually, the rules have never changed, andrew just can't figure them out. ! 3602: * -- mtr ! 3603: */ ! 3604: doincl(fp, file) ! 3605: FILE *fp; /* where #include is to be written to */ ! 3606: char *file[]; /* files to be included */ ! 3607: { ! 3608: char **p; ! 3609: int stflag = 0; /* are there any standard files ? */ ! 3610: ! 3611: /* determine if there are any standard files present */ ! 3612: for (p = file; *p; p++) { ! 3613: if (is_stand(*p)) { ! 3614: stflag = 1; ! 3615: break; ! 3616: } ! 3617: } ! 3618: ! 3619: if (mflag || stflag) { ! 3620: /* PEPYPATH version */ ! 3621: ! 3622: (void) fprintf (fp, "#ifndef PEPYPATH\n"); ! 3623: for (p = file; *p; p++) { ! 3624: if (mflag || is_stand(*p)) ! 3625: (void) fprintf (fp, "#include <isode/%s>\n", *p); ! 3626: } ! 3627: (void) fprintf (fp, "#else\n"); ! 3628: for (p = file; *p; p++) { ! 3629: if (mflag || is_stand(*p)) ! 3630: (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p)); ! 3631: } ! 3632: (void) fprintf (fp, "#endif\n\n"); ! 3633: ! 3634: /* Now the non standard files */ ! 3635: if (!mflag) { ! 3636: for (p = file; *p; p++) { ! 3637: if (!is_stand(*p)) ! 3638: (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p)); ! 3639: } ! 3640: } ! 3641: ! 3642: } else { ! 3643: /* simple include only version */ ! 3644: ! 3645: for (p = file; *p; p++) ! 3646: (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p)); ! 3647: } ! 3648: ! 3649: (void) fprintf (fp, "\n"); ! 3650: } ! 3651: ! 3652: /* standard files - that should be found in the <isode> directory */ ! 3653: static char *stand_f[] = { ! 3654: "psap.h", ! 3655: "pepsy.h", ! 3656: "UNIV-types.h", ! 3657: ! 3658: (char *)0 /* terminating NULL pointer */ ! 3659: }; ! 3660: ! 3661: ! 3662: /* ! 3663: * determine if the given (after stripping any path) file is a standard ! 3664: * include file which should be in the include/isode directory. ! 3665: * return nonzero (true) if it is. ! 3666: */ ! 3667: is_stand(file) ! 3668: char *file; ! 3669: { ! 3670: char **p; ! 3671: ! 3672: for (p = stand_f; *p; p++) { ! 3673: if (strcmp(file, pstrip(*p)) == 0) ! 3674: return (1); ! 3675: } ! 3676: ! 3677: return (0); ! 3678: } ! 3679: ! 3680: /* Number of different external modules that can referenced */ ! 3681: #define EXTMODSIZE 50 ! 3682: ! 3683: /* table of external modules we reference */ ! 3684: static char *extmodtab[EXTMODSIZE]; ! 3685: static int nextmod = 0; /* next free slot in external module table */ ! 3686: ! 3687: /* ! 3688: * build up a list of external modules we have referenced ! 3689: */ ! 3690: addextmod(p) ! 3691: char *p; /* name of external module */ ! 3692: { ! 3693: #if 0 ! 3694: char *s; ! 3695: #endif ! 3696: ! 3697: if (nextmod >= EXTMODSIZE) ! 3698: ferr(1, "Too many external modules reference, table overflow\n"); ! 3699: ! 3700: #if 0 ! 3701: if ((s = (char *)malloc(strlen(p) + 1)) == NULL) ! 3702: ferr(1, "addextmodout of memory\n"); ! 3703: strcpy(s, p); ! 3704: extmodtab[nextmod++] = s; ! 3705: #else ! 3706: extmodtab[nextmod++] = p; ! 3707: #endif ! 3708: } ! 3709: ! 3710: /* ! 3711: * process all the external modules collected to produce the includes ! 3712: * required ! 3713: */ ! 3714: proc_extmod(fp) ! 3715: FILE *fp; ! 3716: { ! 3717: char **p; ! 3718: char *files[EXTMODSIZE + 1]; ! 3719: char *buf; ! 3720: char *tail = "-types.h"; ! 3721: char *prefix = "pepsy/"; ! 3722: int last = 0; ! 3723: ! 3724: if (nextmod <= 0) ! 3725: return; /* no external definitions */ ! 3726: ! 3727: for (p = extmodtab; p < extmodtab + nextmod; p++) { ! 3728: if (last >= EXTMODSIZE) ! 3729: ferr(1, "proc_extmod: too many external modules\n"); ! 3730: ! 3731: buf = concat(*p, tail); ! 3732: if (mflag || is_stand(buf)) /* need to prepend a "pepsy/" */ ! 3733: files[last++] = my_strcat(prefix, buf); ! 3734: else ! 3735: files[last++] = my_new_str(buf); ! 3736: } ! 3737: files[last++] = (char *)0; ! 3738: ! 3739: doincl(fp, files); ! 3740: ! 3741: /* free up this memory */ ! 3742: --last; /* don't free the NULL pointer - can core dump */ ! 3743: while (last > 0) ! 3744: free(files[--last]); ! 3745: ! 3746: } ! 3747:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.