![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ptabs.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 ptabs.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 ! root 1: /* ptabs.c */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header: /f/osi/pepsy/RCS/ptabs.c,v 7.2 90/07/27 08:49:29 mrose Exp $"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header: /f/osi/pepsy/RCS/ptabs.c,v 7.2 90/07/27 08:49:29 mrose Exp $ ! 9: * ! 10: * ! 11: * $Log: ptabs.c,v $ ! 12: * Revision 7.2 90/07/27 08:49:29 mrose ! 13: * update ! 14: * ! 15: * Revision 7.1 90/07/09 14:53:16 mrose ! 16: * sync ! 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 <stdio.h> ! 32: #include "pepsydefs.h" ! 33: #include "pass2.h" ! 34: #include "mine.h" ! 35: ! 36: extern FILE *fptab; ! 37: extern char *c_tag(), *c_class(); ! 38: extern char *ec_tag(), *ec_class(), *pec_class(); ! 39: extern char *strip_last(); ! 40: extern char *str_yp_code[]; ! 41: extern char *get_val(), *get_comp(), *strp2name(); ! 42: extern s_table *lookup_list(), *get_offset(); ! 43: extern YP tprnt_loop(); ! 44: ! 45: extern char *concat(); ! 46: extern char *my_strcat(); ! 47: ! 48: /* ! 49: extern int explicit; ! 50: */ ! 51: ! 52: static int cons_type = 0; ! 53: ! 54: s_table *ptr; ! 55: s_table *save_ptr; ! 56: ! 57: #define WORDSIZE 20 ! 58: ! 59: /* ! 60: * Marshall's three extra conditions for changing the printing output ! 61: */ ! 62: static int mrose1; /* if NamedType */ ! 63: static int mrose2; /* !mrose1 && -h && DefinedType */ ! 64: static int mrose3; /* (mrose1 || !mrose2) && TAG && (OPTIONAL|DEFAULT) */ ! 65: ! 66: /* ! 67: * table printe a type. generate tables for the printing of a type ! 68: */ ! 69: tprnt_typ(yp, id, type) ! 70: YP yp; ! 71: char *id; ! 72: char *type; ! 73: { ! 74: char *t, *f; ! 75: char *p1; ! 76: char *s1, *s2, *s3; ! 77: char *s; ! 78: s_table *ptr1, *ptr2; ! 79: YP y; ! 80: ! 81: if (yp->yp_code < 0 || yp->yp_code > YP_REAL) ! 82: ferrd(1, "tdec_typ: unimplemented type %d\n", yp->yp_code); ! 83: ! 84: if (yp == NULL) { ! 85: ferr(0, "tprnt_typ:NULL arguement\n"); ! 86: return; ! 87: } ! 88: ! 89: if (yp->yp_flags & YP_ID) ! 90: mrose1 = 1; ! 91: else ! 92: mrose1 = 0; ! 93: ! 94: if (!mrose1 && hflag && yp->yp_code == YP_IDEFINED) ! 95: mrose2 = 1; ! 96: else ! 97: mrose2 = 0; ! 98: ! 99: if ((mrose1 || !mrose2) && yp->yp_flags & YP_TAG ! 100: && yp->yp_flags & (YP_OPTIONAL|YP_DEFAULT)) ! 101: mrose3 = 1; ! 102: else ! 103: mrose3 = 0; ! 104: ! 105: if (yp->yp_flags & YP_TAG && !(yp->yp_flags & YP_IMPLICIT)) { ! 106: prte_enoff("ETAG", yp); ! 107: } ! 108: if (type) ! 109: t = type; ! 110: else ! 111: t = my_strcat("struct ", modsym(mymodule, id, "type")); ! 112: f = yp->yp_varexp; ! 113: switch (yp->yp_code) { ! 114: ! 115: case YP_UNDF: ! 116: ferr(1, "tprnt_typ:Undefined type\n"); ! 117: ! 118: case YP_BOOL: ! 119: p1 = "BOOLEAN"; ! 120: if (yp->yp_varexp) { ! 121: } else ! 122: t = NULL; ! 123: break; ! 124: ! 125: /* This needs to be fixed up in the action generating area */ ! 126: case YP_INTLIST: ! 127: ! 128: case YP_INT: ! 129: ! 130: case YP_ENUMLIST: ! 131: p1 = "INTEGER"; ! 132: if (yp->yp_varexp) { ! 133: } else ! 134: t = NULL; ! 135: break; ! 136: ! 137: case YP_REAL: ! 138: p1 = "REALTYPE"; ! 139: if (yp->yp_varexp) { ! 140: } else ! 141: t = NULL; ! 142: break; ! 143: ! 144: ! 145: case YP_BIT: ! 146: case YP_BITLIST: ! 147: if (yp->yp_varexp) { ! 148: p1 = "BITSTRING"; ! 149: break; ! 150: } ! 151: t = NULL; ! 152: p1 = NULL; ! 153: (void) fprintf(fptab, "\t{ SBITSTRING, 0, %s, %s, NULL },\n", ! 154: c_tag(yp), c_class(yp)); ! 155: break; ! 156: ! 157: case YP_OCT: ! 158: if (yp->yp_varexp) { ! 159: p1 = "OCTETSTRING"; ! 160: break; ! 161: } ! 162: t = NULL; ! 163: p1 = NULL; ! 164: prte_noff("SOCTETSTRING", yp); ! 165: break; ! 166: ! 167: case YP_OID: ! 168: if (yp->yp_varexp) { ! 169: p1 = "OBJID"; ! 170: break; ! 171: } ! 172: t = NULL; ! 173: p1 = NULL; ! 174: prte_noff("SOBJID", yp); ! 175: break; ! 176: ! 177: case YP_SEQ: ! 178: case YP_SET: ! 179: case YP_ANY: ! 180: /* ! 181: * if (cons_type) p1 = "CONS_ANY"; else ! 182: */ ! 183: if (yp->yp_varexp) { ! 184: p1 = "ANY"; ! 185: break; ! 186: } ! 187: t = NULL; ! 188: p1 = NULL; ! 189: prte_noff("SANY", yp); ! 190: break; ! 191: ! 192: case YP_NULL: ! 193: p1 = "T_NULL"; ! 194: t = NULL; ! 195: break; ! 196: ! 197: case YP_IDEFINED: ! 198: p1 = NULL; ! 199: pr_deftyp(yp, t, f); ! 200: if (yp->yp_flags & YP_DEFAULT) ! 201: gdflt(yp, G_DEC); ! 202: break; ! 203: ! 204: case YP_SEQLIST: ! 205: p1 = NULL; ! 206: /* support for -h flag */ ! 207: cons_type++; ! 208: save_ptr = ptr; ! 209: if (yp->yp_varexp == NULL && type != NULL) ! 210: ferr(1, "tprnt_typ:YP_SEQLIST:NULL varexp pointer\n"); ! 211: if (type != NULL) ! 212: prte_off("SEQ_START", yp, t, f); ! 213: else ! 214: prte_noff("SEQ_START", yp); ! 215: ! 216: if (yp->yp_flags & YP_DEFAULT) ! 217: gdflt(yp, G_DEC); ! 218: if (y = yp->yp_type) { ! 219: if (type) { ! 220: if (yp->yp_declexp == NULL) ! 221: ferr(1, "tprnt_typ:YP_SEQLIST:no declexp\n"); ! 222: yp->yp_structname = my_strcat("struct ", yp->yp_declexp); ! 223: } else ! 224: yp->yp_structname = t; ! 225: if (optfield(y)) { ! 226: (void) fprintf(fptab, ! 227: "\t{ OPTL, OFFSET(%s, optionals), 0, 0, NULL },\n", ! 228: yp->yp_structname); ! 229: } ! 230: tprnt_loop(y, id, yp->yp_structname); ! 231: } ! 232: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL },\n"); ! 233: ptr = save_ptr; ! 234: cons_type--; ! 235: break; ! 236: ! 237: case YP_SETLIST: ! 238: p1 = NULL; ! 239: /* support for -h flag */ ! 240: cons_type++; ! 241: if (yp->yp_varexp == NULL && type != NULL) ! 242: ferr(1, "tprnt_typ:YP_SETLIST:NULL varexp pointer\n"); ! 243: if (type != NULL) ! 244: prte_off("SET_START", yp, t, f); ! 245: else ! 246: prte_noff("SET_START", yp); ! 247: ! 248: if (yp->yp_flags & YP_DEFAULT) ! 249: ddflt(yp); ! 250: if (y = yp->yp_type) { ! 251: if (type) { ! 252: if (yp->yp_declexp == NULL) ! 253: ferr(1, "tprnt_typ:YP_SETLIST:no declexp\n"); ! 254: yp->yp_structname = my_strcat("struct ", yp->yp_declexp); ! 255: } else ! 256: yp->yp_structname = t; ! 257: if (optfield(y)) { ! 258: (void) fprintf(fptab, ! 259: "\t{ OPTL, OFFSET(%s, optionals), 0, 0, NULL },\n", ! 260: yp->yp_structname); ! 261: } ! 262: tprnt_loop(y, id, yp->yp_structname); ! 263: } ! 264: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL },\n"); ! 265: ptr = save_ptr; ! 266: cons_type--; ! 267: break; ! 268: ! 269: case YP_SEQTYPE: /* What is the difference ?? */ ! 270: p1 = NULL; ! 271: cons_type++; ! 272: save_ptr = ptr; ! 273: if (type != NULL) ! 274: prte_off("SEQOF_START", yp, t, f); ! 275: else ! 276: prte_noff("SEQOF_START", yp); ! 277: if (yp->yp_flags & YP_DEFAULT) ! 278: gdflt(yp, G_DEC); ! 279: ! 280: if (y = yp->yp_type) { ! 281: if (type) { ! 282: if (yp->yp_declexp == NULL) ! 283: ferr(1, "tprnt_typ:YP_SEQTYPE:no declexp\n"); ! 284: yp->yp_structname = my_strcat("struct ", yp->yp_declexp); ! 285: } else ! 286: yp->yp_structname = t; ! 287: tprnt_loop(y, id, yp->yp_structname); ! 288: } ! 289: if (yp->yp_structname != NULL) ! 290: (void) fprintf(fptab, ! 291: "\t{ PE_END, OFFSET(%s, next), 0, 0, NULL },\n", ! 292: yp->yp_structname); ! 293: else ! 294: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL },\n"); ! 295: ptr = save_ptr; ! 296: cons_type--; ! 297: break; ! 298: ! 299: case YP_SETTYPE: ! 300: p1 = NULL; ! 301: cons_type++; ! 302: save_ptr = ptr; ! 303: if (type != NULL) ! 304: prte_off("SETOF_START", yp, t, f); ! 305: else ! 306: prte_noff("SETOF_START", yp); ! 307: ! 308: if (yp->yp_flags & YP_DEFAULT) ! 309: gdflt(yp, G_DEC); ! 310: ! 311: if (y = yp->yp_type) { ! 312: if (type) { ! 313: if (yp->yp_declexp == NULL) ! 314: ferr(1, "tprnt_typ:YP_SETTYPE:no declexp\n"); ! 315: yp->yp_structname = my_strcat("struct ", yp->yp_declexp); ! 316: } else ! 317: yp->yp_structname = t; ! 318: tprnt_loop(y, id, yp->yp_structname); ! 319: } ! 320: if (yp->yp_structname != NULL) ! 321: (void) fprintf(fptab, ! 322: "\t{ PE_END, OFFSET(%s, next), 0, 0, NULL },\n", ! 323: yp->yp_structname); ! 324: else ! 325: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL },\n"); ! 326: ptr = save_ptr; ! 327: cons_type--; ! 328: break; ! 329: ! 330: case YP_CHOICE: ! 331: p1 = NULL; ! 332: /* support for -h flag */ ! 333: if (hflag && (y = yp->yp_type) && !y->yp_next) { ! 334: tprnt_typ(y, id, yp->yp_structname); ! 335: break; ! 336: } ! 337: cons_type++; ! 338: save_ptr = ptr; ! 339: /* Generates an unused tags field - so beware */ ! 340: if (type != NULL) ! 341: prte_off("CHOICE_START", yp, t, f); ! 342: else ! 343: prte_noff("CHOICE_START", yp); ! 344: ! 345: if (yp->yp_flags & YP_DEFAULT) ! 346: gdflt(yp, G_DEC); ! 347: if (y = yp->yp_type) { ! 348: if ((yp->yp_flags & YP_ID) && yp->yp_id) ! 349: (void) fprintf(fptab, ! 350: "\t{ SCTRL, OFFSET(%s, offset), 0, 0, \"%s\" },\n", ! 351: yp->yp_structname, yp->yp_id); ! 352: else ! 353: (void) fprintf(fptab, ! 354: "\t{ SCTRL, OFFSET(%s, offset), 0, 0, NULL },\n", ! 355: yp->yp_structname); ! 356: if (type) { ! 357: if (yp->yp_declexp == NULL) ! 358: ferr(1, "tprnt_typ:YP_CHOICE:no declexp\n"); ! 359: yp->yp_structname = my_strcat("struct ", yp->yp_declexp); ! 360: } else ! 361: yp->yp_structname = t; ! 362: tprnt_loop(y, id, yp->yp_structname); ! 363: } ! 364: (void) fprintf(fptab, "\t{ PE_END, 0, 0, 0, NULL },\n"); ! 365: ptr = save_ptr; ! 366: cons_type--; ! 367: break; ! 368: ! 369: default: ! 370: ferrd(1, "tprnt_typ: yp_code = %d not implemented\n", yp->yp_code); ! 371: } ! 372: ! 373: if (p1 != NULL) { ! 374: if (t != NULL) ! 375: prte_off(p1, yp, t, f); ! 376: else ! 377: prte_noff(p1, yp); ! 378: ! 379: if (yp->yp_flags & YP_DEFAULT) ! 380: gdflt(yp, G_DEC); ! 381: } ! 382: ! 383: ! 384: } ! 385: ! 386: static int fflags[] = { ! 387: 0, 1, 2, 2, 3, 3, 4, 5, 16, 16, 16, 17, 17, 17, ! 388: 0, -1, 7,}; ! 389: ! 390: /* ! 391: * generate tables for printing a contructed type ! 392: */ ! 393: YP ! 394: tprnt_loop(yp, id, type) ! 395: YP yp; ! 396: char *id; ! 397: char *type; ! 398: { ! 399: for (; yp != NULL; yp = yp->yp_next) { ! 400: tprnt_typ(yp, id, type); ! 401: } ! 402: } ! 403: ! 404: ! 405: ddflt(yp) ! 406: YP yp; ! 407: { ! 408: switch (yp->yp_code) { ! 409: case YP_BOOL: ! 410: case YP_INT: ! 411: case YP_INTLIST: ! 412: (void) fprintf(fptab, "\t{DFLT_B, %d, 0, 0 },\n", ! 413: yp->yp_default->yv_number); ! 414: break; ! 415: case YP_BIT: ! 416: case YP_BITLIST: ! 417: case YP_OCT: ! 418: case YP_NULL: ! 419: case YP_SEQ: ! 420: case YP_SEQTYPE: ! 421: case YP_SEQLIST: ! 422: case YP_SET: ! 423: case YP_SETTYPE: ! 424: case YP_SETLIST: ! 425: case YP_CHOICE: ! 426: case YP_ANY: ! 427: case YP_OID: ! 428: case YP_IDEFINED: ! 429: case YP_ENUMLIST: ! 430: case YP_REAL: ! 431: (void) fprintf(fptab, "\t{DFLT_B, 0, 0, 0 },\n"); ! 432: break; ! 433: ! 434: default: ! 435: ferr(1, "ddflt:unknown type %d\n", yp->yp_code); ! 436: } ! 437: ! 438: } ! 439: ! 440: /* ! 441: * print a Non offset table entry ! 442: */ ! 443: prte_noff(type, yp) ! 444: char *type; ! 445: YP yp; ! 446: { ! 447: char *tag; ! 448: char *flags; ! 449: char *typename; ! 450: char buf1[BUFSIZ]; ! 451: ! 452: tag = c_tag(yp); ! 453: flags = c_class(yp); ! 454: if (mrose3) { /* need to append FL_PRTAG flag */ ! 455: strncpy(buf1, flags, BUFSIZ); ! 456: strncat(buf1, "|FL_PRTAG", BUFSIZ); ! 457: flags = buf1; ! 458: } ! 459: if (mrose1) ! 460: typename = yp->yp_id; ! 461: else if (mrose2) ! 462: typename = yp->yp_identifier; ! 463: else ! 464: typename = (char *)0; ! 465: if (typename) ! 466: (void) fprintf(fptab, "\t{ %s, 0, %s, %s, \"%s\" },\n", ! 467: type, tag, flags, typename); ! 468: else ! 469: (void) fprintf(fptab, "\t{ %s, 0, %s, %s, NULL},\n", ! 470: type, tag, flags); ! 471: } ! 472: ! 473: /* ! 474: * print a Non offset table entry for an ETAG - special case ! 475: */ ! 476: prte_enoff(type, yp) ! 477: char *type; ! 478: YP yp; ! 479: { ! 480: char *tag; ! 481: char *flags; ! 482: char *typename; ! 483: char buf1[BUFSIZ]; ! 484: ! 485: tag = ec_tag(yp); ! 486: flags = ec_class(yp); ! 487: if (mrose3) { /* need to append FL_PRTAG flag */ ! 488: strncpy(buf1, flags, BUFSIZ); ! 489: strncat(buf1, "|FL_PRTAG", BUFSIZ); ! 490: flags = buf1; ! 491: mrose3 = 0; /* don't want the next tag */ ! 492: } ! 493: if (mrose1) { ! 494: typename = yp->yp_id; ! 495: mrose1 = 0; ! 496: } else if (mrose2) { ! 497: typename = yp->yp_identifier; ! 498: mrose2 = 0; ! 499: } else ! 500: typename = NULL; ! 501: if (typename) ! 502: (void) fprintf(fptab, "\t{ %s, 0, %s, %s, \"%s\" },\n", ! 503: type, tag, flags, typename); ! 504: else ! 505: (void) fprintf(fptab, "\t{ %s, 0, %s, %s, NULL },\n", ! 506: type, tag, flags); ! 507: } ! 508: ! 509: /* ! 510: * print an offset table entry ! 511: */ ! 512: prte_off(type, yp, t, f) ! 513: char *type; ! 514: YP yp; ! 515: char *t, *f; ! 516: { ! 517: char *tag; ! 518: char *flags; ! 519: char *typename; ! 520: char buf1[BUFSIZ]; ! 521: ! 522: tag = c_tag(yp); ! 523: flags = c_class(yp); ! 524: if (mrose3) { /* need to append FL_PRTAG flag */ ! 525: strncpy(buf1, flags, BUFSIZ); ! 526: strncat(buf1, "|FL_PRTAG", BUFSIZ); ! 527: flags = buf1; ! 528: } ! 529: if (mrose1) ! 530: typename = yp->yp_id; ! 531: else if (mrose2) ! 532: typename = yp->yp_identifier; ! 533: else ! 534: typename = (char *)0; ! 535: if (typename) ! 536: (void) fprintf(fptab, "\t{ %s, OFFSET(%s, %s), %s, %s, \"%s\" },\n", ! 537: type, t, f, tag, flags, typename); ! 538: else ! 539: (void) fprintf(fptab, "\t{ %s, OFFSET(%s, %s), %s, %s, NULL},\n", ! 540: type, t, f, tag, flags); ! 541: } ! 542: ! 543: /* ! 544: * handle the very complex task of defined types. ! 545: * Basically generating object calls ! 546: */ ! 547: pr_deftyp(yp, t, f) ! 548: YP yp; ! 549: char *t; ! 550: char *f; ! 551: { ! 552: /* Predefined Universal Type */ ! 553: struct univ_typ *p, *univtyp(); ! 554: ! 555: if ((p = univtyp(yp->yp_identifier))) { ! 556: if (p->univ_flags & UNF_EXTMOD) { ! 557: yp->yp_module = p->univ_mod; ! 558: goto do_obj; ! 559: } ! 560: prte_univt(p, yp, t, f); ! 561: return; ! 562: } ! 563: ! 564: do_obj: ! 565: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) ! 566: prte_noff("IMP_OBJ", yp); ! 567: if (yp->yp_parm) { ! 568: ferr(1, "tenc_typ:YP_IDEFINED:yp_parm found\n"); ! 569: } ! 570: prte_obj(yp, t, f); ! 571: } ! 572: ! 573: /* ! 574: * print an offset table entry for an OBJECT type entry ! 575: */ ! 576: prte_obj(yp, t, f) ! 577: YP yp; ! 578: char *t, *f; ! 579: { ! 580: char *type; ! 581: char *obj; ! 582: char *flags; ! 583: char *typename; ! 584: char *off; ! 585: char buf1[BUFSIZ]; ! 586: char buf2[BUFSIZ]; ! 587: int extflag; ! 588: ! 589: #if 1 ! 590: if (yp->yp_module == NULL || strcmp(yp->yp_module, mymodule) == 0) { ! 591: if (f) ! 592: type = "OBJECT"; ! 593: else ! 594: type = "SOBJECT"; ! 595: obj = proc_name(yp->yp_identifier, 0); ! 596: extflag = 0; ! 597: } else { ! 598: if (f) ! 599: type = "EXTOBJ"; ! 600: else ! 601: type = "SEXTOBJ"; ! 602: obj = strp2name(yp->yp_identifier, yp->yp_module); ! 603: extflag = 1; ! 604: } ! 605: #else ! 606: if (f) ! 607: type = "OBJECT"; ! 608: else ! 609: type = "SOBJECT"; ! 610: obj = proc_name(yp->yp_identifier, 0); ! 611: #endif ! 612: flags = c_class(yp); ! 613: if (mrose3) { /* need to append FL_PRTAG flag */ ! 614: strncpy(buf1, flags, BUFSIZ); ! 615: strncat(buf1, "|FL_PRTAG", BUFSIZ); ! 616: flags = buf1; ! 617: } ! 618: if (mrose1) ! 619: typename = yp->yp_id; ! 620: else if (mrose2) ! 621: typename = yp->yp_identifier; ! 622: else ! 623: typename = (char *)0; ! 624: if (f) { ! 625: sprintf(buf2, "OFFSET(%s, %s)", t, f); ! 626: off = buf2; ! 627: } else ! 628: off = "0"; ! 629: if (typename) ! 630: (void) fprintf(fptab, "\t{ %s, %s, _Z%s, %s, \"%s\" },\n", ! 631: type, off, obj, flags, typename); ! 632: else ! 633: (void) fprintf(fptab, "\t{ %s, %s, _Z%s, %s, NULL},\n", ! 634: type, off, obj, flags); ! 635: if (extflag) ! 636: (void) fprintf(fptab, "\t{ EXTMOD, %d, 0, 0, NULL },\n", ! 637: gen_modref(yp->yp_module)); ! 638: } ! 639: ! 640: /* ! 641: * print an table entry for Universal type with the given entry ! 642: */ ! 643: prte_univt(p, yp, t, f) ! 644: struct univ_typ *p; ! 645: YP yp; ! 646: char *t, *f; ! 647: { ! 648: char *type; ! 649: int tag; ! 650: int class; ! 651: char *flags; ! 652: char *typename; ! 653: char *off; ! 654: char buf1[BUFSIZ]; ! 655: char buf2[BUFSIZ]; ! 656: char buf3[BUFSIZ]; ! 657: ! 658: if (f == NULL) { ! 659: sprintf(buf3, "S%s", p->univ_tab); ! 660: type = buf3; ! 661: } else ! 662: type = p->univ_tab; ! 663: ! 664: if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) { ! 665: tag = yp->yp_tag->yt_value->yv_number; ! 666: class = yp->yp_tag->yt_class; ! 667: } else { ! 668: tag = p->univ_id; ! 669: class = p->univ_class; ! 670: } ! 671: ! 672: strncpy(buf1, c_flags(yp, class), BUFSIZ); ! 673: #if 0 ! 674: sprintf(buf1, "%d", class); ! 675: #endif ! 676: flags = buf1; ! 677: if (mrose3) { /* need to append FL_PRTAG flag */ ! 678: strncat(buf1, "|FL_PRTAG", BUFSIZ); ! 679: } ! 680: if (mrose1) ! 681: typename = yp->yp_id; ! 682: else if (mrose2) ! 683: typename = yp->yp_identifier; ! 684: else ! 685: typename = (char *)0; ! 686: if (f) { ! 687: sprintf(buf2, "OFFSET(%s, %s)", t, f); ! 688: off = buf2; ! 689: } else ! 690: off = "0"; ! 691: if (typename) ! 692: (void) fprintf(fptab, "\t{ %s, %s, %d, %s, \"%s\" },\n", ! 693: type, off, tag, flags, typename); ! 694: else ! 695: (void) fprintf(fptab, "\t{ %s, %s, %d, %s, NULL},\n", ! 696: type, off, tag, flags); ! 697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.