|
DataMuseum.dkPresents historical artifacts from the history of: DKUUG/EUUG Conference tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about DKUUG/EUUG Conference tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: T p
Length: 43814 (0xab26)
Types: TextFile
Names: »prnt.c«
└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
└─⟦041b9c0f8⟧ »EurOpenD22/isode/pepsy.system-6.0.Z«
└─⟦d49939f05⟧
└─⟦6a28ec38e⟧ »pepsy.tar«
└─⟦this⟧ »pepsy/prnt.c«
/*
* These routines are the driving routines for parsing encoding and printing
* data
*/
#include <stdio.h>
#include <ctype.h>
#include "../h/psap.h"
#include "pep.h"
#include "pepdefs.h"
#define PEPYPARM char **
#ifndef PEPYPARM
#define PEPYPARM char **
#endif
extern PEPYPARM NullParm;
#undef NULLPE
#define NULLPE ((PE) 0)
extern PE p_pr_seq(), p_pr_seqof(), p_pr_set(), p_pr_setof(), p_pr_type();
extern PE en_seq(), en_seqof(), en_set(), en_setof(), en_type();
extern PE p_pr_choice(), en_choice(), en_etype(), p_pr_etype(), p_pr_obj();
extern PE p_setpresent();
extern char *printable();
extern IFP vfnx;
extern FILE *vfp;
extern ptpe *next_ptpe();
extern int _pverbose;
int xlevel = 0;
int tabed = 0;
int xpushed = 0;
#define NEXT_TPE(p) p = next_ptpe(p)
#define CHKTAG(mod, p, pe) p_ismatch(p, mod, pe->pe_class, pe->pe_id)
/*SUPPRESS 36*/ /* for Saber C */
/*
* prntode the specified type of the specified module into the given pe
*/
prnt_f(typ, mod, pe, explicit, len, buf)
/*ARGSUSED*/
int typ; /* which type it is */
modtyp *mod; /* Module it is from */
PE pe;
int explicit;
int *len;
char **buf;
{
ptpe *p;
if (typ < 0 || typ >= mod->md_nentries)
ferrd(1, "prnt_f:Illegal typ %d\n", typ);
p = mod->md_ptab[typ];
if (p->pe_type != PE_START)
ferr(1, "prnt_f: missing PE_START\n");
xpush(p->pe_typename, xlevel);
p++;
if ((pe = (PE) p_pr_obj(explicit, pe, p, mod)) == NULLPE) {
xpull();
return (NOTOK);
}
xpull();
return (OK);
}
/*
* Parse an object. The top level of an object does not have any offset field
* which makes it different to pr_type routine which must assume that it
* has an offset.
*/
PE
p_pr_obj(expl, pe, p, mod)
int expl; /* do we look at the tag */
PE pe;
ptpe *p;
modtyp *mod; /* Module it is from */
{
int cnt = 0;
if (_pverbose > 6) {
(*vfnx) (vfp, "1st Printing the type %d \n", p->pe_type);
}
while (p->pe_type != PE_END) {
if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
if (DEFAULT(p))
ferr(1, "p_pr_obj:Default not implemented\n");
else if (OPTIONAL(p))
goto next;
else {
dmp_tpe(vfp, "p_pr_obj:missing mandatory parameter", p, mod);
return (NULLPE);
}
}
if (_pverbose > 6) {
(*vfnx) (vfp, "2nd Printing the type %d \n", p->pe_type);
}
switch (p->pe_type) {
case PE_END:
case PE_START:
return (NULLPE);
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
switch (p->pe_ucode) {
default:
p++;
if (p_pr_obj(1, pe->pe_cons, p, mod) == NULLPE)
return (NULLPE);
}
break;
case SEQ_START:
if ((pe = p_pr_seq(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEQOF_START:
if ((pe = p_pr_seqof(pe, p, mod)) == NULLPE) {
return (NULLPE);
}
break;
case SET_START:
if ((pe = p_pr_set(pe, p, mod)) == NULLPE) {
return (NULLPE);
}
break;
case SETOF_START:
if ((pe = p_pr_setof(pe, p, mod)) == NULLPE) {
return (NULLPE);
}
break;
case IMP_OBJ:
p++;
if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag,(modtyp *)p[1].pe_ucode, pe, 0, NULL, (char *) 0 );
xpull();
} else {
xpush(p->pe_typename, xlevel);
if ((pe = p_pr_obj(0, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
}
break;
case SOBJECT:
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = p_pr_obj(expl, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_tpe("pr_type: missing EXTMOD", p, mod);
ferr(1, "pr_type:internal error\n");
}
printname(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
(char *) 0 );
break;
default:
if ((pe = p_pr_type(expl, pe, p, mod)) == NULLPE)
return (NULLPE);
break;
}
if (ISDTYPE(p) && cnt > 0)
ferr(1, "p_pr_obj:compound type found\n");
if (ISDTYPE(p) && pe != NULLPE) {
return (pe);
}
next:
NEXT_TPE(p);
}
return (pe);
}
/*
* Parse a single type.
* If a basic type parse it, if a compound type call the appropriate
* parsing routine
*/
PE
p_pr_type(expl, pe, p, mod)
int expl; /* do we look at the tag */
PE pe;
ptpe *p;
modtyp *mod; /* Module it is from */
{
int cnt = 0;
int len, i, val;
char *ptr;
struct qbuf *qptr;
OID oid;
PE pe_ptr;
i = len = val = 0;
if (_pverbose > 6) {
(*vfnx) (vfp, "1st Printing the type %d \n", p->pe_type);
}
while (p->pe_type != PE_END) {
/*
print_pe (pe, 1);
*/
if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
if (DEFAULT(p)) {
setpval(p, p + 1, mod);
goto next;
} else if (OPTIONAL(p))
goto next;
else {
dmp_ptpe("p_pr_type:missing mandatory parameter", p, mod);
return (NULLPE);
}
}
if (_pverbose > 6) {
(*vfnx) (vfp, "2nd Printing the type %d \n", p->pe_type);
}
switch (p->pe_type) {
case PE_END:
case PE_START:
return (NULLPE);
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
switch (p->pe_ucode) {
default:
p++;
if (p_pr_etype(pe->pe_cons, p, mod) == NULLPE)
return (NULLPE);
}
break;
case SEQ_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SEQOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SET_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SETOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case IMP_OBJ:
p++;
if (p->pe_type == EXTOBJ) {
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, (char **) 0 );
xpull();
} else {
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(0, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
}
break;
case SOBJECT:
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(expl, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_type: missing EXTMOD", p, mod);
ferr(1, "p_pr_type:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
(char *) 0 );
xpull();
break;
case INTEGER:
if (pe != NULLPE) {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %d (INTEGER VALUE)\n", (p->pe_typename) ? p->pe_typename : "", prim2num(pe));
else
(*vfnx) (vfp, "%s %d \n", (p->pe_typename) ? p->pe_typename : "", prim2num(pe));
}
break;
case BOOLEAN:
if (pe != NULLPE) {
val = prim2flag(pe);
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (BOOLEAN VALUE)\n", (p->pe_typename) ? p->pe_typename : "", (val) ? "TRUE" : "FALSE");
else
(*vfnx) (vfp, "%s %s \n", (p->pe_typename) ? p->pe_typename : "", (val) ? "TRUE" : "FALSE");
}
break;
case T_NULL:
break;
case SCONS_ANY:
case SANY:
if (pe != NULLPE) {
if (pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_type:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else
pr_pe_element(pe, p);
}
break;
case CONS_ANY:
case ANY:
if (pe != NULLPE) {
if (pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_type:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else
pr_pe_element(pe, p);
}
break;
case SOCTETSTRING:
if (pe != NULLPE) {
if ((((struct qbuf *) qptr) = prim2qb(pe)) ==
(struct qbuf *) NULL && pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_type:bad octet string %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s \"%s\" (OCTETSTRING)\n", (p->pe_typename) ? p->pe_typename : "", qb2str((struct qbuf *) qptr));
else
(*vfnx) (vfp, "%s \"%s\"\n", (p->pe_typename) ? p->pe_typename : "", qb2str((struct qbuf *) qptr));
qb_free(qptr);
}
}
break;
case OCTETSTRING:
if (pe != NULLPE) {
if (((struct qbuf *) qptr
= prim2qb(pe)) == (struct qbuf *) NULL
&& pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_type:bad octet string %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s \"%s\" (OCTETSTRING)\n", (p->pe_typename) ? p->pe_typename : "", qb2str(((struct qbuf *) qptr)));
else
(*vfnx) (vfp, "%s \"%s\" \n", (p->pe_typename) ? p->pe_typename : "", qb2str(((struct qbuf *) qptr )));
}
}
break;
case SBITSTRING:
if (pe != NULLPE) {
/*
if (((PE) pe_ptr = prim2bit(pe))== NULLPE)
I think this is a bug in ISODE's routines prim2bit
does the wrong thing
*/
if (((PE) pe_ptr = pe_cpy(pe)) == NULLPE) {
ferr (1, "p_pr_type:out of memory");
return (NULLPE);
}
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
ptr = bitstr2strb((PE) pe_ptr, &len);
for (i=0; i < len; i+=8)
(*vfnx) (vfp, "%.2x ", *ptr++ & 0xff);
(*vfnx) (vfp, "'H\n");
if (_pverbose) {
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
for (i=0; i < len; i++) {
(*vfnx) (vfp, "%d", bit_test((PE) pe_ptr, i));
if ((i+1) % 4 == 0)
(*vfnx) (vfp, " ");
}
(*vfnx) (vfp, "'B (BITSTRING)\n");
}
}
break;
case BITSTRING:
if (pe != NULLPE) {
/*
if (((PE) pe_ptr = prim2bit(pe))== NULLPE)
I think this is a bug in ISODE's routines prim2bit
does the wrong thing
*/
if (((PE) pe_ptr = pe_cpy(pe)) == NULLPE) {
ferr (1, "p_pr_type:out of memory");
return (NULLPE);
}
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
ptr = bitstr2strb((PE) pe_ptr, &len);
for (i=0; i < len; i+=8)
(*vfnx) (vfp, "%.2x ", *ptr++ & 0xff);
(*vfnx) (vfp, "'H (BITSTRING)\n");
if (_pverbose) {
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
for (i=0; i < len; i++) {
(*vfnx) (vfp, "%d", bit_test((PE) pe_ptr, i));
if ((i+1) % 4 == 0)
(*vfnx) (vfp, " ");
}
(*vfnx) (vfp, "'B\n");
}
}
break;
case SOBJID:
if ((oid = (OID) prim2oid(pe)) == NULLOID) {
ferr (1, "p_pr_type:Object Identifier: out of memory");
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (OBJECT ID)\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
else
(*vfnx) (vfp, "%s %s\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
}
break;
case OBJID:
if ((oid = (OID) prim2oid(pe)) == NULLOID) {
ferr (1, "p_pr_type:Object Identifier: out of memory");
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (OBJECT ID)\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
else
(*vfnx) (vfp, "%s %s\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
}
break;
default:
dmp_ptpe("p_pr_type: type not implemented", p, mod);
ferrd(1, "p_pr_type: %d not implemented\n", p->pe_type);
break;
}
if (ISDTYPE(p) && cnt > 0)
ferr(1, "p_pr_type:compound type found\n");
if (ISDTYPE(p) && pe != NULLPE)
return (pe);
next:
NEXT_TPE(p);
}
return (pe);
}
/*
* Parse a sequence, calling appropriate routines to parse each sub type
*/
PE
p_pr_seq(head, p, mod)
PE head;
ptpe *p;
modtyp *mod; /* Module it is from */
{
PE pe, pe_ptr;
struct qbuf *qptr;
int *popt = NULL; /* Pointer to optional field */
int *int_ptr = NULL;
int optcnt = 0; /* Number of optionals bits so far */
if (p->pe_type != SEQ_START)
ferr(1, "p_pr_seq: missing SEQ_START\n");
p++;
if (p->pe_type == DFLT_B)
p++;
pe = first_member(head);
while (p->pe_type != PE_END) {
if (_pverbose > 6) {
ferr (1, "prnt_seq with the type %d\n",p->pe_type);
}
if (ISDTYPE(p) && OPTIONAL(p)) {
if (pe == NULLPE || CHKTAG(mod, p, pe) == 0)
goto next;
} else if (ISDTYPE(p) && (pe == NULLPE || CHKTAG(mod, p, pe) == 0)) {
if (DEFAULT(p)) {
setpval(p, p + 1, mod);
goto next;
} else {
dmp_ptpe("p_pr_seq:missing mandatory parameter", p, mod);
return (NULLPE);
}
}
switch (p->pe_type) {
case OPTL:
popt = (int *) int_ptr;
break;
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return NULLPE;
break;
case SEQ_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SEQOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SET_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SETOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case IMP_OBJ:
p++;
if (p->pe_type == EXTOBJ) {
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL, (char *) 0);
xpull();
} else {
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(0, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
}
break;
case SOBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_seq: missing EXTMOD", p, mod);
ferr(1, "p_pr_seq:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_seq: missing EXTMOD", p, mod);
ferr(1, "p_pr_seq:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
default:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return (NULLPE);
break;
/*
ferrd(1, "p_pr_seq: unknown type %d\n", p->pe_type);
*/
}
if (ISDTYPE(p) && pe != NULLPE)
pe = next_member(head, pe);
next:
NEXT_TPE(p);
}
return (head);
}
/*
* Parse a set, calling appropriate routines to parse each sub type
*/
PE
p_pr_set(head, p, mod)
PE head;
ptpe *p;
modtyp *mod; /* Module it is from */
{
PE pe;
int *popt = NULL; /* Pointer to optional field */
int *int_ptr = NULL;
int optcnt = 0; /* Number of optionals bits so far */
if (p->pe_type != SET_START)
ferr(1, "p_pr_seq: missing SET_START\n");
p++;
if (p->pe_type == DFLT_B)
p++;
while (p->pe_type != PE_END) {
if (_pverbose > 6) {
ferr (1, "prnt_set with the type %d\n",p->pe_type);
}
if (ISDTYPE(p) && OPTIONAL(p)) {
if ((pe = (PE) p_setpresent(head, p, mod)) == NULLPE)
goto next;
} else if (ISDTYPE(p) && (pe = (PE) p_setpresent(head, p, mod)) == NULLPE) {
if (DEFAULT(p)) {
printname(p->pe_typename, xlevel);
setpval(p, p + 1, mod);
goto next;
} else {
dmp_ptpe("p_pr_set:missing mandatory parameter", p, mod);
return (NULLPE);
}
}
switch (p->pe_type) {
case OPTL:
popt = int_ptr;
break;
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return NULLPE;
break;
case SEQ_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SEQOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SET_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SETOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case IMP_OBJ:
p++;
if (p->pe_type == EXTOBJ) {
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
(char *) 0);
} else {
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(0, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
}
break;
case SOBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_set: missing EXTMOD", p, mod);
ferr(1, "p_pr_set:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_set: missing EXTMOD", p, mod);
ferr(1, "p_pr_set:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
default:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return (NULLPE);
break;
/*
ferrd(1, "p_pr_set: unknown type %d\n", p->pe_type);
*/
}
next:
NEXT_TPE(p);
}
return (head);
}
/*
* Parse a sequence of calling appropriate routines to parse each sub type
*/
PE
p_pr_seqof(head, p, mod)
PE head;
ptpe *p;
modtyp *mod; /* Module it is from */
{
PE pe;
ptpe *start; /* first entry in list */
int dflt = 0;
if (p->pe_type != SEQOF_START) {
dmp_ptpe("p_pr_seqof:missing SEQOF_START", p, mod);
ferr(1, "p_pr_seqof: missing SEQOF_START\n");
}
p++;
if (p->pe_type == DFLT_B)
p++;
start = p;
pe = first_member(head);
while (pe != NULLPE) {
while (p->pe_type != PE_END) {
if (_pverbose > 6) {
ferr (1, "prnt_seqof with the type %d\n",p->pe_type);
}
if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) {
if (DEFAULT(p))
ferr(1, "p_pr_seqof:Default not implemented\n");
else if (OPTIONAL(p))
goto next;
else {
dmp_ptpe( "p_pr_seqof:missing mandatory parameter", p,
mod);
return (NULLPE);
}
}
switch (p->pe_type) {
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return NULLPE;
break;
/* case SCTRL:
parm = (char *) ((char *) parm);
break; */
case SEQ_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SEQOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SET_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SETOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SOBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_seqof: missing EXTMOD", p, mod);
ferr(1, "p_pr_seqof:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_seqof: missing EXTMOD", p, mod);
ferr(1, "p_pr_seqof:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
default:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return (NULLPE);
break;
}
if (ISDTYPE(p) && dflt == 0)
pe = next_member(head, pe);
next:
NEXT_TPE(p);
}
/* parm = (char *) (parm); */
p = start;
}
return (head);
}
/*
* Parse a setof, calling appropriate routines to parse each sub type
*/
PE
p_pr_setof(head, p, mod)
PE head;
ptpe *p;
modtyp *mod; /* Module it is from */
{
PE pe;
int dflt;
ptpe *start;
if (p->pe_type != SETOF_START)
ferr(1, "p_pr_setof: missing SETOF_START\n");
p++;
if (p->pe_type == DFLT_B)
p++;
start = p;
for (pe = first_member(head); pe; pe = next_member(head, pe)) {
while (p->pe_type != PE_END) {
if (_pverbose > 6) {
ferr (1, "prnt_seqof with the type %d\n", p->pe_type);
}
if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
if (DEFAULT(p)) {
setpval(p, p + 1, mod);
goto next;
} else {
dmp_ptpe(
"p_pr_setof:missing mandatory parameter", p, mod);
return (NULLPE);
}
}
else
dflt = 0;
switch (p->pe_type) {
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
if ((pe = (PE) p_pr_type(1, pe->pe_cons, p, mod)) == NULLPE)
return NULLPE;
break;
/* case SCTRL:
parm = (char *) (parm);
break; */
case SEQ_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SEQOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SET_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SETOF_START:
xpush(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE) {
xpull();
return (NULLPE);
}
xpull();
break;
case SOBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe,
mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe, mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE) {
return (NULLPE);
}
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe,
p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_setof: missing EXTMOD", p, mod);
ferr(1, "p_pr_setof:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_setof: missing EXTMOD", p, mod);
ferr(1, "p_pr_setof:internal error\n");
}
xpush(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL, (char *) 0);
xpull();
break;
default:
if ((pe = (PE) p_pr_type(1, pe, p, mod)) == NULLPE)
return (NULLPE);
break;
/*
ferrd(1, "p_pr_setof: unknown type %d\n", p->pe_type);
*/
}
#if 0
/* fixup - we only delete in this function */
if (ISDTYPE(p) && dflt == 0)
set_del(head, pe->pe_class, pe->pe_id);
#endif
next:
NEXT_TPE(p);
}
/* parm = (char *)(parm); */
p = start;
}
return (head);
}
/*
* parse a choice field. This means find which choice is taken
*/
PE
p_pr_choice(head, p, mod)
PE head;
ptpe *p;
modtyp *mod; /* Module it is from */
{
int offset;
int cnt;
PE pe;
if (p->pe_type != CHOICE_START) {
dmp_ptpe("p_pr_choice:missing CHOICE_START", p, mod);
ferrd(1, "p_pr_choice:illegal table entry %d\n", p->pe_type);
}
p++;
xpush(p->pe_typename, xlevel);
if (p->pe_type == DFLT_B)
p++;
if (p->pe_type == SCTRL) {
p++;
}
for (cnt = 1; p->pe_type != PE_END; NEXT_TPE(p), cnt++) {
if (ISDTYPE(p) && p_ismatch(p, mod, head->pe_class, head->pe_id)) {
pe = (PE) p_pr_etype(head, p, mod);
offset = cnt;
xpull();
return (pe);
}
}
dmp_ptpe("p_pr_choice: no choice taken", p, mod);
return (NULLPE);
}
/*
* Calculate the next ptpe entry in the sequence. Count a sequence as one element
*/
ptpe *
next_ptpe(p)
ptpe *p;
{
int level;
level = 0;
if (p->pe_type == PE_END)
ferr(1, "next_ptpe:PE_END");
do {
again:
switch (p->pe_type) {
case SEQ_START:
case SEQOF_START:
case SET_START:
case SETOF_START:
case CHOICE_START:
level++;
break;
case UCODE:
case SCTRL:
case CH_ACT:
case INTEGER:
case BOOLEAN:
case SANY:
case SCONS_ANY:
case ANY:
case CONS_ANY:
case T_NULL:
case OBJECT:
case SOBJECT:
case BITSTRING:
case SBITSTRING:
case OCTETSTRING:
case SOCTETSTRING:
case OBJID:
case SOBJID:
case OPTL:
case EXTMOD:
case DFLT_B:
break;
case IMP_OBJ:
case ETAG:
case EXTOBJ:
case SEXTOBJ:
case DFLT_F:
p++;
goto again;
case PE_END:
level--;
break;
default:
ferrd(1, "next_ptpe: unknown type %d\n", p->pe_type);
}
p++;
} while (level > 0 || p->pe_type == DFLT_B);
return (p);
}
/*
* check that pe is non null and that the tag and class match and return
* zero if the don't
*/
p_chktag(mod, p, pe)
modtyp *mod; /* Module it is from */
ptpe *p;
PE pe;
{
int cl, tag;
if (pe == NULLPE)
return (0);
#if 0
if (p->pe_type == OBJECT && skip_next_tag) /* first time we find skip */
return (1);
if (skip_next_tag) { /* 2nd time reset skip */
skip_next_tag = 0;
return (1);
}
#endif
if (!p_findcltag(p, mod, &cl, &tag))
return (0);
if (pe->pe_id != tag || pe->pe_class != cl)
return (0);
return (1);
}
#if 0
/*
test if we need to check the tag associated with the ptpe entry p
*/
legal_tag(p)
ptpe *p;
{
int ret;
switch (p->pe_type) {
case SCTRL:
case CH_ACT:
case ANY:
case OBJECT:
case CHOICE_START:
case CONS_ANY:
/* case ETAG: don't think we should have this here */
ret = 0;
break;
default:
#if 0
if (skip_next_tag) {
skip_next_tag = 0;
ret = 0;
}
else
#endif
ret = 1;
break;
}
return ret;
}
#endif
/*
* Parse a single type for explicit tag
* If a basic type parse it, if a compound type call the appropriate
* parsing routine
*/
PE
p_pr_etype(pe, p, mod)
PE pe;
ptpe *p;
modtyp *mod; /* Module it is from */
{
int intval, len, i;
char *ptr;
struct qbuf *qptr;
PE pe_ptr;
OID oid;
switch (p->pe_type) {
case PE_END:
case PE_START:
return (NULLPE);
case UCODE:
if ((*mod->md_ducode)(pe, p, mod) != OK)
return (NULLPE);
break;
case ETAG:
switch (p->pe_ucode) {
default:
p++;
if (p_pr_etype(pe->pe_cons, p, mod) == NULLPE)
return (NULLPE);
}
break;
case SEQ_START:
if ((pe = (PE) p_pr_seq(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEQOF_START:
if ((pe = (PE) p_pr_seqof(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SET_START:
if ((pe = (PE) p_pr_set(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SETOF_START:
if ((pe = (PE) p_pr_setof(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case IMP_OBJ:
p++;
if (p->pe_type == EXTOBJ) {
printname(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
(char **) 0);
} else {
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(0, pe,
mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE)
return (NULLPE);
}
break;
case SOBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe,
mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE)
return (NULLPE);
break;
case OBJECT:
printname(p->pe_typename, xlevel);
if ((pe = (PE) p_pr_obj(1, pe,
mod->md_ptab[p->pe_tag] + 1, mod)) == NULLPE)
return (NULLPE);
break;
case CHOICE_START:
if ((pe = (PE) p_pr_choice(pe, p, mod)) == NULLPE)
return (NULLPE);
break;
case SEXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_etype: missing EXTMOD", p, mod);
ferr(1, "p_pr_etype:internal error\n");
}
printname(p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
(char *) 0);
break;
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_pr_etype: missing EXTMOD", p, mod);
ferr(1, "p_pr_etype:internal error\n");
}
printname (p->pe_typename, xlevel);
prnt_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
(char *) 0);
break;
case INTEGER:
if (pe != NULLPE) {
if ((intval = prim2num(pe)) == NOTOK && pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %d (ETAG INTEGER)\n", (p->pe_typename) ? p->pe_typename : "", intval);
else
(*vfnx) (vfp, "%s %d \n", (p->pe_typename) ? p->pe_typename : "", intval);
}
}
break;
case BOOLEAN:
if (pe != NULLPE) {
if ((intval = prim2flag(pe)) == NOTOK && pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (ETAG BOOLEAN)\n", (p->pe_typename) ? p->pe_typename : "", (intval) ? "TRUE" : "FALSE");
else
(*vfnx) (vfp, "%s %s \n", (p->pe_typename) ? p->pe_typename : "", (intval) ? "TRUE" : "FALSE");
}
}
break;
case T_NULL:
break;
case ANY:
case CONS_ANY:
if (pe != NULLPE) {
if (pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else
pr_pe_element(pe, p);
}
break;
case SANY:
case SCONS_ANY:
/* This could require changes when I find out what the CONS_ANY type
* is really for
*/
if (pe != NULLPE) {
if (pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad integer %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else
pr_pe_element(pe, p);
}
break;
case SOCTETSTRING:
if (pe != NULLPE) {
if ((((struct qbuf *) qptr)
= prim2qb(pe)) == (struct qbuf *) NULL
&& pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad octet string %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s \"%s\" (OCTETSTRING)\n", (p->pe_typename) ? p->pe_typename : "", qb2str(qptr));
else
(*vfnx) (vfp, "%s \"%s\"\n", (p->pe_typename) ? p->pe_typename : "", qb2str(qptr));
}
}
break;
case OCTETSTRING:
if (pe != NULLPE) {
if ((((struct qbuf *) qptr)
= prim2qb(pe)) == (struct qbuf *) NULL
&& pe->pe_errno != PE_ERR_NONE) {
ferr (1, "p_pr_etype:bad octet string %s",
pe_error(pe->pe_errno));
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s \"%s\" (OCTETSTRING)\n", (p->pe_typename) ? p->pe_typename : "", qb2str(qptr));
else
(*vfnx) (vfp, "%s \"%s\"\n", (p->pe_typename) ? p->pe_typename : "", qb2str(qptr));
}
}
break;
case SBITSTRING:
if (pe != NULLPE) {
if (((PE) pe_ptr = pe_cpy(pe)) == NULLPE) {
ferr (1, "p_pr_etype:out of memory");
return (NULLPE);
} else
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
ptr = bitstr2strb((PE) pe_ptr, &len);
for (i=0; i < len; i+=8)
(*vfnx) (vfp, "%.2x ", *ptr++ & 0xff);
(*vfnx) (vfp, "'H\n");
if (_pverbose) {
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
for (i=0; i < len; i++) {
(*vfnx) (vfp, "%d", bit_test((PE) pe_ptr, i));
if ((i+1) % 4 == 0)
(*vfnx) (vfp, " ");
}
(*vfnx) (vfp, "'B (BITSTRING)\n");
}
}
break;
case BITSTRING:
if (pe != NULLPE) {
if (((PE) pe_ptr = pe_cpy(pe)) == NULLPE) {
ferr (1, "p_pr_etype:out of memory");
return (NULLPE);
} else
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
ptr = bitstr2strb((PE) pe_ptr, &len);
for (i=0; i < len; i+=8)
(*vfnx) (vfp, "%.2x ", *ptr++ & 0xff);
(*vfnx) (vfp, "'H\n");
if (_pverbose) {
indent();
(*vfnx) (vfp, "%s '", (p->pe_typename) ? p->pe_typename : "");
for (i=0; i < len; i++) {
(*vfnx) (vfp, "%d", bit_test((PE) pe_ptr, i));
if ((i+1) % 4 == 0)
(*vfnx) (vfp, " ");
}
(*vfnx) (vfp, "'B (BITSTRING)\n");
}
}
break;
case SOBJID:
if (((OID) oid = prim2oid(pe)) == NULLOID) {
ferr (1, "p_pr_etype:Object Identifier: out of memory");
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (SOBJECT ID)\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
else
(*vfnx) (vfp, "%s %s\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
}
break;
case OBJID:
if (((OID) oid = prim2oid(pe)) == NULLOID) {
ferr (1, "en_etype:Object Identifier: out of memory");
return (NULLPE);
} else {
indent();
if (_pverbose)
(*vfnx) (vfp, "%s %s (OBJECT ID)\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
else
(*vfnx) (vfp, "%s %s\n", (p->pe_typename) ? p->pe_typename : "", (char *) sprintoid(oid));
}
break;
default:
ferrd(1, "p_pr_etype: %d not implemented\n", p->pe_type);
break;
}
return (pe);
}
/*
* determine what the class and tag must be of the given object
*/
p_findcltag(p, mod, pcl, ptag)
ptpe *p;
modtyp *mod; /* Module it is from */
int *pcl, *ptag;
{
if (!ISDTYPE(p))
return (0);
if (p->pe_type != OBJECT) {
*pcl = CLASS(p);
*ptag = TAG(p);
return (1);
}
p = mod->md_ptab[p->pe_tag] + 1;
while (p->pe_type != PE_END) {
if (ISDTYPE(p))
return (p_findcltag(p, mod, pcl, ptag));
}
dmp_ptpe("p_findcltag:warning:object with no data in it", p, mod);
return (0);
}
/*
* Is there a match at for this tag and class pair. Return 1 if yes 0 if no
* We will search through contained objects and through choices
*/
p_ismatch(p, mod, cl, tag)
ptpe *p;
modtyp *mod; /* Module it is from */
unsigned int cl, tag;
{
if (!ISDTYPE(p))
return (0);
switch (p->pe_type) {
case SOBJECT:
case OBJECT:
/* Needs to be changed for optional and default */
return (p_ismatch(p = mod->md_ptab[p->pe_tag] + 1, mod, cl, tag));
case SEXTOBJ:
case EXTOBJ:
if (p[1].pe_type != EXTMOD) {
dmp_ptpe("p_ismatch: missing EXTMOD", p, mod);
ferr(1, "p_ismatch:internal error\n");
}
return(p_ismatch(((modtyp *)p[1].pe_ucode)->md_ptab[p->pe_tag] + 1,
(modtyp *)p[1].pe_ucode, cl, tag));
case CHOICE_START:
for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) {
if (!ISDTYPE(p))
continue;
if (p_ismatch(p, mod, cl, tag))
return (1);
}
return (0);
default:
return (tag == TAG(p) && cl == CLASS(p));
}
/*NOTREACHED*/
/* return (0); */
}
/*
* determine if the given field is present in the data
* This is simple if the field is a simple type with an obvious tag but
* in the case of an object or a CHOICE type the tag is not obvious. If the
* object is a CHOICE there are more than one possible tag that could match
* and in this case we must try to match each one of them.
*/
PE
p_setpresent(head, p, mod)
PE head;
ptpe *p;
modtyp *mod;
{
PE pe;
if (!ISDTYPE(p))
return (NULLPE);
switch (p->pe_type) {
case OBJECT:
case SOBJECT:
{
/* Needs to be changed for optional and default */
return (p_setpresent(head, p = mod->md_ptab[p->pe_tag] + 1, mod));
}
case CHOICE_START:
for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) {
if (!ISDTYPE(p))
continue;
if ((pe = (PE) p_setpresent(head, p, mod)))
return (pe);
}
return (NULLPE);
default:
return (set_find(head, CLASS(p), TAG(p)));
}
}
/*
* set the default value to that value in the structure
*/
setpval(typ, dflt, mod)
ptpe *typ, *dflt;
modtyp *mod;
{
int len, i, intval;
char *ptr, charval;
PE pe_ptr;
struct qbuf *qptr;
again:
switch (typ->pe_type) {
case INTEGER:
intval = IVAL(dflt);
indent();
(*vfnx) (vfp, "%d (DEFAULT INTEGER)\n", intval);
break;
case BOOLEAN:
intval = IVAL(dflt);
indent();
/* (*vfnx) (vfp, "%s %d (DEFAULT BOOLEAN)\n", (typ->pe_typename) ? typ->pe_typename : "", charval); */
(*vfnx) (vfp, "%d (DEFAULT BOOLEAN)\n", intval);
break;
case T_NULL:
/* Only one value */
break;
case SBITSTRING:
(PE) pe_ptr = strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0);
break;
case BITSTRING:
(PE) pe_ptr =
strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0);
indent();
(*vfnx) (vfp, " '");
ptr = bitstr2strb((PE) pe_ptr, &len);
for (i=0; i < len; i+=8)
(*vfnx) (vfp, "%.2x", *ptr++);
(*vfnx) (vfp, "'H (DEFAULT BITSTRING)\n");
if (_pverbose) {
indent();
(*vfnx) (vfp, " '");
for (i=0; i < len; i++) {
(*vfnx) (vfp, "%d", bit_test((PE) pe_ptr, i));
if ((i+1) % 4 == 0)
(*vfnx) (vfp, " ");
}
(*vfnx) (vfp, "'B (DEFAULT BITSTRING)\n");
}
break;
case SOCTETSTRING:
/* (struct qbuf *) qptr = str2qb(PVAL(dflt), IVAL(dflt), 1);
break; */
case OCTETSTRING:
(struct qbuf *) (qptr) =
str2qb(PVAL(dflt), IVAL(dflt), 1);
if (_pverbose)
(*vfnx) (vfp, "\"%s\" (DEFAULT OCTETSTRING)\n", qb2str((struct qbuf *) qptr));
else
(*vfnx) (vfp, "\"%s\" (DEFAULT OCTETSTRING)\n", qb2str((struct qbuf *) qptr));
break;
case OBJECT:
setpval(mod->md_ptab[typ->pe_tag] + 1, dflt, mod);
break;
case SOBJECT:
setpval(mod->md_ptab[typ->pe_tag] + 1, dflt, mod);
break;
case IMP_OBJ:
typ++;
case SCONS_ANY:
case ANY:
case CONS_ANY:
case SANY:
case SEXTOBJ:
case EXTOBJ:
case OBJID:
case SOBJID:
case SEQ_START:
case SET_START:
case -1: /* Just use the pepy method of null pointers */
/* This is the posy/pepy hack way of doing things at the moment */
(char *) ptr = NULL;
break;
default:
/* dmp_tpe("setpval: type not implemented", typ, mod); - need mod*/
ferrd(1, "setpval: %d not implemented\n", typ->pe_type);
break;
}
}
xpush(string)
char *string;
{
if (string && *string) {
printname(string);
tabed = 0;
xlevel++;
xpushed++;
(*vfnx) (vfp, "{\n");
} else
xpushed++;
}
xpull()
{
int i;
if (xpushed == xlevel) {
xlevel--;
xpushed--;
for (i = xlevel; i > 0; i--)
(*vfnx) (vfp, " ");
(*vfnx) (vfp, "}\n");
} else
xpushed--;
}
char *
printable(strptr)
char *strptr;
{
char *ptr;
if (strptr == NULL) {
ferr(1, "NULL String pointer\n");
return(NULL);
}
if (*strptr == NULL)
return(NULL);
for (ptr=strptr; *ptr; ptr++) {
if (isprint(*ptr))
continue;
else
return(NULL);
}
return(strptr);
}
pr_pe_element(pe_ptr, p)
PE pe_ptr;
ptpe *p;
{
int i = 0;
char *ptr, *class;
PE p1;
switch (pe_ptr->pe_class) {
case PE_CLASS_UNIV:
class = "UNIVERSAL";
break;
case PE_CLASS_APPL:
class = "APPLICATION";
break;
case PE_CLASS_CONT:
class = "CONTEXT";
break;
case PE_CLASS_PRIV:
class = "PRIVATE";
break;
default:
class = "UNDEFINED CLASS";
break;
}
if (pe_ptr->pe_form == PE_FORM_CONS) {
indent();
if (p->pe_typename && *p->pe_typename)
(*vfnx) (vfp, "%s {\n", p->pe_typename);
else
if (pe_ptr->pe_class == PE_CLASS_CONT)
(*vfnx) (vfp, " [%d] {\n", pe_ptr->pe_id);
else
(*vfnx) (vfp, " [%s %d] {\n", class, pe_ptr->pe_id);
xlevel++;
for (p1 = pe_ptr->pe_un1.un_pe_cons; p1; p1 = p1->pe_next) {
p->pe_typename = "";
pr_pe_element(p1, p);
}
xlevel--;
indent();
(*vfnx) (vfp, " }\n");
} else {
indent();
if (ptr = printable(pe_ptr->pe_un1.un_pe_prim))
(*vfnx) (vfp, "%s [%s %d] \"%s\"\n", (p->pe_typename) ? p->pe_typename : "", class, pe_ptr->pe_id, (*ptr) ? ptr : "");
else {
(*vfnx) (vfp, "%s [%s %d] '", (p->pe_typename) ? p->pe_typename : "", class, pe_ptr->pe_id);
if (pe_ptr->pe_un1.un_pe_prim) {
for (ptr= (char *) pe_ptr->pe_un1.un_pe_prim; i < pe_ptr->pe_len; ptr++, i++)
(*vfnx) (vfp, "%.2x", *ptr & 0xff);
}
(*vfnx) (vfp, "'H \n");
}
}
}
printname(string)
char *string;
{
int i;
tabed = 1;
for (i = xlevel; i > 0; i--)
(*vfnx) (vfp, " ");
if (string && *string)
(*vfnx) (vfp, "%s ", string);
}
indent()
{
int i;
if (tabed) {
tabed = 0;
return;
}
for (i = xlevel; i > 0; i--)
(*vfnx) (vfp, " ");
}