![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mosy.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 / others / mosy|
Return to mosy.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / mosy |
1.1 ! root 1: /* mosy.c - Managed Object Syntax-compiler (yacc-based) */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header: /f/osi/others/mosy/RCS/mosy.c,v 7.1 90/07/01 21:04:36 mrose Exp $"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header: /f/osi/others/mosy/RCS/mosy.c,v 7.1 90/07/01 21:04:36 mrose Exp $ ! 9: * ! 10: * ! 11: * $Log: mosy.c,v $ ! 12: * Revision 7.1 90/07/01 21:04:36 mrose ! 13: * pepsy ! 14: * ! 15: * Revision 7.0 89/11/23 22:00:38 mrose ! 16: * Release 6.0 ! 17: * ! 18: */ ! 19: ! 20: /* ! 21: * NOTICE ! 22: * ! 23: * Acquisition, use, and distribution of this module and related ! 24: * materials are subject to the restrictions of a license agreement. ! 25: * Consult the Preface in the User's Manual for the full terms of ! 26: * this agreement. ! 27: * ! 28: */ ! 29: ! 30: ! 31: #include <ctype.h> ! 32: #include <stdio.h> ! 33: #include <varargs.h> ! 34: #include "mosy-defs.h" ! 35: ! 36: /* DATA */ ! 37: ! 38: int Cflag = 0; /* mosy */ ! 39: int dflag = 0; ! 40: int Pflag = 0; /* pepy compat... */ ! 41: int doexternals; ! 42: static int linepos = 0; ! 43: static int mflag = 0; ! 44: static int mosydebug = 0; ! 45: static int sflag = 0; ! 46: ! 47: static char *eval = NULLCP; ! 48: ! 49: char *mymodule = ""; ! 50: OID mymoduleid; ! 51: ! 52: int yysection = NULL; ! 53: char *yyencpref = "none"; ! 54: char *yydecpref = "none"; ! 55: char *yyprfpref = "none"; ! 56: char *yyencdflt = "none"; ! 57: char *yydecdflt = "none"; ! 58: char *yyprfdflt = "none"; ! 59: ! 60: static char *yymode = ""; ! 61: ! 62: static char *classes[] = { ! 63: "UNIVERSAL ", ! 64: "APPLICATION ", ! 65: "", ! 66: "PRIVATE " ! 67: }; ! 68: ! 69: static char autogen[BUFSIZ]; ! 70: ! 71: char *sysin = NULLCP; ! 72: static char sysout[BUFSIZ]; ! 73: ! 74: /* */ ! 75: ! 76: typedef struct yot { ! 77: char *yo_name; ! 78: ! 79: YP yo_syntax; ! 80: YV yo_value; ! 81: ! 82: char *yo_access; ! 83: char *yo_status; ! 84: } yot, *OT; ! 85: #define NULLOT ((OT) 0) ! 86: ! 87: typedef struct yoi { ! 88: char *yi_name; ! 89: ! 90: YV yi_value; ! 91: } yoi, *OI; ! 92: #define NULLOI ((OI) 0) ! 93: ! 94: /* */ ! 95: ! 96: typedef struct symlist { ! 97: char *sy_encpref; ! 98: char *sy_decpref; ! 99: char *sy_prfpref; ! 100: char *sy_module; ! 101: char *sy_name; ! 102: ! 103: union { ! 104: OT sy_un_yo; ! 105: ! 106: OI sy_un_yi; ! 107: ! 108: YP sy_un_yp; ! 109: } sy_un; ! 110: #define sy_yo sy_un.sy_un_yo ! 111: #define sy_yi sy_un.sy_un_yi ! 112: #define sy_yp sy_un.sy_un_yp ! 113: ! 114: struct symlist *sy_next; ! 115: } symlist, *SY; ! 116: #define NULLSY ((SY) 0) ! 117: ! 118: static SY myobjects = NULLSY; ! 119: ! 120: static SY myidentifiers = NULLSY; ! 121: ! 122: static SY mytypes = NULLSY; ! 123: ! 124: ! 125: char *modsym (); ! 126: SY new_symbol (), add_symbol (); ! 127: ! 128: char *id2str (); ! 129: ! 130: YP lookup_type (); ! 131: char *val2str (); ! 132: ! 133: /* MAIN */ ! 134: ! 135: /* ARGSUSED */ ! 136: ! 137: main (argc, argv, envp) ! 138: int argc; ! 139: char **argv, ! 140: **envp; ! 141: { ! 142: register char *cp, ! 143: *sp; ! 144: ! 145: fprintf (stderr, "%s\n", mosyversion); ! 146: ! 147: sysout[0] = NULL; ! 148: for (argc--, argv++; argc > 0; argc--, argv++) { ! 149: cp = *argv; ! 150: ! 151: if (strcmp (cp, "-d") == 0) { ! 152: dflag++; ! 153: continue; ! 154: } ! 155: if (strcmp (cp, "-m") == 0) { ! 156: mflag++; ! 157: continue; ! 158: } ! 159: if (strcmp (cp, "-o") == 0) { ! 160: if (sysout[0]) { ! 161: fprintf (stderr, "too many output files\n"); ! 162: exit (1); ! 163: } ! 164: argc--, argv++; ! 165: if ((cp = *argv) == NULL || (*cp == '-' && cp[1] != NULL)) ! 166: goto usage; ! 167: (void) strcpy (sysout, cp); ! 168: ! 169: continue; ! 170: } ! 171: if (strcmp (cp, "-s") == 0) { ! 172: sflag++; ! 173: continue; ! 174: } ! 175: ! 176: if (sysin) { ! 177: usage: ; ! 178: fprintf (stderr, ! 179: "usage: mosy [-d] [-o module.defs] [-s] module.my\n"); ! 180: exit (1); ! 181: } ! 182: ! 183: if (*cp == '-') { ! 184: if (*++cp != NULL) ! 185: goto usage; ! 186: sysin = ""; ! 187: } ! 188: sysin = cp; ! 189: ! 190: if (sysout[0]) ! 191: continue; ! 192: if (sp = rindex (cp, '/')) ! 193: sp++; ! 194: if (sp == NULL || *sp == NULL) ! 195: sp = cp; ! 196: sp += strlen (cp = sp) - 3; ! 197: if (sp > cp && strcmp (sp, ".my") == 0) ! 198: (void) sprintf (sysout, "%.*s.defs", sp - cp, cp); ! 199: else ! 200: (void) sprintf (sysout, "%s.defs", cp); ! 201: } ! 202: ! 203: switch (mosydebug = (cp = getenv ("MOSYTEST")) && *cp ? atoi (cp) : 0) { ! 204: case 2: ! 205: yydebug++; /* fall */ ! 206: case 1: ! 207: sflag++; /* .. */ ! 208: case 0: ! 209: break; ! 210: } ! 211: ! 212: if (sysin == NULLCP) ! 213: sysin = ""; ! 214: ! 215: if (*sysin && freopen (sysin, "r", stdin) == NULL) { ! 216: fprintf (stderr, "unable to read "), perror (sysin); ! 217: exit (1); ! 218: } ! 219: ! 220: if (strcmp (sysout, "-") == 0) ! 221: sysout[0] = NULL; ! 222: if (*sysout && freopen (sysout, "w", stdout) == NULL) { ! 223: fprintf (stderr, "unable to write "), perror (sysout); ! 224: exit (1); ! 225: } ! 226: ! 227: if (cp = index (mosyversion, ')')) ! 228: for (cp++; *cp != ' '; cp++) ! 229: if (*cp == NULL) { ! 230: cp = NULL; ! 231: break; ! 232: } ! 233: if (cp == NULL) ! 234: cp = mosyversion + strlen (mosyversion); ! 235: (void) sprintf (autogen, "%*.*s", ! 236: cp - mosyversion, cp - mosyversion, mosyversion); ! 237: printf ("-- automatically generated by %s, do not edit!\n\n", autogen); ! 238: ! 239: initoidtbl (); ! 240: ! 241: exit (yyparse ()); /* NOTREACHED */ ! 242: } ! 243: ! 244: /* ERRORS */ ! 245: ! 246: yyerror (s) ! 247: register char *s; ! 248: { ! 249: yyerror_aux (s); ! 250: ! 251: if (*sysout) ! 252: (void) unlink (sysout); ! 253: ! 254: exit (1); ! 255: } ! 256: ! 257: #ifndef lint ! 258: warning (va_alist) ! 259: va_dcl ! 260: { ! 261: char buffer[BUFSIZ]; ! 262: char buffer2[BUFSIZ]; ! 263: char *cp; ! 264: va_list ap; ! 265: ! 266: va_start (ap); ! 267: ! 268: _asprintf (buffer, NULLCP, ap); ! 269: ! 270: va_end (ap); ! 271: ! 272: (void) sprintf (buffer2, "Warning: %s", buffer); ! 273: yyerror_aux (buffer2); ! 274: } ! 275: ! 276: #else ! 277: ! 278: /* VARARGS1 */ ! 279: warning (fmt) ! 280: char *fmt; ! 281: { ! 282: warning (fmt); ! 283: } ! 284: #endif ! 285: ! 286: static yyerror_aux (s) ! 287: register char *s; ! 288: { ! 289: if (linepos) ! 290: fprintf (stderr, "\n"), linepos = 0; ! 291: ! 292: if (eval) ! 293: fprintf (stderr, "%s %s: ", yymode, eval); ! 294: else ! 295: fprintf (stderr, "line %d: ", yylineno); ! 296: fprintf (stderr, "%s\n", s); ! 297: if (!eval) ! 298: fprintf (stderr, "last token read was \"%s\"\n", yytext); ! 299: } ! 300: ! 301: /* */ ! 302: ! 303: #ifndef lint ! 304: myyerror (va_alist) ! 305: va_dcl ! 306: { ! 307: char buffer[BUFSIZ]; ! 308: va_list ap; ! 309: ! 310: va_start (ap); ! 311: ! 312: _asprintf (buffer, NULLCP, ap); ! 313: ! 314: va_end (ap); ! 315: ! 316: yyerror (buffer); ! 317: } ! 318: #else ! 319: /* VARARGS */ ! 320: ! 321: myyerror (fmt) ! 322: char *fmt; ! 323: { ! 324: myyerror (fmt); ! 325: } ! 326: #endif ! 327: ! 328: /* */ ! 329: ! 330: yywrap () { ! 331: if (linepos) ! 332: fprintf (stderr, "\n"), linepos = 0; ! 333: ! 334: return 1; ! 335: } ! 336: ! 337: /* */ ! 338: ! 339: /* ARGSUSED */ ! 340: ! 341: yyprint (s, f, top) ! 342: char *s; ! 343: int f, ! 344: top; ! 345: { ! 346: } ! 347: ! 348: static yyprint_aux (s, mode) ! 349: char *s, ! 350: *mode; ! 351: { ! 352: int len; ! 353: static int nameoutput = 0; ! 354: static int outputlinelen = 79; ! 355: ! 356: if (sflag) ! 357: return; ! 358: ! 359: if (strcmp (yymode, mode)) { ! 360: if (linepos) ! 361: fprintf (stderr, "\n\n"); ! 362: ! 363: fprintf (stderr, "%s", mymodule); ! 364: nameoutput = (linepos = strlen (mymodule)) + 1; ! 365: ! 366: fprintf (stderr, " %ss", yymode = mode); ! 367: linepos += strlen (yymode) + 1; ! 368: fprintf (stderr, ":"); ! 369: linepos += 2; ! 370: } ! 371: ! 372: len = strlen (s); ! 373: if (linepos != nameoutput) ! 374: if (len + linepos + 1 > outputlinelen) ! 375: fprintf (stderr, "\n%*s", linepos = nameoutput, ""); ! 376: else ! 377: fprintf (stderr, " "), linepos++; ! 378: fprintf (stderr, "%s", s); ! 379: linepos += len; ! 380: } ! 381: ! 382: /* PASS1 */ ! 383: ! 384: pass1 () ! 385: { ! 386: printf ("-- object definitions compiled from %s", mymodule); ! 387: if (mymoduleid) ! 388: printf (" %s", oidprint(mymoduleid)); ! 389: printf ("\n\n"); ! 390: } ! 391: ! 392: /* */ ! 393: ! 394: pass1_oid (mod, id, value) ! 395: char *mod, ! 396: *id; ! 397: YV value; ! 398: { ! 399: register SY sy; ! 400: register OI yi; ! 401: ! 402: if ((yi = (OI) calloc (1, sizeof *yi)) == NULLOI) ! 403: yyerror ("out of memory"); ! 404: ! 405: yi -> yi_name = id; ! 406: yi -> yi_value = value; ! 407: ! 408: if (mosydebug) { ! 409: if (linepos) ! 410: fprintf (stderr, "\n"), linepos = 0; ! 411: ! 412: fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id); ! 413: print_yi (yi, 0); ! 414: fprintf (stderr, "--------\n"); ! 415: } ! 416: else ! 417: yyprint_aux (id, "identifier"); ! 418: ! 419: sy = new_symbol (NULLCP, NULLCP, NULLCP, mod, id); ! 420: sy -> sy_yi = yi; ! 421: myidentifiers = add_symbol (myidentifiers, sy); ! 422: } ! 423: ! 424: /* */ ! 425: ! 426: pass1_obj (mod, id, syntax, value, aname, sname) ! 427: char *mod, ! 428: *id, ! 429: *aname, ! 430: *sname; ! 431: YP syntax; ! 432: YV value; ! 433: { ! 434: register SY sy; ! 435: register OT yo; ! 436: ! 437: if ((yo = (OT) calloc (1, sizeof *yo)) == NULLOT) ! 438: yyerror ("out of memory"); ! 439: ! 440: yo -> yo_name = id; ! 441: yo -> yo_syntax = syntax; ! 442: yo -> yo_value = value; ! 443: yo -> yo_access = aname; ! 444: yo -> yo_status = sname; ! 445: ! 446: if (mosydebug) { ! 447: if (linepos) ! 448: fprintf (stderr, "\n"), linepos = 0; ! 449: ! 450: fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id); ! 451: print_yo (yo, 0); ! 452: fprintf (stderr, "--------\n"); ! 453: } ! 454: else ! 455: yyprint_aux (id, "object"); ! 456: ! 457: sy = new_symbol (NULLCP, NULLCP, NULLCP, mod, id); ! 458: sy -> sy_yo = yo; ! 459: myobjects = add_symbol (myobjects, sy); ! 460: } ! 461: ! 462: /* */ ! 463: ! 464: pass1_type (encpref, decpref, prfpref, mod, id, yp) ! 465: register char *encpref, ! 466: *decpref, ! 467: *prfpref, ! 468: *mod, ! 469: *id; ! 470: register YP yp; ! 471: { ! 472: register SY sy; ! 473: ! 474: if (dflag && lookup_type (mod, id)) /* no duplicate entries, please... */ ! 475: return; ! 476: ! 477: if (mosydebug) { ! 478: if (linepos) ! 479: fprintf (stderr, "\n"), linepos = 0; ! 480: ! 481: fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id); ! 482: print_type (yp, 0); ! 483: fprintf (stderr, "--------\n"); ! 484: } ! 485: else ! 486: if (!(yp -> yp_flags & YP_IMPORTED)) ! 487: yyprint_aux (id, "type"); ! 488: ! 489: sy = new_symbol (encpref, decpref, prfpref, mod, id); ! 490: sy -> sy_yp = yp; ! 491: mytypes = add_symbol (mytypes, sy); ! 492: } ! 493: ! 494: /* PASS2 */ ! 495: ! 496: pass2 () { ! 497: register SY sy; ! 498: register YP yp; ! 499: ! 500: if (!sflag) ! 501: (void) fflush (stderr); ! 502: ! 503: yymode = "identifiers"; ! 504: for (sy = myidentifiers; sy; sy = sy -> sy_next) { ! 505: if (sy -> sy_module == NULLCP) ! 506: yyerror ("no module name associated with symbol"); ! 507: ! 508: do_id (sy -> sy_yi, eval = sy -> sy_name); ! 509: } ! 510: if (myidentifiers) ! 511: printf ("\n"); ! 512: ! 513: yymode = "objects"; ! 514: for (sy = myobjects; sy; sy = sy -> sy_next) { ! 515: if (sy -> sy_module == NULLCP) ! 516: yyerror ("no module name associated with symbol"); ! 517: ! 518: do_obj1 (sy -> sy_yo, eval = sy -> sy_name); ! 519: } ! 520: if (myobjects) ! 521: printf ("\n\n"); ! 522: ! 523: (void) fflush (stdout); ! 524: ! 525: if (ferror (stdout)) ! 526: myyerror ("write error - %s", sys_errname (errno)); ! 527: } ! 528: ! 529: /* */ ! 530: ! 531: /* ARGSUSED */ ! 532: ! 533: static do_id (yi, id) ! 534: register OI yi; ! 535: char *id; ! 536: { ! 537: printf ("%-20s %s\n", yi -> yi_name, id2str (yi -> yi_value)); ! 538: } ! 539: ! 540: /* */ ! 541: ! 542: /* ARGSUSED */ ! 543: ! 544: static do_obj1 (yo, id) ! 545: register OT yo; ! 546: char *id; ! 547: { ! 548: register YP yp, ! 549: yz; ! 550: ! 551: printf ("%-20s %-16s ", yo -> yo_name, id2str (yo -> yo_value)); ! 552: ! 553: if ((yp = yo -> yo_syntax) == NULLYP) ! 554: yyerror ("no syntax associated with object type"); ! 555: switch (yp -> yp_code) { ! 556: case YP_INT: ! 557: case YP_INTLIST: ! 558: id = "INTEGER"; ! 559: break; ! 560: ! 561: case YP_OCT: ! 562: id = "OctetString"; ! 563: break; ! 564: ! 565: case YP_OID: ! 566: id = "ObjectID"; ! 567: break; ! 568: ! 569: case YP_NULL: ! 570: id = "NULL"; ! 571: break; ! 572: ! 573: default: ! 574: #ifdef notdef ! 575: yp = new_type (YP_IDEFINED); ! 576: yp -> yp_identifier = new_string (yo -> yo_name); ! 577: yp -> yp_identifier[0] = toupper (yp -> yp_identifier[0]); ! 578: if (lookup_type (mymodule, yp -> yp_identifier)) ! 579: yyerror ("unable to create inline type for object's syntax"); ! 580: pass1_type (yyencpref, yydecpref, yyprfpref, mymodule, ! 581: new_string (yp -> yp_identifier), ! 582: yo -> yo_syntax = yp); ! 583: #endif ! 584: id = "Aggregate"; ! 585: break; ! 586: ! 587: case YP_IDEFINED: ! 588: yz = lookup_type (yp -> yp_module, yp -> yp_identifier); ! 589: again: ; ! 590: switch (yz ? yz -> yp_code : YP_UNDF) { ! 591: case YP_UNDF: ! 592: case YP_INT: ! 593: case YP_INTLIST: ! 594: case YP_OCT: ! 595: case YP_OID: ! 596: case YP_NULL: ! 597: id = yp -> yp_identifier; ! 598: break; ! 599: ! 600: case YP_IDEFINED: ! 601: yz = lookup_type (yz -> yp_module, yz -> yp_identifier); ! 602: goto again; ! 603: ! 604: default: ! 605: id = "Aggregate"; ! 606: break; ! 607: } ! 608: break; ! 609: } ! 610: ! 611: printf ("%-15s %-15s %s\n", id, yo -> yo_access, yo -> yo_status); ! 612: } ! 613: ! 614: /* IDENTIFIER HANDLING */ ! 615: ! 616: static char *id2str (yv) ! 617: register YV yv; ! 618: { ! 619: register char *cp, ! 620: *dp; ! 621: static char buffer[BUFSIZ]; ! 622: ! 623: if (yv -> yv_code != YV_OIDLIST) ! 624: yyerror ("need an object identifer"); ! 625: ! 626: cp = buffer; ! 627: for (yv = yv -> yv_idlist, dp = ""; yv; yv = yv -> yv_next, dp = ".") { ! 628: (void) sprintf (cp, "%s%s", dp, val2str (yv)); ! 629: cp += strlen (cp); ! 630: } ! 631: *cp = NULL; ! 632: ! 633: return buffer; ! 634: } ! 635: ! 636: /* TYPE HANDLING */ ! 637: ! 638: static YP lookup_type (mod, id) ! 639: register char *mod, ! 640: *id; ! 641: { ! 642: register SY sy; ! 643: ! 644: for (sy = mytypes; sy; sy = sy -> sy_next) { ! 645: if (mod) { ! 646: if (strcmp (sy -> sy_module, mod)) ! 647: continue; ! 648: } ! 649: else ! 650: if (strcmp (sy -> sy_module, mymodule) ! 651: && strcmp (sy -> sy_module, "UNIV")) ! 652: continue; ! 653: ! 654: if (strcmp (sy -> sy_name, id) == 0) ! 655: return sy -> sy_yp; ! 656: } ! 657: ! 658: return NULLYP; ! 659: } ! 660: ! 661: /* VALUE HANDLING */ ! 662: ! 663: static char *val2str (yv) ! 664: register YV yv; ! 665: { ! 666: static char buffer[BUFSIZ]; ! 667: ! 668: switch (yv -> yv_code) { ! 669: case YV_BOOL: ! 670: yyerror ("need a sub-identifier, not a boolean"); ! 671: ! 672: case YV_NUMBER: ! 673: (void) sprintf (buffer, "%d", yv -> yv_number); ! 674: return buffer; ! 675: ! 676: case YV_STRING: ! 677: yyerror ("need a sub-identifier, not a string"); ! 678: ! 679: case YV_IDEFINED: ! 680: return yv -> yv_identifier; ! 681: ! 682: case YV_IDLIST: ! 683: yyerror ("haven't written symbol table for values yet"); ! 684: ! 685: case YV_VALIST: ! 686: yyerror ("need a sub-identifier, not a list of values"); ! 687: ! 688: case YV_OIDLIST: ! 689: yyerror ("need a sub-identifier, not an object identifier"); ! 690: ! 691: case YV_NULL: ! 692: yyerror ("need a sub-identifier, not NULL"); ! 693: ! 694: default: ! 695: myyerror ("unknown value: %d", yv -> yv_code); ! 696: } ! 697: /* NOTREACHED */ ! 698: } ! 699: ! 700: /* */ ! 701: ! 702: static int val2int (yv) ! 703: register YV yv; ! 704: { ! 705: switch (yv -> yv_code) { ! 706: case YV_BOOL: ! 707: case YV_NUMBER: ! 708: return yv -> yv_number; ! 709: ! 710: case YV_STRING: ! 711: yyerror ("need an integer, not a string"); ! 712: ! 713: case YV_IDEFINED: ! 714: case YV_IDLIST: ! 715: yyerror ("haven't written symbol table for values yet"); ! 716: ! 717: case YV_VALIST: ! 718: yyerror ("need an integer, not a list of values"); ! 719: ! 720: case YV_OIDLIST: ! 721: yyerror ("need an integer, not an object identifier"); ! 722: ! 723: case YV_NULL: ! 724: yyerror ("need an integer, not NULL"); ! 725: ! 726: default: ! 727: myyerror ("unknown value: %d", yv -> yv_code); ! 728: } ! 729: /* NOTREACHED */ ! 730: } ! 731: ! 732: /* */ ! 733: ! 734: static val2prf (yv, level) ! 735: register YV yv; ! 736: int level; ! 737: { ! 738: register YV y; ! 739: ! 740: if (yv -> yv_flags & YV_ID) ! 741: printf ("%s ", yv -> yv_id); ! 742: ! 743: #ifdef notdef ! 744: if (yv -> yv_flags & YV_TYPE) /* will this REALLY work??? */ ! 745: do_type (yv -> yv_type, level, NULLCP); ! 746: #endif ! 747: ! 748: switch (yv -> yv_code) { ! 749: case YV_BOOL: ! 750: printf (yv -> yv_number ? "TRUE" : "FALSE"); ! 751: break; ! 752: ! 753: case YV_NUMBER: ! 754: if (yv -> yv_named) ! 755: printf ("%s", yv -> yv_named); ! 756: else ! 757: printf ("%d", yv -> yv_number); ! 758: break; ! 759: ! 760: case YV_STRING: ! 761: printf ("\"%s\"", yv -> yv_string); ! 762: break; ! 763: ! 764: case YV_IDEFINED: ! 765: if (yv -> yv_module) ! 766: printf ("%s.", yv -> yv_module); ! 767: printf ("%s", yv -> yv_identifier); ! 768: break; ! 769: ! 770: case YV_IDLIST: ! 771: case YV_VALIST: ! 772: printf ("{"); ! 773: for (y = yv -> yv_idlist; y; y = y -> yv_next) { ! 774: printf (" "); ! 775: val2prf (y, level + 1); ! 776: printf (y -> yv_next ? ", " : " "); ! 777: } ! 778: printf ("}"); ! 779: break; ! 780: ! 781: case YV_OIDLIST: ! 782: printf ("{"); ! 783: for (y = yv -> yv_idlist; y; y = y -> yv_next) { ! 784: printf (" "); ! 785: val2prf (y, level + 1); ! 786: printf (" "); ! 787: } ! 788: printf ("}"); ! 789: break; ! 790: ! 791: case YV_NULL: ! 792: printf ("NULL"); ! 793: break; ! 794: ! 795: default: ! 796: myyerror ("unknown value: %d", yv -> yv_code); ! 797: /* NOTREACHED */ ! 798: } ! 799: } ! 800: ! 801: /* ACTION HANDLING */ ! 802: ! 803: static act2prf (cp, level, e1, e2) ! 804: char *cp, ! 805: *e1, ! 806: *e2; ! 807: int level; ! 808: { ! 809: register int i, ! 810: j, ! 811: l4; ! 812: register char *dp, ! 813: *ep, ! 814: *fp; ! 815: char *gp; ! 816: ! 817: if (e1) ! 818: printf (e1, level * 4, ""); ! 819: ! 820: if (!(ep = index (dp = cp, '\n'))) { ! 821: printf ("%s", dp); ! 822: goto out; ! 823: } ! 824: ! 825: for (;;) { ! 826: i = expand (dp, ep, &gp); ! 827: if (gp) { ! 828: if (i == 0) ! 829: printf ("%*.*s\n", ep - dp, ep - dp, dp); ! 830: else ! 831: break; ! 832: } ! 833: ! 834: if (!(ep = index (dp = ep + 1, '\n'))) { ! 835: printf ("%s", dp); ! 836: return; ! 837: } ! 838: } ! 839: ! 840: ! 841: printf ("\n"); ! 842: l4 = (level + 1) * 4; ! 843: for (; *dp; dp = fp) { ! 844: if (ep = index (dp, '\n')) ! 845: fp = ep + 1; ! 846: else ! 847: fp = ep = dp + strlen (dp); ! 848: ! 849: j = expand (dp, ep, &gp); ! 850: if (gp == NULL) { ! 851: if (*fp) ! 852: printf ("\n"); ! 853: continue; ! 854: } ! 855: ! 856: if (j < i) ! 857: j = i; ! 858: if (j) ! 859: printf ("%*s", l4 + j - i, ""); ! 860: printf ("%*.*s\n", ep - gp, ep - gp, gp); ! 861: } ! 862: ! 863: printf ("%*s", level * 4, ""); ! 864: out: ; ! 865: if (e2) ! 866: printf (e2, level * 4, ""); ! 867: } ! 868: ! 869: ! 870: static expand (dp, ep, gp) ! 871: register char *dp, ! 872: *ep; ! 873: char **gp; ! 874: { ! 875: register int i; ! 876: ! 877: *gp = NULL; ! 878: for (i = 0; dp < ep; dp++) { ! 879: switch (*dp) { ! 880: case ' ': ! 881: i++; ! 882: continue; ! 883: ! 884: case '\t': ! 885: i += 8 - (i % 8); ! 886: continue; ! 887: ! 888: default: ! 889: *gp = dp; ! 890: break; ! 891: } ! 892: break; ! 893: } ! 894: ! 895: return i; ! 896: } ! 897: ! 898: /* DEBUG */ ! 899: ! 900: static print_yo (yo, level) ! 901: register OT yo; ! 902: register int level; ! 903: { ! 904: if (yo == NULLOT) ! 905: return; ! 906: ! 907: fprintf (stderr, "%*sname=%s\n", level * 4, "", yo -> yo_name); ! 908: ! 909: if (yo -> yo_syntax) { ! 910: fprintf (stderr, "%*ssyntax\n", level * 4, ""); ! 911: print_type (yo -> yo_syntax, level + 1); ! 912: } ! 913: if (yo -> yo_value) { ! 914: fprintf (stderr, "%*svalue\n", level * 4, ""); ! 915: print_value (yo -> yo_value, level + 1); ! 916: } ! 917: } ! 918: ! 919: /* */ ! 920: ! 921: static print_yi (yi, level) ! 922: register OI yi; ! 923: register int level; ! 924: { ! 925: if (yi == NULLOI) ! 926: return; ! 927: ! 928: fprintf (stderr, "%*sname=%s\n", level * 4, "", yi -> yi_name); ! 929: ! 930: if (yi -> yi_value) { ! 931: fprintf (stderr, "%*svalue\n", level * 4, ""); ! 932: print_value (yi -> yi_value, level + 1); ! 933: } ! 934: } ! 935: ! 936: /* */ ! 937: ! 938: static print_type (yp, level) ! 939: register YP yp; ! 940: register int level; ! 941: { ! 942: register YP y; ! 943: register YV yv; ! 944: ! 945: if (yp == NULLYP) ! 946: return; ! 947: ! 948: fprintf (stderr, "%*scode=0x%x flags=%s\n", level * 4, "", ! 949: yp -> yp_code, sprintb (yp -> yp_flags, YPBITS)); ! 950: fprintf (stderr, ! 951: "%*sintexp=\"%s\" strexp=\"%s\" prfexp=%c declexp=\"%s\" varexp=\"%s\"\n", ! 952: level * 4, "", yp -> yp_intexp, yp -> yp_strexp, yp -> yp_prfexp, ! 953: yp -> yp_declexp, yp -> yp_varexp); ! 954: fprintf(stderr, ! 955: "%*sstructname=\"%s\" ptrname=\"%s\"\n", level * 4, "", ! 956: yp -> yp_structname, yp -> yp_ptrname); ! 957: ! 958: if (yp -> yp_action0) ! 959: fprintf (stderr, "%*saction0 at line %d=\"%s\"\n", level * 4, "", ! 960: yp -> yp_act0_lineno, yp -> yp_action0); ! 961: if (yp -> yp_action1) ! 962: fprintf (stderr, "%*saction1 at line %d=\"%s\"\n", level * 4, "", ! 963: yp -> yp_act1_lineno, yp -> yp_action1); ! 964: if (yp -> yp_action2) ! 965: fprintf (stderr, "%*saction2 at line %d=\"%s\"\n", level * 4, "", ! 966: yp -> yp_act2_lineno, yp -> yp_action2); ! 967: if (yp -> yp_action3) ! 968: fprintf (stderr, "%*saction3 at line %d=\"%s\"\n", level * 4, "", ! 969: yp -> yp_act3_lineno, yp -> yp_action3); ! 970: ! 971: if (yp -> yp_flags & YP_TAG) { ! 972: fprintf (stderr, "%*stag class=0x%x value=0x%x\n", level * 4, "", ! 973: yp -> yp_tag -> yt_class, yp -> yp_tag -> yt_value); ! 974: print_value (yp -> yp_tag -> yt_value, level + 1); ! 975: } ! 976: ! 977: if (yp -> yp_flags & YP_DEFAULT) { ! 978: fprintf (stderr, "%*sdefault=0x%x\n", level * 4, "", yp -> yp_default); ! 979: print_value (yp -> yp_default, level + 1); ! 980: } ! 981: ! 982: if (yp -> yp_flags & YP_ID) ! 983: fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yp -> yp_id); ! 984: ! 985: if (yp -> yp_flags & YP_BOUND) ! 986: fprintf (stderr, "%*sbound=\"%s\"\n", level * 4, "", yp -> yp_bound); ! 987: ! 988: if (yp -> yp_offset) ! 989: fprintf (stderr, "%*soffset=\"%s\"\n", level * 4, "", yp -> yp_offset); ! 990: ! 991: switch (yp -> yp_code) { ! 992: case YP_INTLIST: ! 993: case YP_BITLIST: ! 994: fprintf (stderr, "%*svalue=0x%x\n", level * 4, "", yp -> yp_value); ! 995: for (yv = yp -> yp_value; yv; yv = yv -> yv_next) { ! 996: print_value (yv, level + 1); ! 997: fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 998: } ! 999: break; ! 1000: ! 1001: case YP_SEQTYPE: ! 1002: case YP_SEQLIST: ! 1003: case YP_SETTYPE: ! 1004: case YP_SETLIST: ! 1005: case YP_CHOICE: ! 1006: fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yp -> yp_type); ! 1007: for (y = yp -> yp_type; y; y = y -> yp_next) { ! 1008: print_type (y, level + 1); ! 1009: fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 1010: } ! 1011: break; ! 1012: ! 1013: case YP_IDEFINED: ! 1014: fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n", ! 1015: level * 4, "", yp -> yp_module ? yp -> yp_module : "", ! 1016: yp -> yp_identifier); ! 1017: break; ! 1018: ! 1019: default: ! 1020: break; ! 1021: } ! 1022: } ! 1023: ! 1024: /* */ ! 1025: ! 1026: static print_value (yv, level) ! 1027: register YV yv; ! 1028: register int level; ! 1029: { ! 1030: register YV y; ! 1031: ! 1032: if (yv == NULLYV) ! 1033: return; ! 1034: ! 1035: fprintf (stderr, "%*scode=0x%x flags=%s\n", level * 4, "", ! 1036: yv -> yv_code, sprintb (yv -> yv_flags, YVBITS)); ! 1037: ! 1038: if (yv -> yv_action) ! 1039: fprintf (stderr, "%*saction at line %d=\"%s\"\n", level * 4, "", ! 1040: yv -> yv_act_lineno, yv -> yv_action); ! 1041: ! 1042: if (yv -> yv_flags & YV_ID) ! 1043: fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yv -> yv_id); ! 1044: ! 1045: if (yv -> yv_flags & YV_NAMED) ! 1046: fprintf (stderr, "%*snamed=\"%s\"\n", level * 4, "", yv -> yv_named); ! 1047: ! 1048: if (yv -> yv_flags & YV_TYPE) { ! 1049: fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yv -> yv_type); ! 1050: print_type (yv -> yv_type, level + 1); ! 1051: } ! 1052: ! 1053: switch (yv -> yv_code) { ! 1054: case YV_NUMBER: ! 1055: case YV_BOOL: ! 1056: fprintf (stderr, "%*snumber=0x%x\n", level * 4, "", ! 1057: yv -> yv_number); ! 1058: break; ! 1059: ! 1060: case YV_STRING: ! 1061: fprintf (stderr, "%*sstring=0x%x\n", level * 4, "", ! 1062: yv -> yv_string); ! 1063: break; ! 1064: ! 1065: case YV_IDEFINED: ! 1066: if (yv -> yv_flags & YV_BOUND) ! 1067: fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n", ! 1068: level * 4, "", yv -> yv_module, yv -> yv_identifier); ! 1069: else ! 1070: fprintf (stderr, "%*sbound identifier=\"%s\"\n", ! 1071: level * 4, "", yv -> yv_identifier); ! 1072: break; ! 1073: ! 1074: case YV_IDLIST: ! 1075: case YV_VALIST: ! 1076: case YV_OIDLIST: ! 1077: for (y = yv -> yv_idlist; y; y = y -> yv_next) { ! 1078: print_value (y, level + 1); ! 1079: fprintf (stderr, "%*s----\n", (level + 1) * 4, ""); ! 1080: } ! 1081: break; ! 1082: ! 1083: default: ! 1084: break; ! 1085: } ! 1086: } ! 1087: ! 1088: /* SYMBOLS */ ! 1089: ! 1090: static SY new_symbol (encpref, decpref, prfpref, mod, id) ! 1091: register char *encpref, ! 1092: *decpref, ! 1093: *prfpref, ! 1094: *mod, ! 1095: *id; ! 1096: { ! 1097: register SY sy; ! 1098: ! 1099: if ((sy = (SY) calloc (1, sizeof *sy)) == NULLSY) ! 1100: yyerror ("out of memory"); ! 1101: sy -> sy_encpref = encpref; ! 1102: sy -> sy_decpref = decpref; ! 1103: sy -> sy_prfpref = prfpref; ! 1104: sy -> sy_module = mod; ! 1105: sy -> sy_name = id; ! 1106: ! 1107: return sy; ! 1108: } ! 1109: ! 1110: ! 1111: static SY add_symbol (s1, s2) ! 1112: register SY s1, ! 1113: s2; ! 1114: { ! 1115: register SY sy; ! 1116: ! 1117: if (s1 == NULLSY) ! 1118: return s2; ! 1119: ! 1120: for (sy = s1; sy -> sy_next; sy = sy -> sy_next) ! 1121: continue; ! 1122: sy -> sy_next = s2; ! 1123: ! 1124: return s1; ! 1125: } ! 1126: ! 1127: /* TYPES */ ! 1128: ! 1129: YP new_type (code) ! 1130: int code; ! 1131: { ! 1132: register YP yp; ! 1133: ! 1134: if ((yp = (YP) calloc (1, sizeof *yp)) == NULLYP) ! 1135: yyerror ("out of memory"); ! 1136: yp -> yp_code = code; ! 1137: ! 1138: return yp; ! 1139: } ! 1140: ! 1141: ! 1142: YP add_type (y1, y2) ! 1143: register YP y1, ! 1144: y2; ! 1145: { ! 1146: register YP yp; ! 1147: ! 1148: for (yp = y1; yp -> yp_next; yp = yp -> yp_next) ! 1149: continue; ! 1150: yp -> yp_next = y2; ! 1151: ! 1152: return y1; ! 1153: } ! 1154: ! 1155: /* VALUES */ ! 1156: ! 1157: YV new_value (code) ! 1158: int code; ! 1159: { ! 1160: register YV yv; ! 1161: ! 1162: if ((yv = (YV) calloc (1, sizeof *yv)) == NULLYV) ! 1163: yyerror ("out of memory"); ! 1164: yv -> yv_code = code; ! 1165: ! 1166: return yv; ! 1167: } ! 1168: ! 1169: ! 1170: YV add_value (y1, y2) ! 1171: register YV y1, ! 1172: y2; ! 1173: { ! 1174: register YV yv; ! 1175: ! 1176: for (yv = y1; yv -> yv_next; yv = yv -> yv_next) ! 1177: continue; ! 1178: yv -> yv_next = y2; ! 1179: ! 1180: return y1; ! 1181: } ! 1182: ! 1183: /* TAGS */ ! 1184: ! 1185: YT new_tag (class) ! 1186: PElementClass class; ! 1187: { ! 1188: register YT yt; ! 1189: ! 1190: if ((yt = (YT) calloc (1, sizeof *yt)) == NULLYT) ! 1191: yyerror ("out of memory"); ! 1192: yt -> yt_class = class; ! 1193: ! 1194: return yt; ! 1195: } ! 1196: ! 1197: /* STRINGS */ ! 1198: ! 1199: char *new_string (s) ! 1200: register char *s; ! 1201: { ! 1202: register char *p; ! 1203: ! 1204: if ((p = malloc ((unsigned) (strlen (s) + 1))) == NULLCP) ! 1205: yyerror ("out of memory"); ! 1206: ! 1207: (void) strcpy (p, s); ! 1208: return p; ! 1209: } ! 1210: ! 1211: /* SYMBOLS */ ! 1212: ! 1213: static struct triple { ! 1214: char *t_name; ! 1215: PElementClass t_class; ! 1216: PElementID t_id; ! 1217: } triples[] = { ! 1218: "IA5String", PE_CLASS_UNIV, PE_DEFN_IA5S, ! 1219: "ISO646String", PE_CLASS_UNIV, PE_DEFN_IA5S, ! 1220: "NumericString", PE_CLASS_UNIV, PE_DEFN_NUMS, ! 1221: "PrintableString", PE_CLASS_UNIV, PE_DEFN_PRTS, ! 1222: "T61String", PE_CLASS_UNIV, PE_DEFN_T61S, ! 1223: "TeletexString", PE_CLASS_UNIV, PE_DEFN_T61S, ! 1224: "VideotexString", PE_CLASS_UNIV, PE_DEFN_VTXS, ! 1225: "GeneralizedTime", PE_CLASS_UNIV, PE_DEFN_GENT, ! 1226: "GeneralisedTime", PE_CLASS_UNIV, PE_DEFN_GENT, ! 1227: "UTCTime", PE_CLASS_UNIV, PE_DEFN_UTCT, ! 1228: "UniversalTime", PE_CLASS_UNIV, PE_DEFN_UTCT, ! 1229: "GraphicString", PE_CLASS_UNIV, PE_DEFN_GFXS, ! 1230: "VisibleString", PE_CLASS_UNIV, PE_DEFN_VISS, ! 1231: "GeneralString", PE_CLASS_UNIV, PE_DEFN_GENS, ! 1232: "EXTERNAL", PE_CLASS_UNIV, PE_CONS_EXTN, ! 1233: "ObjectDescriptor", PE_CLASS_UNIV, PE_PRIM_ODE, ! 1234: ! 1235: NULL ! 1236: }; ! 1237: ! 1238: /* */ ! 1239: ! 1240: static char *modsym (module, id, prefix) ! 1241: register char *module, ! 1242: *id; ! 1243: char *prefix; ! 1244: { ! 1245: char buf1[BUFSIZ], ! 1246: buf2[BUFSIZ], ! 1247: buf3[BUFSIZ]; ! 1248: register struct triple *t; ! 1249: static char buffer[BUFSIZ]; ! 1250: ! 1251: if (module == NULLCP) ! 1252: for (t = triples; t -> t_name; t++) ! 1253: if (strcmp (t -> t_name, id) == 0) { ! 1254: module = "UNIV"; ! 1255: break; ! 1256: } ! 1257: ! 1258: if (prefix) ! 1259: modsym_aux (prefix, buf1); ! 1260: modsym_aux (module ? module : mymodule, buf2); ! 1261: modsym_aux (id, buf3); ! 1262: if (prefix) ! 1263: (void) sprintf (buffer, "%s_%s_%s", buf1, buf2, buf3); ! 1264: else ! 1265: (void) sprintf (buffer, "%s_%s", buf2, buf3); ! 1266: ! 1267: return buffer; ! 1268: } ! 1269: ! 1270: ! 1271: static modsym_aux (name, bp) ! 1272: register char *name, ! 1273: *bp; ! 1274: { ! 1275: register char c; ! 1276: ! 1277: while (c = *name++) ! 1278: switch (c) { ! 1279: case '-': ! 1280: *bp++ = '_'; ! 1281: *bp++ = '_'; ! 1282: break; ! 1283: ! 1284: default: ! 1285: *bp++ = c; ! 1286: break; ! 1287: } ! 1288: ! 1289: *bp = NULL; ! 1290: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.