![[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.