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