![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dec.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 / rosap / test|
Return to dec.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / rosap / test |
1.1 ! root 1: /* dec.c */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header$"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header$ ! 9: * ! 10: * ! 11: * $Log$ ! 12: */ ! 13: ! 14: /* ! 15: * NOTICE ! 16: * ! 17: * Acquisition, use, and distribution of this module and related ! 18: * materials are subject to the restrictions of a license agreement. ! 19: * Consult the Preface in the User's Manual for the full terms of ! 20: * this agreement. ! 21: * ! 22: */ ! 23: ! 24: ! 25: /* ! 26: * These routines are the driving routines for parsing encoding and printing ! 27: * data ! 28: */ ! 29: #include <stdio.h> ! 30: #include "../h/psap.h" ! 31: #include "pep.h" ! 32: #include "pepdefs.h" ! 33: ! 34: #define PEPYPARM char ** ! 35: #ifndef PEPYPARM ! 36: #define PEPYPARM char ** ! 37: #endif ! 38: extern PEPYPARM NullParm; ! 39: ! 40: ! 41: ! 42: extern PE pr_seq(), pr_seqof(), pr_set(), pr_setof(), pr_type(); ! 43: extern PE en_seq(), en_seqof(), en_set(), en_setof(), en_type(); ! 44: extern PE pr_choice(), en_choice(), en_etype(), pr_etype(), pr_obj(); ! 45: extern PE setpresent(); ! 46: ! 47: extern tpe *next_tpe(); ! 48: extern int _pverbose; ! 49: ! 50: #define NEXT_TPE(p) p = next_tpe(p) ! 51: #define CHKTAG(mod, p, pe) ismatch(p, mod, pe->pe_class, pe->pe_id) ! 52: ! 53: /* Have we got an optional object which we have allocated sapce for */ ! 54: #define ALLOC_MEM(p, parm) (p->pe_type == SOBJECT \ ! 55: && p[-1].pe_type == MALLOC) ! 56: ! 57: /*SUPPRESS 36*/ /* for Saber C */ ! 58: ! 59: /* ! 60: * decode the specified type of the specified module into the given pe ! 61: */ ! 62: dec_f(typ, mod, pe, explicit, len, buf, parm) ! 63: /*ARGSUSED*/ ! 64: int typ; /* which type it is */ ! 65: modtyp *mod; /* Module it is from */ ! 66: PE pe; ! 67: int explicit; ! 68: int *len; ! 69: char **buf; ! 70: PEPYPARM parm; ! 71: { ! 72: tpe *p; ! 73: ! 74: if (typ < 0 || typ >= mod->md_nentries) ! 75: ferrd(1, "dec_f:Illegal typ %d\n", typ); ! 76: ! 77: p = mod->md_dtab[typ]; ! 78: if (p->pe_type != PE_START) ! 79: ferr(1, "dec_f: missing PE_START\n"); ! 80: p++; ! 81: if ((pe = pr_obj(explicit, pe, parm, p, mod)) == NULLPE) ! 82: return (NOTOK); ! 83: ! 84: return (OK); ! 85: } ! 86: ! 87: /* ! 88: * Parse an object. The top level of an object does not have any offset field ! 89: * which makes it different to pr_type routine which must assume that it ! 90: * has an offset. ! 91: */ ! 92: PE ! 93: pr_obj(expl, pe, parm, p, mod) ! 94: int expl; /* do we look at the tag */ ! 95: PE pe; ! 96: PEPYPARM parm; ! 97: tpe *p; ! 98: modtyp *mod; /* Module it is from */ ! 99: { ! 100: int cnt = 0; ! 101: ! 102: ! 103: if (_pverbose > 6) { ! 104: printf(dfp, "1st Decoding the type %d \n",p->pe_type); ! 105: } ! 106: while (p->pe_type != PE_END) { ! 107: ! 108: if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) { ! 109: if (DEFAULT(p)) ! 110: ferr(1, "pr_obj:Default not implemented\n"); ! 111: else if (OPTIONAL(p)) { ! 112: if (ALLOC_MEM(p, parm)) ! 113: fix_mem(parm, p); ! 114: goto next; ! 115: } else { ! 116: dmp_tpe("pr_obj:missing mandatory parameter", p, mod); ! 117: return (NULLPE); ! 118: } ! 119: } ! 120: ! 121: if (_pverbose > 6) { ! 122: printf("2nd Decoding the type %d \n",p->pe_type); ! 123: } ! 124: ! 125: switch (p->pe_type) { ! 126: case PE_END: ! 127: case PE_START: ! 128: return (NULLPE); ! 129: ! 130: case UCODE: ! 131: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 132: return (NULLPE); ! 133: break; ! 134: ! 135: case ETAG: ! 136: switch (p->pe_ucode) { ! 137: default: ! 138: p++; ! 139: if (pr_obj(1, pe->pe_cons, parm, p, mod) == NULLPE) ! 140: return (NULLPE); ! 141: } ! 142: break; ! 143: ! 144: case MALLOC: ! 145: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL) ! 146: return NULLPE; ! 147: break; ! 148: ! 149: case SEQ_START: ! 150: if ((pe = pr_seq(pe, parm, p, mod)) == NULLPE) ! 151: return (NULLPE); ! 152: break; ! 153: ! 154: case SEQOF_START: ! 155: if ((pe = pr_seqof(pe, parm, p, mod)) == NULLPE) ! 156: return (NULLPE); ! 157: break; ! 158: ! 159: case SET_START: ! 160: if ((pe = pr_set(pe, parm, p, mod)) == NULLPE) ! 161: return (NULLPE); ! 162: break; ! 163: ! 164: case SETOF_START: ! 165: if ((pe = pr_setof(pe, parm, p, mod)) == NULLPE) ! 166: return (NULLPE); ! 167: break; ! 168: ! 169: case IMP_OBJ: ! 170: p++; ! 171: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) { ! 172: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, ! 173: (char **) 0, parm); ! 174: } else { ! 175: if (p->pe_type == SOBJECT) { ! 176: if ((pe = pr_obj(0, pe, parm, ! 177: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 178: return (NULLPE); ! 179: } else ! 180: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode, ! 181: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 182: return (NULLPE); ! 183: } ! 184: break; ! 185: ! 186: case SOBJECT: ! 187: case OBJECT: ! 188: if ((pe = pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 189: return (NULLPE); ! 190: break; ! 191: ! 192: case CHOICE_START: ! 193: if ((pe = pr_choice(pe, parm, p, mod)) == NULLPE) ! 194: return (NULLPE); ! 195: break; ! 196: ! 197: case SEXTOBJ: ! 198: case EXTOBJ: ! 199: if (p[1].pe_type != EXTMOD) { ! 200: dmp_tpe("pr_type: missing EXTMOD", p, mod); ! 201: ferr(1, "pr_type:internal error\n"); ! 202: } ! 203: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 204: (char **) 0, parm); ! 205: break; ! 206: ! 207: default: ! 208: if ((pe = pr_type(expl, pe, parm, p, mod)) == NULLPE) ! 209: return (NULLPE); ! 210: break; ! 211: } ! 212: if (ISDTYPE(p) && cnt > 0) ! 213: ferr(1, "pr_obj:compound type found\n"); ! 214: if (ISDTYPE(p) && pe != NULLPE) ! 215: return (pe); ! 216: next: ! 217: NEXT_TPE(p); ! 218: } ! 219: ! 220: return (pe); ! 221: } ! 222: /* ! 223: * Parse a single type. ! 224: * If a basic type parse it, if a compound type call the appropriate ! 225: * parsing routine ! 226: */ ! 227: PE ! 228: pr_type(expl, pe, parm, p, mod) ! 229: int expl; /* do we look at the tag */ ! 230: PE pe; ! 231: PEPYPARM parm; ! 232: tpe *p; ! 233: modtyp *mod; /* Module it is from */ ! 234: { ! 235: int cnt = 0; ! 236: OID oid; ! 237: ! 238: ! 239: if (_pverbose > 6) { ! 240: printf("pr_type:type %d \n",p->pe_type); ! 241: } ! 242: while (p->pe_type != PE_END) { ! 243: /* ! 244: print_pe (pe, 1); ! 245: */ ! 246: ! 247: if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) { ! 248: if (DEFAULT(p)) { ! 249: setdval(p, p + 1, parm, mod); ! 250: goto next; ! 251: } else if (OPTIONAL(p)) { ! 252: if (ALLOC_MEM(p, parm)) ! 253: fix_mem(parm, p); ! 254: goto next; ! 255: } else { ! 256: dmp_tpe("pr_type:missing mandatory parameter", p, mod); ! 257: return (NULLPE); ! 258: } ! 259: } ! 260: ! 261: if (_pverbose > 6) { ! 262: printf("2nd prtype: type %d \n",p->pe_type); ! 263: } ! 264: ! 265: switch (p->pe_type) { ! 266: case PE_END: ! 267: case PE_START: ! 268: return (NULLPE); ! 269: ! 270: case UCODE: ! 271: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 272: return (NULLPE); ! 273: break; ! 274: ! 275: case ETAG: ! 276: switch (p->pe_ucode) { ! 277: default: ! 278: p++; ! 279: if (pr_etype(pe->pe_cons, parm, p, mod) == NULLPE) ! 280: return (NULLPE); ! 281: } ! 282: break; ! 283: ! 284: case MALLOC: ! 285: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL) ! 286: return NULLPE; ! 287: break; ! 288: ! 289: case SEQ_START: ! 290: if ((pe = pr_seq(pe, parm, p, mod)) == NULLPE) ! 291: return (NULLPE); ! 292: break; ! 293: ! 294: case SEQOF_START: ! 295: if ((pe = pr_seqof(pe, parm, p, mod)) == NULLPE) ! 296: return (NULLPE); ! 297: break; ! 298: ! 299: case SET_START: ! 300: if ((pe = pr_set(pe, parm, p, mod)) == NULLPE) ! 301: return (NULLPE); ! 302: break; ! 303: ! 304: case SETOF_START: ! 305: if ((pe = pr_setof(pe, parm, p, mod)) == NULLPE) ! 306: return (NULLPE); ! 307: break; ! 308: ! 309: case IMP_OBJ: ! 310: p++; ! 311: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) { ! 312: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, ! 313: (char **) 0, parm); ! 314: } else { ! 315: if (p->pe_type == SOBJECT) { ! 316: if ((pe = pr_obj(0, pe, parm, ! 317: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 318: return (NULLPE); ! 319: } else ! 320: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode, ! 321: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 322: return (NULLPE); ! 323: } ! 324: break; ! 325: ! 326: case SOBJECT: ! 327: case OBJECT: ! 328: if ((pe = pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 329: return (NULLPE); ! 330: break; ! 331: ! 332: case CHOICE_START: ! 333: if ((pe = pr_choice(pe, parm, p, mod)) == NULLPE) ! 334: return (NULLPE); ! 335: break; ! 336: ! 337: case SEXTOBJ: ! 338: case EXTOBJ: ! 339: if (p[1].pe_type != EXTMOD) { ! 340: dmp_tpe("pr_type: missing EXTMOD", p, mod); ! 341: ferr(1, "pr_type:internal error\n"); ! 342: } ! 343: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 344: (char **) 0, parm); ! 345: break; ! 346: ! 347: case INTEGER: ! 348: if (pe != NULLPE) { ! 349: if (_pverbose > 6) { ! 350: printf("integer value is %d\n",prim2num(pe)); ! 351: } ! 352: if (((*(int *)(*parm + p->pe_ucode)) = prim2num(pe)) ! 353: == NOTOK && pe->pe_errno != PE_ERR_NONE) { ! 354: printf("pr_type:bad integer %s", ! 355: pe_error(pe->pe_errno)); ! 356: return (NULLPE); ! 357: } ! 358: } ! 359: break; ! 360: ! 361: case BOOLEAN: ! 362: if (pe != NULLPE) { ! 363: if (_pverbose > 6) { ! 364: printf("boolean value is %d\n",prim2flag(pe)); ! 365: } ! 366: if (((* (char *)(*parm + p->pe_ucode)) = prim2flag(pe))==NOTOK && pe->pe_errno != PE_ERR_NONE) { ! 367: printf("pr_type:bad integer %s", ! 368: pe_error(pe->pe_errno)); ! 369: return (NULLPE); ! 370: } ! 371: } ! 372: break; ! 373: ! 374: case T_NULL: ! 375: break; ! 376: ! 377: case SCONS_ANY: ! 378: case SANY: ! 379: if (pe != NULLPE) { ! 380: ((* (PE *) parm) = pe)->pe_refcnt++; ! 381: if (pe->pe_errno != PE_ERR_NONE) { ! 382: printf("pr_type:bad integer %s", ! 383: pe_error(pe->pe_errno)); ! 384: return (NULLPE); ! 385: } ! 386: } ! 387: break; ! 388: ! 389: ! 390: case CONS_ANY: ! 391: case ANY: ! 392: if (pe != NULLPE) { ! 393: (* (PE *) (*parm + p->pe_ucode) = pe) ->pe_refcnt++; ! 394: if (pe->pe_errno != PE_ERR_NONE) { ! 395: printf("pr_type:bad integer %s", ! 396: pe_error(pe->pe_errno)); ! 397: return (NULLPE); ! 398: } ! 399: } ! 400: break; ! 401: ! 402: case SOCTETSTRING: ! 403: if (pe != NULLPE) { ! 404: if ((*((struct qbuf **) parm) = prim2qb(pe)) == ! 405: (struct qbuf *) NULL && pe->pe_errno != PE_ERR_NONE) { ! 406: printf("pr_type:bad octet string %s", ! 407: pe_error(pe->pe_errno)); ! 408: return (NULLPE); ! 409: } ! 410: } ! 411: break; ! 412: ! 413: case OCTETSTRING: ! 414: if (pe != NULLPE) { ! 415: if ((*((struct qbuf **) (*parm + p->pe_ucode)) ! 416: = prim2qb(pe)) == (struct qbuf *) NULL ! 417: && pe->pe_errno != PE_ERR_NONE) { ! 418: printf("pr_type:bad octet string %s", ! 419: pe_error(pe->pe_errno)); ! 420: return (NULLPE); ! 421: } ! 422: } ! 423: break; ! 424: ! 425: case SBITSTRING: ! 426: if (pe != NULLPE) { ! 427: /* ! 428: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe))== NULLPE) ! 429: I think this is a bug in ISODE's routines prim2bit ! 430: does the wrong thing ! 431: */ ! 432: if ((*((PE *)parm)=prim2bit(pe_cpy(pe))) == NULLPE) { ! 433: printf("pr_type:out of memory"); ! 434: return (NULLPE); ! 435: } ! 436: } ! 437: break; ! 438: ! 439: case BITSTRING: ! 440: if (pe != NULLPE) { ! 441: /* ! 442: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe))== NULLPE) ! 443: I think this is a bug in ISODE's routines prim2bit ! 444: does the wrong thing ! 445: */ ! 446: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe_cpy(pe))) == NULLPE) { ! 447: printf("pr_type:out of memory"); ! 448: return (NULLPE); ! 449: } ! 450: } ! 451: break; ! 452: ! 453: case SOBJID: ! 454: /* This is messy because ISODE's library routine uses a static. Don't ! 455: * know why they do ! 456: */ ! 457: if ((oid = prim2oid(pe)) == NULLOID ! 458: || (*(OID *)parm = oid_cpy(oid)) == NULLOID) { ! 459: printf("pr_type:Object Identifier: out of memory"); ! 460: if (oid && oid->oid_elements) { ! 461: free(oid->oid_elements); ! 462: oid->oid_elements = NULL; ! 463: } ! 464: return (NULLPE); ! 465: } ! 466: if (oid && oid->oid_elements) { ! 467: free(oid->oid_elements); ! 468: oid->oid_elements = NULL; ! 469: } ! 470: break; ! 471: ! 472: case OBJID: ! 473: if ((oid = prim2oid(pe)) == NULLOID ! 474: || (*(OID *)(*parm + p->pe_ucode) = oid_cpy(oid)) == NULLOID) { ! 475: printf("pr_type:Object Identifier: out of memory"); ! 476: if (oid && oid->oid_elements) { ! 477: free(oid->oid_elements); ! 478: oid->oid_elements = NULL; ! 479: } ! 480: return (NULLPE); ! 481: } ! 482: if (oid && oid->oid_elements) { ! 483: free(oid->oid_elements); ! 484: oid->oid_elements = NULL; ! 485: } ! 486: break; ! 487: ! 488: default: ! 489: dmp_tpe("pr_type: type not implemented", p, mod); ! 490: ferrd(1, "pr_type: %d not implemented\n", p->pe_type); ! 491: break; ! 492: } ! 493: if (ISDTYPE(p) && cnt > 0) ! 494: ferr(1, "pr_type:compound type found\n"); ! 495: if (ISDTYPE(p) && pe != NULLPE) ! 496: return (pe); ! 497: next: ! 498: NEXT_TPE(p); ! 499: } ! 500: ! 501: return (pe); ! 502: } ! 503: ! 504: /* ! 505: * Parse a sequence, calling appropriate routines to parse each sub type ! 506: */ ! 507: PE ! 508: pr_seq(head, parm, p, mod) ! 509: PE head; ! 510: PEPYPARM parm; ! 511: tpe *p; ! 512: modtyp *mod; /* Module it is from */ ! 513: { ! 514: PE pe; ! 515: int *popt = NULL; /* Pointer to optional field */ ! 516: int optcnt = 0; /* Number of optionals bits so far */ ! 517: ! 518: if (p->pe_type != SEQ_START) ! 519: ferr(1, "pr_seq: missing SEQ_START\n"); ! 520: p++; ! 521: ! 522: if (p->pe_type == DFLT_B) ! 523: p++; ! 524: ! 525: pe = first_member(head); ! 526: while (p->pe_type != PE_END) { ! 527: if (_pverbose > 6) { ! 528: printf("pr_seq:type %d\n",p->pe_type); ! 529: } ! 530: ! 531: ! 532: if (ISDTYPE(p) && OPTIONAL(p)) { ! 533: switch (p->pe_type) { ! 534: case INTEGER: ! 535: case BOOLEAN: ! 536: case T_NULL: ! 537: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) { ! 538: optcnt++; ! 539: goto next; ! 540: } ! 541: SETBIT(*popt, optcnt++); ! 542: break; ! 543: ! 544: #if 0 ! 545: case ANY: ! 546: case CONS_ANY: ! 547: case SANY: ! 548: case SCONS_ANY: ! 549: dmp_tpe("pr_seq:optional/default ANY", p, mod); ! 550: ferr(1, "unable to distinguish tags"); ! 551: #endif ! 552: ! 553: default: ! 554: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) { ! 555: if (ALLOC_MEM(p, parm)) ! 556: fix_mem(parm, p); ! 557: goto next; ! 558: } ! 559: break; ! 560: } ! 561: } else if (ISDTYPE(p) && (pe == NULLPE || CHKTAG(mod, p, pe) == 0)) { ! 562: if (DEFAULT(p)) { ! 563: setdval(p, p + 1, parm, mod); ! 564: goto next; ! 565: } else { ! 566: dmp_tpe("pr_seq:missing mandatory parameter", p, mod); ! 567: return (NULLPE); ! 568: } ! 569: } ! 570: ! 571: switch (p->pe_type) { ! 572: case OPTL: ! 573: popt = (int *) (*parm + p->pe_ucode); ! 574: break; ! 575: ! 576: case UCODE: ! 577: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 578: return (NULLPE); ! 579: break; ! 580: ! 581: case ETAG: ! 582: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 583: return NULLPE; ! 584: break; ! 585: ! 586: case MALLOC: ! 587: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL) ! 588: return NULLPE; ! 589: break; ! 590: ! 591: case SEQ_START: ! 592: if ((pe = pr_seq(pe, (char **)(*parm + p->pe_ucode), p, mod)) ! 593: == NULLPE) ! 594: return (NULLPE); ! 595: break; ! 596: ! 597: case SEQOF_START: ! 598: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 599: return (NULLPE); ! 600: break; ! 601: ! 602: case SET_START: ! 603: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 604: return (NULLPE); ! 605: break; ! 606: ! 607: case SETOF_START: ! 608: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 609: return (NULLPE); ! 610: break; ! 611: ! 612: case IMP_OBJ: ! 613: p++; ! 614: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) { ! 615: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, ! 616: (char **) 0, *parm + p->pe_ucode); ! 617: } else { ! 618: if (p->pe_type == SOBJECT) { ! 619: if ((pe = pr_obj(0, pe, parm, ! 620: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 621: return (NULLPE); ! 622: } else ! 623: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode, ! 624: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 625: return (NULLPE); ! 626: } ! 627: break; ! 628: ! 629: case SOBJECT: ! 630: if ((pe = pr_obj(1, pe, parm, ! 631: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 632: return (NULLPE); ! 633: break; ! 634: ! 635: case OBJECT: ! 636: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode, ! 637: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 638: return (NULLPE); ! 639: break; ! 640: ! 641: case CHOICE_START: ! 642: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 643: return (NULLPE); ! 644: break; ! 645: ! 646: case SEXTOBJ: ! 647: if (p[1].pe_type != EXTMOD) { ! 648: dmp_tpe("pr_seq: missing EXTMOD", p, mod); ! 649: ferr(1, "pr_seq:internal error\n"); ! 650: } ! 651: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 652: (char **) 0, parm); ! 653: break; ! 654: ! 655: case EXTOBJ: ! 656: if (p[1].pe_type != EXTMOD) { ! 657: dmp_tpe("pr_seq: missing EXTMOD", p, mod); ! 658: ferr(1, "pr_seq:internal error\n"); ! 659: } ! 660: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 661: (char **) 0, *parm + p->pe_ucode); ! 662: break; ! 663: ! 664: default: ! 665: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 666: return (NULLPE); ! 667: break; ! 668: /* ! 669: ferrd(1, "pr_seq: unknown type %d\n", p->pe_type); ! 670: */ ! 671: } ! 672: ! 673: if (ISDTYPE(p) && pe != NULLPE) ! 674: pe = next_member(head, pe); ! 675: next: ! 676: NEXT_TPE(p); ! 677: } ! 678: ! 679: return (head); ! 680: ! 681: } ! 682: ! 683: ! 684: /* ! 685: * Parse a set, calling appropriate routines to parse each sub type ! 686: */ ! 687: PE ! 688: pr_set(head, parm, p, mod) ! 689: PE head; ! 690: PEPYPARM parm; ! 691: tpe *p; ! 692: modtyp *mod; /* Module it is from */ ! 693: { ! 694: PE pe; ! 695: int *popt = NULL; /* Pointer to optional field */ ! 696: int optcnt = 0; /* Number of optionals bits so far */ ! 697: ! 698: if (p->pe_type != SET_START) ! 699: ferr(1, "pr_seq: missing SET_START\n"); ! 700: p++; ! 701: ! 702: if (p->pe_type == DFLT_B) ! 703: p++; ! 704: ! 705: while (p->pe_type != PE_END) { ! 706: ! 707: if (_pverbose > 6) { ! 708: printf("dec_set with the type %d\n",p->pe_type); ! 709: } ! 710: ! 711: if (ISDTYPE(p) && OPTIONAL(p)) { ! 712: switch (p->pe_type) { ! 713: case INTEGER: ! 714: case BOOLEAN: ! 715: case T_NULL: ! 716: if ((pe = setpresent(head, p, mod)) == NULLPE) { ! 717: optcnt++; ! 718: goto next; ! 719: } ! 720: SETBIT(*popt, optcnt++); ! 721: break; ! 722: ! 723: #if 0 ! 724: case ANY: ! 725: case CONS_ANY: ! 726: case SANY: ! 727: case SCONS_ANY: ! 728: dmp_tpe("pr_set:optional/default ANY\n", p, mod); ! 729: ferr(1, "unable to distinguish tags"); ! 730: #endif ! 731: ! 732: default: ! 733: if ((pe = setpresent(head, p, mod)) == NULLPE) { ! 734: if (ALLOC_MEM(p, parm)) ! 735: fix_mem(parm, p); ! 736: goto next; ! 737: } ! 738: break; ! 739: } ! 740: } else if (ISDTYPE(p) && (pe = setpresent(head, p, mod)) == NULLPE) { ! 741: if (DEFAULT(p)) { ! 742: setdval(p, p + 1, parm, mod); ! 743: goto next; ! 744: } else { ! 745: dmp_tpe("pr_set:missing mandatory parameter", p, mod); ! 746: return (NULLPE); ! 747: } ! 748: } ! 749: ! 750: switch (p->pe_type) { ! 751: case OPTL: ! 752: popt = (int *) (*parm + p->pe_ucode); ! 753: break; ! 754: ! 755: case UCODE: ! 756: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 757: return (NULLPE); ! 758: break; ! 759: ! 760: case ETAG: ! 761: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 762: return NULLPE; ! 763: break; ! 764: ! 765: case MALLOC: ! 766: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL) ! 767: return NULLPE; ! 768: break; ! 769: ! 770: case SEQ_START: ! 771: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 772: return (NULLPE); ! 773: break; ! 774: ! 775: case SEQOF_START: ! 776: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 777: return (NULLPE); ! 778: break; ! 779: ! 780: case SET_START: ! 781: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 782: return (NULLPE); ! 783: break; ! 784: ! 785: case SETOF_START: ! 786: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 787: return (NULLPE); ! 788: break; ! 789: ! 790: case IMP_OBJ: ! 791: p++; ! 792: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) { ! 793: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, ! 794: (char **) 0, *parm + p->pe_ucode); ! 795: } else { ! 796: if (p->pe_type == SOBJECT) { ! 797: if ((pe = pr_obj(0, pe, parm, ! 798: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 799: return (NULLPE); ! 800: } else ! 801: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode, ! 802: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 803: return (NULLPE); ! 804: } ! 805: break; ! 806: ! 807: case SOBJECT: ! 808: if ((pe = pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, ! 809: mod)) == NULLPE) ! 810: return (NULLPE); ! 811: break; ! 812: ! 813: case OBJECT: ! 814: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode, ! 815: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 816: return (NULLPE); ! 817: break; ! 818: ! 819: case CHOICE_START: ! 820: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 821: return (NULLPE); ! 822: break; ! 823: ! 824: case SEXTOBJ: ! 825: if (p[1].pe_type != EXTMOD) { ! 826: dmp_tpe("pr_set: missing EXTMOD", p, mod); ! 827: ferr(1, "pr_set:internal error\n"); ! 828: } ! 829: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 830: (char **) 0, parm); ! 831: break; ! 832: ! 833: case EXTOBJ: ! 834: if (p[1].pe_type != EXTMOD) { ! 835: dmp_tpe("pr_set: missing EXTMOD", p, mod); ! 836: ferr(1, "pr_set:internal error\n"); ! 837: } ! 838: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 839: (char **) 0, *parm + p->pe_ucode); ! 840: break; ! 841: ! 842: default: ! 843: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 844: return (NULLPE); ! 845: break; ! 846: /* ! 847: ferrd(1, "pr_set: unknown type %d\n", p->pe_type); ! 848: */ ! 849: } ! 850: ! 851: next: ! 852: NEXT_TPE(p); ! 853: } ! 854: ! 855: return (head); ! 856: ! 857: } ! 858: ! 859: ! 860: /* ! 861: * Parse a sequence of calling appropriate routines to parse each sub type ! 862: */ ! 863: PE ! 864: pr_seqof(head, parm, p, mod) ! 865: PE head; ! 866: PEPYPARM parm; ! 867: tpe *p; ! 868: modtyp *mod; /* Module it is from */ ! 869: { ! 870: PE pe; ! 871: tpe *start; /* first entry in list */ ! 872: int dflt = 0; ! 873: ! 874: if (p->pe_type != SEQOF_START) { ! 875: dmp_tpe("pr_seqof:missing SEQOF_START", p, mod); ! 876: ferr(1, "pr_seqof: missing SEQOF_START\n"); ! 877: } ! 878: p++; ! 879: ! 880: if (p->pe_type == DFLT_B) ! 881: p++; ! 882: ! 883: start = p; ! 884: ! 885: pe = first_member(head); ! 886: while (pe != NULLPE) { ! 887: while (p->pe_type != PE_END) { ! 888: ! 889: if (_pverbose > 6) { ! 890: printf("dec_seqof with the type %d\n",p->pe_type); ! 891: } ! 892: ! 893: if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) { ! 894: if (DEFAULT(p)) { ! 895: setdval(p, p + 1, parm, mod); ! 896: goto next; ! 897: } else if (OPTIONAL(p)) { ! 898: if (ALLOC_MEM(p, parm)) ! 899: fix_mem(parm, p); ! 900: goto next; ! 901: } else { ! 902: dmp_tpe( "pr_seqof:missing mandatory parameter", p, ! 903: mod); ! 904: return (NULLPE); ! 905: } ! 906: } ! 907: ! 908: switch (p->pe_type) { ! 909: case UCODE: ! 910: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 911: return (NULLPE); ! 912: break; ! 913: ! 914: case ETAG: ! 915: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 916: return NULLPE; ! 917: break; ! 918: ! 919: case MALLOC: ! 920: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL) ! 921: return NULLPE; ! 922: break; ! 923: ! 924: case SCTRL: ! 925: parm = (char **) ((char *)*parm + p->pe_ucode); ! 926: break; ! 927: ! 928: case SEQ_START: ! 929: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 930: return (NULLPE); ! 931: break; ! 932: ! 933: case SEQOF_START: ! 934: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 935: return (NULLPE); ! 936: break; ! 937: ! 938: case SET_START: ! 939: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 940: return (NULLPE); ! 941: break; ! 942: ! 943: case SETOF_START: ! 944: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 945: return (NULLPE); ! 946: break; ! 947: ! 948: case SOBJECT: ! 949: if ((pe = pr_obj(1, pe, parm, ! 950: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 951: return (NULLPE); ! 952: break; ! 953: ! 954: case OBJECT: ! 955: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode, ! 956: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 957: return (NULLPE); ! 958: break; ! 959: ! 960: case CHOICE_START: ! 961: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 962: return (NULLPE); ! 963: break; ! 964: ! 965: case SEXTOBJ: ! 966: if (p[1].pe_type != EXTMOD) { ! 967: dmp_tpe("pr_seqof: missing EXTMOD", p, mod); ! 968: ferr(1, "pr_seqof:internal error\n"); ! 969: } ! 970: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 971: (char **) 0, parm); ! 972: break; ! 973: ! 974: case EXTOBJ: ! 975: if (p[1].pe_type != EXTMOD) { ! 976: dmp_tpe("pr_seqof: missing EXTMOD", p, mod); ! 977: ferr(1, "pr_seqof:internal error\n"); ! 978: } ! 979: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 980: (char **) 0, *parm + p->pe_ucode); ! 981: break; ! 982: ! 983: default: ! 984: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 985: return (NULLPE); ! 986: break; ! 987: } ! 988: ! 989: if (ISDTYPE(p) && dflt == 0) ! 990: pe = next_member(head, pe); ! 991: next: ! 992: NEXT_TPE(p); ! 993: } ! 994: parm = (char **)(*parm + p->pe_ucode); ! 995: p = start; ! 996: } ! 997: ! 998: return (head); ! 999: ! 1000: } ! 1001: ! 1002: /* ! 1003: * Parse a setof, calling appropriate routines to parse each sub type ! 1004: */ ! 1005: PE ! 1006: pr_setof(head, parm, p, mod) ! 1007: PE head; ! 1008: PEPYPARM parm; ! 1009: tpe *p; ! 1010: modtyp *mod; /* Module it is from */ ! 1011: { ! 1012: PE pe; ! 1013: int dflt; ! 1014: tpe *start; ! 1015: ! 1016: if (p->pe_type != SETOF_START) ! 1017: ferr(1, "pr_setof: missing SETOF_START\n"); ! 1018: p++; ! 1019: ! 1020: if (p->pe_type == DFLT_B) ! 1021: p++; ! 1022: ! 1023: start = p; ! 1024: pe = first_member(head); ! 1025: ! 1026: for (pe = first_member(head); pe; pe = next_member(head, pe)) { ! 1027: while (p->pe_type != PE_END) { ! 1028: if (_pverbose > 6) { ! 1029: printf("dec_seqof with the type %d\n", p->pe_type); ! 1030: } ! 1031: ! 1032: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) { ! 1033: if (DEFAULT(p)) { ! 1034: setdval(p, p + 1, parm, mod); ! 1035: goto next; ! 1036: } else { ! 1037: dmp_tpe( "pr_setof:missing mandatory parameter", ! 1038: p, mod); ! 1039: return (NULLPE); ! 1040: } ! 1041: } ! 1042: else ! 1043: dflt = 0; ! 1044: ! 1045: switch (p->pe_type) { ! 1046: case UCODE: ! 1047: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 1048: return (NULLPE); ! 1049: break; ! 1050: ! 1051: case ETAG: ! 1052: if ((pe = pr_type(1, pe->pe_cons, parm, p, mod)) == NULLPE) ! 1053: return NULLPE; ! 1054: break; ! 1055: ! 1056: case MALLOC: ! 1057: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL) ! 1058: return NULLPE; ! 1059: break; ! 1060: ! 1061: case SCTRL: ! 1062: parm = (char **) (*parm + p->pe_ucode); ! 1063: break; ! 1064: ! 1065: case SEQ_START: ! 1066: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1067: return (NULLPE); ! 1068: break; ! 1069: ! 1070: case SEQOF_START: ! 1071: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1072: return (NULLPE); ! 1073: break; ! 1074: ! 1075: case SET_START: ! 1076: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1077: return (NULLPE); ! 1078: break; ! 1079: ! 1080: case SETOF_START: ! 1081: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1082: return (NULLPE); ! 1083: break; ! 1084: ! 1085: case SOBJECT: ! 1086: if ((pe = pr_obj(1, pe, parm, ! 1087: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1088: return (NULLPE); ! 1089: break; ! 1090: ! 1091: case OBJECT: ! 1092: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode, ! 1093: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1094: return (NULLPE); ! 1095: break; ! 1096: ! 1097: case CHOICE_START: ! 1098: if ((pe = pr_choice(pe, *parm + p->pe_ucode, ! 1099: p, mod)) == NULLPE) ! 1100: return (NULLPE); ! 1101: break; ! 1102: ! 1103: case SEXTOBJ: ! 1104: if (p[1].pe_type != EXTMOD) { ! 1105: dmp_tpe("pr_setof: missing EXTMOD", p, mod); ! 1106: ferr(1, "pr_setof:internal error\n"); ! 1107: } ! 1108: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, ! 1109: NULL, (char **) 0, parm); ! 1110: break; ! 1111: ! 1112: case EXTOBJ: ! 1113: if (p[1].pe_type != EXTMOD) { ! 1114: dmp_tpe("pr_setof: missing EXTMOD", p, mod); ! 1115: ferr(1, "pr_setof:internal error\n"); ! 1116: } ! 1117: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, ! 1118: NULL, (char **) 0, *parm + p->pe_ucode); ! 1119: break; ! 1120: ! 1121: default: ! 1122: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE) ! 1123: return (NULLPE); ! 1124: break; ! 1125: /* ! 1126: ferrd(1, "pr_setof: unknown type %d\n", p->pe_type); ! 1127: */ ! 1128: } ! 1129: ! 1130: #if 0 ! 1131: /* fixup - we only delete in this function */ ! 1132: if (ISDTYPE(p) && dflt == 0) ! 1133: set_del(head, pe->pe_class, pe->pe_id); ! 1134: #endif ! 1135: next: ! 1136: NEXT_TPE(p); ! 1137: } ! 1138: parm = (char **)(*parm + p->pe_ucode); ! 1139: p = start; ! 1140: } ! 1141: ! 1142: return (head); ! 1143: ! 1144: } ! 1145: ! 1146: /* ! 1147: * parse a choice field. This means find which choice is taken ! 1148: */ ! 1149: PE ! 1150: pr_choice(head, parm, p, mod) ! 1151: PE head; ! 1152: PEPYPARM parm; ! 1153: tpe *p; ! 1154: modtyp *mod; /* Module it is from */ ! 1155: { ! 1156: int *poffset; ! 1157: int cnt; ! 1158: PE pe; ! 1159: ! 1160: if (p->pe_type != CHOICE_START) { ! 1161: dmp_tpe("pr_choice:missing CHOICE_START", p, mod); ! 1162: ferrd(1, "pr_choice:illegal table entry %d\n", p->pe_type); ! 1163: } ! 1164: ! 1165: p++; ! 1166: ! 1167: if (p->pe_type == DFLT_B) ! 1168: p++; ! 1169: ! 1170: if (p->pe_type == MALLOC) { ! 1171: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL) ! 1172: return NULLPE; ! 1173: p++; ! 1174: } ! 1175: if (p->pe_type == SCTRL) { ! 1176: if ((poffset = (int *) (*parm + p->pe_ucode)) == NULL) ! 1177: return NULLPE; ! 1178: p++; ! 1179: } ! 1180: ! 1181: for (cnt = 1; p->pe_type != PE_END; NEXT_TPE(p), cnt++) { ! 1182: if (ISDTYPE(p) && ismatch(p, mod, head->pe_class, head->pe_id)) { ! 1183: pe = pr_etype(head, parm, p, mod); ! 1184: *poffset = cnt; ! 1185: return (pe); ! 1186: } ! 1187: } ! 1188: dmp_tpe("pr_choice: no choice taken", p, mod); ! 1189: return (NULLPE); ! 1190: } ! 1191: ! 1192: /* ! 1193: * Calculate the next tpe entry in the sequence. Count a sequence as one element ! 1194: */ ! 1195: tpe * ! 1196: next_tpe(p) ! 1197: tpe *p; ! 1198: { ! 1199: int level; ! 1200: ! 1201: ! 1202: ! 1203: level = 0; ! 1204: if (p->pe_type == PE_END) ! 1205: ferr(1, "next_tpe:PE_END"); ! 1206: do { ! 1207: again: ! 1208: switch (p->pe_type) { ! 1209: case SEQ_START: ! 1210: case SEQOF_START: ! 1211: case SET_START: ! 1212: case SETOF_START: ! 1213: case CHOICE_START: ! 1214: level++; ! 1215: break; ! 1216: ! 1217: case UCODE: ! 1218: case MALLOC: ! 1219: case SCTRL: ! 1220: case CH_ACT: ! 1221: case INTEGER: ! 1222: case BOOLEAN: ! 1223: case SANY: ! 1224: case SCONS_ANY: ! 1225: case ANY: ! 1226: case CONS_ANY: ! 1227: case T_NULL: ! 1228: case OBJECT: ! 1229: case SOBJECT: ! 1230: case BITSTRING: ! 1231: case SBITSTRING: ! 1232: case OCTETSTRING: ! 1233: case SOCTETSTRING: ! 1234: case OBJID: ! 1235: case SOBJID: ! 1236: case OPTL: ! 1237: case EXTMOD: ! 1238: case DFLT_B: ! 1239: break; ! 1240: ! 1241: case IMP_OBJ: ! 1242: case ETAG: ! 1243: case EXTOBJ: ! 1244: case SEXTOBJ: ! 1245: case DFLT_F: ! 1246: p++; ! 1247: goto again; ! 1248: ! 1249: case PE_END: ! 1250: level--; ! 1251: break; ! 1252: ! 1253: default: ! 1254: ferrd(1, "next_tpe: unknown type %d\n", p->pe_type); ! 1255: } ! 1256: p++; ! 1257: } while (level > 0 || p->pe_type == DFLT_B); ! 1258: ! 1259: return (p); ! 1260: } ! 1261: ! 1262: /* ! 1263: * check that pe is non null and that the tag and class match and return ! 1264: * zero if the don't ! 1265: */ ! 1266: chktag(mod, p, pe) ! 1267: modtyp *mod; /* Module it is from */ ! 1268: tpe *p; ! 1269: PE pe; ! 1270: { ! 1271: int cl, tag; ! 1272: ! 1273: if (pe == NULLPE) ! 1274: return (0); ! 1275: #if 0 ! 1276: if (p->pe_type == OBJECT && skip_next_tag) /* first time we find skip */ ! 1277: return (1); ! 1278: if (skip_next_tag) { /* 2nd time reset skip */ ! 1279: skip_next_tag = 0; ! 1280: return (1); ! 1281: } ! 1282: #endif ! 1283: if (!findcltag(p, mod, &cl, &tag)) ! 1284: return (0); ! 1285: if (pe->pe_id != tag || pe->pe_class != cl) ! 1286: return (0); ! 1287: ! 1288: return (1); ! 1289: } ! 1290: ! 1291: #if 0 ! 1292: /* ! 1293: test if we need to check the tag associated with the tpe entry p ! 1294: */ ! 1295: legal_tag(p) ! 1296: tpe *p; ! 1297: { ! 1298: int ret; ! 1299: ! 1300: switch (p->pe_type) { ! 1301: ! 1302: case MALLOC: ! 1303: case SCTRL: ! 1304: case CH_ACT: ! 1305: case ANY: ! 1306: case OBJECT: ! 1307: case CHOICE_START: ! 1308: case CONS_ANY: ! 1309: /* case ETAG: don't think we should have this here */ ! 1310: ret = 0; ! 1311: break; ! 1312: ! 1313: default: ! 1314: #if 0 ! 1315: if (skip_next_tag) { ! 1316: skip_next_tag = 0; ! 1317: ret = 0; ! 1318: } ! 1319: else ! 1320: #endif ! 1321: ret = 1; ! 1322: break; ! 1323: } ! 1324: return ret; ! 1325: } ! 1326: #endif ! 1327: ! 1328: /* ! 1329: * Parse a single type for explicit tag ! 1330: * If a basic type parse it, if a compound type call the appropriate ! 1331: * parsing routine ! 1332: */ ! 1333: PE ! 1334: pr_etype(pe, parm, p, mod) ! 1335: PE pe; ! 1336: PEPYPARM parm; ! 1337: tpe *p; ! 1338: modtyp *mod; /* Module it is from */ ! 1339: { ! 1340: switch (p->pe_type) { ! 1341: case PE_END: ! 1342: case PE_START: ! 1343: return (NULLPE); ! 1344: ! 1345: case UCODE: ! 1346: if ((*mod->md_ducode)(pe, parm, p, mod) != OK) ! 1347: return (NULLPE); ! 1348: break; ! 1349: ! 1350: case ETAG: ! 1351: switch (p->pe_ucode) { ! 1352: ! 1353: default: ! 1354: p++; ! 1355: if (pr_etype(pe->pe_cons, parm, p, mod) == NULLPE) ! 1356: return (NULLPE); ! 1357: } ! 1358: break; ! 1359: ! 1360: case MALLOC: ! 1361: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL) ! 1362: return NULLPE; ! 1363: break; ! 1364: ! 1365: case SEQ_START: ! 1366: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1367: return (NULLPE); ! 1368: break; ! 1369: ! 1370: case SEQOF_START: ! 1371: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1372: return (NULLPE); ! 1373: break; ! 1374: ! 1375: case SET_START: ! 1376: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1377: return (NULLPE); ! 1378: break; ! 1379: ! 1380: case SETOF_START: ! 1381: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1382: return (NULLPE); ! 1383: break; ! 1384: ! 1385: case IMP_OBJ: ! 1386: p++; ! 1387: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) { ! 1388: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, ! 1389: (char **) 0, *parm + p->pe_ucode); ! 1390: } else { ! 1391: if (p->pe_type == SOBJECT) { ! 1392: if ((pe = pr_obj(0, pe, parm, ! 1393: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1394: return (NULLPE); ! 1395: } else ! 1396: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode, ! 1397: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1398: return (NULLPE); ! 1399: } ! 1400: break; ! 1401: ! 1402: case SOBJECT: ! 1403: if ((pe = pr_obj(1, pe, parm, ! 1404: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1405: return (NULLPE); ! 1406: break; ! 1407: ! 1408: case OBJECT: ! 1409: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode, ! 1410: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE) ! 1411: return (NULLPE); ! 1412: break; ! 1413: ! 1414: case CHOICE_START: ! 1415: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE) ! 1416: return (NULLPE); ! 1417: break; ! 1418: ! 1419: case SEXTOBJ: ! 1420: if (p[1].pe_type != EXTMOD) { ! 1421: dmp_tpe("pr_etype: missing EXTMOD", p, mod); ! 1422: ferr(1, "pr_etype:internal error\n"); ! 1423: } ! 1424: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 1425: (char **) 0, parm); ! 1426: break; ! 1427: ! 1428: case EXTOBJ: ! 1429: if (p[1].pe_type != EXTMOD) { ! 1430: dmp_tpe("pr_etype: missing EXTMOD", p, mod); ! 1431: ferr(1, "pr_etype:internal error\n"); ! 1432: } ! 1433: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, ! 1434: (char **) 0, *parm + p->pe_ucode); ! 1435: break; ! 1436: ! 1437: case INTEGER: ! 1438: if (pe != NULLPE) { ! 1439: if (_pverbose > 6) { ! 1440: printf("integer value is %d\n",prim2num(pe)); ! 1441: } ! 1442: if (((*(int *)(*parm + p->pe_ucode)) = prim2num(pe))== NOTOK && pe->pe_errno != PE_ERR_NONE) { ! 1443: printf("pr_etype:bad integer %s", ! 1444: pe_error(pe->pe_errno)); ! 1445: return (NULLPE); ! 1446: } ! 1447: } ! 1448: break; ! 1449: ! 1450: case BOOLEAN: ! 1451: if (pe != NULLPE) { ! 1452: if (_pverbose > 6) { ! 1453: printf("boolean value is %d\n",prim2flag(pe)); ! 1454: } ! 1455: if (((* (char *)(*parm + p->pe_ucode)) = prim2flag(pe))==NOTOK && pe->pe_errno != PE_ERR_NONE) { ! 1456: printf("pr_etype:bad integer %s", ! 1457: pe_error(pe->pe_errno)); ! 1458: return (NULLPE); ! 1459: } ! 1460: } ! 1461: break; ! 1462: ! 1463: case T_NULL: ! 1464: break; ! 1465: ! 1466: case ANY: ! 1467: case CONS_ANY: ! 1468: if (pe != NULLPE) { ! 1469: (* (PE *) (*parm + p->pe_ucode) = pe) ->pe_refcnt++; ! 1470: if (pe->pe_errno != PE_ERR_NONE) { ! 1471: printf("pr_etype:bad integer %s", ! 1472: pe_error(pe->pe_errno)); ! 1473: return (NULLPE); ! 1474: } ! 1475: } ! 1476: break; ! 1477: ! 1478: case SANY: ! 1479: case SCONS_ANY: ! 1480: /* This could require changes when I find out what the CONS_ANY type ! 1481: * is really for ! 1482: */ ! 1483: if (pe != NULLPE) { ! 1484: ((PE) (*parm ) = pe) ->pe_refcnt++; ! 1485: if (pe->pe_errno != PE_ERR_NONE) { ! 1486: printf("pr_etype:bad integer %s", ! 1487: pe_error(pe->pe_errno)); ! 1488: return (NULLPE); ! 1489: } ! 1490: } ! 1491: break; ! 1492: ! 1493: case SOCTETSTRING: ! 1494: if (pe != NULLPE) { ! 1495: if ((*((struct qbuf **) parm) ! 1496: = prim2qb(pe)) == (struct qbuf *) NULL ! 1497: && pe->pe_errno != PE_ERR_NONE) { ! 1498: printf("pr_etype:bad octet string %s", ! 1499: pe_error(pe->pe_errno)); ! 1500: return (NULLPE); ! 1501: } ! 1502: } ! 1503: break; ! 1504: ! 1505: case OCTETSTRING: ! 1506: if (pe != NULLPE) { ! 1507: if ((*((struct qbuf **) (*parm + p->pe_ucode)) ! 1508: = prim2qb(pe)) == (struct qbuf *) NULL ! 1509: && pe->pe_errno != PE_ERR_NONE) { ! 1510: printf("pr_etype:bad octet string %s", ! 1511: pe_error(pe->pe_errno)); ! 1512: return (NULLPE); ! 1513: } ! 1514: } ! 1515: break; ! 1516: ! 1517: case SBITSTRING: ! 1518: if (pe != NULLPE) { ! 1519: if (((*(PE *) parm) = pe_cpy(pe)) == NULLPE) { ! 1520: printf("pr_etype:out of memory"); ! 1521: return (NULLPE); ! 1522: } ! 1523: } ! 1524: break; ! 1525: ! 1526: case BITSTRING: ! 1527: if (pe != NULLPE) { ! 1528: if ((*((PE *) (*parm + p->pe_ucode))= pe_cpy(pe)) == NULLPE) { ! 1529: printf("pr_etype:out of memory"); ! 1530: return (NULLPE); ! 1531: } ! 1532: } ! 1533: break; ! 1534: ! 1535: case SOBJID: ! 1536: if ((*(OID *)parm = oid_cpy(prim2oid(pe))) == NULLOID) { ! 1537: printf("pr_etype:Object Identifier: out of memory"); ! 1538: return (NULLPE); ! 1539: } ! 1540: break; ! 1541: ! 1542: case OBJID: ! 1543: if ((*(OID *)(*parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID) { ! 1544: printf("en_etype:Object Identifier: out of memory"); ! 1545: return (NULLPE); ! 1546: } ! 1547: break; ! 1548: ! 1549: default: ! 1550: ferrd(1, "pr_etype: %d not implemented\n", p->pe_type); ! 1551: break; ! 1552: } ! 1553: ! 1554: return (pe); ! 1555: } ! 1556: ! 1557: /* ! 1558: * determine what the class and tag must be of the given object ! 1559: */ ! 1560: findcltag(p, mod, pcl, ptag) ! 1561: tpe *p; ! 1562: modtyp *mod; /* Module it is from */ ! 1563: int *pcl, *ptag; ! 1564: { ! 1565: if (!ISDTYPE(p)) ! 1566: return (0); ! 1567: if (p->pe_type != OBJECT) { ! 1568: *pcl = CLASS(p); ! 1569: *ptag = TAG(p); ! 1570: return (1); ! 1571: } ! 1572: p = mod->md_dtab[p->pe_tag] + 1; ! 1573: while (p->pe_type != PE_END) { ! 1574: if (ISDTYPE(p)) ! 1575: return (findcltag(p, mod, pcl, ptag)); ! 1576: } ! 1577: dmp_tpe("findcltag:warning:object with no data in it", p, mod); ! 1578: return (0); ! 1579: } ! 1580: ! 1581: /* ! 1582: * Is there a match at for this tag and class pair. Return 1 if yes 0 if no ! 1583: * We will search through contained objects and through choices ! 1584: */ ! 1585: ismatch(p, mod, cl, tag) ! 1586: tpe *p; ! 1587: modtyp *mod; /* Module it is from */ ! 1588: unsigned int cl, tag; ! 1589: { ! 1590: while (!ISDTYPE(p)) ! 1591: p++; ! 1592: ! 1593: switch (p->pe_type) { ! 1594: case SOBJECT: ! 1595: case OBJECT: ! 1596: /* Needs to be changed for optional and default */ ! 1597: return (ismatch(p = mod->md_dtab[p->pe_tag] + 1, mod, cl, tag)); ! 1598: ! 1599: case SEXTOBJ: ! 1600: case EXTOBJ: ! 1601: if (p[1].pe_type != EXTMOD) { ! 1602: dmp_tpe("ismatch: missing EXTMOD", p, mod); ! 1603: ferr(1, "ismatch:internal error\n"); ! 1604: } ! 1605: return(ismatch(((modtyp *)p[1].pe_ucode)->md_dtab[p->pe_tag] + 1, ! 1606: (modtyp *)p[1].pe_ucode, cl, tag)); ! 1607: ! 1608: case CHOICE_START: ! 1609: for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) { ! 1610: if (!ISDTYPE(p)) ! 1611: continue; ! 1612: if (ismatch(p, mod, cl, tag)) ! 1613: return (1); ! 1614: } ! 1615: return (0); ! 1616: ! 1617: case SANY: ! 1618: case SCONS_ANY: ! 1619: return (1); ! 1620: ! 1621: case ANY: ! 1622: case CONS_ANY: ! 1623: if (TAG(p) == -1) ! 1624: return (1); ! 1625: /* else fall through - not sure if this is needed */ ! 1626: ! 1627: default: ! 1628: return (tag == TAG(p) && cl == CLASS(p)); ! 1629: } ! 1630: } ! 1631: ! 1632: /* ! 1633: * determine if the given field is present in the data ! 1634: * This is simple if the field is a simple type with an obvious tag but ! 1635: * in the case of an object or a CHOICE type the tag is not obvious. If the ! 1636: * object is a CHOICE there are more than one possible tag that could match ! 1637: * and in this case we must try to match each one of them. ! 1638: */ ! 1639: PE ! 1640: setpresent(head, p, mod) ! 1641: PE head; ! 1642: tpe *p; ! 1643: modtyp *mod; ! 1644: { ! 1645: PE pe; ! 1646: ! 1647: if (!ISDTYPE(p)) ! 1648: return (NULLPE); ! 1649: switch (p->pe_type) { ! 1650: case OBJECT: ! 1651: case SOBJECT: ! 1652: /* Needs to be changed for optional and default */ ! 1653: return (setpresent(head, p = mod->md_dtab[p->pe_tag] + 1, mod)); ! 1654: ! 1655: case CHOICE_START: ! 1656: for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) { ! 1657: if (!ISDTYPE(p)) ! 1658: continue; ! 1659: if ((pe = setpresent(head, p, mod))) ! 1660: return (pe); ! 1661: } ! 1662: return (NULLPE); ! 1663: ! 1664: default: ! 1665: return (set_find(head, CLASS(p), TAG(p))); ! 1666: } ! 1667: } ! 1668: ! 1669: /* ! 1670: * set the default value to that value in the structure ! 1671: */ ! 1672: setdval(typ, dflt, parm, mod) ! 1673: tpe *typ, *dflt; ! 1674: char **parm; ! 1675: modtyp *mod; ! 1676: { ! 1677: ! 1678: again: ! 1679: switch (typ->pe_type) { ! 1680: case MALLOC: ! 1681: if ((*(parm) = (char *) calloc(1, typ->pe_tag)) == NULL) ! 1682: ferrd(1, "setdval:calloc failed on %d\n", typ->pe_tag); ! 1683: typ++; ! 1684: goto again; ! 1685: ! 1686: case INTEGER: ! 1687: *(int *)(*parm + typ->pe_ucode) = IVAL(dflt); ! 1688: break; ! 1689: ! 1690: case BOOLEAN: ! 1691: *(char *)(*parm + typ->pe_ucode) = IVAL(dflt); ! 1692: break; ! 1693: ! 1694: case T_NULL: ! 1695: /* Only one value */ ! 1696: break; ! 1697: ! 1698: case SBITSTRING: ! 1699: *(PE *)parm = strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0); ! 1700: break; ! 1701: ! 1702: case BITSTRING: ! 1703: *(PE *)(*parm + typ->pe_ucode) = ! 1704: strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0); ! 1705: break; ! 1706: ! 1707: case SOCTETSTRING: ! 1708: *(struct qbuf **)parm = str2qb(PVAL(dflt), IVAL(dflt), 1); ! 1709: break; ! 1710: ! 1711: case OCTETSTRING: ! 1712: *(struct qbuf **)(*parm + typ->pe_ucode) = ! 1713: str2qb(PVAL(dflt), IVAL(dflt), 1); ! 1714: break; ! 1715: ! 1716: case OBJECT: ! 1717: setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, ! 1718: (char **) (*parm + typ->pe_ucode), mod); ! 1719: break; ! 1720: ! 1721: case SOBJECT: ! 1722: setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, parm, mod); ! 1723: break; ! 1724: ! 1725: case IMP_OBJ: ! 1726: typ++; ! 1727: ! 1728: case SCONS_ANY: ! 1729: case ANY: ! 1730: case CONS_ANY: ! 1731: case SANY: ! 1732: case SEXTOBJ: ! 1733: case EXTOBJ: ! 1734: case OBJID: ! 1735: case SOBJID: ! 1736: case SEQ_START: ! 1737: case SET_START: ! 1738: case -1: /* Just use the pepy method of null pointers */ ! 1739: /* This is the posy/pepy hack way of doing things at the moment */ ! 1740: *(char **)(*parm + typ->pe_ucode) = NULL; ! 1741: break; ! 1742: ! 1743: default: ! 1744: /* dmp_tpe("setdval: type not implemented", typ, mod); - need mod*/ ! 1745: ferrd(1, "setdval: %d not implemented\n", typ->pe_type); ! 1746: break; ! 1747: } ! 1748: ! 1749: } ! 1750: /* ! 1751: * fix up the allocation of memory. We have allocated memory for an optional ! 1752: * object that is not present. ISODE routines get upset if this is present ! 1753: * because it then believes the object is present and tries to process it ... ! 1754: */ ! 1755: fix_mem(parm, p) ! 1756: char **parm; ! 1757: tpe *p; ! 1758: { ! 1759: if (p->pe_type != SOBJECT || p[-1].pe_type != MALLOC ! 1760: || p[1].pe_type != PE_END) ! 1761: ferr(1, "fix_mem:inconsistency\n"); ! 1762: if (*parm) ! 1763: free(*parm); ! 1764: *parm = NULL; ! 1765: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.