BSD 4_3_Net_2 development
authorCSRG <csrg@ucbvax.Berkeley.EDU>
Fri, 22 Feb 1991 03:04:13 +0000 (19:04 -0800)
committerCSRG <csrg@ucbvax.Berkeley.EDU>
Fri, 22 Feb 1991 03:04:13 +0000 (19:04 -0800)
Work on file usr/src/contrib/isode/pepsy/Makefile
Work on file usr/src/contrib/isode/pepsy/dec.c
Work on file usr/src/contrib/isode/pepsy/dtabs.c
Work on file usr/src/contrib/isode/pepsy/enc.c
Work on file usr/src/contrib/isode/pepsy/etabs.c
Work on file usr/src/contrib/isode/pepsy/lex.l.gnrc
Work on file usr/src/contrib/isode/pepsy/main.c
Work on file usr/src/contrib/isode/pepsy/pass2.c
Work on file usr/src/contrib/isode/pepsy/pep.output
Work on file usr/src/contrib/isode/pepsy/pepsy.c
Work on file usr/src/contrib/isode/pepsy/pepsydefs.h.gnrc
Work on file usr/src/contrib/isode/pepsy/pepsy_misc.c
Work on file usr/src/contrib/isode/pepsy/prnt.c
Work on file usr/src/contrib/isode/pepsy/ptabs.c
Work on file usr/src/contrib/isode/pepsy/t1.py
Work on file usr/src/contrib/isode/pepsy/t3.py
Work on file usr/src/contrib/isode/pepsy/test_table.h
Work on file usr/src/contrib/isode/pepsy/vprint.c
Work on file usr/src/contrib/isode/pepsy/util.c
Work on file usr/src/contrib/isode/pepsy/yacc.y.gnrc

Synthesized-from: CSRG/cd2/net.2

20 files changed:
usr/src/contrib/isode/pepsy/Makefile [new file with mode: 0644]
usr/src/contrib/isode/pepsy/dec.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/dtabs.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/enc.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/etabs.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/lex.l.gnrc [new file with mode: 0644]
usr/src/contrib/isode/pepsy/main.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/pass2.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/pep.output [new file with mode: 0644]
usr/src/contrib/isode/pepsy/pepsy.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/pepsy_misc.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/pepsydefs.h.gnrc [new file with mode: 0644]
usr/src/contrib/isode/pepsy/prnt.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/ptabs.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/t1.py [new file with mode: 0644]
usr/src/contrib/isode/pepsy/t3.py [new file with mode: 0644]
usr/src/contrib/isode/pepsy/test_table.h [new file with mode: 0644]
usr/src/contrib/isode/pepsy/util.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/vprint.c [new file with mode: 0644]
usr/src/contrib/isode/pepsy/yacc.y.gnrc [new file with mode: 0644]

diff --git a/usr/src/contrib/isode/pepsy/Makefile b/usr/src/contrib/isode/pepsy/Makefile
new file mode 100644 (file)
index 0000000..c94bfd0
--- /dev/null
@@ -0,0 +1,366 @@
+###############################################################################
+#   Instructions to Make, for compilation of ISODE PEPSY process
+###############################################################################
+
+###############################################################################
+#
+# $Header: /f/osi/pepsy/RCS/Makefile,v 7.12 91/02/22 09:48:38 mrose Interim $
+#
+#
+# $Log:        Makefile,v $
+# Revision 7.12  91/02/22  09:48:38  mrose
+# Interim 6.8
+# 
+# Revision 7.11  91/01/09  13:51:43  mrose
+# foo
+# 
+# Revision 7.10  91/01/08  12:49:17  mrose
+# update
+# 
+# Revision 7.9  90/12/23  18:42:01  mrose
+# update
+# 
+# Revision 7.8  90/12/11  10:33:05  mrose
+# sync
+# 
+# Revision 7.7  90/11/20  15:27:02  mrose
+# update
+# 
+# Revision 7.6  90/11/11  10:53:31  mrose
+# update
+# 
+# Revision 7.5  90/11/04  19:17:04  mrose
+# update
+# 
+# Revision 7.4  90/09/07  17:34:18  mrose
+# touch-up
+# 
+# Revision 7.3  90/08/08  14:14:12  mrose
+# update
+# 
+# Revision 7.2  90/07/27  08:49:06  mrose
+# update
+# 
+# Revision 7.1  90/07/09  14:52:16  mrose
+# sync
+# 
+# Revision 7.0  90/07/01  19:54:10  mrose
+# *** empty log message ***
+# 
+###############################################################################
+
+###############################################################################
+#
+#                               NOTICE
+#
+#    Acquisition, use, and distribution of this module and related
+#    materials are subject to the restrictions of a license agreement.
+#    Consult the Preface in the User's Manual for the full terms of
+#    this agreement.
+#
+###############################################################################
+
+
+PEPYPATH=      -DPEPYPATH -DPEPSYPATH=\".:$(PEPSYDIRM)\" 
+
+# to prevent a lot of unnecessary re-loading
+PEPSYLIBES=    $(TOPDIR)psap/sprintoid.o $(TOPDIR)psap/pl_tables.o \
+               $(TOPDIR)psap/oid_cmp.o $(TOPDIR)psap/oid_cpy.o \
+               $(TOPDIR)psap/oid_free.o \
+               $(TOPDIR)compat/asprintf.o $(TOPDIR)compat/serror.o \
+               $(TOPDIR)compat/sprintb.o
+LIBES   =      $(TOPDIR)libpsap.a $(TOPDIR)libcompat.a
+LLIBS   =      $(TOPDIR)llib-lpsap $(TOPDIR)llib-lcompat
+HFILES =       $(HDIR)psap.h \
+               $(HDIR)manifest.h $(HDIR)general.h $(HDIR)config.h
+
+DRFILES        =       enc.o dec.o fre.o prnt.o util.o
+SUPFILES=      vprint.o UNIV_tables.o pepsy_strings.o py_advise.o
+LIBFILES=      $(DRFILES) $(SUPFILES)
+
+CFILES =       enc.c dec.c fre.c prnt.c main.c util.c  \
+               vprint.c pepsy_strings.c py_advise.c
+
+HFILES =       $(TOPDIR)h/pepsy.h test_table.h
+HEADERS        =       UNIV.ph UNIV-types.h UNIV_defs.h UNIV_pre_defs.h
+
+OFILES =       $(LIBFILES) main.o
+
+T_FILES =      T1_tables.c T2_tables.c T3_tables.c
+
+
+##################################################################
+# Here it is...
+##################################################################
+
+all:           pepsy libpepsy # peptest
+inst-all:      inst-pepsy inst-headers manuals # inst-libpepsy
+install:       inst-all clean
+lint:          l-pepsy l-libpepsy
+
+
+##################################################################
+# pepsy
+##################################################################
+
+inst-pepsy:    $(BINDIR)pepsy
+
+$(BINDIR)pepsy:        xpepsy
+               -cp $@ zxpepsy
+               -rm -f $@
+               cp xpepsy $@
+               -@ls -gls $@
+               -@echo ""
+
+pepsy:         xpepsy
+
+xpepsy:                pepsyvrsn.o $(PEPSYLIBES)
+               $(LDCC) $(LDFLAGS) -o $@ pepsy.o pepsy-yacc.o pepsy_misc.o \
+                       pass2.o etabs.o dtabs.o ptabs.o dfns.o mod.o \
+                       pepsyvrsn.o $(PEPSYLIBES) $(LSOCKET) -lm
+
+pepsy.o:       pepsy.c pepsydefs.h $(HFILES)
+               $(CC) $(CFLAGS) -c pepsy.c
+
+pepsyvrsn.c:   pepsy.o pepsy-yacc.o pepsy_misc.o pass2.o \
+                       etabs.o dtabs.o ptabs.o dfns.o mod.o 
+               $(UTILDIR)version.sh pepsy > $@
+
+pepsy-yacc.o:  pepsy-yacc.c lex.c
+               $(CC) $(CFLAGS) -c pepsy-yacc.c
+
+pepsy-yacc.c:  pepsy-yacc.y
+               -@echo "expect 40 shift/reduce and 11 reduce/reduce conflicts"
+               yacc $(YACCFLAGS) pepsy-yacc.y
+               mv y.tab.c $@
+
+pepsy-yacc.y:  yacc.y.gnrc
+               $(UTILDIR)extract.sh PEPSY SCTRL < $? > $@
+
+pepsy_misc.o:  pepsy_misc.c pepsydefs.h
+               $(CC) $(CFLAGS) -c pepsy_misc.c
+
+lex.c:         lex.l
+               $(LEX) $(LEXFLAGS) lex.l
+               mv lex.yy.c $@
+
+lex.l:         lex.l.gnrc
+               $(UTILDIR)extract.sh PEPSY < $? > $@
+
+pepsydefs.h:   pepsydefs.h.gnrc
+               $(UTILDIR)extract.sh PEPSY < $? > $@
+
+pass2.o:       pass2.c
+               $(CC) $(CFLAGS) -c pass2.c
+etabs.o:       etabs.c
+               $(CC) $(CFLAGS) -c etabs.c
+dtabs.o:       dtabs.c
+               $(CC) $(CFLAGS) -c dtabs.c
+ptabs.o:       ptabs.c
+               $(CC) $(CFLAGS) -c ptabs.c
+dfns.o:                dfns.c
+               $(CC) $(CFLAGS) -c dfns.c
+mod.o:         mod.c
+               $(CC) $(CFLAGS) -c mod.c
+
+
+l-pepsy:       pepsy.c pepsy_misc.c pepsydefs.h pepsyvrsn.c true
+               $(LINT) $(LFLAGS) -DPEPSYPATH=\".:$(PEPSYDIRM)\" pepsy.c \
+                       pepsy_misc.c  pepsyvrsn.c $(LLIBS) \
+                       | grep -v "warning: possible pointer alignment problem"
+
+
+################################################################
+# libpepsy
+################################################################
+
+inst-libpepsy: $(LIBDIR)libpepsy.a inst-headers
+
+libpepsy:      libpepsy.a true
+               -@rm -f $(TOPDIR)h/UNIV*.h
+               -@$(LN) UNIV-types.h $(TOPDIR)h/UNIV-types.h
+               -@$(LN) UNIV_defs.h $(TOPDIR)h/UNIV_defs.h
+               -@$(LN) UNIV_pre_defs.h $(TOPDIR)h/UNIV_pre_defs.h
+
+libpepsy.a:     $(LIBFILES)
+               -rm -f $@
+               @$(UTILDIR)make-lib.sh $(SYSTEM) $(ARFLAGS) $@ $(LIBFILES)
+               -@rm -f $(TOPDIR)libpepsy.a
+               -@$(LN) libpepsy.a $(TOPDIR)libpepsy.a
+               -@ls -l $@
+               -@echo "PEPSY library built normally"
+
+inst-headers:; -mkdir $(PEPSYDIRM)
+               @for h in $(HEADERS); do $(MAKE) TARGET=$$h inst-target; done
+
+inst-target:   $(PEPSYDIR)$(TARGET)
+
+$(PEPSYDIR)$(TARGET):  $(TARGET)
+               -cp $@ z$(TARGET)
+               cp $(TARGET) $@
+               -@ls -gls $@
+               -@echo ""
+
+UNIV_tables.o: UNIV_tables.c UNIV-types.h
+
+UNIV-types.h UNIV_tables.c: UNIV.py xpepsy
+               ./xpepsy -A -f -h -m UNIV.py
+
+l-libpepsy:    $(CFILES) $(T_FILES) true
+               $(LINT) $(LFLAGS) $(CFILES) $(T_FILES) \
+                       $(LLIBS) \
+                       | grep -v "warning: possible pointer alignment problem"
+
+vprint.o:      UNIV-types.h $(HDIR)psap.h $(HDIR)general.h $(HDIR)manifest.h \
+               $(HDIR)logger.h
+
+
+##################################################################
+# pep
+##################################################################
+alltests:      tabletest peptest
+
+peptest:       pep.results pep.output
+               -diff pep.output pep.results
+               touch peptest
+
+pep.results:   pep
+               ./pep > pep.results
+
+tabletest:     xpepsy t1test t2test t3test psap2test acsaptest ftamtest 
+
+psap2test:     ../psap2/PS_tables.c ../psap2/PS-types.h
+       ./xpepsy -A -f -h -m ../psap2/ps.py
+       -diff ../psap2/PS_tables.c . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff ../psap2/PS-types.h . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -rm -f PS_tables.c PS-types.h 
+
+acsaptest:     ../acsap/ACS_tables.c ../acsap/ACS-types.h
+       ./xpepsy -A -f -h -m ../acsap/acs.py
+       -diff ../acsap/ACS_tables.c . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff ../acsap/ACS-types.h . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -rm -f ACS_tables.c ACS-types.h 
+
+ftamtest:      ../ftam/FTAM_tables.c ../ftam/FTAM-types.h
+       ./xpepsy -A -f -h -m ../ftam/ftam.py
+       -diff ../ftam/FTAM_tables.c . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff ../ftam/FTAM-types.h . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -rm -f FTAM_tables.c FTAM-types.h 
+
+fadutest:      ../ftam/FADU_tables.c ../ftam/FADU-types.h
+       ./xpepsy -A -f -h -m ../ftam/fadu.py
+       -diff ../ftam/FADU_tables.c . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff ../ftam/FADU-types.h . | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -rm -f FADU_tables.c FADU-types.h 
+
+t1test:        T1_tables.c T1-types.h
+       mv T1_tables.c T1_tables.c_orig
+       mv T1-types.h T1-types.h_orig
+       ./xpepsy -A -f -m t1.py
+       -diff T1_tables.c_orig T1_tables.c | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff T1-types.h_orig T1-types.h | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+
+t2test:        T2_tables.c T2-types.h
+       mv T2_tables.c T2_tables.c_orig
+       mv T2-types.h T2-types.h_orig
+       ./xpepsy -A -f -m t2.py
+       -diff T2_tables.c_orig T2_tables.c | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff T2-types.h_orig T2-types.h | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+
+t3test:        T3_tables.c T3-types.h
+       mv T3_tables.c T3_tables.c_orig
+       mv T3-types.h T3-types.h_orig
+       ./xpepsy -A -f -m -i pepsy-refs.h t3.py
+       -diff T3_tables.c_orig T3_tables.c | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+       -diff T3-types.h_orig T3-types.h | grep -v "^[><] # line" \
+               | grep -v "do not edit"
+
+PEPLIBS        =       ../libpsap.a ../libcompat.a
+PEPFILES=      T1_tables.o T2_tables.o T3_tables.o $(OFILES) $(PEPLIBS) # malloctrace.a
+
+pep:           $(PEPFILES)
+               #$(LDCC) $(LDFLAGS) -o pep $(PEPFILES) malloctrace.a $(LSOCKET)
+               $(LDCC) $(LDFLAGS) -o pep $(PEPFILES) $(LSOCKET) -lm
+
+pep-saber:     $(PEPFILES)
+               #load $(CFLAGS) (PEPFILES)
+
+main.o:        T1-types.h test_table.h main.c
+               $(CC) $(CFLAGS) -DPRNT=1 -c main.c
+
+enc.o:         enc.c pepsy-driver.h
+               $(CC) $(LIBCFLAGS) -c enc.c
+
+dec.o:         dec.c pepsy-driver.h
+               $(CC) $(LIBCFLAGS) -c dec.c
+
+prnt.o:        prnt.c pepsy-driver.h
+               $(CC) $(LIBCFLAGS) -c prnt.c
+
+util.o:        util.c pepsy-driver.h
+               $(CC) $(LIBCFLAGS) -c util.c
+
+T1_tables.o:   T1_tables.c T1-types.h UNIV-types.h
+
+T1_tables.c T1-types.h:        t1.py xpepsy
+               ./xpepsy -A -f -m t1.py
+
+T1_tables.c:   T2-types.h T3-types.h
+
+T2_tables.o:   T2_tables.c T2-types.h UNIV-types.h
+
+T2_tables.c T2-types.h:        t2.py xpepsy
+               ./xpepsy -A -f -m t2.py
+
+T3_tables.o:   T3_tables.c T3-types.h UNIV-types.h
+
+T3_tables.c T3-types.h:        t3.py xpepsy
+               ./xpepsy -A -f -m -i pepy-refs.h t3.py
+
+prt.o:         prnt.c $(TOPDIR)h/pepsy.h
+               $(CC) $(CFLAGS) -Dprintf=vprint -o $@ prnt.c
+
+
+################################################################
+# manual pages
+################################################################
+
+MANUALS        =       pepsy.1 # libpepsy.3
+
+manuals:;      @$(UTILDIR)inst-man.sh $(MANOPTS) $(MANUALS)
+               -@echo ""
+
+
+################################################################
+# clean
+################################################################
+
+clean:;                rm -f *.o *.a x* z* _* core pepsydefs.h *yacc.y *yacc.c lex.l \
+                       lex.c *.ph UNIV_* UNIV-* _* core $(TOPDIR)h/UNIV*.h \
+                       pp.c pp pep libpepsy.a pepsy-yacc.y T1* T2* T3* t? \
+                       peptest pep.results
+
+grind:;                iprint Makefile
+               tgrind -lc pepsydefs.h pepsy.c pepsy.c pepsyvrsn.c
+               tgrind -ly yacc.y lex.l
+               tgrind -lpepsy -d $(TOPDIR)pepy/grindefs UNIV.py
+               tgrind -lc $(CFILES)
+               @echo $(MANUALS) | \
+                       tr " " "\012" | \
+                       sed -e "s%.*%itroff -man &%" | \
+                       sh -ve
+
+true:;
diff --git a/usr/src/contrib/isode/pepsy/dec.c b/usr/src/contrib/isode/pepsy/dec.c
new file mode 100644 (file)
index 0000000..05fbdd0
--- /dev/null
@@ -0,0 +1,2159 @@
+/* dec.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/dec.c,v 7.12 91/02/22 09:48:41 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/dec.c,v 7.12 91/02/22 09:48:41 mrose Interim $
+ *
+ *
+ * $Log:       dec.c,v $
+ * Revision 7.12  91/02/22  09:48:41  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.11  90/12/23  17:24:17  mrose
+ * patches
+ * 
+ * Revision 7.10  90/12/11  10:33:08  mrose
+ * sync
+ * 
+ * Revision 7.9  90/11/20  15:27:05  mrose
+ * update
+ * 
+ * Revision 7.8  90/11/11  10:53:33  mrose
+ * update
+ * 
+ * Revision 7.7  90/11/04  19:18:12  mrose
+ * update
+ * 
+ * Revision 7.6  90/10/23  20:42:52  mrose
+ * update
+ * 
+ * Revision 7.5  90/10/17  14:39:26  mrose
+ * update
+ * 
+ * Revision 7.4  90/08/18  00:44:05  mrose
+ * touch-up
+ * 
+ * Revision 7.3  90/08/08  14:14:13  mrose
+ * update
+ * 
+ * Revision 7.2  90/07/27  08:48:54  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:52:18  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:13  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/* LINTLIBRARY */
+
+#include       <stdio.h>
+#include       "pepsy-driver.h"
+#include       "psap.h"
+#include       "pepsy.h"
+#include       "tailor.h"
+
+extern int pepsylose ();
+
+extern tpe *next_tpe(), *fdflt_b();
+
+#define NEXT_TPE(p)    (p = next_tpe(p))
+#define CHKTAG(mod, p, pe)     ismatch(p, mod, pe->pe_class, pe->pe_id)
+
+
+static char oomsg[] = "Out of memory";
+#define oom(a,b)       pepsylose ((a), (b), NULLPE, oomsg)
+
+static char inpmsg[] = "Illegal Null Pointer";
+#define inpm(a,b)      pepsylose ((a), (b), NULLPE, inpmsg)
+
+static PE setpresent();
+
+#define F_CI 0x100     /* called internally */
+
+/* Have we got an optional object which we have allocated space for */
+#define ALLOC_MEM(p, parm)     (p->pe_type == SOBJECT \
+       && p[-1].pe_type == MEMALLOC)
+
+/*
+ * decode the specified type of the specified module into the given
+ * pe
+ */
+dec_f(typ, mod, pe, explicit, len, buf, parm)
+/* ARGSUSED */
+int     typ;                   /* which type it is */
+modtyp *mod;                   /* Module it is from */
+PE      pe;
+int    explicit;
+int    *len;
+char   **buf;
+char   **parm;
+{
+    tpe    *p;
+    int            iflag;      /* are we called internally ? */
+
+    if (typ < 0 || typ >= mod->md_nentries) {
+       return (pepsylose (mod, NULLTPE, NULLPE, "dec_f: Illegal typ %d", typ));
+    }
+
+    p = mod->md_dtab[typ];
+    if (p->pe_type != PE_START) {
+       return (pepsylose (mod, NULLTPE, NULLPE, "dec_f: missing PE_START"));
+    }
+    p++;
+    iflag = explicit & F_CI;
+    explicit &= ~F_CI;
+    if (!iflag)
+       *parm = NULLCP; /* initialise this for the MALLOCs that follow */
+
+    if (pr_obj(explicit, pe, parm, p, mod) == NOTOK)
+       goto bad;
+
+    return (OK);
+bad:
+    return (NOTOK);
+}
+
+/*
+ * 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.
+ */
+static int
+pr_obj(expl, pe, parm, p, mod)
+int     expl;                  /* do we look at the tag */
+PE      pe;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    int     cnt = 0;
+
+
+    DLOG (psap_log, LLOG_DEBUG, ("1st Decoding the type %d", p->pe_type));
+
+    while (p->pe_type != PE_END) {
+
+       if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
+           if (DEFAULT(p)) 
+               return pepsylose (mod, p, pe,
+                                 "pr_obj:Default not implemented");
+           else if (OPTIONAL(p)) {
+               if (ALLOC_MEM(p, parm))
+                   fix_mem(parm, p);
+               goto next;
+           } else
+               return pepsylose (mod, p, pe, "pr_obj:missing mandatory parameter");
+       }
+       DLOG (psap_log, LLOG_DEBUG, ("2nd Decoding the type %d", p->pe_type));
+
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           return pepsylose (mod, p, pe, "pr_obj:illegal END/START");
+
+       /*
+        * This allows Functions to be called at the very end of the 
+        * decoding -- With the decoded data - I hope - very messy
+        */
+       case UCODE:
+           if (mod->md_ducode == NULLIFP
+           || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+               goto bad;
+           break;
+
+
+       default:
+           if (pr_type(expl, pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+       if (ISDTYPE(p) && cnt > 0)
+           return pepsylose (mod, p, NULLPE, "pr_obj:compound type found");
+next:
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a single type. If a basic type parse it, if a compound type
+ * call the appropriate parsing routine
+ */
+static int
+pr_type(expl, pe, parm, p, mod)
+int     expl;                  /* do we look at the tag */
+PE      pe;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    int        cnt = 0;
+    int len;
+    OID     oid;
+    char    *nparm;
+    /* there is no such pointer as &(*parm + p->pe_ucode) (ucode non zero) so
+     * we fudge it by making a temporary one. As no memory needs to be
+     * allocated through it this should work
+     */
+
+
+    DLOG (psap_log, LLOG_DEBUG, ("pr_type:type %d", p->pe_type));
+
+    while (p->pe_type != PE_END) {
+
+       if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
+           if (DEFAULT(p)) {
+               if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
+                   goto bad;
+               return (NO_DATA_USED);
+           } else if (OPTIONAL(p)) {
+               if (ALLOC_MEM(p, parm))
+                   fix_mem(parm, p);
+               return (NO_DATA_USED);
+           } else
+               return pepsylose (mod, p, pe,
+                                 "pr_type:missing mandatory parameter");
+       }
+       DLOG (psap_log, LLOG_DEBUG, ("pr_type: type %d", p->pe_type));
+
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           return pepsylose (mod, p, pe, "pr_type:illegal END/START");
+
+       case BOPTIONAL:
+           if (CHKTAG(mod, p + 1, pe) == 0) {
+               if (ALLOC_MEM(p, parm))
+                    fix_mem(parm, p);
+               if (IF_USELECT(p)) {
+                   if (p -> pe_ucode >= 0 &&
+                       (mod -> md_ducode == NULLIFP ||
+                        (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
+                       goto bad;
+               }
+               else CLR_OPT_PRESENT(p, parm);
+               return (NO_DATA_USED);
+           }
+           if (IF_USELECT(p)) {
+               if (p -> pe_ucode >= 0 &&
+                   (mod -> md_ducode == NULLIFP ||
+                    (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
+                   goto bad;
+           }
+           else
+               SET_OPT_PRESENT(p, parm);
+           p++;
+           continue;
+
+       case FREE_ONLY: /* the next entry(s) only for freeing routines 
+                        * so skip this and next entry
+                        */
+           break;
+       
+       case FFN_CALL:  /* call function to free - skip this here */
+           break;
+
+       case UCODE:
+           if (mod->md_ducode == NULLIFP
+           || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+               goto bad;
+           break;
+
+       case ETAG:
+           switch (p->pe_ucode) {
+           default:
+               p++;
+               if (pr_etype(pe->pe_cons, parm, p, mod) == NOTOK)
+                   return (NOTOK);
+           }
+           break;
+
+       case MEMALLOC:
+           if (*parm)
+               break;  /* already allocated */
+           if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag)) == NULL)
+               return oom(mod, p);
+           break;
+
+       /* The difference between here and the en_type makes me think
+        * that this is never called for SEQ_START ???? 
+        */
+       case SSEQ_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_seq(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_seq(pe, parm, p, mod) == NOTOK)
+                   goto bad;
+           break;
+
+       case SEQ_START:
+           if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SSEQOF_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_seqof(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_seqof(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SSET_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_set(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_set(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SSETOF_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_setof(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_setof(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ) {
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                     (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                     goto bad;
+           } else if (p->pe_type == SEXTOBJ) {
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                         (char **) 0, (char **) &nparm) == NOTOK)
+                         goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                         (char **) 0, (char **) parm) == NOTOK)
+                     goto bad;
+           } else {
+               if (p->pe_type == SOBJECT) {
+                   if (p->pe_ucode > 0) {
+                       if (*parm == NULLCP)
+                           return inpm(mod, p);
+                       nparm = *parm + p->pe_ucode;
+                       if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                           goto bad;
+                   } else if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                       goto bad;
+               } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
+                       mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+           }
+           break;
+
+       case SOBJECT:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_obj(expl, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
+                   goto bad;
+           } else if (pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
+               goto bad;
+           break;
+
+       case OBJECT:
+
+           if (pr_obj(expl, pe, (char **) (*parm + p->pe_ucode),
+              mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
+               goto bad;
+           break;
+
+       case SCHOICE_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_choice(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case CHOICE_START:
+           if (pr_choice(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p, pe, "pr_type: missing EXTMOD");
+               nparm = *parm + p->pe_ucode;
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
+                     (char **) 0, &nparm) == NOTOK)
+                     goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
+                     (char **) 0, parm) == NOTOK)
+                 goto bad;
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, p, pe, "pr_type: missing EXTMOD");
+           if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
+                 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                 goto bad;
+           break;
+
+       case INTEGER:
+           if (pe != NULLPE) {
+               DLOG (psap_log, LLOG_DEBUG, ("pr_type:integer %d",
+                                            prim2num(pe)));
+               if (((*(integer *) (*parm + p->pe_ucode)) = prim2num(pe))
+                   == NOTOK && pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose (mod, p, pe, "pr_type:bad integer %s",
+                                     pe_error(pe->pe_errno));
+           }
+           break;
+
+#ifdef PEPSY_REALS
+       case REALTYPE:
+           if (pe != NULLPE) {
+               DLOG (psap_log, LLOG_DEBUG, ("pr_type:Real %g",
+                                             prim2real(pe)));
+
+               if (((*(double *) (*parm + p->pe_ucode)) = prim2real(pe))
+                   == NOTOK && pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose (mod, p, pe, "pr_type:bad real %s",
+                                     pe_error(pe->pe_errno));
+           }
+           break;
+
+#endif
+
+       case BOOLEAN:
+           if (pe != NULLPE) {
+               int     i;
+
+               DLOG (psap_log, LLOG_DEBUG, ("boolean %d",
+                                            prim2flag(pe)));
+               if ((i = prim2flag (pe)) == NOTOK)
+                     return pepsylose (mod, p, pe, "pr_type:bad integer %s",
+                                       pe_error(pe->pe_errno));
+               *(char *) (*parm + p->pe_ucode) = i & 0xff;
+           }
+           break;
+
+       case T_NULL:
+           break;
+
+       case SANY:
+           if (pe != NULLPE) {
+               ((*(PE *) (parm + p->pe_ucode)) = pe)->pe_refcnt++;
+               if (pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose (mod, p, pe, "pr_type:bad ANY %s",
+                                     pe_error(pe->pe_errno));
+           }
+           break;
+
+       case ANY:
+           if (pe != NULLPE) {
+               (*(PE *) (*parm + p->pe_ucode) = pe)->pe_refcnt++;
+               if (pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose(mod, p, pe, "pr_type:bad ANY %s",
+                                    pe_error(pe->pe_errno));
+           }
+           break;
+
+       case SOCTETSTRING:
+           if (pe != NULLPE) {
+               if ((*((struct qbuf **) (parm + p->pe_ucode)) = prim2qb(pe)) ==
+                   (struct qbuf *) NULL && pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose(mod, p, pe, "pr_type:bad octet string %s",
+                                    pe_error(pe->pe_errno));
+           }
+           break;
+
+       case OCTETSTRING:
+           if (pe != NULLPE) {
+               if ((*((struct qbuf **) (*parm + p->pe_ucode))
+                    = prim2qb(pe)) == (struct qbuf *) NULL
+                   && pe->pe_errno != PE_ERR_NONE)
+                   return pepsylose (mod, p, pe,
+                                     "pr_type:bad octet string %s",
+                                     pe_error(pe->pe_errno));
+           }
+           break;
+
+       case T_STRING:
+           if ((*((char **) (*parm + p->pe_ucode)) = prim2str(pe, &len))
+               == NULLCP && pe->pe_errno != PE_ERR_NONE)
+                 return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
+                                 pe_error(pe->pe_errno));
+           /* undocumented feature of prim2str that it adds a NULL char
+            * to the end of the string
+            */
+           break;
+
+       case BITSTR_PTR:
+           if (p[1].pe_type != BITSTR_LEN)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "pr_type: missing BITSTR_PTR");
+
+           pe = prim2bit(pe);
+           if ((*((char **) (*parm + p->pe_ucode)) =
+               bitstr2strb(pe, (int *)(*parm + (p + 1)->pe_ucode)))
+               == NULLCP && pe->pe_errno != PE_ERR_NONE)
+                 return pepsylose (mod, p, pe, "pr_type:bad bit string %s",
+                                 pe_error(pe->pe_errno));
+           break;
+
+
+       case OCTET_PTR:
+           if (p[1].pe_type != OCTET_LEN)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "pr_type: missing OCTET_PTR");
+           if ((*((char **) (*parm + p->pe_ucode)) =
+               prim2str(pe, (int *)(*parm + (p + 1)->pe_ucode)))
+               == NULLCP && pe->pe_errno != PE_ERR_NONE)
+                 return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
+                                 pe_error(pe->pe_errno));
+           break;
+
+
+       case SBITSTRING:
+           if (pe != NULLPE) {
+               if ((*((PE *) (parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
+                   return pepsylose (mod, p, pe, "pr_type:out of memory");
+           }
+           break;
+
+       case BITSTRING:
+           if (pe != NULLPE) {
+               if ((*((PE *) (*parm + p->pe_ucode)) =
+                    prim2bit(pe_cpy(pe))) == NULLPE)
+                   return pepsylose(mod, p, pe, "pr_type:out of memory");
+           }
+           break;
+
+       case SOBJID:
+           /*
+            * This is messy because ISODE's library routine uses a
+            * static. Don't know why they do
+            */
+           if ((oid = prim2oid(pe + p->pe_ucode)) == NULLOID
+               || (*(OID *) parm = oid_cpy(oid)) == NULLOID) {
+               if (oid && oid->oid_elements) {
+                   free((char *) oid->oid_elements);
+                   oid->oid_elements = NULL;
+               }
+               return pepsylose (mod, p, pe,
+                                 "pr_type:Object Identifier: out of memory");
+           }
+           if (oid && oid->oid_elements) {
+               free((char *) oid->oid_elements);
+               oid->oid_elements = NULL;
+           }
+           break;
+
+       case OBJID:
+           if ((oid = prim2oid(pe)) == NULLOID
+               || (*(OID *) (*parm + p->pe_ucode) = oid_cpy(oid)) == NULLOID) {
+               if (oid && oid->oid_elements) {
+                   free((char *) oid->oid_elements);
+                   oid->oid_elements = NULL;
+               }
+               return pepsylose (mod, p, pe,
+                                 "pr_type:Object Identifier: out of memory");
+           }
+           if (oid && oid->oid_elements) {
+               free((char *) oid->oid_elements);
+               oid->oid_elements = NULL;
+           }
+           break;
+
+       case FN_CALL:
+           if ((FN_PTR(mod, p))(parm, pe) == NOTOK)
+               return pepsylose (mod, p, NULLPE,
+                                 "pr_type:FN_CALL:call failed");
+           break;
+
+       default:
+           return pepsylose (mod, p, pe, "pr_type: type not implemented");
+       }
+       if (ISDTYPE(p) && cnt > 0)
+           return pepsylose (mod, p, pe, "pr_type:compound type found");
+
+       if (ISDTYPE(p) && pe != NULLPE)
+           return (OK);
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a sequence, calling appropriate routines to parse each sub
+ * type
+ */
+static int
+pr_seq(head, parm, p, mod)
+PE      head;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+    int    *popt = NULL;       /* Pointer to optional field */
+    int     optcnt = 0;                /* Number of optionals bits so far */
+    char    *nparm;
+
+    if (p->pe_type != SEQ_START && p->pe_type != SSEQ_START)
+       return pepsylose (mod, p, head, "pr_seq: missing SEQ_START");
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    pe = first_member(head);
+    while (p->pe_type != PE_END) {
+       DLOG (psap_log, LLOG_DEBUG, ("pr_seq:type %d", p->pe_type));
+
+       if (ISDTYPE(p) && OPTIONAL(p)) {
+           switch (p->pe_type) {
+           case INTEGER:
+           case REALTYPE:
+           case BOOLEAN:
+           case T_NULL:
+               if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
+                   optcnt++;
+                   goto next;
+               }
+               SETBIT(*popt, optcnt++);
+               break;
+
+
+           default:
+               if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
+                   if (ALLOC_MEM(p, parm))
+                       fix_mem(parm, p);
+                   goto next;
+               }
+               break;
+           }
+       } else if (ISDTYPE(p) && (pe == NULLPE || CHKTAG(mod, p, pe) == 0)) {
+           if (DEFAULT(p)) {
+               if(setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
+                   goto bad;
+               goto next;
+           } else 
+               return pepsylose (mod, p, pe,
+                                 "pr_seq:missing mandatory parameter");
+       }
+       switch (p->pe_type) {
+       case OPTL:
+           popt = (int *) (*parm + p->pe_ucode);
+           break;
+
+       case FREE_ONLY: /* the next entry(s) only for freeing routines 
+                        * so skip this and next entry
+                        */
+           break;
+       
+       case FFN_CALL:  /* call function to free - skip this here */
+           break;
+
+       case UCODE:
+           if (mod->md_ducode == NULLIFP
+           || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+               goto bad;
+           break;
+
+       case BOPTIONAL:
+           if (pe == NULLPE || CHKTAG(mod, p + 1, pe) == 0) {
+               if (ALLOC_MEM(p, parm))
+                    fix_mem(parm, p);
+               if (IF_USELECT(p)) {
+                   if (p -> pe_ucode >= 0 &&
+                       (mod -> md_ducode == NULLIFP ||
+                        (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
+                       goto bad;
+               }
+               else CLR_OPT_PRESENT(p, parm);
+               goto next;
+           }
+           if (IF_USELECT(p)) {
+               if (p -> pe_ucode >= 0 &&
+                   (mod -> md_ducode == NULLIFP ||
+                    (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
+                   goto bad;
+           }
+           else SET_OPT_PRESENT(p, parm);
+           p++;
+           continue;
+
+       case ETAG:
+           if (pr_type(1, pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case MEMALLOC:
+           if (*parm)
+               break;  /* already allocated */
+           if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))==NULLCP)
+               return oom(mod, p);
+           break;
+
+       case SEQ_START:
+           if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ) {
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                     (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                     goto bad;
+           } else if (p->pe_type == SEXTOBJ) {
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                         (char **) 0, (char **) &nparm) == NOTOK)
+                         goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
+                         (char **) 0, (char **) parm) == NOTOK)
+                     goto bad;
+           } else {
+               if (p->pe_type == SOBJECT) {
+                   if (p->pe_ucode > 0) {
+                       if (*parm == NULLCP)
+                           return inpm(mod, p);
+                       nparm = *parm + p->pe_ucode;
+                       if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                           goto bad;
+                   } else 
+                       if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                           goto bad;
+               } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
+                       mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+           }
+           break;
+
+       case SOBJECT:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case OBJECT:
+           if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
+                   mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SCHOICE_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_choice(pe, parm, p, mod) == NOTOK)
+                   goto bad;
+           break;
+
+       case CHOICE_START:
+           if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, p, pe, "pr_seq: missing EXTMOD");
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                     (char **) 0, &nparm) == NOTOK)
+                     goto bad;
+           } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                     (char **) 0, parm) == NOTOK)
+                     goto bad;
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, p, pe, "pr_seq: missing EXTMOD");
+
+           if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                 goto bad;
+           break;
+
+       default:
+           /* only called if we have a match */
+           if (pr_type(1, pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+
+       if (ISDTYPE(p) && pe != NULLPE)
+           pe = next_member(head, pe);
+next:
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a set, calling appropriate routines to parse each sub type
+ */
+static int
+pr_set(head, parm, p, mod)
+PE      head;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+    int    *popt = NULL;       /* Pointer to optional field */
+    int     optcnt = 0;                /* Number of optionals bits so far */
+    char    *nparm;
+
+    if (p->pe_type != SET_START && p->pe_type != SSET_START)
+       return pepsylose (mod, p, NULLPE, "pr_seq: missing SET_START");
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    while (p->pe_type != PE_END) {
+       DLOG (psap_log, LLOG_DEBUG, ("pr_set type %d", p->pe_type));
+
+       if (ISDTYPE(p) && OPTIONAL(p)) {
+           switch (p->pe_type) {
+           case INTEGER:
+           case REALTYPE:
+           case BOOLEAN:
+           case T_NULL:
+               if ((pe = setpresent(head, p, mod)) == NULLPE) {
+                   optcnt++;
+                   goto next;
+               }
+               SETBIT(*popt, optcnt++);
+               break;
+
+
+           default:
+               if ((pe = setpresent(head, p, mod)) == NULLPE) {
+                   if (ALLOC_MEM(p, parm))
+                       fix_mem(parm, p);
+                   goto next;
+               }
+               break;
+           }
+       } else if (ISDTYPE(p) && (pe = setpresent(head, p, mod)) == NULLPE) {
+           if (DEFAULT(p)) {
+               if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
+                   goto bad;
+               goto next;
+           } else
+               return pepsylose (mod, p, pe,
+                                 "pr_set:missing mandatory parameter");
+       }
+       switch (p->pe_type) {
+       case OPTL:
+           popt = (int *) (*parm + p->pe_ucode);
+           break;
+
+       case FREE_ONLY: /* the next entry(s) only for freeing routines 
+                        * so skip this and next entry
+                        */
+           break;
+       
+       case FFN_CALL:  /* call function to free - skip this here */
+           break;
+
+       case UCODE:
+           if (mod->md_ducode == NULLIFP
+           || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+               goto bad;
+           break;
+
+       case BOPTIONAL:
+           if ((pe = setpresent(head, p + 1, mod)) == NULLPE) {
+               if (ALLOC_MEM(p, parm))
+                    fix_mem(parm, p);
+               if (IF_USELECT(p)) {
+                   if (p -> pe_ucode >= 0 &&
+                       (mod -> md_ducode == NULLIFP ||
+                       (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
+                       goto bad;
+               }
+               else CLR_OPT_PRESENT(p, parm);
+               goto next;
+           }
+           if (IF_USELECT(p)) {
+               if (p -> pe_ucode >= 0 &&
+                   (mod -> md_ducode == NULLIFP ||
+                    (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
+                   goto bad;
+           }
+           else SET_OPT_PRESENT(p, parm);
+           p++;
+           continue;
+
+       case ETAG:
+           if (pr_type(1, pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case MEMALLOC:
+           if (*parm)
+               break;  /* already allocated */
+           if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))==NULLCP)
+               return oom(mod, p);
+           break;
+
+       case SEQ_START:
+           if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ) {
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                     (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                     goto bad;
+           } else if (p->pe_type == SEXTOBJ) {
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                         (char **) 0, (char **) &nparm) == NOTOK)
+                         goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                         (char **) 0, (char **) parm) == NOTOK)
+                         goto bad;
+           } else {
+               if (p->pe_type == SOBJECT) {
+                   if (p->pe_ucode > 0) {
+                       if (*parm == NULLCP)
+                           return inpm(mod, p);
+                       nparm = *parm + p->pe_ucode;
+                       if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                           goto bad;
+                   } else if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
+                               == NOTOK)
+                           goto bad;
+               } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
+                       mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+           }
+           break;
+
+       case SOBJECT:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)== NOTOK)
+                   goto bad;
+           } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)== NOTOK)
+                   goto bad;
+           break;
+
+       case OBJECT:
+           if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
+                   mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SCHOICE_START:
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+           } else if (pr_choice(pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case CHOICE_START:
+           if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, p, pe, "pr_set: missing EXTMOD");
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                     (char **) 0, &nparm) == NOTOK)
+                     goto bad;
+           } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                     (char **) 0, parm) == NOTOK)
+                     goto bad;
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD) 
+               return pepsylose (mod, p, pe, "pr_set: missing EXTMOD");
+
+           if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                 goto bad;
+           break;
+
+       default:
+           if (pr_type(1, pe, parm, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+
+next:
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+
+}
+
+
+/*
+ * Parse a sequence of calling appropriate routines to parse each sub
+ * type
+ */
+static int
+pr_seqof(head, parm, p, mod)
+PE      head;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+    tpe    *start;             /* first entry in list */
+    int     dflt = 0;
+    char    *nparm;
+
+    if (p->pe_type != SEQOF_START && p->pe_type != SSEQOF_START)
+       return pepsylose (mod, p, head, "pr_seqof:missing SEQOF_START");
+
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    start = p;
+
+    pe = first_member(head);
+    while (pe != NULLPE) {
+       while (p->pe_type != PE_END) {
+
+           DLOG (psap_log, LLOG_DEBUG, ("pr_seqof type %d", p->pe_type));
+
+           if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) {
+               if (DEFAULT(p)) {
+                   if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
+                       goto bad;
+                   goto next;
+               } else if (OPTIONAL(p)) {
+                   if (ALLOC_MEM(p, parm))
+                       fix_mem(parm, p);
+                   goto next;
+               } else
+                   return pepsylose (mod, p, pe,
+                                     "pr_seqof:missing mandatory parameter");
+           }
+           switch (p->pe_type) {
+           case FREE_ONLY:     /* the next entry(s) only for freeing routines 
+                            * so skip this and next entry
+                            */
+               break;
+           
+           case FFN_CALL:      /* call function to free - skip this here */
+               break;
+
+           case UCODE:
+               if (mod->md_ducode == NULLIFP
+               || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+                   goto bad;
+               break;
+
+           case BOPTIONAL:
+               if (pe == NULLPE || CHKTAG(mod, p + 1, pe) == 0) {
+                   if (ALLOC_MEM(p, parm))
+                       fix_mem(parm, p);
+                   if (IF_USELECT(p)) {
+                       if (p -> pe_ucode >= 0 &&
+                           (mod -> md_ducode == NULLIFP ||
+                            (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
+                           goto bad;
+                   }
+                   else CLR_OPT_PRESENT(p, parm);
+                   goto next;
+               }
+               if (IF_USELECT(p)) {
+                   if (p -> pe_ucode >= 0 &&
+                       (mod -> md_ducode == NULLIFP ||
+                        (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
+                       goto bad;
+               }
+               else SET_OPT_PRESENT(p, parm);
+               p++;
+               continue;
+
+           case ETAG:
+               if (pr_type(1, pe, parm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case MEMALLOC:
+               if (*parm)
+                   break;      /* already allocated */
+               if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))
+                       == NULLCP)
+                   return oom(mod, p);
+               break;
+
+           case SCTRL:
+               parm = (char **) ((char *) *parm + p->pe_ucode);
+               break;
+
+           case SEQ_START:
+               if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
+               goto bad;
+               break;
+
+           case SEQOF_START:
+               if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p,mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SET_START:
+               if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
+                   goto bad;
+               break;
+
+           case SETOF_START:
+               if (pr_setof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SOBJECT:
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (pr_obj(1,pe, &nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+               } else if (pr_obj(1,pe, parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+               break;
+
+           case OBJECT:
+               if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
+                       mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case SCHOICE_START:
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case CHOICE_START:
+               if (pr_choice(pe, (char **)(*parm + p->pe_ucode), p,mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p, pe, "pr_seqof: missing EXTMOD");
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                         (char **) 0, &nparm) == NOTOK)
+                         goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                         (char **) 0, parm) == NOTOK)
+                         goto bad;
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD) 
+                   return pepsylose (mod, p, pe, "pr_seqof: missing EXTMOD");
+
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                     (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                     goto bad;
+               break;
+
+           default:
+               if (pr_type(1, pe, parm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+           }
+
+           if (ISDTYPE(p) && dflt == 0)
+               pe = next_member(head, pe);
+    next:
+           if (NEXT_TPE(p) == NULLTPE)
+               goto bad;
+       }
+       parm = (char **) (*parm + p->pe_ucode);
+       p = start;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a setof, calling appropriate routines to parse each sub type
+ */
+static int
+pr_setof(head, parm, p, mod)
+PE      head;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+    tpe    *start;
+    char       *nparm;
+
+    if (p->pe_type != SETOF_START && p->pe_type != SSETOF_START)
+       return pepsylose(mod, p, head, "pr_setof: missing SETOF_START");
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    start = p;
+    pe = first_member(head);
+
+    for (pe = first_member(head); pe; pe = next_member(head, pe)) {
+       while (p->pe_type != PE_END) {
+           DLOG (psap_log, LLOG_DEBUG, ("pr_setof type %d", p->pe_type));
+
+           if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
+               if (DEFAULT(p)) {
+                   if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
+                       goto bad;
+                   goto next;
+               } else
+                   return pepsylose (mod, p, pe,
+                                     "pr_setof:missing mandatory parameter");
+           }
+
+           switch (p->pe_type) {
+           case FREE_ONLY:     /* the next entry(s) only for freeing routines 
+                            * so skip this and next entry
+                            */
+               break;
+           
+           case FFN_CALL:      /* call function to free - skip this here */
+               break;
+
+           case UCODE:
+               if (mod->md_ducode == NULLIFP
+               || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+                   goto bad;
+               break;
+
+           case BOPTIONAL:
+               if ((pe = setpresent(head, p + 1, mod)) == NULLPE) {
+                   if (ALLOC_MEM(p, parm))
+                       fix_mem(parm, p);
+                   if (IF_USELECT(p)) {
+                       if (p -> pe_ucode >= 0 &&
+                           (mod -> md_ducode == NULLIFP ||
+                            (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
+                           goto bad;
+                   }
+                   else CLR_OPT_PRESENT(p, parm);
+                   goto next;
+               }
+               if (IF_USELECT(p)) {
+                   if (p -> pe_ucode >= 0 &&
+                       (mod -> md_ducode == NULLIFP ||
+                        (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
+                       goto bad;
+               }
+               else SET_OPT_PRESENT(p, parm);
+               p++;
+               continue;
+
+           case ETAG:
+               if (pr_type(1, pe->pe_cons, parm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case MEMALLOC:
+               if (*parm)
+                   break;      /* already allocated */
+               if ((*(parm) = (char *) calloc(1, (unsigned )p->pe_tag))
+                       == NULLCP)
+                   return oom(mod, p);
+               break;
+
+           case SCTRL:
+               parm = (char **) (*parm + p->pe_ucode);
+               break;
+
+           case SEQ_START:
+               if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
+                   goto bad;
+               break;
+
+           case SEQOF_START:
+               if (pr_seqof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SET_START:
+               if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
+                   goto bad;
+               break;
+
+           case SETOF_START:
+               if (pr_setof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SOBJECT:
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+               } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+               break;
+
+           case OBJECT:
+               if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
+                       mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case SCHOICE_START:
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+                       goto bad;
+               } else if (pr_choice(pe, parm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case CHOICE_START:
+               if (pr_choice(pe, (char **)(*parm + p->pe_ucode), p,mod)==NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p, pe, "pr_setof: missing EXTMOD");
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
+                         (int *) 0, (char **) 0, &nparm) == NOTOK)
+                         goto bad;
+               } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
+                         (int *) 0, (char **) 0, parm) == NOTOK)
+                         goto bad;
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p, pe, "pr_setof: missing EXTMOD");
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
+                     (int *) 0, (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                     goto bad;
+               break;
+
+           default:
+               if (pr_type(1, pe, parm, p, mod) == NOTOK)
+                   goto bad;
+               break;
+           }
+
+    next:
+           if (NEXT_TPE(p) == NULLTPE)
+               goto bad;
+       }
+       parm = (char **) (*parm + p->pe_ucode);
+       p = start;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * parse a choice field. This means find which choice is taken
+ */
+static int
+pr_choice(head, parm, p, mod)
+PE      head;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    int    *poffset;
+    int     cnt;
+    tpe    *savep = NULLTPE;
+
+    if (p->pe_type != CHOICE_START && p->pe_type != SCHOICE_START)
+       return pepsylose (mod, p, head, "pr_choice:missing CHOICE_START");
+
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    if (p->pe_type == MEMALLOC) {
+           if (*parm == NULLCP) {
+               /* not already allocated */
+               if ((*(parm) = (char *) calloc(1,(unsigned )p->pe_tag))==NULLCP)
+                   return oom(mod, p);
+           }
+       p++;
+    }
+    if (p->pe_type == SCTRL) {
+       if (IF_USELECT(p)) {
+           savep = p;
+       } else if ((poffset = (int *) (*parm + p->pe_ucode)) == NULL)
+           goto bad;
+       p++;
+    }
+    for (cnt = 1; p->pe_type != PE_END; NEXT_TPE(p)) {
+       if (ISDTYPE(p)) {
+           if (ismatch(p, mod, head->pe_class, head->pe_id)) {
+               if (pr_etype(head, parm, p, mod) == NOTOK)
+                   goto bad;
+               if (savep) {
+                   if (savep -> pe_ucode >= 0  &&
+                       (mod -> md_ducode == NULLIFP ||
+                        (*mod -> md_ducode)(parm, head, savep, cnt) == NOTOK))
+                       goto bad;
+               }
+               else
+                   *poffset = cnt;
+               NEXT_TPE(p);
+               if (p->pe_type == UCODE) {
+                   if (mod->md_ducode == NULLIFP
+                   || (*mod->md_ducode) (parm, head, p, 0) == NOTOK)
+                       return (NOTOK);
+               }
+               return (OK);
+           }
+           cnt++;
+       }
+    }
+    (void) pepsylose(mod, p, head, "pr_choice: no choice taken");
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a single type for explicit tag If a basic type parse it, if
+ * a compound type call the appropriate parsing routine
+ */
+static int
+pr_etype(pe, parm, p, mod)
+PE      pe;
+char   **parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+{
+    int cnt;
+    char    *nparm;
+
+    switch (p->pe_type) {
+    case PE_END:
+    case PE_START:
+       return pepsylose (mod, p, pe, "pr_etype:illegal END/START");
+
+    case FREE_ONLY:    /* the next entry(s) only for freeing routines 
+                    * so skip this and next entry
+                    */
+       break;
+    
+    case FFN_CALL:     /* call function to free - skip this here */
+       break;
+
+    case UCODE:
+       if (mod->md_ducode == NULLIFP
+           || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
+           goto bad;
+       break;
+
+    case BOPTIONAL:
+       return pepsylose (mod, p, pe, "pr_etype:illegal BOPTIONAL");
+       
+    case ETAG:
+       switch (p->pe_ucode) {
+
+       default:
+           p++;
+           if (pr_etype(pe->pe_cons, parm, p, mod) == NOTOK)
+               goto bad;
+       }
+       break;
+
+    case MEMALLOC:
+       if (*parm)
+           break;      /* already allocated */
+       if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag)) == NULLCP)
+           return oom(mod, p);
+       break;
+
+    case SEQ_START:
+       if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSEQOF_START:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_seqof(pe, &nparm, p, mod) == NOTOK)
+               goto bad;
+       } else if (pr_seqof(pe, parm, p, mod) == NOTOK)
+               goto bad;
+       break;
+
+    case SEQOF_START:
+       if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSEQ_START:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_seq(pe, &nparm, p, mod) == NOTOK)
+               goto bad;
+       } else if (pr_seq(pe, parm, p, mod) == NOTOK)
+               goto bad;
+       break;
+
+    case SET_START:
+       if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSET_START:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_set(pe, &nparm, p, mod) == NOTOK)
+               goto bad;
+       } else if (pr_set(pe, parm, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SETOF_START:
+       if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSETOF_START:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_setof(pe, &nparm, p, mod) == NOTOK)
+               goto bad;
+       } else if (pr_setof(pe, parm, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case IMP_OBJ:
+       p++;
+       if (p->pe_type == EXTOBJ) {
+           if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+                 goto bad;
+       } else if (p->pe_type == SEXTOBJ) {
+           if (p->pe_ucode > 0) {
+               if (*parm == NULLCP)
+                   return inpm(mod, p);
+               nparm = *parm + p->pe_ucode;
+               if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                     (char **) 0, (char **) &nparm) == NOTOK)
+                     goto bad;
+           } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
+                     (char **) 0, (char **) parm) == NOTOK)
+                     goto bad;
+       } else {
+           if (p->pe_type == SOBJECT) {
+               if (p->pe_ucode > 0) {
+                   if (*parm == NULLCP)
+                       return inpm(mod, p);
+                   nparm = *parm + p->pe_ucode;
+                   if (pr_obj(0, pe, (char **)&nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+               } else if (pr_obj(0, pe, (char **)parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
+                       goto bad;
+           } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
+                   mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+               goto bad;
+       }
+       break;
+
+    case SOBJECT:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+               goto bad;
+       } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case OBJECT:
+       if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
+               mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SCHOICE_START:
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (pr_choice(pe, &nparm, p, mod) == NOTOK)
+               goto bad;
+       } else if (pr_choice(pe, parm, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case CHOICE_START:
+       if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SEXTOBJ:
+       if (p[1].pe_type != EXTMOD)
+           return pepsylose (mod, p, pe, "pr_etype: missing EXTMOD");
+       if (p->pe_ucode > 0) {
+           if (*parm == NULLCP)
+               return inpm(mod, p);
+           nparm = *parm + p->pe_ucode;
+           if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                 (char **) 0, &nparm) == NOTOK)
+                 goto bad;
+       } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+                 (char **) 0, parm) == NOTOK)
+             goto bad;
+       break;
+
+    case EXTOBJ:
+       if (p[1].pe_type != EXTMOD)
+           return pepsylose (mod, p, pe, "pr_etype: missing EXTMOD");
+
+       if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
+             (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
+             goto bad;
+       break;
+
+    case INTEGER:
+       if (pe != NULLPE) {
+           DLOG (psap_log, LLOG_DEBUG, ("pr_etype:integer %d", prim2num(pe)));
+
+           if (((*(integer *)(*parm + p->pe_ucode)) = prim2num(pe)) == NOTOK &&
+               pe->pe_errno != PE_ERR_NONE) 
+               return pepsylose (mod, p, pe, "pr_etype:bad integer %s",
+                                 pe_error(pe->pe_errno));
+       }
+       break;
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       if (pe != NULLPE) {
+           DLOG (psap_log, LLOG_DEBUG, ("pr_etype:Real %g", prim2real(pe)));
+
+           if (((*(double *) (*parm + p->pe_ucode)) = prim2real(pe))
+               == NOTOK && pe->pe_errno != PE_ERR_NONE) 
+                 return pepsylose (mod, p, pe, "pr_etype:bad real %s",
+                                   pe_error(pe->pe_errno));
+       }
+       break;
+
+#endif
+
+    case BOOLEAN:
+       if (pe != NULLPE) {
+           int     i;
+
+           DLOG(psap_log, LLOG_DEBUG, ("pr_etype:boolean %d", prim2flag(pe)));
+
+           if ((i = prim2flag (pe)) == NOTOK)
+               return pepsylose (mod, p, pe, "pr_etype:bad integer %s",
+                                 pe_error(pe->pe_errno));
+           (*(char *) (*parm + p->pe_ucode)) = i & 0xff;
+       }
+       break;
+
+    case T_NULL:
+       break;
+
+    case ANY:
+       if (pe != NULLPE) {
+           (*(PE *) (*parm + p->pe_ucode) = pe)->pe_refcnt++;
+           if (pe->pe_errno != PE_ERR_NONE)
+               return pepsylose (mod, p, pe, "pr_etype:bad ANY %s",
+                                 pe_error(pe->pe_errno));
+       }
+       break;
+
+    case SANY:
+       if (pe != NULLPE) {
+           (*(PE *) (parm + p->pe_ucode) = pe) -> pe_refcnt++;
+           if (pe->pe_errno != PE_ERR_NONE)
+               return pepsylose (mod, p, pe, "pr_etype:bad ANY %s",
+                                 pe_error(pe->pe_errno));
+       }
+       break;
+
+    case SOCTETSTRING:
+       if (pe != NULLPE) {
+           if ((*((struct qbuf **) (parm + p->pe_ucode))
+                = prim2qb(pe)) == (struct qbuf *) NULL
+               && pe->pe_errno != PE_ERR_NONE)
+               return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
+                                 pe_error(pe->pe_errno));
+       }
+       break;
+
+    case OCTETSTRING:
+       if (pe != NULLPE) {
+           if ((*((struct qbuf **) (*parm + p->pe_ucode))
+                = prim2qb(pe)) == (struct qbuf *) NULL
+               && pe->pe_errno != PE_ERR_NONE)
+               return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
+                                 pe_error(pe->pe_errno));
+       }
+       break;
+
+    case T_STRING:
+       if ((*((char **) (*parm + p->pe_ucode)) = prim2str(pe, &cnt))
+           == NULLCP && pe->pe_errno != PE_ERR_NONE)
+             return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
+                             pe_error(pe->pe_errno));
+       /* undocumented feature of prim2str that it adds a NULL char
+        * to the end of the string
+        */
+       break;
+
+    case OCTET_PTR:
+       if (p[1].pe_type != OCTET_LEN)
+           return pepsylose (mod, &p[1], NULLPE,"pr_etype: missing OCTET_PTR");
+       if ((*((char **) (*parm + p->pe_ucode)) =
+           prim2str(pe, (int *)(*parm + (p + 1)->pe_ucode)))
+           == NULLCP && pe->pe_errno != PE_ERR_NONE)
+             return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
+                             pe_error(pe->pe_errno));
+       break;
+
+       case BITSTR_PTR:
+           if (p[1].pe_type != BITSTR_LEN)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "pr_etype: missing BITSTR_PTR");
+           pe = prim2bit(pe);
+           if ((*((char **) (*parm + p->pe_ucode)) =
+               bitstr2strb(pe, (int *)(*parm + (p + 1)->pe_ucode)))
+               == NULLCP && pe->pe_errno != PE_ERR_NONE)
+                 return pepsylose (mod, p, pe, "pr_etype:bad bit string %s",
+                                 pe_error(pe->pe_errno));
+           break;
+
+    case SBITSTRING:
+       if (pe != NULLPE) {
+           if (((*(PE *) (parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
+               return pepsylose (mod, p, pe, "pr_etype:out of memory");
+       }
+       break;
+
+    case BITSTRING:
+       if (pe != NULLPE) {
+           if ((*((PE *) (*parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
+               return pepsylose (mod, p, pe, "pr_etype:out of memory");
+       }
+       break;
+
+    case SOBJID:
+       if ((*(OID *) (parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID)
+           return pepsylose (mod, p, pe, "pr_etype:OID: out of memory");
+       break;
+
+    case OBJID:
+       if ((*(OID *) (*parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID)
+           return pepsylose (mod, p, pe, "en_etype:OID: out of memory");
+       break;
+
+    case FN_CALL:
+       if ((FN_PTR(mod, p))(parm, pe) == NOTOK)
+           return pepsylose (mod, p, NULLPE, "pr_etype:FN_CALL:call failed");
+       break;
+
+    default:
+       return pepsylose(mod, p, pe,
+                        "pr_etype: %d not implemented", p->pe_type);
+    }
+
+    return (OK);
+bad:
+    return (NOTOK);
+}
+
+
+/*
+ * 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.
+ */
+static PE
+setpresent(head, p, mod)
+PE      head;
+tpe    *p;
+modtyp *mod;
+{
+    PE      pe;
+    modtyp     *nmod;
+
+    while (!ISDTYPE(p) && p->pe_type != PE_END) {
+       p++;
+    }
+    if (!ISDTYPE(p) || p->pe_type == PE_END)
+       return (NULLPE);
+
+    switch (p->pe_type) {
+    case EXTOBJ:
+    case SEXTOBJ:
+       /* Needs to be changed for optional and default */
+       nmod = EXT2MOD(mod, (p + 1));
+       return (setpresent(head, p = nmod->md_dtab[p->pe_tag] + 1, nmod));
+
+    case OBJECT:
+    case SOBJECT:
+       /* Needs to be changed for optional and default */
+       return (setpresent(head, p = mod->md_dtab[p->pe_tag] + 1, mod));
+
+    case SCHOICE_START:
+    case CHOICE_START:
+       for (p++; p && p->pe_type != PE_END; p = NEXT_TPE(p)) {
+           if (!ISDTYPE(p))
+               continue;
+           if ((pe = 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
+ */
+static int
+setdval(typ, dflt, parm, mod)
+tpe    *typ, *dflt;
+char  **parm;
+modtyp *mod;
+{
+    char       *p;
+    integer    i;
+    int                no;     /* number of octets */
+    char       *nparm;
+
+again:
+    switch (typ->pe_type) {
+    case MEMALLOC:
+        if (*parm)
+            break;     /* already allocated */
+
+       if ((*(parm) = (char *) calloc(1, (unsigned ) typ->pe_tag)) == NULL) {
+           (void) pepsylose (mod, typ, NULLPE,
+                             "setdval:calloc failed on %d", typ->pe_tag);
+           return NOTOK;
+       }
+        /* fall through and do the same stuff as for ETAG */
+       
+    case ETAG:
+       typ++;
+       goto again;
+
+    case INTEGER:
+       *(integer *) (*parm + typ->pe_ucode) = IVAL(mod, dflt);
+       break;
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       *(double *) (*parm + typ->pe_ucode) = RVAL(mod, dflt);
+       break;
+#endif
+
+    case BOOLEAN:
+       *(char *) (*parm + typ->pe_ucode) = IVAL(mod, dflt);
+       break;
+
+    case T_NULL:
+       /* Only one value */
+       break;
+
+    case SBITSTRING:
+       *(PE *) (parm + typ->pe_ucode) = strb2bitstr(PVAL(mod, dflt), (int )IVAL(mod, dflt), 0, 0);
+       break;
+
+    case BITSTRING:
+       *(PE *) (*parm + typ->pe_ucode) =
+          strb2bitstr(PVAL(mod, dflt), (int )IVAL(mod, dflt), 0, 0);
+       break;
+
+    case SOCTETSTRING:
+       *(struct qbuf **) (parm + typ->pe_ucode) = str2qb(PVAL(mod, dflt),
+           (int )IVAL(mod, dflt), 1);
+       break;
+
+    case OCTETSTRING:
+       *(struct qbuf **) (*parm + typ->pe_ucode) =
+          str2qb(PVAL(mod, dflt), (int )IVAL(mod, dflt), 1);
+       break;
+
+    case T_STRING:
+       *(char **) (*parm + typ->pe_ucode) = strdup(PVAL(mod, dflt));
+       break;
+
+    case OCTET_PTR:
+       if (typ[1].pe_type != OCTET_LEN)
+           return pepsylose (mod, typ, NULLPE, "setdval:missing OCTET_LEN");
+       i = IVAL(mod, dflt);
+       p = smalloc((int )i + 1);
+       bcopy(PVAL(mod, dflt), p, (int )i);
+       p[i] = '\0';
+       *(char **) (*parm + typ->pe_ucode) = p;
+       *(int *) (*parm + (typ + 1)->pe_ucode) = i;
+       break;
+
+    case BITSTR_PTR:
+       if (typ[1].pe_type != BITSTR_LEN)
+           return pepsylose (mod, typ, NULLPE, "setdval:missing BITSTR_LEN");
+       i = IVAL(mod, dflt);
+       no = (i + 7)/8; /* round up */
+       p = smalloc(no + 1);
+       bcopy(PVAL(mod, dflt), p, no);
+       p[no] = '\0';
+       *(char **) (*parm + typ->pe_ucode) = p;
+       *(int *) (*parm + (typ + 1)->pe_ucode) = i;
+       break;
+
+    case OBJECT:
+       if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt,
+                   (char **) (*parm + typ->pe_ucode), mod) == NOTOK)
+           return NOTOK;
+       break;
+
+    case SOBJECT:
+       if (typ->pe_ucode > 0) {
+           nparm = *parm + typ->pe_ucode;
+           if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, &nparm, mod) == NOTOK)
+               return NOTOK;
+       } else if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, parm, mod) == NOTOK)
+               return NOTOK;
+       break;
+
+    case IMP_OBJ:
+       typ++;
+
+    case 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 **) (*parm + typ->pe_ucode) = NULL;
+       break;
+
+    case FN_CALL:
+       if ((FN_PTR(mod, typ))(parm, NULLPE) == NOTOK)
+           return pepsylose (mod, typ, NULLPE,
+                             "setdval:FN_CALL:call failed");
+       break;
+
+    default:
+       /*
+        * dmp_tpe("setdval: type not implemented", typ, mod); - need
+        * mod
+        */
+       (void) pepsylose(mod, typ, NULLPE,
+                        "setdval: %d not implemented", typ->pe_type);
+       return NOTOK;
+    }
+    return OK;
+}
+/*
+ * fix up the allocation of memory. We have allocated memory for an
+ * optional object that is not present. ISODE routines get upset if
+ * this is present because it then believes the object is present and
+ * tries to process it ...
+ */
+static int
+fix_mem(parm, p)
+char  **parm;
+tpe    *p;
+{
+    if (p->pe_type != SOBJECT || p[-1].pe_type != MEMALLOC
+       || p[1].pe_type != PE_END)
+       SLOG (psap_log, LLOG_EXCEPTIONS, NULLCP, ("fix_mem:inconsistency"));
+    if (*parm)
+       free(*parm);
+    *parm = NULL;
+}
diff --git a/usr/src/contrib/isode/pepsy/dtabs.c b/usr/src/contrib/isode/pepsy/dtabs.c
new file mode 100644 (file)
index 0000000..79dfca7
--- /dev/null
@@ -0,0 +1,835 @@
+/* dtabs.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/dtabs.c,v 7.10 91/02/22 09:48:47 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/dtabs.c,v 7.10 91/02/22 09:48:47 mrose Interim $
+ *
+ *
+ * $Log:       dtabs.c,v $
+ * Revision 7.10  91/02/22  09:48:47  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.9  91/01/08  12:49:21  mrose
+ * update
+ * 
+ * Revision 7.8  90/12/23  17:24:26  mrose
+ * patches
+ * 
+ * Revision 7.7  90/12/11  10:33:19  mrose
+ * sync
+ * 
+ * Revision 7.5  90/11/11  09:58:51  mrose
+ * touch-up
+ * 
+ * Revision 7.4  90/11/04  19:18:21  mrose
+ * update
+ * 
+ * Revision 7.3  90/08/18  00:44:15  mrose
+ * touch-up
+ * 
+ * Revision 7.2  90/07/27  08:49:09  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:52:25  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:15  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <stdio.h>
+#include "pepsydefs.h"
+#include "pass2.h"
+#include "mine.h"
+#include <ctype.h>
+
+
+extern FILE *fp;
+extern char *c_tag(), *c_class();
+extern char *ec_tag(), *ec_class();
+extern char *strip_last();
+extern char *str_yp_code[];
+extern char *get_val(), *get_comp(), *strp2name();
+extern s_table *lookup_list(), *get_offset();
+extern YP tdec_loop();
+
+extern char *concat();
+extern char *my_strcat();
+extern char    *rm_indirect();
+extern char    *getfield();
+extern char    *setfield();
+
+extern int     gen_sentry();
+
+/* extern int explicit; */
+
+#define WORDSIZE       20
+
+/*
+ * table encode a type. generate tables for the encoding of a type
+ */
+tdec_typ(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+    char   *t, *f;
+    char   *p1;
+    char   *s1, *s2, *s3;
+    char   *s;
+    s_table *ptr1, *ptr2;
+    YP      y;
+    YAL        yal;
+
+    if (yp->yp_code < 0 || yp->yp_code > YP_REAL)
+       ferrd(1, "tdec_typ: unimplemented type %d\n", yp->yp_code);
+
+    if (yp == NULL) {
+       ferr(0, "tdec_typ:NULL arguement\n");
+       return;
+    }
+
+    if (type)
+       t = type;
+    else if (yp->yp_param_type) {
+       char *t1;
+       /* we have a [[ P type ]] specification */
+       if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+           fprintf(stderr,
+           "\ntdec_typ:SETLIST can't extract direct type from %s\n",
+               yp->yp_param_type);
+           exit(1);
+       }
+       t = strdup(t1);
+    } else
+       t = my_strcat("struct ", modsym(mymodule, id, "type"));
+
+    if (yal = yp->yp_bef_alist) {
+       yal->yal_type = t;
+       if (yal->yal_dec)
+           gen_act(fp, yp->yp_bef_alist->yal_dec);
+    }
+    if (yal = yp->yp_aft_alist) {
+       yal->yal_type = t;
+    }
+    if (yal = yp->yp_control_act)
+       yal -> yal_type = t;
+
+    if (yal = yp->yp_optional_act)
+       yal -> yal_type = t;
+
+    if (type == NULLCP) {
+       switch (yp->yp_code) {
+           /*
+            * These generate MEMALLOC entries inside *_START ..
+            * PE_END fields for historical reasons. One day we might
+            * fix this to be all done the same way.
+            */
+       case YP_SEQLIST:
+       case YP_SEQTYPE:
+       case YP_SETLIST:
+       case YP_SETTYPE:
+       case YP_CHOICE:
+           break;
+
+       default:
+           if (yp->yp_varexp == NULL)
+               break;          /* S* type entry - doesn't need a
+                                * malloc */
+
+           (void) fprintf(fp, "\t{ MEMALLOC, 0, sizeof (%s), 0 },\n", t);
+           break;
+       }
+    }
+
+
+    if ((yp->yp_flags & YP_PARMVAL) && yp->yp_parm) {
+       if ((f = getfield(yp->yp_parm)) == NULLCP) {
+           fprintf(stderr, "\ntdec_typ: can't extract field from %s\n",
+               yp->yp_parm);
+           exit(1);
+       }
+       f = strdup(f);
+    } else
+       f = yp->yp_varexp;
+
+    if ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+       == (YP_OPTIONAL|YP_OPTCONTROL)) {
+       char *f1;
+       char *bitno;
+
+       if (yp -> yp_optional_act && yp -> yp_optional_act -> yal_dec) {
+           (void) fprintf (fp, "\t{ BOPTIONAL, %d, 0, FL_USELECT},\n",
+                           control_act(yp -> yp_optional_act -> yal_dec));
+       }
+       else {
+           if ((f1 = getfldbit(yp->yp_optcontrol, &bitno)) == NULLCP) {
+               fprintf(stderr,
+                       "\ntdec_typ:BOPTIONAL: can't extract field from %s\n",
+                       yp->yp_optcontrol);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ BOPTIONAL, AOFFSET(%s, %s), %s, 0},\n", t,
+                          f1, bitno);
+       }
+    }
+
+    if (yp->yp_flags & YP_TAG && !(yp->yp_flags & YP_IMPLICIT)) {
+       (void) fprintf(fp, "\t{ ETAG, 0, ");
+       (void) fprintf(fp, "%s, %s },\n", ec_tag(yp), ec_class(yp));
+    }
+
+    if (yp->yp_yfn && yp->yp_yfn->yfn_dec) {
+
+       gen_fn(fp, yp, yp->yp_yfn->yfn_dec);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (gen_freefn(fp, yp)) {
+           if (yp->yp_aft_alist && yp->yp_aft_alist->yal_dec)
+               gen_act(fp, yp->yp_aft_alist->yal_dec);
+           return;
+       }
+    }
+
+    switch (yp->yp_code) {
+
+    case YP_UNDF:
+       ferr(1, "tdec_typ:Undefined type\n");
+
+    case YP_BOOL:
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:BOOL: must specify a field for boolean\n");
+       p1 = "BOOLEAN";
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f)))
+           break;
+       ferr(1, "tdec_typ:BOOL: couldn't determine type\n");
+
+       /* This needs to be fixed up in the action generating area */
+    case YP_INTLIST:
+
+    case YP_INT:
+
+    case YP_ENUMLIST:
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:INT: must specify a field for an integer\n");
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f))) {
+           p1 = "INTEGER";
+           break;
+       }
+       ferr(1, "tdec_typ:INT: couldn't determine type\n");
+       break;
+
+    case YP_REAL:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:REAL: must specify a field for a REAL\n");
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "REALTYPE";
+           break;
+       }
+       ferr(1, "tdec_typ:REAL: couldn't determine type\n");
+       break;
+
+
+    case YP_BIT:
+    case YP_BITLIST:
+       if (yp->yp_strexp && yp->yp_intexp) {
+           if (yp->yp_strexp)
+               f = setfield(yp->yp_strexp);
+           if (noindirect(f))
+               ferr(1, "tdec_typ:BIT: must specify a [[ x ... ]] value\n");
+           p1 = "BITSTR_PTR";
+           prnte(fp, t, f, yp, p1);
+           if (yp->yp_intexp)
+               f = setfield(yp->yp_intexp);
+           if (noindirect(f))
+               ferr(1, "tdec_typ:BIT: must specify a [[ x ... ]] value\n");
+           p1 = "BITSTR_LEN";
+           break;
+       }
+       if (yp->yp_strexp == NULLCP && yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f))) {
+           p1 = "BITSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SBITSTRING, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_OCT:
+       if (yp->yp_strexp) {
+           switch (yp->yp_prfexp) {
+           case 'q': /* [[ q parm->qbufptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   p1 = "SOCTETSTRING";
+               else
+                   p1 = "OCTETSTRING";
+               break;
+
+           case 's': /* [[ s ptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCTET: must specify a field [[ s .. ]]\n");
+               p1 = "T_STRING";
+               break;
+               
+           case 'o': /* [[ o ptr $ length ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCTET: must specify a field [[ o .. ]]\n");
+               p1 = "OCTET_PTR";
+               prnte(fp, t, f, yp, p1);
+               if (yp->yp_intexp)
+                   f = setfield(yp->yp_intexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCTET: must specify a field [[ o .. $ .. ]]\n");
+               p1 = "OCTET_LEN";
+               break;
+
+           default:
+              fprintf(stderr,"\ntdec_typ: Unknown Octet string specifier %c\n",
+                  yp->yp_prfexp);
+               exit(1);
+           }
+           break;
+       }
+       if (f) {
+           p1 = "OCTETSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SOCTETSTRING, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_OID:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "OBJID";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SOBJID, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_SEQ:
+    case YP_SET:
+    case YP_ANY:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "ANY";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SANY, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_NULL:
+       p1 = "T_NULL";
+       t = NULL;
+       break;
+
+    case YP_IDEFINED:
+       p1 = NULL;
+
+       if ((yp->yp_flags & YP_PARMVAL) && yp->yp_prfexp)
+               ferr(1,
+    "\n[[ ? reference ]] [[ p reference ]] is illegal\n\t only one allowed\n");
+
+       if (yp->yp_prfexp) { /* [[ ? parm->field ]] - complex to process */
+           gen_identry(fp, t, f, yp, gen_ventry);
+
+           if (yp->yp_flags & YP_DEFAULT)
+               gdflt(fp, yp, G_DEC);
+
+           break;
+       }
+
+       {
+           /* Predefined Universal Type */
+           struct univ_typ *p, *univtyp();
+
+           if ((p = univtyp(yp->yp_identifier))) {
+               if (p->univ_flags & UNF_EXTMOD) {
+                   yp->yp_module = p->univ_mod;
+                   goto do_obj;
+               }
+               if (f == NULL || noindirect(f)) {/* No offset type */
+                   if (yp->yp_flags & YP_TAG
+                       && yp->yp_flags & YP_IMPLICIT)
+                               prstfield(fp, p->univ_tab, t, f,
+                                int2tstr(yp->yp_tag->yt_value->yv_number),
+                                c_flags(yp, yp->yp_tag->yt_class));
+                   else
+                        prstfield(fp, p->univ_tab, t, f, int2tstr(p->univ_id),
+                                c_flags(yp, p->univ_class));
+                   goto out;
+               }
+               if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
+                        prtfield(fp, p->univ_tab, t, f,
+                            int2tstr(yp->yp_tag->yt_value->yv_number),
+                            c_flags(yp, yp->yp_tag->yt_class));
+               else
+                    prtfield(fp, p->univ_tab, t, f, int2tstr(p->univ_id),
+                            c_flags(yp, p->univ_class));
+               goto out;
+           }
+       }
+do_obj:
+       if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
+           (void) fprintf(fp, "\t{ IMP_OBJ, 0, %s, %s },\n", c_tag(yp), c_class(yp));
+       if (yp->yp_module == NULL
+           || strcmp(yp->yp_module, mymodule) == 0) {
+           if (f == NULL || noindirect(f))
+                  prstfield(fp, "OBJECT", t, f,
+                      concat("_Z", proc_name(yp->yp_identifier, 0)),
+                      c_class(yp));
+           else
+                  prtfield(fp, "OBJECT", t, f,
+                      concat("_Z", proc_name(yp->yp_identifier, 0)),
+                      c_class(yp));
+
+       } else {
+           if (f == NULL || noindirect(f))
+                  prstfield(fp, "EXTOBJ", t, f,
+                      concat("_Z", strp2name(yp->yp_identifier, yp->yp_module)),
+                        c_class(yp));
+           else
+                  prtfield(fp, "EXTOBJ", t, f,
+                      concat("_Z", strp2name(yp->yp_identifier, yp->yp_module)),
+                        c_class(yp));
+           (void) fprintf(fp, "\t{ EXTMOD, %d, 0, 0 },\n",
+                   gen_modref(yp->yp_module));
+       }
+    out:
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       break;
+
+    case YP_SEQLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tdec_typ:YP_SEQLIST:NULL varexp pointer\n");
+       prcte(fp, type, t, f, yp, "SEQ_START");
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntdec_typ:SEQLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_SEQLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (!type || !noindirect(f))
+               genmalloc(fp, yp);
+
+           if (optfield(y)) {
+               (void) fprintf(fp,
+                       "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
+                       yp->yp_structname);
+           }
+           tdec_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       break;
+
+    case YP_SETLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       p1 = NULL;
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tdec_typ:YP_SETLIST:NULL varexp pointer\n");
+       prcte(fp, type, t, f, yp, "SET_START");
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntdec_typ:SETLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_SETLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (!type || !noindirect(f))
+               genmalloc(fp, yp);
+
+           if (optfield(y)) {
+               (void) fprintf(fp,
+                       "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
+                       yp->yp_structname);
+           }
+           tdec_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       break;
+
+    case YP_SEQTYPE:           /* What is the difference ?? */
+       p1 = NULL;
+       prcte(fp, type, t, f, yp, "SEQOF_START");
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntdec_typ:SEQTYPE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_SEQTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (!type || !noindirect(f))
+               genmalloc(fp, yp);
+
+           tdec_loop(fp, y, id, yp->yp_structname);
+       }
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntdec_typ:SEQ OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
+                   yp->yp_structname);
+       else
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       break;
+
+    case YP_SETTYPE:
+       p1 = NULL;
+       prcte(fp, type, t, f, yp, "SETOF_START");
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (y = yp->yp_type) {
+           char *t1;
+
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntdec_typ:SETTYPE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_SETTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (!type || !noindirect(f))
+               genmalloc(fp, yp);
+
+           tdec_loop(fp, y, id, yp->yp_structname);
+       }
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntdec_typ:SET OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
+                   yp->yp_structname);
+       else
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       break;
+
+    case YP_CHOICE:
+       p1 = NULL;
+       /* support for -h flag */
+       if (hflag && (y = yp->yp_type) && !y->yp_next) {
+           tdec_typ(fp, y, id, yp->yp_structname);
+           break;
+       }
+       if (type == NULL || type && noindirect(f))
+           prstfield(fp, "CHOICE_START", t, f, 0, c_class(yp));
+       else
+           prtfield(fp, "CHOICE_START", t, type ? f : NULLCP, 0, c_class(yp));
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntdec_typ:CHOICE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_CHOICE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (!type || !noindirect(f))
+               genmalloc(fp, yp);
+
+
+           if (yp -> yp_control_act && yp->yp_control_act->yal_dec) {
+               (void) fprintf (fp, "\t{ SCTRL, %d, 0, FL_USELECT },\n",
+                               control_act(yp->yp_control_act -> yal_dec));
+           }
+           else if (yp->yp_flags & YP_CONTROLLED) {
+               char *f1;
+
+               if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+                   fprintf(stderr, "\ntdec_typ:CHOICE: can't extract field from %s\n",
+                           yp->yp_control);
+                   exit(1);
+               }
+               (void) fprintf(fp, "\t{ SCTRL, OFFSET(%s, %s), 0, 0 },\n",
+                              yp->yp_structname, f1);
+           } else if (yp->yp_structname != NULL)
+               (void) fprintf(fp,"\t{ SCTRL, OFFSET(%s, offset), 0, 0 },\n",
+                              yp->yp_structname);
+           else
+               ferr(1, "\nCHOICE missing SCTRL\n");
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                           "\ntdec_typ:CHOICE can't extract direct type from %s\n",
+                           yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tdec_typ:YP_CHOICE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tdec_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       break;
+
+    default:
+       ferrd(1, "tdec_typ: yp_code = %d  not implemented\n", yp->yp_code);
+    }
+
+    if (p1 != NULL) {
+       prnte(fp, t, f, yp, p1);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+    }
+
+    if (yp->yp_aft_alist && yp->yp_aft_alist->yal_dec)
+       gen_act(fp, yp->yp_aft_alist->yal_dec);
+
+}
+
+static int fflags[] = {
+    0, 1, 2, 2, 3, 3, 4, 5, 16, 16, 16, 17, 17, 17,
+0, -1, 7,};
+
+/*
+ * generate tables for encoding a contructed type
+ */
+YP 
+tdec_loop(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+    for (; yp != NULL; yp = yp->yp_next) {
+       tdec_typ(fp, yp, id, type);
+    }
+}
+/*
+ * Generate a malloc of for the given object
+ */
+genmalloc(fp, yp)
+FILE   *fp;
+YP      yp;
+{
+    if (hasdatstr(yp))
+       (void) fprintf(fp, "\t{ MEMALLOC, 0, sizeof (%s), 0 },\n",
+           yp->yp_structname);
+}
+/*
+ * Has Data Structure,
+ * determine if this type needs a data structure allocated to it - calls
+ * itself recursively to handle the cases of pulled up types
+ * returns non zero if it does need a type allocated for it
+ */
+hasdatstr(yp)
+YP      yp;
+{
+    YP     y;
+    YP yp1;
+    struct univ_typ    *p;
+
+   switch (yp -> yp_code) {
+       case YP_BIT: 
+       case YP_BITLIST: 
+       case YP_SEQ: 
+       case YP_SET: 
+       case YP_ANY: 
+       case YP_OCT: 
+       case YP_OID: 
+           break;
+
+       case YP_IDEFINED: 
+
+       yp1 = lkup(yp);
+
+       if (yp1->yp_code == YP_IDEFINED) {
+           if ((p = univtyp(yp1->yp_identifier)) == NULL
+             || p->univ_type <= YP_UNDF) {
+                   return (1); /* we can't tell unless we know what this is */
+                   /* ferr(0, "\tcomptag:treated as implicit\n"); */
+               }
+               if (p->univ_flags & UNF_HASDATA)
+                   return (1);
+               return (0);
+       } else
+           return (hasdatstr(yp1));
+
+       case YP_SEQLIST: 
+       case YP_SETLIST: 
+       case YP_CHOICE: 
+           if (hflag && (y = yp -> yp_type) && !y -> yp_next) {
+               return (hasdatstr(y));
+           }
+           /* else fall */
+
+       default: 
+           return (1);
+    }
+    return (0);
+}
+
+int control_act (act)
+Action act;
+{
+    register char *p;
+
+    for (p = act -> a_data; *p; p++)
+       if (!isspace (*p) && *p == '0')
+           return -1;
+    return act -> a_num;
+}
+
+/*
+ * generate an entry for the freeing routines
+ * if there is a freeing function just call that
+ * if not specify the type and offset so the free routines know how to free it
+ * return non zero if we don't want the normal decoding entry to be
+ * generated after us for freeing purposes.
+ */
+gen_freefn(fp, yp)
+FILE   *fp;
+YP     yp;
+{
+    char       *p1;
+    char       *fn;
+
+    if (yp->yp_yfn && (fn = yp->yp_yfn->yfn_fre)) {
+       (void) fprintf(fp, "\t{ FFN_CALL, %d, 0, 0, },\n", addptr(fn));
+       return (1);     /* don't free as per normal */
+    }
+
+    (void) fprintf(fp, "\t{ FREE_ONLY, 0, 0, 0, },\n");
+    return (0);
+    
+}
+
diff --git a/usr/src/contrib/isode/pepsy/enc.c b/usr/src/contrib/isode/pepsy/enc.c
new file mode 100644 (file)
index 0000000..acb3d3f
--- /dev/null
@@ -0,0 +1,1575 @@
+/* enc.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/enc.c,v 7.7 91/02/22 09:48:50 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/enc.c,v 7.7 91/02/22 09:48:50 mrose Interim $
+ *
+ *
+ * $Log:       enc.c,v $
+ * Revision 7.7  91/02/22  09:48:50  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.6  90/12/11  10:33:22  mrose
+ * sync
+ * 
+ * Revision 7.5  90/11/04  19:18:24  mrose
+ * update
+ * 
+ * Revision 7.4  90/10/23  20:42:57  mrose
+ * update
+ * 
+ * Revision 7.3  90/08/08  14:14:20  mrose
+ * update
+ * 
+ * Revision 7.2  90/07/27  08:49:34  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:52:27  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:16  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/* LINTLIBRARY */
+
+#include       <stdio.h>
+#include       <ctype.h>
+#include       "pepsy-driver.h"
+#include       "psap.h"
+#include       "pepsy.h"
+#include       "tailor.h"
+
+#ifndef        PEPYPARM
+#define PEPYPARM       char *
+#endif
+
+
+extern tpe *next_tpe(), *fdflt_f();
+char   *idname(), *clname();
+
+#define NEXT_TPE(p) (p = next_tpe(p))
+#define CHKTAG(mod, p, pe)     ismatch(p, mod, pe->pe_class, pe->pe_id)
+
+static char oomsg[] = "Out of memory";
+#define oom(a,b)       pepsylose ((a), (b), NULLPE, oomsg);
+#define RET_OK(rpe, pe)                *(rpe) = (pe), (OK)
+
+/*
+ * encode the specified type of the specified module into the given
+ * pe
+ */
+enc_f(typ, mod, pe, explicit, len, buf, parm)
+/* ARGSUSED */
+int     typ;                   /* which type it is */
+modtyp *mod;                   /* Module it is from */
+register PE *pe;
+int     explicit;
+int     len;
+char   *buf;
+char   *parm;
+{
+    register tpe *p;
+
+    if (typ < 0 || typ >= mod->md_nentries) {
+       (void) pepsylose (mod, NULLTPE, NULLPE, "enc_f:Illegal typ %d", typ);
+       return NOTOK;
+    }
+
+    p = mod->md_etab[typ];
+    if (p->pe_type != PE_START) {
+       return (pepsylose (mod, NULLTPE, NULLPE, "enc_f: missing PE_START"));
+    }
+    p++;
+
+    return (en_obj(parm, p, mod, pe));
+}
+
+/*
+ * Encode an object. If the object is a simple type it may have a
+ * compressed type reference. If it is a compound type it will not
+ * have an offset. This is very important as it means we cannot just
+ * use en_type to handle this which must always assume the field can
+ * have an offset.
+ */
+static int
+en_obj(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      pe = NULLPE;       /* for pepsylose calls */
+    int     cnt = 0;
+    tpe    *tmp;
+
+    DLOG (psap_log, LLOG_DEBUG, ("en_obj: type %d", p->pe_type));
+
+    *rpe = NULLPE;     /* default case */
+
+    while (p->pe_type != PE_END) {
+
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           return (pepsylose (mod, p, pe, "en_obj:END/START type"));
+
+       /*
+        * This allows Functions to be called at the very end of the 
+        * encoding -- With the encoded data - very messy
+        */
+       case UCODE:
+           if (mod->md_eucode == NULLIFP
+           || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       default:
+           if (en_type(parm, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+       }
+       if (ISDTYPE(p) && cnt++ > 0)
+           return pepsylose (mod, p, NULLPE, "en_obj:compound type found");
+
+       if (ISDTYPE(p)) {
+           if (pe == NULLPE)
+               return pepsylose (mod, p, NULLPE,
+                                 "en_obj: missing mandatory value");
+       }
+       /* make sure any final UCODEs get run
+       if (ISDTYPE(p) && pe != NULLPE)
+           return (RET_OK(rpe, pe));
+        */
+
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (RET_OK(rpe, pe));
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Encode a single type. If a basic type encode it, if a compound
+ * type call the appropriate encoding routine
+ */
+static int
+en_type(parm, p, mod, rpe)
+register PEPYPARM parm;
+register tpe    *p;
+register modtyp *mod;                  /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      pe = NULLPE;
+    int     cnt = 0;
+    int     i;                 /* Integer for encoding type */
+    tpe    *tmp;
+    char   *cp;
+
+    DLOG (psap_log, LLOG_DEBUG, ("Encoding the type %d", p->pe_type));
+
+    *rpe = NULLPE;
+    while (p->pe_type != PE_END) {
+
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           return (pepsylose (mod, p, pe, "en_type:END/START type"));
+
+       case DFLT_F:
+           tmp = p;
+           p = FDFLT_F(p);
+           if ((i = same(p, tmp, parm, mod)) == NOTOK)
+               return (NOTOK); /* Error */
+           if (i)
+               return (RET_OK(rpe, NULLPE));/* don't encode it */
+           p = tmp + 1;
+           continue;
+
+       case BOPTIONAL:
+           if (IF_USELECT(p)) {
+               if (mod -> md_eucode == NULLIFP)
+                   goto bad;
+               if ((*mod->md_eucode) (parm, &pe, p) == 0)
+                   return (RET_OK(rpe,NULLPE)); /* don't encode it */
+           } else if (!OPT_PRESENT(p, parm))
+               return (RET_OK(rpe, NULLPE));/* don't encode it */
+           p++; /* encode it */
+           continue;
+
+       case UCODE:
+           if (mod->md_eucode == NULLIFP
+           || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case ETAG:
+           if ((pe = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+               return oom (mod, p);
+
+           switch (p->pe_ucode) {
+
+           default:
+               p++;
+               if (en_etype(parm, p, mod, &pe->pe_cons) == NOTOK)
+                   goto bad;
+           }
+           break;
+
+       case SEQ_START:
+           if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SSEQ_START:
+           if (en_seq(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SSEQOF_START:
+           if (en_seqof(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SSET_START:
+           if (en_set(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SSETOF_START:
+           if (en_setof(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           tmp = p++;
+           if (p->pe_type == EXTOBJ) {
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                     0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+           } else if (p->pe_type == SEXTOBJ) {
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                     0, (char *)0, (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+           } else if (p->pe_type == SOBJECT) {
+               if (en_obj((char *) (parm + p->pe_ucode), mod->md_etab[p->pe_tag] + 1, mod, &pe)
+                 == NOTOK)
+                    goto bad;;
+           } else
+               if (en_obj(*(char **) (parm + p->pe_ucode),
+                       mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                   goto bad;
+
+           pe->pe_class = CLASS(tmp);
+           pe->pe_id = TAG(tmp);
+           break;
+
+       case SOBJECT:
+           if (en_obj((char *) (parm + p->pe_ucode), mod->md_etab[p->pe_tag] + 1, mod, &pe)
+             == NOTOK)
+               goto bad;
+           break;
+
+       case OBJECT:
+           if (en_obj(*(char **) (parm + p->pe_ucode),
+             mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case CHOICE_START:
+           if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe) ==NOTOK)
+               goto bad;
+           break;
+
+       case SCHOICE_START:
+           if (en_choice(parm + p->pe_ucode, p, mod, &pe) ==NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_seq: missing EXTMOD");
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 (char *) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_seq: missing EXTMOD");
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 *(char **) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       case INTEGER:
+           DLOG (psap_log, LLOG_DEBUG,
+               ("en_type:INTEGER offset is %d, value is %d",
+                               p->pe_ucode, *(integer *)(parm + p->pe_ucode)));
+
+           if ((pe = num2prim(*(integer *) (parm + p->pe_ucode),
+                              CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+#ifdef PEPSY_REALS
+       case REALTYPE:
+           DLOG (psap_log, LLOG_DEBUG, ("en_type:REAL: offset %d value %g",
+                                        p->pe_ucode,
+                                        *(double *) (parm + p->pe_ucode)));
+
+           if ((pe = real2prim(*(double *) (parm + p->pe_ucode),
+                              CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+#endif
+       case BOOLEAN:
+           DLOG (psap_log, LLOG_DEBUG, ("en_type:BOOLEAN:offset %d value %d",
+                                        p->pe_ucode,
+                                        *(char *) (parm + p->pe_ucode)));
+           if ((pe = flag2prim(*(char *) (parm + p->pe_ucode),
+                               CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case T_NULL:
+           DLOG (psap_log, LLOG_DEBUG, ("en_type:NULL:offset %d",p->pe_ucode));
+
+           if ((pe = pe_alloc(CLASS(p), PE_FORM_PRIM,
+                              TAG(p))) == NULLPE)
+               return oom(mod,p);
+
+           break;
+
+       case SANY:
+           (pe = (PE) (parm + p->pe_ucode))->pe_refcnt++;
+           break;
+
+       case ANY:
+           if ((parm + p->pe_ucode) == 0 || *(PE *) (parm + p->pe_ucode) == 0)
+#if ROSAP_HACK
+               /* hack for ROSAP. expects this strangeness */
+               pe = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL);
+#else
+               pe = NULLPE;
+#endif
+           else
+               (pe = *(PE *) (parm + p->pe_ucode))->pe_refcnt++;
+           break;
+
+       case SOCTETSTRING:
+           if ((pe = qb2prim((struct qbuf *) (parm + p->pe_ucode), CLASS(p), TAG(p)))
+               == NULLPE)
+               return oom(mod, p)
+           break;
+
+       case OCTETSTRING:
+           if ((pe = qb2prim(*(struct qbuf **) (parm + p->pe_ucode),
+                             CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case T_STRING:
+           if (*(char **) (parm + p->pe_ucode) == NULLCP)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:T_STRING missing pointer");
+           if ((pe = str2prim(*(char **) (parm + p->pe_ucode),
+                             strlen(*(char **) (parm + p->pe_ucode)),
+                             CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case OCTET_PTR:
+           if (p[1].pe_type != OCTET_LEN)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:missing OCTET_LEN");
+
+           if (*(char **) (parm + p->pe_ucode) == NULLCP)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:OCTET_PTR  missing pointer");
+
+           if (*(int *) (parm + (p + 1)->pe_ucode) < 0)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:OCTET_LEN negative length");
+
+           if ((pe = str2prim(*(char **) (parm + p->pe_ucode),
+                             *(int *) (parm + (p + 1)->pe_ucode),
+                             CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case BITSTR_PTR:
+           if (p[1].pe_type != BITSTR_LEN)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:missing BITSTR_LEN");
+
+           if (*(char **) (parm + p->pe_ucode) == NULLCP)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:BITSTR_PTR  missing pointer");
+
+           if (*(int *) (parm + (p + 1)->pe_ucode) < 0)
+               return pepsylose (mod, &p[1], NULLPE,
+                                 "en_type:BITSTR_LEN negative length");
+
+           if ((pe = strb2bitstr(*(char **) (parm + p->pe_ucode),
+                             *(int *) (parm + (p + 1)->pe_ucode),
+                             CLASS(p), TAG(p))) == NULLPE
+               || (pe = bit2prim(pe)) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case SBITSTRING:
+           if ((cp = bitstr2strb((PE) (parm + p->pe_ucode), &i)) == NULL)
+               return oom(mod, p);
+           if ((pe = strb2bitstr(cp, i, CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           free(cp);
+           if ((pe = bit2prim(pe)) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case BITSTRING:
+           if ((cp = bitstr2strb(*(PE *) (parm + p->pe_ucode), &i))
+               == NULL)
+               return oom(mod, p);
+
+           if ((pe = strb2bitstr(cp, i, CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+
+           free(cp);
+           if ((pe = bit2prim(pe)) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case SOBJID:
+           if ((pe = obj2prim((OID) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case OBJID:
+           if ((pe = obj2prim(*(OID *) (parm + p->pe_ucode), CLASS(p), TAG(p)))
+               == NULLPE)
+               return oom(mod, p);
+           break;
+
+       case FN_CALL:
+           if ((FN_PTR(mod, p))(parm, &pe) == NOTOK)
+               return pepsylose (mod, p, NULLPE,
+                                 "en_type:FN_CALL:call failed");
+           if (STAG(p) >= 0) {
+               pe->pe_class = CLASS(p);
+               pe->pe_id = TAG(p);
+           }
+           break;
+
+       default:
+           return pepsylose (mod, p, NULLPE, "en_type: type not implemented");
+       }
+       if (ISDTYPE(p) && cnt++ > 0)
+           return pepsylose (mod, p, NULLPE, "en_type:compound type found");
+
+       if (ISDTYPE(p)) {
+           if (pe == NULLPE)
+               return pepsylose (mod, p, NULLPE,
+                                 "en_type: missing mandatory value");
+       }
+       if (ISDTYPE(p) && pe != NULLPE)
+           return (RET_OK(rpe, pe));
+       if (NEXT_TPE(p) == NULLTPE)
+           goto bad;
+    }
+
+    return (RET_OK(rpe, pe));
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Build a sequence, calling appropriate routines to build each sub
+ * type
+ */
+static int
+en_seq(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      head;
+    PE      pe = NULLPE;
+    tpe    *tmp;               /* first entry in list */
+    int    *popt = NULL;       /* Pointer to optional field */
+    int     optcnt = 0;                /* Number of optionals bits so far */
+    int            val;
+
+    if (p->pe_type != SEQ_START && p->pe_type != SSEQ_START)
+           return (pepsylose (mod, p, pe, "en_seq: missing SEQ_START\n"));
+
+    if ((head = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+       return oom (mod, p);
+    p++;
+
+    while (p->pe_type != PE_END) {
+
+       DLOG (psap_log, LLOG_DEBUG, ("en_seq type%d", p->pe_type));
+
+       if (ISDTYPE(p) && OPTIONAL(p)) {
+           switch (p->pe_type) {
+           case INTEGER:
+           case REALTYPE:
+           case BOOLEAN:
+           case T_NULL:
+               if (!TESTBIT(*popt, optcnt++))
+                   goto next;  /* Missing so skip */
+               break;
+
+           case FN_CALL:
+               if ((val = hasdata(parm, p, mod, popt, optcnt)) == NOTOK)
+                   goto bad;
+               if (val == 0)
+                   goto next;
+               break;
+
+           case ETAG:
+               if ((val = hasdata(parm, p + 1, mod, popt, optcnt)) == NOTOK)
+                   goto bad;
+               if (val == 0)
+                   goto next;
+               break;
+
+           case IMP_OBJ:
+               if (p[1].pe_type == SOBJECT && parm == NULL
+                   || *((char **) (parm + p[1].pe_ucode)) == NULL)
+                   goto next;
+               break;
+
+           case SOBJECT:
+               if (((char *) parm) == NULL)
+                   goto next;
+               break;
+
+           default:
+               if (*((char **) (parm + p->pe_ucode)) == NULL)
+                   goto next;
+               break;
+           }
+       }
+       switch (p->pe_type) {
+       case OPTL:
+           popt = (int *) (parm + p->pe_ucode);
+           break;
+
+       case UCODE:
+           if (mod->md_eucode == NULLIFP
+           || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case ETAG:
+           if (en_type(parm, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQ_START:
+           if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           tmp = p++;
+           if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                     0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+           } else if (p->pe_type == SOBJECT) {
+               if (en_obj((char *) (parm + p->pe_ucode), mod->md_etab[p->pe_tag] + 1, mod,
+                     &pe) == NOTOK)
+                   goto bad;
+           } else
+               if (en_obj(*(char **) (parm + p->pe_ucode),
+                       mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                   goto bad;
+           pe->pe_class = CLASS(tmp);
+           pe->pe_id = TAG(tmp);
+           break;
+
+       case SOBJECT:
+           if (en_obj((char *) (parm + p->pe_ucode), mod->md_etab[p->pe_tag] + 1, mod, &pe)
+                   == NOTOK)
+               goto bad;
+           break;
+
+       case OBJECT:
+           if (en_obj(*(char **) (parm + p->pe_ucode),
+                   mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case CHOICE_START:
+           if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SCHOICE_START:
+           if (en_choice((char *) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, &p[1], NULLPE, "en_seq: missing EXTMOD");
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 (char *) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, &p[1], NULLPE, "en_seq: missing EXTMOD");
+
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 *(char **) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       default:
+           if (en_type(parm, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+       }
+
+       if ((ISDTYPE(p) || p->pe_type == BOPTIONAL) && pe != NULLPE) {
+           if (seq_add(head, pe, -1) == NOTOK)
+               return pepsylose (mod, p, NULLPE, "en_seq bad sequence: %s",
+                      pe_error(pe->pe_errno));
+       }
+next:
+       if (NEXT_TPE(p) == NULLTPE)
+           return (NOTOK);
+    }
+
+    return (RET_OK(rpe, head));
+
+bad:
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a set, calling appropriate routines to parse each sub type
+ */
+static int
+en_set(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      head;
+    PE      pe = NULLPE;
+    tpe    *tmp;
+    int    *popt = NULL;       /* Pointer to optional field */
+    int     optcnt = 0;                /* Number of optionals bits so far */
+    int            val;
+
+    if (p->pe_type != SET_START && p->pe_type != SSET_START)
+       return pepsylose (mod, p, pe, "en_set: missing SET_START");
+
+    if ((head = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+       return oom(mod, p);
+
+    p++;
+    while (p->pe_type != PE_END) {
+
+       DLOG (psap_log, LLOG_DEBUG, ("en_set type %d", p->pe_type));
+
+       if (ISDTYPE(p) && OPTIONAL(p)) {
+           switch (p->pe_type) {
+           case INTEGER:
+           case REALTYPE:
+           case BOOLEAN:
+           case T_NULL:
+               if (!TESTBIT(*popt, optcnt++))
+                   goto next;  /* Missing so skip */
+               break;
+
+           case FN_CALL:
+               if ((val = hasdata(parm, p, mod, popt, optcnt)) == NOTOK)
+                   goto bad;
+               if (val == 0)
+                   goto next;
+               break;
+
+           case ETAG:
+               if ((val = hasdata(parm, p + 1, mod, popt, optcnt)) == NOTOK)
+                   goto bad;
+               if (val == 0)
+                   goto next;
+               break;
+
+           case IMP_OBJ:
+               if (p[1].pe_type == SOBJECT && parm == NULL
+                   || *((char **) (parm + p[1].pe_ucode)) == NULL)
+                   goto next;
+               break;
+
+           case SOBJECT:
+               if (((char *) (parm + p->pe_ucode)) == NULL)
+                   goto next;
+               break;
+
+           default:
+               if (*((char **) (parm + p->pe_ucode)) == NULL)
+                   goto next;
+               break;
+           }
+       }
+       switch (p->pe_type) {
+       case OPTL:
+           popt = (int *) (parm + p->pe_ucode);
+           break;
+
+       case UCODE:
+           if (mod->md_eucode == NULLIFP
+           || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case ETAG:
+           if (en_type(parm, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQ_START:
+           if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQOF_START:
+           if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SET_START:
+           if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SETOF_START:
+           if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case IMP_OBJ:
+           tmp = p++;
+           if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                     0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+           } else if (p->pe_type == SOBJECT) {
+               if (en_obj((char *) parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod,
+                       &pe) == NOTOK)
+                   goto bad;
+           } else
+               if (en_obj(*(char **) (parm + p->pe_ucode),
+                       mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                   goto bad;
+           pe->pe_class = CLASS(tmp);
+           pe->pe_id = TAG(tmp);
+           break;
+
+       case SOBJECT:
+           if (en_obj(parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case OBJECT:
+           if (en_obj(*(char **) (parm + p->pe_ucode),
+                   mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case CHOICE_START:
+           if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe) ==NOTOK)
+               goto bad;
+           break;
+
+
+       case SCHOICE_START:
+           if (en_choice((char *) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD)
+               return pepsylose (mod, p, NULLPE, "en_set: missing EXTMOD");
+
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 parm + p->pe_ucode) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD) 
+               return pepsylose (mod, p, NULLPE, "en_set: missing EXTMOD");
+
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                 *(char **) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+           break;
+
+       default:
+           if (en_type(parm, p, mod, &pe) == NOTOK)
+               goto bad;
+           break;
+       }
+
+       if ((ISDTYPE(p) || p->pe_type == BOPTIONAL) && pe != NULLPE) {
+           if (set_add(head, pe) == NOTOK)
+               return pepsylose (mod, p, NULLPE, "en_set bad set: %s",
+                                 pe_error(pe->pe_errno));
+       }
+next:
+       NEXT_TPE(p);
+    }
+
+    return (RET_OK(rpe, head));
+
+bad:
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a sequence of calling appropriate routines to parse each sub
+ * type
+ */
+static int
+en_seqof(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      head;
+    PE      pe = NULLPE;
+    tpe    *start;             /* first entry in list */
+    tpe    *tmp;
+
+    if (p->pe_type != SEQOF_START && p->pe_type != SSEQOF_START)
+       return pepsylose (mod, p, NULLPE, "en_seqof: missing SEQOF_START");
+
+    if ((head = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+       return oom(mod, p);
+
+    start = p;
+    while ((char *) parm != NULL) {
+       p++;
+       while (p->pe_type != PE_END) {
+
+           DLOG (psap_log, LLOG_DEBUG, ("en_seqof type%d", p->pe_type));
+
+           switch (p->pe_type) {
+           case UCODE:
+               if (mod->md_eucode == NULLIFP
+               || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+                   goto bad;
+               break;
+
+           case ETAG:
+               if (en_type(parm, p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEQ_START:
+               if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe)==NOTOK)
+                   goto bad;
+               break;
+
+           case SEQOF_START:
+               if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+           case SET_START:
+               if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe)==NOTOK)
+                   goto bad;
+               break;
+
+           case SETOF_START:
+               if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+           case IMP_OBJ:
+               tmp = p++;
+               if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+                   if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                      0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                      return (NOTOK);
+               } else if (p->pe_type == SOBJECT) {
+                   if (en_obj((char *) (parm + p->pe_ucode), mod->md_etab[p->pe_tag] + 1,
+                           mod, &pe) == NOTOK)
+                       goto bad;
+               } else if (en_obj(*(char **) (parm + p->pe_ucode),
+                           mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                       goto bad;
+               pe->pe_class = CLASS(tmp);
+               pe->pe_id = TAG(tmp);
+               break;
+
+           case SOBJECT:
+               if (en_obj(parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod, &pe) ==NOTOK)
+                   goto bad;
+               break;
+
+           case OBJECT:
+               if (en_obj(*(char **) (parm + p->pe_ucode),
+                       mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case CHOICE_START:
+               if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+
+           case SCHOICE_START:
+               if (en_choice((char *) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p+1, NULLPE,
+                                     "en_seqof: missing EXTMOD");
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                     parm + p->pe_ucode) == NOTOK)
+                     return (NOTOK);
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD) 
+                   return pepsylose (mod, p+1, NULLPE,
+                                     "en_seqof: missing EXTMOD");
+
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                     *(char **) (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+               break;
+
+           default:
+               if (en_type(parm, p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+           }
+           if (ISDTYPE(p) && pe != NULLPE) {
+               if (seq_add(head, pe, -1) == NOTOK)
+                   return pepsylose (mod, p, NULLPE,
+                                     "en_seqof bad sequence: %s",
+                                     pe_error(pe->pe_errno));
+           }
+           if (NEXT_TPE(p) == NULLTPE)
+               goto bad;
+       }
+       parm = *(char **) (parm + p->pe_ucode); /* Any more ? */
+       p = start;
+    }
+
+    return (RET_OK(rpe, head));
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a setof, calling appropriate routines to parse each sub type
+ */
+static int
+en_setof(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    PE      head;
+    PE      pe = NULLPE, last = NULLPE;
+    tpe    *start;
+    tpe    *tmp;
+
+    if (p->pe_type != SETOF_START && p->pe_type != SSETOF_START)
+       return pepsylose (mod, p, NULLPE, "en_setof: missing SETOF_START");
+
+    if ((head = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+       return oom(mod,p);
+
+    start = p;
+    while ((char *) parm != NULL) {
+       p++;
+       while (p->pe_type != PE_END) {
+           DLOG (psap_log, LLOG_DEBUG, ("en_setof type%d",
+                                        p->pe_type));
+
+           switch (p->pe_type) {
+           case UCODE:
+               if (mod->md_eucode == NULLIFP
+               || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+                   goto bad;
+               break;
+
+           case ETAG:
+               if (en_type(parm, p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEQ_START:
+               if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe)==NOTOK)
+                   goto bad;
+               break;
+
+           case SEQOF_START:
+               if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+           case SET_START:
+               if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe)==NOTOK)
+                   goto bad;
+               break;
+
+           case SETOF_START:
+               if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+           case IMP_OBJ:
+               tmp = p++;
+               if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+                   if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                      0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                      return (NOTOK);
+               } else if (p->pe_type == SOBJECT) {
+                   if (en_obj((char *) parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1,
+                           mod, &pe) == NOTOK)
+                       goto bad;
+               } else
+                   if (en_obj(*(char **) (parm + p->pe_ucode),
+                           mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                       goto bad;
+               pe->pe_class = CLASS(tmp);
+               pe->pe_id = TAG(tmp);
+               break;
+
+           case SOBJECT:
+               if (en_obj(parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod, &pe) ==NOTOK)
+                   goto bad;
+               break;
+
+           case OBJECT:
+               if (en_obj(*(char **) (parm + p->pe_ucode),
+                       mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case CHOICE_START:
+               if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe)
+                       == NOTOK)
+                   goto bad;
+               break;
+
+
+           case SCHOICE_START:
+               if (en_choice((char *) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p + 1, NULLPE,
+                                     "en_setof: missing EXTMOD");
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                     parm + p->pe_ucode) == NOTOK)
+                     return (NOTOK);
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD)
+                   return pepsylose (mod, p + 1, NULLPE,
+                                     "en_setof: missing EXTMOD");
+
+               if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+                     *(char **) (parm + p->pe_ucode)) == NOTOK)
+                     return (NOTOK);
+               break;
+
+           default:
+               if (en_type(parm, p, mod, &pe) == NOTOK)
+                   goto bad;
+               break;
+           }
+
+           if (ISDTYPE(p) && pe != NULLPE) {
+               if (set_addon(head, last, pe) == NOTOK)
+                   return pepsylose (mod, p, NULLPE, "en_setof bad set: %s",
+                                     pe_error(pe->pe_errno));
+               else
+                   last = pe;
+           }
+
+           if (NEXT_TPE(p) == NULLTPE)
+               goto bad;;
+       }
+       parm = *(char **) (parm + p->pe_ucode); /* Any more ? */
+       p = start;
+    }
+
+    return (RET_OK(rpe, head));
+
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * encode a choice field. This means find which choice is taken and
+ * call en_type to encode it
+ */
+static int
+en_choice(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    int     cnt;
+
+    if (p->pe_type != CHOICE_START && p->pe_type != SCHOICE_START)
+       return pepsylose (mod, p, NULLPE, "en_choice:missing CHOICE_START");
+    p++;
+    if (p->pe_type != SCTRL)
+       return pepsylose (mod, p, NULLPE, "en_choice:missing SCTRL");
+
+    if (IF_USELECT(p)) {
+       if (mod->md_eucode == NULLIFP ||
+           (cnt = (*mod -> md_eucode) (parm, &rpe, p)) == NOTOK)
+           return pepsylose (mod, p, NULLPE, "choice selection failed");
+    }
+    else
+       cnt = *(int *) (parm + p->pe_ucode);
+
+    DLOG (psap_log, LLOG_DEBUG, ("cnt %d", cnt));
+
+    if (cnt != 0)
+       cnt--;
+    if (cnt < 0)
+       return pepsylose (mod, p, NULLPE, "en_choice:offset %d negative", cnt);
+
+    for (p++; p->pe_type != PE_END; NEXT_TPE(p)) {
+       if (cnt == 0 && p->pe_type == UCODE) {
+               if (mod->md_eucode == NULLIFP
+               || (*mod->md_eucode) (parm, &rpe, p) == NOTOK)
+                   return (NOTOK);
+       }
+       if (ISDTYPE(p)) {
+           if (cnt == 0) {
+               if (en_etype(parm, p, mod, rpe) == NOTOK)
+                   return (NOTOK);
+               return (OK);
+           }
+           cnt--;
+       }
+    }
+
+    return pepsylose (mod, p, NULLPE, "en_choice: no choice taken");
+}
+
+
+/*
+ * check to see if the object is present or not
+ */
+static int
+chkobj(mod, p, head)
+modtyp *mod;
+tpe    *p;
+PE      head;
+{
+
+    for (; p->pe_type != PE_END; NEXT_TPE(p)) {
+       if (!ISDTYPE(p))
+           continue;
+
+       if (p->pe_type == OBJECT) {
+           if (chkobj(mod, p, head))
+               return (1);
+       } else if (CHKTAG(mod, p, head))
+           return (1);
+
+       if (OPTIONAL(p) || DEFAULT(p))
+           continue;
+
+       return (0);
+    }
+    return (0);
+}
+
+/*
+ * Encode a single type for an explicit tag field If a basic type
+ * encode it, if a compound type call the appropriate encoding
+ * routine. Similar to en_type except we do the indirection on the
+ * ucode field
+ */
+static int
+en_etype(parm, p, mod, rpe)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+PE     *rpe;           /* Return value PE */
+{
+    tpe    *tmp;
+    PE      pe = NULLPE;
+
+    switch (p->pe_type) {
+    case PE_END:
+    case PE_START:
+       return (pepsylose (mod, p, pe, "en_etype:END/START type"));
+
+    case UCODE:
+       if (mod->md_eucode == NULLIFP
+       || (*mod->md_eucode) (parm, &pe, p) == NOTOK)
+           goto bad;
+       break;
+
+    case ETAG:
+       if ((pe = pe_alloc(CLASS(p), PE_FORM_CONS, TAG(p))) == NULLPE)
+           return oom(mod, p);
+       switch (p->pe_ucode) {
+       default:
+           p++;
+           if (en_etype(parm, p, mod, &pe->pe_cons) == NOTOK)
+               goto bad;
+       }
+       break;
+
+    case SEQ_START:
+       if (en_seq(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SEQOF_START:
+       if (en_seqof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SET_START:
+       if (en_set(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SETOF_START:
+       if (en_setof(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SSEQ_START:
+       if (en_seq(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SSEQOF_START:
+       if (en_seqof(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SSET_START:
+       if (en_set(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SSETOF_START:
+       if (en_setof(parm + p->pe_ucode, p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case IMP_OBJ:
+       tmp = p++;
+       if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+           if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1,
+                 0, (char *)0, *(char **) (parm + p->pe_ucode)) == NOTOK)
+                 return (NOTOK);
+       } else if (p->pe_type == SOBJECT) {
+           if (en_obj((char *) parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod, &pe)
+                   == NOTOK)
+               goto bad;
+       } else
+           if (en_obj(*(char **) (parm + p->pe_ucode),
+                   mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+               goto bad;
+       pe->pe_class = CLASS(tmp);
+       pe->pe_id = TAG(tmp);
+       break;
+
+    case SOBJECT:
+       if (en_obj(parm + p->pe_ucode, mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case OBJECT:
+       if (en_obj(*(char **) (parm + p->pe_ucode),
+               mod->md_etab[p->pe_tag] + 1, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case CHOICE_START:
+       if (en_choice(*(char **) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+           goto bad;
+       break;
+
+    case SCHOICE_START:
+        if (en_choice((char *) (parm + p->pe_ucode), p, mod, &pe) == NOTOK)
+          goto bad;
+      break;
+
+    case INTEGER:
+       DLOG (psap_log, LLOG_DEBUG, ("offset %d value %d",
+                                    p->pe_ucode,
+                                    *(integer *) (parm + p->pe_ucode)));
+       if ((pe = num2prim(*(integer *) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+           return oom (mod, p);
+
+       break;
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       DLOG (psap_log,  LLOG_DEBUG, ("offset %d value %g",
+                                     p->pe_ucode,
+                                     *(double *) (parm + p->pe_ucode)));
+           if ((pe = real2prim(*(double *) (parm + p->pe_ucode),
+                              CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           break;
+
+#endif
+    case BOOLEAN:
+       DLOG (psap_log, LLOG_DEBUG, ("offset %d value %d",
+                                    p->pe_ucode,
+                                    *(char *) (parm + p->pe_ucode)));
+
+       if ((pe = flag2prim(*(char *) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case T_NULL:
+       DLOG (psap_log, LLOG_DEBUG, ("offset %d", p->pe_ucode));
+       if ((pe = pe_alloc(CLASS(p), PE_FORM_PRIM, TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case SANY:
+       (pe = (PE) (parm + p->pe_ucode))->pe_refcnt++;
+       break;
+
+    case ANY:
+       if ((parm + p->pe_ucode) == 0 || *(PE *) (parm + p->pe_ucode) == 0)
+#if ROSAP_HACK
+           /* hack for ROSAP. expects this strangeness */
+           pe = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL);
+#else
+           pe = NULLPE;
+#endif
+       else
+           (pe = *(PE *) (parm + p->pe_ucode))->pe_refcnt++;
+       break;
+
+    case SEXTOBJ:
+       if (p[1].pe_type != EXTMOD)
+           return pepsylose (mod, p+1, NULLPE, "en_etype: missing EXTMOD");
+       if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+           parm + p->pe_ucode) == NOTOK)
+           return (NOTOK);
+       break;
+
+    case EXTOBJ:
+       if (p[1].pe_type != EXTMOD)
+           return pepsylose (mod, p+1, NULLPE, "en_etype: missing EXTMOD");
+       if (enc_f(p->pe_tag, EXT2MOD(mod, (p + 1)), &pe, 1, 0, (char *)0,
+             *(char **) (parm + p->pe_ucode)) == NOTOK)
+             return (NOTOK);
+       break;
+
+    case SOCTETSTRING:
+       if ((pe = qb2prim((struct qbuf *) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case SBITSTRING:
+       {
+           char   *cp;
+           int     i;
+
+           if ((cp = bitstr2strb((PE) (parm + p->pe_ucode), &i)) == NULL)
+               return oom(mod, p);
+           if ((pe = strb2bitstr(cp, i, CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           free(cp);
+           if ((pe = bit2prim (pe)) == NULLPE)
+               return oom(mod, p);
+       }
+       break;
+
+    case OCTETSTRING:
+       if ((pe = qb2prim(*(struct qbuf **) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case T_STRING:
+       if (*(char **) (parm + p->pe_ucode) == NULLCP)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:T_STRING missing pointer");
+
+       if ((pe = str2prim(*(char **) (parm + p->pe_ucode),
+                         strlen(*(char **) (parm + p->pe_ucode)),
+                         CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case OCTET_PTR:
+       if (p[1].pe_type != OCTET_LEN)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype: missing OCTET_LEN");
+
+       if (*(char **) (parm + p->pe_ucode) == NULLCP)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:OCTET_PTR missing pointer");
+
+       if (*(int *) (parm + (p + 1)->pe_ucode) < 0)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:OCTET_LEN negative length");
+
+       if ((pe = str2prim(*(char **) (parm + p->pe_ucode),
+                         *(int *) (parm + (p + 1)->pe_ucode),
+                         CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case BITSTR_PTR:
+       if (p[1].pe_type != BITSTR_LEN)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:missing BITSTR_LEN");
+
+       if (*(char **) (parm + p->pe_ucode) == NULLCP)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:BITSTR_PTR  missing pointer");
+
+       if (*(int *) (parm + (p + 1)->pe_ucode) < 0)
+           return pepsylose (mod, &p[1], NULLPE,
+                             "en_etype:BITSTR_LEN negative length");
+
+       if ((pe = strb2bitstr(*(char **) (parm + p->pe_ucode),
+                         *(int *) (parm + (p + 1)->pe_ucode),
+                         CLASS(p), TAG(p))) == NULLPE
+           || (pe = bit2prim(pe)) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case BITSTRING:
+       {
+           char   *cp;
+           int     i;
+
+           if ((cp = bitstr2strb(*(PE *) (parm + p->pe_ucode), &i)) == NULL)
+               return oom(mod, p);
+           if ((pe = strb2bitstr(cp, i, CLASS(p), TAG(p))) == NULLPE)
+               return oom(mod, p);
+           free(cp);
+           if ((pe = bit2prim(pe)) == NULLPE)
+               return oom(mod, p);
+       }
+       break;
+
+    case SOBJID:
+       if ((pe = obj2prim((OID) (parm + p->pe_ucode), CLASS(p), TAG(p))) == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case OBJID:
+       if ((pe = obj2prim(*(OID *) (parm + p->pe_ucode), CLASS(p), TAG(p)))
+           == NULLPE)
+           return oom(mod, p);
+       break;
+
+    case FN_CALL:
+       if ((FN_PTR(mod, p))(parm, &pe) == NOTOK)
+           return pepsylose (mod, p, NULLPE,
+                             "en_etype:FN_CALL:call failed");
+       if (STAG(p) >= 0) {
+           pe->pe_class = CLASS(p);
+           pe->pe_id = TAG(p);
+       }
+       break;
+
+    default:
+       return pepsylose (mod, p, NULLPE, "en_etype: type not implemented");
+    }
+    return (RET_OK(rpe, pe));
+
+bad:
+    return (NOTOK);
+}
diff --git a/usr/src/contrib/isode/pepsy/etabs.c b/usr/src/contrib/isode/pepsy/etabs.c
new file mode 100644 (file)
index 0000000..0bed500
--- /dev/null
@@ -0,0 +1,2299 @@
+/* etabs.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/etabs.c,v 7.8 91/02/22 09:48:54 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/etabs.c,v 7.8 91/02/22 09:48:54 mrose Interim $
+ *
+ *
+ * $Log:       etabs.c,v $
+ * Revision 7.8  91/02/22  09:48:54  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.7  91/01/08  12:49:27  mrose
+ * update
+ * 
+ * Revision 7.6  90/12/11  10:33:33  mrose
+ * sync
+ * 
+ * Revision 7.5  90/11/11  10:53:43  mrose
+ * update
+ * 
+ * Revision 7.4  90/11/04  19:18:31  mrose
+ * update
+ * 
+ * Revision 7.3  90/08/18  00:44:20  mrose
+ * touch-up
+ * 
+ * Revision 7.2  90/07/27  08:49:15  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:52:33  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:18  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include "pepsydefs.h"
+#include "sym.h"
+#include "pass2.h"
+#include "mine.h"
+
+s_table *head;
+
+extern s_table *lookup_list(), *proc_def();
+
+extern char *c_tag(), *c_class();
+extern char *ec_tag(), *ec_class();
+extern char *strip_last();
+extern char *get_val(), *get_comp(), *get_string();
+extern s_table *get_offset();
+extern char *my_strcat(), *strp2name();
+extern char *my_new_str();
+extern char *mymodule;
+extern char *modsym();
+extern char *concat();
+extern char *genlabel();
+extern char *notidtoid();
+extern char *code2name();
+extern char *yp2name();
+extern YV calc_yv();
+extern SY syfind();
+static s_table *en_ptr;
+extern s_table *ptr;
+extern char    *rm_indirect();
+extern char    *getfield();
+extern char    *setfield();
+
+static int cons_type = 0;
+/* int     explicit; */
+
+s_table *save_ptr;
+
+extern YT gen_etag();
+
+#define WORDSIZE       20
+#define MAXNAME                256     /* maximum size of a identifier */
+
+#ifdef DEBUG
+char   *str_yp_code[] = {
+    "Undefined", "Boolean", "Integer", "Named number list", "Bitstring",
+    "Named Bitstring list", "Octet String", "Null", "Sequence",
+    "Sequence of", "Sequence list", "Set", "Set of", "Set list",
+    "Choice", "Any", "Object Identifier",
+    "", "", "", "", "", "", "", "",
+    "", "", "", "", "", "", "", "Identifier",
+
+};
+
+#endif
+
+/*
+ * table encode a type. generate tables for the encoding of a type
+ */
+tenc_typ(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+
+    char   *t, *f;
+    char   *p1;
+    char   *s1, *s2, *s3;
+    char   *s;
+    s_table *ptr1, *ptr2;
+    YP      y;
+    YAL                yal;
+
+
+    if (yp->yp_code < 0 || yp->yp_code > YP_REAL)
+       ferrd(1, "tenc_typ: unimplemented type %d\n", yp->yp_code);
+
+    if (yp == NULL) {
+       ferr(0, "tenc_typ:NULL argument\n");
+       return;
+    }
+
+    /* Preserve the type of the containing object */
+    if (type)
+       t = type;
+    else if (yp->yp_param_type) {
+       char *t1;
+       /* we have a [[ P type ]] specification */
+       if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+           fprintf(stderr,
+           "\ntenc_typ:SETLIST can't extract direct type from %s\n",
+               yp->yp_param_type);
+           exit(1);
+       }
+       t = strdup(t1);
+    } else
+       t = my_strcat("struct ", modsym(mymodule, id, "type"));
+
+    if (yal = yp->yp_bef_alist) {
+       yal->yal_type = t;
+       if (yal->yal_enc)
+           gen_act(fp, yp->yp_bef_alist->yal_enc);
+    }
+    if (yal = yp->yp_aft_alist) {
+       yal->yal_type = t;
+    }
+    if (yal = yp->yp_control_act)
+       yal -> yal_type = t;
+
+    if (yal = yp->yp_optional_act)
+       yal -> yal_type = t;
+
+    if (yp->yp_flags & YP_DEFAULT)
+       gdflt(fp, yp, G_ENC);
+
+    if ((yp->yp_flags & YP_PARMVAL) && yp->yp_parm) {
+       if ((f = getfield(yp->yp_parm)) == NULLCP) {
+           fprintf(stderr, "\ntenc_typ: can't extract field from %s\n",
+               yp->yp_parm);
+           exit(1);
+       }
+       f = strdup(f);
+    } else
+       f = yp->yp_varexp;
+
+    if ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+       == (YP_OPTIONAL|YP_OPTCONTROL)) {
+       char    *f1;
+       char    *bitno;
+
+       if (yp -> yp_optional_act && yp -> yp_optional_act -> yal_enc) {
+           fprintf (fp, "\t{ BOPTIONAL, %d, 0, FL_USELECT},\n",
+                    yp -> yp_optional_act -> yal_enc -> a_num);
+       }
+       else {
+           if ((f1 = getfldbit(yp->yp_optcontrol, &bitno)) == NULLCP) {
+               fprintf(stderr,
+                       "\ntenc_typ:BOPTIONAL: can't extract field from %s\n",
+                       yp->yp_optcontrol);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ BOPTIONAL, AOFFSET(%s, %s), %s, 0},\n",
+                          t, f1, bitno);
+       }
+    }
+
+    /* handle explicit tags - one day may have to change this if anyone
+     * ever defines a type with more than one explicit tag
+     */
+    if (yp->yp_flags & YP_TAG && !(yp->yp_flags & YP_IMPLICIT)) {
+       (void) fprintf(fp, "\t{ ETAG, 0, ");
+       (void) fprintf(fp, "%s, %s },\n", ec_tag(yp), ec_class(yp));
+    }
+
+    if (yp->yp_yfn && yp->yp_yfn->yfn_enc) {
+       gen_fn(fp, yp, yp->yp_yfn->yfn_enc);
+
+       if (yp->yp_aft_alist && yp->yp_aft_alist->yal_enc)
+           gen_act(fp, yp->yp_aft_alist->yal_enc);
+
+       return;
+    }
+
+    switch (yp->yp_code) {
+
+    case YP_UNDF:
+       ferr(1, "tenc_typ:Undefined type\n");
+
+    case YP_BOOL:
+       p1 = "BOOLEAN";
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tenc_typ:BOOL: must specify a field [[ b .. ]]\n");
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f)))
+           break;
+       ferr(1, "tenc_typ:BOOL: couldn't determine type\n");
+
+    case YP_INTLIST:
+
+    case YP_INT:
+
+    case YP_ENUMLIST:
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tenc_typ:INT: must specify a field [[ i .. ]]\n");
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f))) {
+           p1 = "INTEGER";
+           break;
+       }
+       ferr(1, "tenc_typ:INT: couldn't determine type\n");
+       break;
+
+    case YP_REAL:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (noindirect(f))
+           ferr(1, "tenc_typ:REAL: must specify a field [[ r .. ]]\n");
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "REALTYPE";
+           break;
+       }
+       ferr(1, "tenc_typ:REAL: couldn't determine type\n");
+       break;
+
+    case YP_BIT:
+    case YP_BITLIST:
+       if (yp->yp_strexp && yp->yp_intexp) {
+           if (yp->yp_strexp)
+               f = setfield(yp->yp_strexp);
+           if (noindirect(f))
+               ferr(1, "tenc_typ:BIT: must specify a field [[ x .. ]]\n");
+           p1 = "BITSTR_PTR";
+           prnte(fp, t, f, yp, p1);
+           if (yp->yp_intexp)
+               f = setfield(yp->yp_intexp);
+           if (noindirect(f))
+               ferr(1, "tenc_typ:BIT: must specify a field [[ x .. ]]\n");
+           p1 = "BITSTR_LEN";
+           break;
+       }
+       if (yp->yp_strexp == NULLCP && yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f))) {
+           p1 = "BITSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SBITSTRING, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_OCT:
+       if (yp->yp_strexp) {
+           switch (yp->yp_prfexp) {
+           case 'q': /* [[ q parm->qbufptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   p1 = "SOCTETSTRING";
+               else
+                   p1 = "OCTETSTRING";
+               break;
+
+           case 's': /* [[ s ptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tenc_typ:OCT: must specify a field [[ s .. ]]\n");
+               p1 = "T_STRING";
+               break;
+               
+           case 'o': /* [[ o ptr $ length ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tenc_typ:OCT: must specify a field [[ s .. ]]\n");
+               p1 = "OCTET_PTR";
+               prnte(fp, t, f, yp, p1);
+               if (yp->yp_intexp)
+                   f = setfield(yp->yp_intexp);
+               if (noindirect(f))
+                   ferr(1, "tenc_typ:OCT: must specify a field [[ s .. ]]\n");
+               p1 = "OCTET_LEN";
+               break;
+
+           default:
+              fprintf(stderr,"\ntenc_typ: Unknown Octet string specifier %c\n",
+                  yp->yp_prfexp);
+               exit(1);
+           }
+           break;
+       }
+
+       if (f && !noindirect(f)) {
+           p1 = "OCTETSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SOCTETSTRING, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_OID:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "OBJID";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SOBJID, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+
+    case YP_SEQ:
+    case YP_SET:
+    case YP_ANY:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "ANY";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SANY, 0, %s, %s },\n",
+               c_tag(yp), c_class(yp));
+       break;
+
+    case YP_NULL:
+       p1 = "T_NULL";
+       t = NULL;
+       break;
+
+    case YP_IDEFINED:
+       p1 = NULL;
+       if ((yp->yp_flags & YP_PARMVAL) && yp->yp_prfexp)
+               ferr(1,
+    "\n[[ ? reference ]] [[ p reference ]] is illegal\n\t only one allowed\n");
+
+       if (yp->yp_prfexp) { /* [[ ? parm->field ]] - complex to process */
+           gen_identry(fp, t, f, yp, gen_ventry);
+           break;
+       }
+
+       {
+           /* Predefined Universal Type */
+           struct univ_typ *p, *univtyp();
+
+           if ((p = univtyp(yp->yp_identifier))) {
+               if (p->univ_flags & UNF_EXTMOD) {
+                   yp->yp_module = p->univ_mod;
+                   goto do_obj;
+               }
+               if (f == NULL || noindirect(f)) {/* No offset type */
+                   if (yp->yp_flags & YP_TAG
+                       && yp->yp_flags & YP_IMPLICIT)
+                               prstfield(fp, p->univ_tab, t, f,
+                               int2tstr(yp->yp_tag->yt_value->yv_number),
+                               c_flags(yp, yp->yp_tag->yt_class));
+                       /*
+                       (void) fprintf(fp, "\t{ S%s, 0, %d, %s },\n",
+                               p->univ_tab,
+                               yp->yp_tag->yt_value->yv_number,
+                               c_flags(yp, yp->yp_tag->yt_class));
+                        */
+                   else
+                       prstfield(fp, p->univ_tab, t, f, int2tstr(p->univ_id),
+                               c_flags(yp, p->univ_class));
+                       /*
+                       (void) fprintf(fp, "\t{ S%s, 0, %d, %s },\n",
+                               p->univ_tab, p->univ_id,
+                               c_flags(yp, p->univ_class));
+                        */
+                   break;
+               }
+               if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
+                       prtfield(fp, p->univ_tab, t, f,
+                           int2tstr(yp->yp_tag->yt_value->yv_number),
+                           c_flags(yp, yp->yp_tag->yt_class));
+                   /*
+                   (void) fprintf(fp, "\t{ %s, OFFSET(%s, %s), %d, %s },\n",
+                           p->univ_tab, t, f,
+                           yp->yp_tag->yt_value->yv_number,
+                           c_flags(yp, yp->yp_tag->yt_class));
+                    */
+               else
+                   prtfield(fp, p->univ_tab, t, f, int2tstr(p->univ_id),
+                           c_flags(yp, p->univ_class));
+                   /*
+                   (void) fprintf(fp, "\t{ %s, OFFSET(%s, %s), %d, %s },\n",
+                           p->univ_tab, t, f, p->univ_id,
+                           c_flags(yp, p->univ_class));
+                    */
+               break;
+           }
+       }
+do_obj:
+       if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
+           (void) fprintf(fp, "\t{ IMP_OBJ, 0, %s, %s },\n", c_tag(yp), c_class(yp));
+       if (yp->yp_module == NULL
+           || strcmp(yp->yp_module, mymodule) == 0) {
+           if (f == NULL || noindirect(f)) {   /* No offset type */
+                 prstfield(fp, "OBJECT", t, f,
+                     concat("_Z", proc_name(yp->yp_identifier, 0)),
+                     c_class(yp));
+               /*
+               (void) fprintf(fp, "\t{ SOBJECT, 0, _Z%s, %s },\n",
+                     proc_name(yp->yp_identifier, 0), c_class(yp));
+                */
+           } else
+                 prtfield(fp, "OBJECT", t, f,
+                     concat("_Z", proc_name(yp->yp_identifier, 0)),
+                     c_class(yp));
+               /*
+               (void) fprintf(fp,
+                       "\t{ OBJECT, OFFSET(%s, %s), _Z%s, %s },\n",
+               t, f, proc_name(yp->yp_identifier, 0), c_class(yp));
+               */
+       } else {
+           if (f == NULL || noindirect(f)) {   /* No offset type */
+                 prstfield(fp, "EXTOBJ", t, f,
+                     concat("_Z", strp2name(yp->yp_identifier, yp->yp_module)),
+                       c_class(yp));
+               /*
+               (void) fprintf(fp, "\t{ SEXTOBJ, 0, _Z%s, %s },\n",
+                       strp2name(yp->yp_identifier, yp->yp_module),
+                       c_class(yp));
+                */
+           } else
+                 prtfield(fp, "EXTOBJ", t, f,
+                     concat("_Z", strp2name(yp->yp_identifier, yp->yp_module)),
+                       c_class(yp));
+               /*
+               (void) fprintf(fp,
+                       "\t{ EXTOBJ, OFFSET(%s, %s), _Z%s, %s },\n",
+                 t, f, strp2name(yp->yp_identifier, yp->yp_module),
+                       c_class(yp));
+                */
+
+           (void) fprintf(fp, "\t{ EXTMOD, %d, 0, 0 },\n",
+                   gen_modref(yp->yp_module));
+       }
+       break;
+
+    case YP_SEQLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       cons_type++;
+       save_ptr = en_ptr;
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tenc_typ:YP_SEQLIST:NULL varexp pointer\n");
+       prcte(fp, type, t, f, yp, "SEQ_START");
+       if (y = yp->yp_type) {
+           char *t1;
+
+           /* compute the type of data */
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntenc_typ:SEQLIST: can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tenc_typ:YP_SEQLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (optfield(y)) {
+               (void) fprintf(fp,
+                       "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
+                       yp->yp_structname);
+           }
+           tenc_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       en_ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SETLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       cons_type++;
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tenc_typ:YP_SETLIST:NULL varexp pointer\n");
+       prcte(fp, type, t, f, yp, "SET_START");
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntenc_typ:SETLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tenc_typ:YP_SETLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           if (optfield(y)) {
+               (void) fprintf(fp,
+                       "\t{ OPTL, OFFSET(%s, optionals), 0, 0 },\n",
+                       yp->yp_structname);
+           }
+           tenc_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       en_ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SEQTYPE:
+       p1 = NULL;
+       cons_type++;
+       save_ptr = en_ptr;
+       prcte(fp, type, t, f, yp, "SEQOF_START");
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntenc_typ:SETLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tenc_typ:YP_SEQTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tenc_loop(fp, y, id, yp->yp_structname);
+       }
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntenc_typ:SEQ OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
+                   yp->yp_structname);
+       else
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       en_ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SETTYPE:
+       p1 = NULL;
+       cons_type++;
+       save_ptr = en_ptr;
+       prcte(fp, type, t, f, yp, "SETOF_START");
+
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntenc_typ:SETTYPE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tenc_typ:YP_SETTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tenc_loop(fp, y, id, yp->yp_structname);
+       }
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntenc_typ:SET OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, next), 0, 0 },\n",
+                   yp->yp_structname);
+       else
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       en_ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_CHOICE:
+       p1 = NULL;
+       /* support for -h flag */
+       if (hflag && (y = yp->yp_type) && !y->yp_next) {
+           tenc_typ(fp, y, id, yp->yp_structname);
+           break;
+       }
+       cons_type++;
+       save_ptr = en_ptr;
+       if (type == NULL || type && noindirect(f))
+           prstfield(fp, "CHOICE_START", t, f, 0, c_class(yp));
+       else
+           prtfield(fp, "CHOICE_START", t, type ? f : NULLCP, 0, c_class(yp));
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntenc_typ:CHOICE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tenc_typ:YP_CHOICE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+
+           if (yp -> yp_control_act && yp->yp_control_act->yal_enc) {
+               (void) fprintf (fp, "\t{ SCTRL, %d, 0, FL_USELECT },\n",
+                               yp -> yp_control_act -> yal_enc -> a_num);
+           }
+           else if (yp->yp_flags & YP_CONTROLLED) {
+               char *f1;
+
+               if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+                   fprintf(stderr, "\ntenc_typ:CHOICE: can't extract field from %s\n",
+                       yp->yp_control);
+                   exit(1);
+               }
+               (void) fprintf(fp, "\t{ SCTRL, OFFSET(%s, %s), 0, 0 },\n",
+                       yp->yp_structname, f1);
+           } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp, "\t{ SCTRL, OFFSET(%s, offset), 0, 0 },\n",
+                   yp->yp_structname);
+           else
+               ferr(1, "\nCHOICE missing SCTRL\n");
+           tenc_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0 },\n");
+       en_ptr = save_ptr;
+       cons_type--;
+       break;
+
+    default:
+       ferrd(1, "tenc_typ: yp_code = %d  not implemented\n", yp->yp_code);
+    }
+
+    if (p1 != NULL)
+       prnte(fp, t, f, yp, p1);
+
+    if (yp->yp_aft_alist && yp->yp_aft_alist->yal_enc)
+       gen_act(fp, yp->yp_aft_alist->yal_enc);
+
+}
+
+static int fflags[] = {
+    0, 1, 2, 2, 3, 3, 4, 5, 16, 16, 16, 17, 17, 17,
+0, -1, 6, 0, 10, 9};
+
+/*
+ * calculate the tag string of the given type and return it
+ */
+char   *
+c_tag(yp)
+YP      yp;
+{
+    static char buf[WORDSIZE];
+    int     i;
+
+    if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) {
+       i = yp->yp_tag->yt_value->yv_number;
+    } else {
+       if (yp->yp_code < 0 || yp->yp_code > YP_REAL
+           || yp->yp_code == YP_CHOICE)
+           i = 0;
+       else
+           i = fflags[yp->yp_code];
+       /* Choice now legal argument - to allow prte_* routines to work */
+       if (i == 0 && yp->yp_code != YP_CHOICE)
+           ferrd (1, "c_tag:Unknown Tag %d", yp->yp_code);
+    }
+
+    (void) sprintf(buf, "%d", i);
+
+    return (buf);
+}
+
+/*
+ * calculate the tag string of the explicit tag and return it
+ */
+char   *
+ec_tag(yp)
+YP      yp;
+{
+    static char buf[WORDSIZE];
+    int     i;
+
+    if (!(yp->yp_flags & YP_TAG) || yp->yp_flags & YP_IMPLICIT)
+       ferr(1, "ec_tag:internal error:called with out explicit tag\n");
+
+    i = yp->yp_tag->yt_value->yv_number;
+
+    (void) sprintf(buf, "%d", i);
+
+    return (buf);
+}
+
+/*
+ * produce a string that represents the class/flags field for a given
+ * yp entry taking the class to be that given in cl
+ */
+char   *
+c_flags(yp, cl)
+YP      yp;
+int     cl;
+{
+    char   *p1;
+    static char buf[STRSIZE];
+
+    switch (yp->yp_code) {
+    case YP_IDEFINED:
+    case YP_CHOICE:
+       if (yp->yp_flags & YP_TAG)
+           break;
+       if (yp->yp_flags & YP_OPTIONAL
+           && ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+               != (YP_OPTIONAL|YP_OPTCONTROL))) {
+           p1 = "FL_OPTIONAL";
+       } else if (yp->yp_flags & YP_DEFAULT) {
+           p1 = "FL_DEFAULT";
+       } else
+           p1 = "0";
+       return (p1);
+
+    default:
+       break;
+    }
+    p1 = class2str(cl);
+    if (yp->yp_flags & YP_OPTIONAL
+           && ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+               != (YP_OPTIONAL|YP_OPTCONTROL))) {
+       strncpy(buf, p1, STRSIZE);
+       p1 = strncat(buf, "|FL_OPTIONAL", STRSIZE);
+    } else if (yp->yp_flags & YP_DEFAULT) {
+       strncpy(buf, p1, STRSIZE);
+       p1 = strncat(buf, "|FL_DEFAULT", STRSIZE);
+    }
+    return (p1);
+}
+/*
+ * turn the class number into its corresponding string
+ */
+char   *
+class2str(cl)
+int    cl;
+{
+    register char *p1;
+
+    switch (cl) {
+    case PE_CLASS_UNIV:
+       p1 = "FL_UNIVERSAL";
+       break;
+
+    case PE_CLASS_APPL:
+       p1 = "FL_APPLICATION";
+       break;
+
+    case PE_CLASS_PRIV:
+       p1 = "FL_PRIVATE";
+       break;
+
+    case PE_CLASS_CONT:
+       p1 = "FL_CONTEXT";
+       break;
+
+    default:
+       ferrd(1, "class2str: illegal class found %d\n", cl);
+
+    }
+    return (p1);
+}
+
+/*
+ * calculate a string specifying the class for the given type and
+ * return it
+ */
+char   *
+c_class(yp)
+YP      yp;
+{
+    int     i;
+
+    if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) {
+       i = yp->yp_tag->yt_class;
+    } else {
+       i = PE_CLASS_UNIV;
+    }
+    return (c_flags(yp, i));
+
+}
+/*
+ * calculate a string specifying the class for the explicit tag and
+ * return it
+ */
+char   *
+ec_class(yp)
+YP      yp;
+{
+    int     i;
+    char   *p1;
+    static char buf[STRSIZE];
+
+    if (!(yp->yp_flags & YP_TAG) || yp->yp_flags & YP_IMPLICIT)
+       ferr(1, "ec_class:internal error:called with out explicit tag\n");
+    switch (yp->yp_code) {
+    case YP_IDEFINED:
+    case YP_CHOICE:
+       if (yp->yp_flags & YP_TAG)
+           break;
+       if (yp->yp_flags & YP_OPTIONAL
+           && ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+               != (YP_OPTIONAL|YP_OPTCONTROL))) {
+           p1 = "FL_OPTIONAL";
+       } else if (yp->yp_flags & YP_DEFAULT) {
+           p1 = "FL_DEFAULT";
+       } else
+           p1 = "0";
+       return (p1);
+
+    default:
+       break;
+    }
+
+    i = yp->yp_tag->yt_class;
+
+    switch (i) {
+    case PE_CLASS_UNIV:
+       p1 = "FL_UNIVERSAL";
+       break;
+
+    case PE_CLASS_APPL:
+       p1 = "FL_APPLICATION";
+       break;
+
+    case PE_CLASS_PRIV:
+       p1 = "FL_PRIVATE";
+       break;
+
+    case PE_CLASS_CONT:
+       p1 = "FL_CONTEXT";
+       break;
+
+    default:
+       ferrd(1, "c_class: illegal class found %d\n", i);
+
+    }
+    if ((yp->yp_flags & YP_OPTIONAL) 
+           && ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+               != (YP_OPTIONAL|YP_OPTCONTROL))) {
+       strncpy(buf, p1, STRSIZE);
+       p1 = strncat(buf, "|FL_OPTIONAL", STRSIZE);
+    } else if (yp->yp_flags & YP_DEFAULT) {
+       strncpy(buf, p1, STRSIZE);
+       p1 = strncat(buf, "|FL_DEFAULT", STRSIZE);
+    }
+    return (p1);
+}
+
+/*
+ * generate tables for encoding a contructed type
+ */
+tenc_loop(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+    for (; yp != NULL; yp = yp->yp_next) {
+       tenc_typ(fp, yp, id, type);
+    }
+}
+
+/*
+ * Print the string and exit if argument greater than zero
+ */
+ferr(i, s)
+int     i;
+char   *s;
+{
+    (void) fprintf(stderr, "%s", s);
+    if (i > 0)
+       exit(i);
+}
+
+/*
+ * Print the integer and exit if argument greater than zero
+ */
+ferrd(i, s, d)
+int     i;
+char   *s;
+int     d;
+{
+    (void) fprintf(stderr, s, d);
+    if (i > 0)
+       exit(i);
+}
+
+/*
+ * Print the string and exit if argument greater than zero
+ */
+ferrs(i, s, d)
+int     i;
+char   *s;
+char   *d;
+{
+    (void) fprintf(stderr, s, d);
+    if (i > 0)
+       exit(i);
+}
+
+/*
+ * return a copy of the string s minus its last character
+ */
+char   *
+strip_last(s)
+char   *s;
+{
+    char   *t, *r;
+
+    if (s) {
+       t = new_string(s);
+       for (r = t; *r != '\0'; r++);
+       ;
+       *--r = '\0';
+       return t;
+    } else
+       return NULL;
+}
+
+/*
+ * add the declaration specified by the strings type and id to the
+ * start of the declaration list
+ */
+add_list(type, id)
+char   *type, *id;
+{
+
+    s_table *prev;
+
+    if ((prev = (s_table *) malloc(sizeof(s_table))) == NULL)
+       ferr(1, "add_list: Out of memory\n");
+    prev->type = type;
+    prev->name = id;
+    prev->parent = NULL;
+    prev->defined = 0;
+    prev->next = head;
+    head = prev;
+}
+
+/*
+ * print the declaration list
+ */
+print_list()
+{
+    s_table *prev;
+
+    for (prev = head; prev != NULL; prev = prev->next) {
+       (void) printf("type is %s\n", prev->type);
+       (void) printf("name is %s\n", prev->name);
+       (void) printf("\n");
+    }
+}
+
+/*
+ * parse the declaration in the string s returning the type in v1 and
+ * the name in v2
+ */
+parse_decl(s, v1, v2)
+char  **s, **v1, **v2;
+{
+    char   *t;
+
+    for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_'); t++);
+
+    *s = t;
+    if (*t != '\0') {
+       for (; *t != '*'; t++);
+       *t = '\0';
+       *v1 = my_strcat(*s, "*");
+       Printf(3, ("the type is %s\n", *v1));
+       if (*++t == '*')
+           t++;
+       for (*s = t; isalnum(*t) || *t == '_'; t++);
+       if (*t != '\0') {
+           *t = '\0';
+           t++;
+       }
+       *v2 = new_string(*s);   /* don't really need new_string */
+       Printf(2, ("the name is %s\n", *v2));
+       *s = t;
+    }
+}
+
+/*
+ * return the next identifier in the string s
+ */
+char   *
+get_val(s)
+char  **s;
+{
+    char   *t, *r;
+
+    for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_' || *t == '.'); t++);
+
+    if (*t != '\0') {
+       for (*s = t; isalnum(*t) || *t == '_' || *t == '.'; t++);
+       *t = '\0';
+       r = *s;
+       Printf(3, ("arg is |%s|\n", r));
+       *s = ++t;
+       return r;
+    } else
+       return NULL;
+}
+
+/*
+ * return the next component (sequence of characters up to the next
+ * ';' or '\0') of the string s
+ */
+char   *
+get_comp(s)
+char  **s;
+{
+    char   *t, *r;
+
+    for (t = *s; *t != '\0' && !(isalnum(*t) || *t == '_' || *t == ';'); t++);
+
+    if (*t != '\0') {
+       for (*s = t; *t != '\0' && *t != ';'; t++);
+       *t = '\0';
+       r = *s;
+       Printf(3, ("component is |%s|\n", r));
+       *s = ++t;
+       return r;
+    } else
+       return NULL;
+}
+
+/*
+ * return a copy of that part of the string s which may contain
+ * definitions for the variables generated by posy
+ */
+char   *
+get_string(s, direction)
+char   *s;
+int     direction;
+{
+    char   *t, *t1;
+
+    if (direction & YP_ENCODER)
+       return new_string(s);
+    if (direction & YP_DECODER) {
+       t = new_string(s);
+       for (t1 = t; !(isalnum(*t1) || *t1 == '_'); t1++);
+       if (*t1 == 'i' && *++t1 == 'f' && *++t1 == ' ') {       /* MEMALLOC code */
+           for (; *t1 != '}'; t1++)    /* skip MEMALLOC code */
+               ;
+           t1++;
+           Printf(4, ("returning the string %s\n", t1));
+           return t1;
+       } else
+           return t;
+    }
+}
+
+/*
+ * Determine wether this list contains any items that will generate
+ * an optional field. If so return non zero
+ */
+optfield(yp)
+YP      yp;
+{
+    for (; yp; yp = yp->yp_next) {
+       if (yp->yp_flags & YP_OPTIONAL) {
+
+           if ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+               == (YP_OPTIONAL|YP_OPTCONTROL))
+               return (0);
+
+           switch (yp->yp_code) {
+           case YP_BOOL:
+           case YP_INT:
+           case YP_INTLIST:
+           case YP_ENUMLIST:
+           case YP_NULL:
+               return (1);
+           }
+       }
+    }
+    return (0);
+}
+
+gen_dflts(fp, yp, type)
+YP      yp;
+char   *type;
+{
+    YP      y;
+
+    if (yp == NULL)
+       return;
+    switch (yp->yp_code) {
+    case YP_IDEFINED:
+       break;
+
+    case YP_CHOICE:
+    case YP_SEQTYPE:
+    case YP_SETTYPE:
+    case YP_SEQLIST:
+    case YP_SETLIST:
+       for (y = yp->yp_type; y != NULL; y = y->yp_next) {
+           gen_dflts(fp, y, type);
+       }
+       break;
+
+    default:
+       break;
+    }
+    /* Output definitions for default entries */
+    if (yp->yp_flags & YP_DEFAULT)
+       defdflt(fp, yp, type);
+    
+    if (yp->yp_yfn)
+       declfns(fp, yp->yp_yfn);
+}
+/*
+ * Compute the concatenation into a temporary buffer of two strings
+ * after having run notid on them first
+ */
+char   *
+strp2name(s1, s2)
+char   *s1, *s2;
+{
+    char   *p;
+    static char buf[STRSIZE * 2 + 5];
+
+    if (strlen(s1) > STRSIZE || strlen(s2) > STRSIZE)
+       ferr(1, "strp2name:string to big\n");
+    strcpy(buf, p = notidtoid(s1));
+    free(p);
+    strcat(buf, p = notidtoid(s2));
+    free(p);
+
+    return (buf);
+}
+
+/*
+ * Output the definitions for default entries and initialise the yp's
+ * to have pointers which reference these definitions for use by
+ * gdflt routine.
+ */
+defdflt(fp, yp, name)
+YP      yp;
+char   *name;
+{
+    YV      yv;
+    YV      yv1;
+    SY      sy;
+    YP      yp1;
+    int     size, i;
+    char   *str;
+    char   *label;
+    struct univ_typ    *p;
+    int                code;
+
+    if ((yp->yp_flags & YP_DEFAULT) == 0)
+       ferrd(1, "defdflt:called with out a default code = %d\n", yp->yp_code);
+    yv = yp->yp_default;
+
+    yp1 = yp;
+
+    /* Find the bottom definition */
+    code = yp1->yp_code;
+    while (code == YP_IDEFINED) {
+       if ((sy = syfind(yp1->yp_identifier)) == NULL) {
+           if ((p = univtyp(yp1->yp_identifier)) == NULL
+              || p->univ_type <= YP_UNDF)
+               ferrs(1,
+                   "defdflt:IDEFINED:cannot find definition of symbol %s\n",
+                   yp1->yp_identifier);
+           code = p->univ_type;
+           break;
+               
+       }
+       yp1 = sy->sy_type;
+       code = yp1->yp_code;
+    }
+
+    switch (code) {
+    case YP_BOOL:
+    case YP_INT:
+    case YP_INTLIST:
+    case YP_ENUMLIST:
+       switch (yv->yv_code) {
+       case YV_NUMBER:
+       case YV_BOOL:
+           /* None needed */
+           break;
+
+       case YV_IDEFINED:
+           if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
+               ferrs(1, "defdflt:BOOL/INT:cannot find definition of %s\n",
+                     yv->yv_identifier);
+           }
+           /* None Needed */
+           break;
+
+       default:
+           ferrd(1, "defdflt:INT/BOOL:unimplemented value code = %d\n",
+                 yv->yv_code);
+       }
+       break;
+
+    case YP_REAL:
+       switch (yv->yv_code) {
+       case YV_REAL:
+            yv1 = yv;
+            goto dumpdef3;
+
+       case YV_IDEFINED:
+           if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
+               ferrs(1, "defdflt:REAL:cannot find definition of %s\n",
+                     yv->yv_identifier);
+           }
+           goto dumpdef3;
+           break;
+
+       default:
+           ferrd(1, "defdflt:REAL:unimplemented value code = %d\n",
+                 yv->yv_code);
+       }
+       break;
+
+    case YP_BIT:
+    case YP_BITLIST:
+       switch (yv->yv_code) {
+           /*
+            * This is an illegal value for a bit string ! - BUT ACSE
+            * uses it !
+            */
+           /* gdflt also patched to support it */
+       case YV_IDEFINED:
+           ferrs(0,
+                 "warning:bitstring default specified illegally with identifier %s\n",
+                 yv->yv_identifier);
+           if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
+               ferrs(1, "defdflt:BIT:cannot find definition of %s\n",
+                     yv->yv_identifier);
+           }
+           /* doesn't work fix posy-yacc.y */
+           size = numtobstr(yv1, &str);
+           goto dumpdef1;
+
+       case YV_NUMBER:
+           size = numtobstr(yv, &str);
+           goto dumpdef1;
+
+       case YV_VALIST:
+           if ((size = valisttobs(yp1, yv, &str)) < 0) {
+               ferrs(1, "defdflt:bad default value for bit string %s\n",
+                     yp->yp_flags & YP_ID ? yp->yp_identifier : "");
+           }
+           goto dumpdef1;
+
+       case YV_HSTRING:
+           str = yv->yv_xstring;
+           size = yv->yv_xlength*4;
+           goto dumpdef1;
+
+       case YV_BSTRING:
+           str = yv->yv_xstring;
+           size = yv->yv_xlength;
+           goto dumpdef1;
+
+       default:
+           /* Could be a syntax error */
+           ferrd(1, "defdflt:BIT:illegal value code = %d\n", yv->yv_code);
+       }
+       break;
+
+    case YP_IDEFINED:
+       ferrs(1, "defdflt:IDEFINED:internal error on symbol %s\n",
+             yp1->yp_identifier);
+       break;
+
+    case YP_OCT:
+       switch (yv->yv_code) {
+       case YV_NUMBER:
+           size = numtobstr(yv, &str);
+           goto dumpdef2;
+
+       case YV_STRING:
+           str = yv->yv_string;
+           size = strlen(str);
+           goto dumpdef2;
+
+       case YV_HSTRING:
+           str = yv->yv_xstring;
+           size = (yv->yv_xlength + 1)/2;
+           goto dumpdef2;
+
+       case YV_BSTRING:
+           str = yv->yv_xstring;
+           size = (yv->yv_xlength + 7)/8;      /* round up */
+           goto dumpdef2;
+
+       default:
+           /* Could be a syntax error */
+           ferrd(1, "defdflt:OCT:illegal value code = %d\n", yv->yv_code);
+       }
+       break;
+
+    case YP_NULL:
+    case YP_SEQ:
+    case YP_SEQTYPE:
+    case YP_SEQLIST:
+    case YP_SET:
+    case YP_SETTYPE:
+    case YP_SETLIST:
+    case YP_CHOICE:
+    case YP_ANY:
+    case YP_OID:
+       /* None yet */
+       break;
+
+    default:
+       ferrd(1, "defdflt:unknown type %d\n", code);
+    }
+
+    return;
+
+dumpdef1:      /* Bitstrings */
+    label = genlabel(name, yp);
+    yp->yp_action0 = label;
+    yp->yp_act0_lineno = size;
+    i = (size + NBPC - 1) / NBPC;
+    (void) fprintf(fp, "\nstatic char %s[] = ", label);
+    if (printable(str, i))
+       prstr(fp, str, i);
+    else
+       prhstr(fp, str, i);
+    (void) fprintf(fp, ";\n");
+    return;
+
+dumpdef2:      /* Octet strings (and aliases) */
+    label = genlabel(name, yp);
+    yp->yp_action0 = label;
+    yp->yp_act0_lineno = size;
+    (void) fprintf(fp, "\nstatic char %s[] = ", label);
+    if (printable(str, size))
+       prstr(fp, str, size);
+    else
+       prhstr(fp, str, size);
+    (void) fprintf(fp, ";\n");
+    return;
+
+dumpdef3:      /* Reals */
+    label = genlabel(name, yp);
+    yp->yp_action0 = label;
+    (void) fprintf(fp, "\nstatic double %s = %f;\n", label, yv1->yv_real);
+    return;
+
+}
+/*
+ * generate the default entry for encoding/decoding fields. This
+ * should contain the default value which the encoder will know means
+ * default encoding
+ */
+gdflt(fp, yp, which)
+FILE   *fp;
+YP      yp;
+int     which;                 /* Which type of entries to generate
+                                * G_ENC encode G_DEC decode */
+{
+    YV      yv;
+    YV      yv1;
+    SY      sy;
+    YP      yp1;
+    int     size;
+    char   *str;
+
+    char   *ndflt;
+    struct univ_typ     *p;
+    int         code;
+
+
+    if (which == G_ENC)
+       ndflt = "DFLT_F";
+    else
+       ndflt = "DFLT_B";
+
+    if ((yp->yp_flags & YP_DEFAULT) == 0)
+       ferrd(1, "gdflt:called with out a default code = %d\n", yp->yp_code);
+    yv = yp->yp_default;
+
+    yp1 = yp;
+
+    /* Find the bottom definition */
+    code = yp1->yp_code;
+    while (code == YP_IDEFINED) {
+       if ((sy = syfind(yp1->yp_identifier)) == NULL) {
+             if ((p = univtyp(yp1->yp_identifier)) == NULL
+               || p->univ_type <= YP_UNDF)
+                   ferrs(1,
+                       "gdflt:IDEFINED:cannot find definition of symbol %s\n",
+                       yp1->yp_identifier);
+            code = p->univ_type;
+            break;
+
+       }
+       yp1 = sy->sy_type;
+       code = yp1->yp_code;
+    }
+
+    switch (code) {
+    case YP_BOOL:
+    case YP_INT:
+    case YP_INTLIST:
+    case YP_ENUMLIST:
+       switch (yv->yv_code) {
+       case YV_NUMBER:
+       case YV_BOOL:
+           (void) fprintf(fp, "\t{ %s, %d,     0,      0 },\n", ndflt,
+                   yp->yp_default->yv_number);
+           break;
+
+       case YV_IDEFINED:
+           if ((yv1 = calc_yv(yp1, yv->yv_identifier)) == NULL) {
+               ferrs(1, "gdflt:BOOL/INT:cannot find definition of %s\n",
+                     yv->yv_identifier);
+           }
+           (void) fprintf(fp, "\t{ %s, %d,     0,      0 },\n", ndflt,
+                   yv1->yv_number);
+           break;
+
+       default:
+           ferrd(1, "gdflt:INT/BOOL:unimplemented value code = %d\n",
+                 yv->yv_code);
+       }
+       break;
+
+    case YP_BIT:
+    case YP_BITLIST:
+       switch (yv->yv_code) {
+#ifdef ILLEGAL_DEFAULTS
+       case YV_IDEFINED:       /* supporting illegal default
+                                * specification */
+#endif
+       case YV_NUMBER:
+       case YV_HSTRING:
+       case YV_BSTRING:
+       case YV_VALIST:
+           (void) fprintf(fp, "\t{ %s, %d,     %d,     0 },\n", ndflt,
+                   yp->yp_act0_lineno, addptr(yp->yp_action0));
+           break;
+
+       default:
+           /* Could be a syntax error */
+           ferrd(1, "gdflt:BIT:illegal value code = %d\n", yv->yv_code);
+       }
+       break;
+
+    case YP_IDEFINED:
+       ferrs(1, "gdflt:IDEFINED:internal error on symbol %s\n",
+             yp1->yp_identifier);
+       break;
+
+    case YP_REAL:
+       switch (yv->yv_code) {
+#ifdef ILLEGAL_DEFAULTS
+       case YV_IDEFINED:       /* Illegal according to ASN.1 but we can do it
+                                * so why not support it
+                                */
+#endif
+       case YV_REAL:
+           (void) fprintf(fp, "\t{ %s, 0,      %d,     0 },\n", ndflt,
+                   addptr(concat("&", yp->yp_action0)));
+           break;
+
+       default:
+           /* Could be a syntax error */
+           ferrd(1, "gdflt:REAL:illegal value code = %d\n", yv->yv_code);
+       }
+       break;
+
+    case YP_OCT:
+       switch (yv->yv_code) {
+       case YV_NUMBER:
+       case YV_STRING:
+       case YV_HSTRING:
+       case YV_BSTRING:
+           (void) fprintf(fp, "\t{ %s, %d,     %d,     0 },\n", ndflt,
+                   yp->yp_act0_lineno, addptr(yp->yp_action0));
+           break;
+
+       default:
+           /* Could be a syntax error */
+           ferrd(1, "gdflt:OCT:illegal value code = %d\n", yv->yv_code);
+       }
+       break;
+
+    case YP_NULL:
+    case YP_SEQ:
+    case YP_SEQTYPE:
+    case YP_SEQLIST:
+    case YP_SET:
+    case YP_SETTYPE:
+    case YP_SETLIST:
+    case YP_CHOICE:
+    case YP_ANY:
+    case YP_OID:
+       (void) fprintf(fp, "\t{ %s,     0,      0,      0 },\n", ndflt);
+       break;
+
+    default:
+       ferrd(1, "gdflt:unknown type %d\n", yp->yp_code);
+    }
+
+}
+/*
+ * Calculate the value associated with the given identifier id by
+ * looking at the value definitions associated with type definition
+ * yp. Returns the value definition if found or NULL if not.
+ */
+YV
+calc_yv(yp, id)
+YP      yp;
+char   *id;
+{
+    YV      yv;
+
+    for (yv = yp->yp_value; yv != NULL; yv = yv->yv_next) {
+       if (yv->yv_flags & YV_NAMED && strcmp(yv->yv_named, id) == 0)
+           return (yv);
+    }
+
+    return (NULL);
+}
+
+/*
+ * ******* This does not work. posy needs to be fixed for case of
+ * '01'b ***** Turn a Literal number value in yv into a bistring
+ * initialisation. Return the length of the bit string or less than
+ * zero on error. Set the (char *) pointer, whose address is in
+ * ppstr, to point to a string containing the a reference to a
+ * character array which contains the bits.
+ */
+
+numtobstr(yv, ppstr)
+YV      yv;
+char  **ppstr;
+{
+
+    int     ibits, lastb, i;
+    char   *buf;
+
+    buf = malloc(NBPI / NBPC + 1);
+    bzero(buf, NBPI / NBPC + 1);
+    lastb = -1;
+    ibits = yv->yv_number;
+    for (i = 0; i < NBPI; i++) {
+       if ((1 << i) & ibits) {
+           buf[i / NBPC] |= 1 << (NBPC - 1 - (i % NBPC));
+           lastb = i;
+       }
+    }
+
+    *ppstr = buf;
+    return (lastb + 1);
+}
+#define ROUNDUP                10
+/*
+ * Take a list of Values (YV_VALIST) which should contain a list of
+ * bits and convert them into a bitstring initialisation. As in
+ * numtobstr return the size of the bit string or a negative number
+ * if there is an error. Put a reference to a character array which
+ * contains the definition of the bits in the character pointer whose
+ * address is in ppstr. yp is the definition of the type which
+ * contains the names of all the defined bits.
+ */
+valisttobs(yp, yv, ppstr)
+YP      yp;
+YV      yv;
+char  **ppstr;
+{
+
+    YV      yv1, yv2;
+    int     lastb, val, nsize, size;
+    char   *buf;
+
+    lastb = -1;
+    size = ROUNDUP;
+    if ((buf = malloc(size)) == NULL) {
+       ferrd(1, "valisttobs:malloc:failed on %d\n", size);
+    }
+    bzero(buf, size);
+    for (yv1 = yv->yv_idlist; yv1 != NULL; yv1 = yv1->yv_next) {
+       if ((yv2 = calc_yv(yp, yv1->yv_identifier)) == NULL) {
+           return (-1);
+       }
+       val = yv2->yv_number;
+       /* Bug here probably */
+       if (size < val / NBPC) {
+           nsize = val / NBPC + ROUNDUP;
+           if ((buf = realloc(buf, nsize)) == NULL) {
+               ferrd(1, "valisttobs:realloc:failed on %d\n", nsize);
+           }
+           bzero(buf + size, nsize - size);
+           size = nsize;
+       }
+       buf[val / NBPC] |= 1 << (NBPC - 1 - (val % NBPC));
+       if (val > lastb)
+           lastb = val;
+    }
+    *ppstr = buf;
+    return (lastb + 1);
+}
+/*
+ * Print the string out in a format acceptable as a quoted string in
+ * a C program including the quotes. Using \ escapes for unprintable
+ * characters
+ */
+prstr(fp, str, len)
+FILE   *fp;
+char   *str;
+int     len;
+{
+    (void) fputc('"', fp);
+    while (len-- > 0) {
+       if (isprint(*str & 0xff)) {
+           (void) fputc(*str & 0xff, fp);
+           str++;
+           continue;
+       }
+       (void) fprintf(fp, "\\%0o", *str & 0xff);
+    }
+    (void) fputc('"', fp);
+#define MAXPLINE       16
+}
+/*
+ * output a initialisation for a character array as unsigned hex
+ * numbers
+ */
+prhstr(fp, str, len)
+FILE   *fp;
+char   *str;
+int     len;
+{
+    int     npline;            /* number on this line */
+
+    (void) fprintf(fp, "{\n");
+    npline = 0;
+    while (len > 0) {
+       if (npline >= MAXPLINE) {
+           (void) fputc('\n', fp);
+           npline = 0;
+       }
+       npline++;
+       (void) fprintf(fp, " 0x%02x,", *str++ & 0xff);
+       len--;
+    }
+    (void) fprintf(fp, "}");
+}
+/*
+ * determine if the string is printable i.e. only sensible to be read
+ * as a character string. 1 (true) if it is 0, if it isn't
+ */
+printable(str, i)
+char   *str;
+int     i;
+{
+    while (i-- > 0) {
+       if (!isprint(*str & 0xff))
+           return (0);         /* look for the first non printable
+                                * character */
+       str++;
+    }
+    return (1);
+}
+/*
+ * generate a unique identifier  using the name given and the name if
+ * present in yp. Return a pointer to it in a space malloc'ed out
+ */
+char   *
+genlabel(name, yp)
+char   *name;
+YP      yp;
+{
+    char    buf[MAXNAME];
+    static int cnt;
+    char   *p1, *p2;
+
+    p1 = notidtoid(name);
+    if (yp->yp_flags & YP_ID) {
+       p2 = notidtoid(yp->yp_id);
+       (void) sprintf(buf, "L%s_%s_%d", p1, p2, cnt++);
+       free(p2);
+    } else
+       (void) sprintf(buf, "L%s_X_%d", p1, cnt++);
+    free(p1);
+
+    return (my_new_str(buf));
+}
+/*
+ * generate a ptr table reference for the given module table entry
+ */
+gen_modref(mod)
+char   *mod;
+{
+    char       buf[BUFSIZ];
+    char       *p1;
+    int                ind;
+
+    p1 = notidtoid(mod);
+    (void) sprintf(buf, "&%s%s%s", PREFIX, p1, MODTYP_SUFFIX);
+    ind = addptr(buf);
+    free(p1);
+
+    return (ind);
+}
+
+char   *
+setfield(p)
+char   *p;
+{
+    char       *f;
+
+    if ((f = getfield(p)) == NULLCP) {
+       fprintf(stderr, "\nsetfield: can't extract field from %s\n", p);
+       exit(1);
+    }
+    return (strdup(f));
+}
+
+/*
+ * print a normal table entry
+ */
+prnte(fp, t, f, yp, p1)
+FILE   *fp;
+char   *t;     /* parent type */
+char   *f;     /* field name */
+YP     *yp;    /* object */
+char   *p1;    /* table entry name */
+{
+    if (p1 == NULL)
+       ferr(1, "prnte: called with a NULL p1\n");
+
+    if (t && noindirect(f))
+       prstfield(fp, p1, t, f, c_tag(yp), c_class(yp));
+    else
+       prtfield(fp, p1, t, f, c_tag(yp), c_class(yp));
+}
+
+/*
+ * generate the entry allowing for defined types and then call the given
+ * function to generate the base entry
+ * Algorithm:
+ * If we can find the base type 
+ *   i) generate any ETAG that subsequent definitions might have
+ *   ii) call the function to generate the base entry
+ *   iii) and  the function checks that it matches the type of the value pass
+ * else - can't find the base type - probably because it is external
+ *   i)  generate a warning and exit
+ */
+gen_identry(fp, t, f, yp, fn)
+FILE   *fp;
+char   *t, *f;
+YP     yp;
+int    (*fn)();
+{
+   YP  yp1;
+   int code;
+   SY  sy;
+   YT  pd_yt = NULLYT; /* Passed down tag if any */
+   YT  yt;
+   struct univ_typ     *p = NULL;
+   char        *flags;         /* the flags if any which each subtype must have */
+   int save_flags;
+    
+    yp1 = yp;
+    code = yp1->yp_code;
+
+    if (yp->yp_flags & YP_OPTIONAL)
+       flags = "|FL_OPTIONAL";
+    else if (yp->yp_flags & YP_DEFAULT)
+       flags = "|FL_DEFAULT";
+    else
+       flags = "";
+
+    /* any explicit tag for original yp type is handled before this
+     * routine is called so don't call gen_etag for it here
+     * but we do need to initialise pd_yt for the case of an IMPLICIT TAG.
+     */
+    if ((yp->yp_flags & (YP_TAG|YP_IMPLICIT))== (YP_TAG|YP_IMPLICIT))
+       pd_yt = yp->yp_tag;
+
+    while (code == YP_IDEFINED) {
+        if ((sy = syfind(yp1->yp_identifier)) == NULL) {
+            if ((p = univtyp(yp1->yp_identifier)) == NULL
+               || p->univ_type <= YP_UNDF)
+                ferrs(1,
+                    "\ngen_identry:symbol %s is not defined in this file:\npepsy cannot support value passing for this type, sorry\n",
+                    yp1->yp_identifier);
+            code = p->univ_type;
+            break;
+
+        }
+        yp1 = sy->sy_type;
+           /* check for Explicit tags & generate ETAG entries */
+       pd_yt = gen_etag(fp, pd_yt, yp1, flags);
+        code = yp1->yp_code;
+    }
+
+    if (p) {
+       /* how do we check type is consistent with value passed ? */
+       yp1 = new_type(code, -1);
+
+       yp1->yp_flags |= yp->yp_flags & (YP_OPTIONAL|YP_DEFAULT);
+
+       if (pd_yt == NULLYT) {
+           yp1->yp_tag = new_tag(p->univ_class);
+           yp1->yp_tag->yt_value = new_value(YV_NUMBER);
+           yp1->yp_tag->yt_value->yv_number = p->univ_id;
+       } else
+           yp1->yp_tag = pd_yt;
+       yp1->yp_flags |= YP_TAG|YP_IMPLICIT;
+
+       (*fn)(fp, yp, yp1, t, f);
+
+     /* lets free the yp1 allocated above */
+       if (pd_yt == NULLYT) {
+           free(yp1->yp_tag->yt_value);
+           free(yp1->yp_tag);
+       }
+       free(yp1);
+
+       return;
+    }
+       /* check type is consistent with value passed some where??*/
+
+    save_flags = yp1->yp_flags;
+    yp1->yp_flags |= yp->yp_flags & (YP_OPTIONAL|YP_DEFAULT);
+
+    if (pd_yt) {
+       yt = yp1->yp_tag;
+       yp1->yp_tag = pd_yt;
+       yp1->yp_flags |= YP_TAG|YP_IMPLICIT;
+    }
+
+    (*fn)(fp, yp, yp1, t, f);
+
+    if (pd_yt) {       /* restore the tag for later */
+       yp1->yp_tag = yt;
+    }
+    yp1->yp_flags = save_flags;
+
+}
+
+/*
+ * generate the ETAG entry if needed for following the given defined type
+ * down to what it is. Given that its use above has an IMPLICIT tag pd_yt
+ * if it is non Null
+ */
+YT
+gen_etag(fp, pd_yt, yp, flags)
+FILE   *fp;
+YT     pd_yt;
+YP     yp;
+char   *flags;
+{
+    YT yt;
+
+    yt = yp->yp_tag;
+    if (yt && yt->yt_value) {
+       if ((yp->yp_flags & (YP_TAG|YP_IMPLICIT)) == YP_TAG) {
+                                   /* EXPLICIT TAG so generate an ETAG */
+           if (pd_yt)
+               yt = pd_yt;  /* if we have a value passed down use that */
+           (void) fprintf(fp, "\t{ ETAG, 0, %d, %s%s },\n",
+               yt->yt_value->yv_number, class2str(yt->yt_class), flags);
+           pd_yt = NULLYT; /* non't pass on any value */
+
+       } else if ((yp->yp_flags & (YP_TAG|YP_IMPLICIT))== YP_TAG|YP_IMPLICIT) {
+           /* otherwise it is implicit and so pass its tag down
+            * unless we already have a tag being passed in which case
+            * the passed down tag overrides this current tag
+            */
+           if (pd_yt == NULLYT)
+               pd_yt = yt;
+       }
+    }
+
+    return (pd_yt);
+}
+
+/*
+ * generate the table entry for a value passing defined type which
+ * is equivalent to the given primative type
+ */
+gen_ventry(fp, oyp, yp, t, f)
+FILE   *fp;
+YP     oyp, yp;
+char   *t, *f;
+{
+    char       *p1;
+    register char      s = oyp->yp_prfexp;     /* type of value passing */
+
+
+    if (noindirect(f) && s != 'q' && s != 'a')
+       ferrs(1,
+        "gen_ventry: must specify a field for primative value- not %s\n", f);
+
+    switch (s) {
+    case 'q': /* [[ q parm->qbufptr ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("qbuf pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+                
+       f = setfield(oyp->yp_strexp);
+       if (noindirect(f))
+           p1 = "SOCTETSTRING";
+       else
+           p1 = "OCTETSTRING";
+       break;
+
+    case 's': /* [[ s ptr ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("string pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "T_STRING";
+       break;
+
+    case 'o': /* [[ o ptr $ length ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("octet/length pair passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       p1 = "OCTET_PTR";
+       prnte(fp, t, f, yp, p1);
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "gen_ventry:OCT: must specify a field [[ s .. ]]\n");
+       p1 = "OCTET_LEN";
+       break;
+
+    case 'x': /* [[ x ptr $ length ]] */
+       if (yp->yp_code != YP_BIT && yp->yp_code != YP_BITLIST)
+           warning("bit string/length pair passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "BITSTR_PTR";
+       prnte(fp, t, f, yp, p1);
+       f = setfield(oyp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tenc_typ:BIT: must specify a field [[ x .. ]]\n");
+       p1 = "BITSTR_LEN";
+       break;
+
+    case 'r': /* [[ r REAL ]] */
+       if (yp->yp_code != YP_REAL)
+           warning("Real passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "REALTYPE";
+       break;
+
+    case 'i': /* [[ i INTEGER ]] */
+       if (yp->yp_code != YP_INT && yp->yp_code != YP_INTLIST
+        && yp->yp_code != YP_ENUMLIST)
+           warning("integer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       p1 = "INTEGER";
+       break;
+
+    case 't': /* [[ t Bitvector ]] */
+       if (yp->yp_code != YP_BIT && yp->yp_code != YP_BITLIST)
+           warning("Bitvector (PE) passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_intexp);
+       if (oyp->yp_varexp && !noindirect(f))
+           p1 = "BITSTRING";
+       else
+           p1 = "SBITSTRING";
+       break;
+
+    case 'b': /* [[ b BOOLEAN ]] */
+       if (yp->yp_code != YP_BOOL)
+           warning("Boolean passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       p1 = "BOOLEAN";
+       break;
+
+    case 'O': /* [[ O Object Identifier ]] */
+       if (yp->yp_code != YP_OID)
+           warning("Object Identifier pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       p1 = "OBJID";
+       break;
+
+    case 'a': /* [[ a ANY ]] */
+       if (yp->yp_code != YP_ANY)
+           warning("PE pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       if (noindirect(f))
+           p1 = "SANY";
+       else
+           p1 = "ANY";
+       break;
+     default:
+       ferrd("gen_vident:unknown Value passed %d\n", (int )s);
+   }
+
+    prnte(fp, t, f, yp, p1);
+}
+
+/*
+ * generate a table entry for a function call that handles this type
+ */
+gen_fn(fp, yp, fn)
+FILE   *fp;
+YP     yp;
+char   *fn;    /* name of routine to generate */
+{
+
+    gen_identry(fp, fn, NULLCP, yp, gen_fnentry);
+}
+
+/*
+ * generate a table entry for a function call that handles this type
+ */
+gen_fnentry(fp, oyp, yp, fn, dummy)
+FILE   *fp;
+YP     oyp;
+YP     yp;
+char   *fn;    /* name of routine to generate */
+char   *dummy;
+{
+
+    (void) fprintf(fp, "\t{ FN_CALL, %d, %s, %s },\n",
+       addptr(fn), c_tag(yp), c_class(yp));
+}
+/*
+ * declare the functions that are used
+ * One day generate ANSII C definitions as well
+ */
+declfns(fp, fn)
+FILE   *fp;
+YFN    fn;
+{
+    if (fn->yfn_enc) {
+       (void) fprintf(fp, "extern int  %s();\n", fn->yfn_enc);
+    }
+    if (fn->yfn_dec) {
+       (void) fprintf(fp, "extern int  %s();\n", fn->yfn_dec);
+    }
+    if (fn->yfn_prt) {
+       (void) fprintf(fp, "extern int  %s();\n", fn->yfn_prt);
+    }
+    if (fn->yfn_fre) {
+       (void) fprintf(fp, "extern int  %s();\n", fn->yfn_fre);
+    }
+}
+/*
+ * generate the table entry to handle an action - UCODE
+ */
+gen_act(fp, act)
+FILE   *fp;
+Action act;
+{
+    (void) fprintf(fp, "\t{ UCODE, %d, 0, 0 }, /* line %d */\n", act->a_num, 
+                       act->a_line);
+}
+
+/*
+ * print out the field entry for a type where all the parameters are given
+ */
+prtfield(fp, typ, t, f, cl, fl)
+FILE   *fp;
+char   *typ, *t, *f, *cl, *fl;
+{
+    if (cl == NULLCP)
+       cl = "0";
+
+    if (f && t) {
+       if (*f == '&')
+           f++;
+       (void) fprintf(fp, "\t{ %s, OFFSET(%s, %s), %s, %s },\n", typ, t, f,
+                                                       cl, fl);
+    } else
+       (void) fprintf(fp, "\t{ %s, 0, %s, %s },\n", typ, cl, fl);
+}
+
+/*
+ * print out the field entry for a Simple type where all the parameters
+ * are given
+ */
+prstfield(fp, typ, t, f, cl, fl)
+FILE   *fp;
+char   *typ, *t, *f, *cl, *fl;
+{
+    if (cl == NULLCP)
+       cl = "0";
+
+    if (f && t && *f == '&') {
+           f++;
+       (void) fprintf(fp, "\t{ S%s, OFFSET(%s, %s), %s, %s },\n", typ, t, f,
+                                                       cl, fl);
+    } else
+       (void) fprintf(fp, "\t{ S%s, 0, %s, %s },\n", typ, cl, fl);
+}
+
+/*
+ * convert an integer into a temporary string. Useful for calling
+ * the printing routines with
+ */
+char   *
+int2tstr(i)
+int    i;
+{
+    static char        buf[STRSIZE];
+
+    sprintf(buf, "%d", i);
+
+    return (buf);
+}
+
+static char    *codetab[] = {
+    "Undefined", "BOOLEAN", "INTEGER", "INTEGER (named numbers)", "BIT STRING",
+    "BIT STRING (named bits)", "OCTET STRING", "NULL", "SEQUENCE",
+    "SEQUENCE OF", "SEQUENCE",  "SET", "SET OF", "SET", "CHOICE",
+    "ANY", "OBJECT IDENTIFIER", "Defined type", "ENUMERATED",
+    "REAL", "Imported type",
+
+    NULL
+};
+/*
+ * produce a user readable name for a yp_code value
+ */
+char   *
+code2name(code)
+int    code;
+{
+    static char        buf[STRSIZE];
+
+    if (code < 0 || code > YP_IMPTYPE) {
+       sprintf(buf, "Unknown code (%d)", code);
+       return (buf);
+    }
+
+    return (codetab[code]);
+}
+/*
+ * print out a description of the yp type for the user that is good enough
+ * for them to identifier the entry if possible
+ */
+char   *
+yp2name(yp)
+YP     yp;
+{
+    static char        buf[STRSIZE*4];
+    char       *p;
+
+    p = buf;
+    if (yp->yp_code == YP_IDEFINED) {
+       if (yp->yp_module) {
+            sprintf(p, "%s.", yp->yp_module);
+            p += strlen(p);
+       }
+       if (yp->yp_identifier)
+            sprintf(p, "%s", yp->yp_identifier);
+       else
+            strcpy(p, "(no identifier)");
+       p += strlen(p);
+       if (yp->yp_modid) {
+            sprintf(p, " (%s)", sprintoid(yp->yp_modid));
+            p += strlen(p);
+       }
+    } else {
+       sprintf(p, "%s", code2name(yp->yp_code));
+       p += strlen(p);
+    }
+
+    if (yp->yp_flags & YP_ID) {
+       sprintf(p, " %s", yp->yp_id);
+       p += strlen(p);
+    }
+
+    if (yp->yp_lineno > 0) {
+       sprintf(p, " on line %d", yp->yp_lineno);
+       p += strlen(p);
+    }
+
+    return (buf);
+
+}
+/*
+ * generate a table entry for the given compound type. It determines wether to
+ * generate a simple type (prstfield) or not.
+ */
+prcte(fp, type, t, f, yp, p1)
+FILE   *fp;
+char   *type;  /* zero if we are foundation type of the table */
+char   *t;     /* parent type */
+char   *f;     /* field name */
+YP     *yp;    /* object */
+char   *p1;    /* table entry name */
+{
+    if (type == NULL || type && noindirect(f))
+       prstfield(fp, p1, t, f, c_tag(yp), c_class(yp));
+    else
+       prtfield(fp, p1, t, type ? f : NULLCP, c_tag(yp), c_class(yp));
+}
diff --git a/usr/src/contrib/isode/pepsy/lex.l.gnrc b/usr/src/contrib/isode/pepsy/lex.l.gnrc
new file mode 100644 (file)
index 0000000..635ff2b
--- /dev/null
@@ -0,0 +1,635 @@
+/* lex.l - lex ASN.1 analyzer */
+/* %WARNING% */
+
+%{
+#ifndef        lint
+static char *RCSid = "$Header: /f/osi/pepsy/RCS/lex.l.gnrc,v 7.5 91/02/22 09:49:01 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/lex.l.gnrc,v 7.5 91/02/22 09:49:01 mrose Interim $
+ *
+ *
+ * $Log:       lex.l.gnrc,v $
+ * Revision 7.5  91/02/22  09:49:01  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.4  91/01/08  12:49:40  mrose
+ * update
+ * 
+ * Revision 7.3  90/12/11  10:33:40  mrose
+ * sync
+ * 
+ * Revision 7.2  90/11/11  10:53:55  mrose
+ * update
+ * 
+ * Revision 7.1  90/11/04  19:17:10  mrose
+ * update
+ * 
+ * Revision 7.0  90/11/03  21:18:11  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ *
+ */
+
+
+struct table {
+    char   *t_keyword;
+    int            t_value;
+    int            t_porting;
+};
+
+static struct table reserved[] = {
+    "ABSENT", ABSENT, 0,
+    "ANY", ANY, 0,
+    "APPLICATION", APPLICATION, 0,
+    "BEGIN", BGIN, 0,
+    "BIT", BIT, 0,
+    "BITSTRING", BITSTRING, 0,
+    "BOOLEAN", BOOLEAN, 0,
+    "BY", BY, 0,
+    "CHOICE", CHOICE, 0,
+    "COMPONENT", COMPONENT, 0,
+    "COMPONENTS", COMPONENTS, 0,
+    "COMPONENTSOF", COMPONENTSOF, 0,
+    "DECODER", DECODER, 0,
+    "DEFAULT", DEFAULT, 0,
+    "DEFINED", DEFINED, 0,
+    "DEFINITIONS", DEFINITIONS, 0,
+    "ENCODER", ENCODER, 0,
+    "ENCRYPTED", ENCRYPTED, 0,
+    "END", END, 0,
+    "ENUMERATED", ENUMERATED, 0,
+    "EXPLICIT", EXPLICIT, 0,
+    "EXPORTS", EXPORTS, 0,
+    "FALSE", FALSE, 0,
+    "FROM", FROM, 0,
+    "IDENTIFIER", IDENTIFIER, 0,
+    "IMPLICIT", IMPLICIT, 0,
+    "IMPORTS", IMPORTS, 0,
+    "INCLUDE", INCLUDES, 0,
+    "INTEGER", INTEGER, 0,
+    "MIN", MIN, 0,
+    "MAX", MAX, 0,
+    "NULL", NIL, 0,
+    "OBJECT", OBJECT, 0,
+    "OCTET", OCTET, 0,
+    "OCTETSTRING", OCTETSTRING, 0,
+    "OF", OF, 0,
+    "OPTIONAL", OPTIONAL, 0,
+    "PREFIXES", PREFIXES, 0,
+    "PRESENT", PRESENT, 0,
+    "PRINTER", PRINTER, 0,
+    "PRIVATE", PRIVATE, 0,
+    "REAL", REAL, 0,
+    "SECTIONS", SECTIONS, 0,
+    "SEQUENCE", SEQUENCE, 0,
+    "SEQUENCEOF", SEQUENCEOF, 0,
+    "SET", SET, 0,
+    "SETOF", SETOF, 0,
+    "SIZE", SIZE, 0,
+    "STRING", STRING, 0,
+    "TAGS", TAGS, 0,
+    "TRUE", TRUE, 0,
+    "UNIVERSAL", UNIVERSAL, 0,
+    "WITH", WITH, 0,
+    "PLUS-INFINITY", PLUSINFINITY, 0,
+    "MINUS-INFINITY", MINUSINFINITY, 0,
+%BEGIN(ROSY)%
+    "OPERATION", OPERATION, 1,
+    "ARGUMENT", ARGUMENT, 0,
+    "RESULT", RESULT, 0,
+    "ERRORS", ERRORS, 0,
+    "LINKED", LINKED, 0,
+    "ERROR", ERROR, 1,
+    "PARAMETER", PARAMETER, 0,
+/* start new stuff */
+    "ABSTRACT-OPERATION", OPERATION, 0,
+    "ABSTRACT-ERROR", ERROR, 0,
+    "ABSTRACT", ABSTRACT, 0,
+    "OPERATIONS", OPERATIONS, 0,
+    "CONSUMER", CONSUMER, 0,
+    "SUPPLIER", SUPPLIER, 0,
+    "INVOKES", INVOKES, 0,
+    "PORT", PORT, 0,
+    "PORTS", PORTS, 0,
+/* refine is beyond me! (JPO)
+    "REFINE", REFINE, 0,
+    "AS", AS, 0,
+    "RECURRING", RECURRING, 0,
+    "VISIBLE", VISIBLE, 0,
+    "PAIRED", PAIRED, 0,
+*/
+/* end new stuff */
+%END(ROSY)%
+%BEGIN(MOSY)%
+    "OBJECT-TYPE", OBJECTYPE, 1,
+    "SYNTAX", SYNTAX, 0,
+    "ACCESS", ACCESS, 0,
+    "STATUS", STATUS, 0,
+%END(MOSY)%
+    NULL, 0
+};
+
+%}
+
+%%
+
+"--"                   {   register int c, d;
+
+                           for (d = 0; c = input (); d = c == '-')
+                               if (c == '\n' || (d && c == '-'))
+                                   break;
+                       }
+[ \t]*                 {
+                           if (yydebug)
+                               fprintf (stderr, "WT\n");
+                       }
+\n                     {
+                           if (yydebug)
+                               fprintf (stderr, "NL\n");
+                       }
+"::="                  {
+                           if (yydebug)
+                               fprintf (stderr, "SY: CCE\n");
+                           return CCE;
+                       }
+"..."                  {
+                           if (yydebug)
+                               fprintf (stderr, "SY: DOTDOTDOT\n");
+                           return DOTDOTDOT;
+                       }
+".."                   {
+                           if (yydebug)
+                               fprintf (stderr, "SY: DOTDOT\n");
+                           return DOTDOT;
+                       }
+"."                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: DOT\n");
+                           return DOT;
+                       }
+";"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: SEMICOLON");
+                           return SEMICOLON;
+                       }
+","                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: COMMA\n");
+                           return COMMA;
+                       }
+"{"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: LBRACE\n");
+                           return LBRACE;
+                       }
+"}"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: RBRACE\n");
+                           return RBRACE;
+                       }
+"|"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: BAR\n");
+                           return BAR;
+                       }
+"-"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: MINUS\n");
+                           return MINUS;
+                       }
+"+"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: PLUS\n");
+                           return PLUS;
+                       }
+%BEGIN(ROSY)%
+"[S]"                  {
+                           if (yydebug)
+                               fprintf (stderr, "SY: OBJECTSUPPLIER\n");
+                           return OBJECTSUPPLIER;
+                       }
+"[C]"                  {
+                           if (yydebug)
+                               fprintf (stderr, "SY: OBJECTCONSUMER\n");
+                           return OBJECTCONSUMER;
+                       }
+%END(ROSY)%
+"[["|"$"|"<<"          {   register int tok, c, d, len;
+                           register char *cp, *ep, *pp;
+
+                           if (*yytext == '$')
+                               tok = VLENGTH;
+                           else
+                               if (*yytext == '<')
+                                   tok = CONTROL;
+                               else {
+                                   while((c = input()) == ' ' || c =='\t')
+                                       continue;
+                                   switch (c) {
+                                       case 'a': tok = VALA;
+                                                 break;
+                                       case 'b': tok = VALB;
+                                                 break;
+                                       case 'i': tok = VALI;
+                                                 break;
+                                       case 's': tok = VALS;
+                                                 break;
+                                       case 'o': tok = VALO;
+                                                 break;
+                                       case 'x': tok = VALX;
+                                                 break;
+                                       case 'p': tok = VALP;
+                                                 break;
+                                       case 'q': tok = VALQ;
+                                                 break;
+                                       case 'r': tok = VALR;
+                                                 break;
+                                       case 't': tok = VALT;
+                                                 break;
+                                       case 'O': tok = VALOID;
+                                                 break;
+                                       case 'P': tok = PARAMETERTYPE;
+                                                 break;
+                                       case 'T': tok = VALTYPE;
+                                                 break;
+                                       case 'E': tok = ENC_FN;
+                                                 break;
+                                       case 'D': tok = DEC_FN;
+                                                 break;
+                                       case 'F': tok = FRE_FN;
+                                                 break;
+                                       default : myyerror ("unknown token: \"%s\"", yytext);
+                                                 break;
+                                   }
+                                   if ((c = input()) != ' ' && c != '\t'
+                                       && c != '\n')
+                                       yyerror ("syntax error in [[ ... ]]");
+                               }
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading value");
+                               if ((d == ']' && c == ']' && tok !=CONTROL) ||
+                                   (c == '$' && (tok ==VALX || tok ==VALO)) ||
+                                   (d == '>' && c == '>' && tok ==CONTROL)) {
+                                   if ((tok == VALX || tok == VALO) &&
+                                      (c != '$'))
+                                      yyerror("Missing '$' in [[ - ]]");
+                                   if (c == '$') {unput(c); *cp = NULL;}
+                                   else *--cp = NULL;
+                                   yylval.yy_string = pp;
+                                   if (yydebug)
+                                       fprintf (stderr, "VAL: \"%s\"\n",
+                                               yylval.yy_string);
+                                   return tok;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+"["                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: LBRACKET\n");
+                           return LBRACKET;
+                       }
+"]"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: RBRACKET\n");
+                           return RBRACKET;
+                       }
+"<"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: LANGLE\n");
+                           return LANGLE;
+                       }
+"("                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: LPAREN\n");
+                           return LPAREN;
+                       }
+")"                    {
+                           if (yydebug)
+                               fprintf (stderr, "SY: RPAREN\n");
+                           return RPAREN;
+                       }
+"\*"                   {
+                           if (yydebug)
+                               fprintf (stderr, "SY: STAR\n");
+                           return STAR;
+                       }
+[0-9]+                 {
+                           (void) sscanf (yytext, "%d", &yylval.yy_number);
+                           if (yydebug)
+                               fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
+                           return LITNUMBER;
+                       }
+-[0-9]+                        {
+                           (void) sscanf (yytext, "%d", &yylval.yy_number);
+                           if (yydebug)
+                               fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
+                           return LITNUMBER;
+                       }
+'[^'$]*'[BbHh]         {   register char *cp; register int i;
+
+                           switch (*(cp = yytext + strlen (yytext) - 1)) {
+                               case 'H':
+                               case 'h':
+                                   *--cp = NULL;
+                                   for (cp = yytext + 1; *cp; cp++)
+                                       if (!isxdigit(*cp))
+                                           yyerror ("bad hex string");
+                                   yylval.yy_string = new_string(yytext + 1);
+                                   if (yydebug)
+                                       fprintf (stderr,
+                                           "HSTRING: %s\n", yylval.yy_string);
+                                   return HSTRING;
+
+                               case 'B':
+                               case 'b':
+                                   *--cp = NULL;
+                                   for (cp = yytext + 1; *cp; cp++)
+                                       if (*cp != '0' && *cp != '1')
+                                           yyerror ("bad bit string");
+                                   yylval.yy_string = new_string(yytext + 1);
+                                   if (yydebug)
+                                       fprintf (stderr,
+                                           "BSTRING: %s\n", yylval.yy_string);
+                                   return BSTRING;
+                           }
+                           yyerror ("illegal string");
+                       }
+\"[^\"$]*\"            {
+                           yytext[strlen (yytext) - 1] = NULL;
+                           yylval.yy_string = new_string (yytext + 1);
+                           if (yydebug)
+                               fprintf (stderr, "LIT: \"%s\"\n", yylval.yy_string);
+                           return LITSTRING;
+                       }
+[A-Z][A-Za-z0-9-]*     {   register struct table *t;
+
+                           for (t = reserved; t -> t_keyword; t++)
+                               if (strcmp (t -> t_keyword, yytext) == 0) {
+                                   if (yyporting && t -> t_porting)
+                                       break;
+                                   if (yydebug)
+                                       fprintf (stderr,
+                                                 "KE: \"%s\"\n", yytext);
+                                   yylval.yy_number = yylineno;
+                                   return t -> t_value;
+                               }
+                           yylval.yy_string = new_string (yytext);
+                           if (yydebug)
+                               fprintf (stderr, "ID: \"%s\"\n", yylval.yy_string);
+                           return ID;
+                       }
+[a-z][A-Za-z0-9-]*     {   yylval.yy_string = new_string (yytext);
+                           if (yydebug)
+                               fprintf (stderr, "NAME: \"%s\"\n", yylval.yy_string);
+                           return NAME;
+                       }
+"%["                   {   register int c, d, len;
+                           register char *cp, *ep, *pp;
+
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading value");
+                               if (d == '%' && c == ']' ) {
+                                   *--cp = NULL;
+                                   yylval.yy_string = pp;
+                                   if (yydebug)
+                                       fprintf (stderr, "VAL: \"%s\"\n",
+                                                yylval.yy_string);
+                                   return SCTRL;
+                               }
+                               if (d == '\n')
+                                   yyerror ("newline in %[ %] construct");
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+"%{"                   {   register int c, d, len;
+                           int     mylineno;
+                           register char *cp, *ep, *pp;
+
+                           mylineno = yylineno;
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading action");
+                               if (d == '%' && c == '}') {
+                                   *--cp = NULL;
+                                   yylval.yy_action = new_action (pp, mylineno);;
+                                   if (yydebug)
+                                       fprintf (stderr, "ACTION: \"%s\", %d\n",
+                                               yylval.yy_action -> ya_text,
+                                               yylval.yy_action -> ya_lineno);
+                                   return ACTION;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+%BEGIN(PEPSY)%
+\<[DEP]<                       {   register int c, d, len;
+                           int     mylineno;
+                           register char *cp, *ep, *pp;
+                           int c_typ = (yytext[1] == 'D' ? DCHOICE :
+                               (yytext[1] == 'E' ? ECHOICE : PCHOICE));
+
+                           mylineno = yylineno;
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading action");
+                               if (d == '>' && c == '>') {
+                                   *--cp = NULL;
+                                   yylval.yy_action = new_action (pp, mylineno);;
+                                   if (yydebug)
+                                       fprintf (stderr,"%cCHOICE: \"%s\", %d\n",
+                                                yytext[1],
+                                               yylval.yy_action -> ya_text,
+                                               yylval.yy_action -> ya_lineno);
+                                   return c_typ;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+
+"%E{"                  {   register int c, d, len;
+                           int     mylineno;
+                           register char *cp, *ep, *pp;
+
+                           mylineno = yylineno;
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading action");
+                               if (d == '%' && c == '}') {
+                                   *--cp = NULL;
+                                   yylval.yy_action = new_action (pp, mylineno);;
+                                   if (yydebug)
+                                       fprintf (stderr,"EACTION: \"%s\", %d\n",
+                                               yylval.yy_action -> ya_text,
+                                               yylval.yy_action -> ya_lineno);
+                                   return EACTION;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+"%D{"                  {   register int c, d, len;
+                           int     mylineno;
+                           register char *cp, *ep, *pp;
+
+                           mylineno = yylineno;
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading action");
+                               if (d == '%' && c == '}') {
+                                   *--cp = NULL;
+                                   yylval.yy_action = new_action (pp, mylineno);;
+                                   if (yydebug)
+                                       fprintf (stderr,"DACTION: \"%s\", %d\n",
+                                               yylval.yy_action -> ya_text,
+                                               yylval.yy_action -> ya_lineno);
+                                   return DACTION;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+"%P{"                  {   register int c, d, len;
+                           int     mylineno;
+                           register char *cp, *ep, *pp;
+
+                           mylineno = yylineno;
+                           if ((pp = malloc ((unsigned) (len = BUFSIZ)))
+                                   == NULL)
+                               yyerror ("out of memory");
+
+                           for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
+                               if ((c = input ()) == NULL)
+                                   yyerror ("end-of-file while reading action");
+                               if (d == '%' && c == '}') {
+                                   *--cp = NULL;
+                                   yylval.yy_action = new_action (pp, mylineno);;
+                                   if (yydebug)
+                                       fprintf (stderr,"PACTION: \"%s\", %d\n",
+                                               yylval.yy_action -> ya_text,
+                                               yylval.yy_action -> ya_lineno);
+                                   return PACTION;
+                               }
+                               if (cp >= ep) {
+                                   register int curlen = cp - pp;
+                                   register char *dp;
+
+                                   if ((dp = realloc (pp,
+                                               (unsigned) (len += BUFSIZ)))
+                                           == NULL)
+                                       yyerror ("out of memory");
+                                   cp = dp + curlen;
+                                   ep = (pp = dp) + len - 1;
+                               }
+                               *cp++ = c;
+                           }
+                       }
+%END(PEPSY)%
+.                      {   
+                           myyerror ("unknown token: \"%s\"", yytext);
+                       }
+
+%%
diff --git a/usr/src/contrib/isode/pepsy/main.c b/usr/src/contrib/isode/pepsy/main.c
new file mode 100644 (file)
index 0000000..563000b
--- /dev/null
@@ -0,0 +1,4246 @@
+/* main.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/main.c,v 7.4 91/02/22 09:49:05 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/main.c,v 7.4 91/02/22 09:49:05 mrose Interim $
+ *
+ *
+ * $Log:       main.c,v $
+ * Revision 7.4  91/02/22  09:49:05  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.3  90/12/23  17:24:34  mrose
+ * patches
+ * 
+ * Revision 7.2  90/11/04  19:18:40  mrose
+ * update
+ * 
+ * Revision 7.1  90/10/17  11:59:49  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:21  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include       <stdio.h>
+#include       <ctype.h>
+#include "config.h"
+#ifdef PEPSY_REALS
+#include       <math.h>
+#define F_SMALL        (1.0e-10)       /* How accurate should reals agree */
+#endif
+#include       "psap.h"
+#include       "T1-types.h"
+#include       "T2-types.h"
+#include       "T3-types.h"
+
+
+
+#include "test_table.h"
+       /* compactly generate the new item of data */
+#define new(x) ((x *)calloc(1, sizeof (x)))
+
+#define NULLQB (struct qbuf *)0
+char   *fill();
+static char   *idname();
+static char   *clname();
+static int prntbits();
+static int pclen();
+static int prntos();
+static int prntstr();
+
+extern int print_pe();
+extern modtyp  _ZBIT_1;
+extern char    *bitstr2strb();
+extern PE mkpelist(), mkpe();
+extern OID     mkoid();
+extern struct type_UNIV_EXTERNAL *mkext();
+
+extern struct rep_elem *mkrep_elem();
+extern struct rep_int  *mkrep_int();
+
+extern void    exit();
+
+static int     t_test = 1;     /* Iteration of the test */
+
+#define NullParm       ((char  *) 0)
+/*ARGSUSED*/
+main(argc, argv)
+int    argc;
+char   **argv;
+{
+    int        i;
+    int succ, fail;
+
+    succ = fail = 0;
+    if (argc <= 1) {
+       for (i = MAXTCASE - 1; i >= 0; i--) {
+           if (t_case[i].tst_entry < 0)
+               continue;
+           for (t_test = t_case[i].tst_tests; t_test > 0; t_test--) {
+               if (ed_tst(i) != OK) {
+                   (void) printf("Failed\n");
+                   fail++;
+               } else
+                   succ++;
+           }
+       }
+       if (fail > 0)
+           (void) printf("Failed\n");
+       (void) printf("Total %d  = %d successes %d failures\n", fail + succ, succ, fail);
+#ifdef PEP_TEST
+       tailorfree();
+#endif
+    } else {
+       i = atoi(argv[1]);
+       if (argc > 2)
+           t_test = atoi(argv[2]);
+       (void) printf("Test %d\n", i);
+       if (ed_tst(i) != OK)
+           (void) printf("Failed\n");
+#ifdef PEP_TEST
+       tailorfree();
+#endif
+    }
+    return (fail);
+
+}
+
+/*
+ * Perform a test of encoding/decoding on type number tynum
+ */
+ed_tst(tynum)
+int    tynum;
+{
+    PE pe;
+    char *parm1, *parm2;
+
+    if (tynum < 0 || tynum >= MAXTCASE)
+           ferrd(1, "ed_tst illegal type %d\n", tynum);
+    
+
+    if ((parm1 = fill(tynum)) == NULL) {
+       ferr(1, "calloc did not work\n");
+    }
+
+#define encode(tynum, x, parm) \
+       enc_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, 0, NULLCP, (parm))
+
+    if (encode(tynum, &pe, parm1) == NOTOK) {
+       (void) printf("encode:failed on %s: %s\n", t_case[tynum].tst_name,
+            PY_pepy);
+       return(NOTOK);
+    }
+       
+
+#define decode(tynum, x, parm) \
+       dec_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, (int *) 0, (char **)NULL, (parm))
+
+    if (decode(tynum, pe, &parm2) == NOTOK) {
+           (void) printf("decode:failed on %s: %s\n", t_case[tynum].tst_name,
+                PY_pepy);
+           return (NOTOK);
+    }
+       
+    if (tcmp(tynum, parm1, parm2)) {
+       (void) printf("%s: not transfered properly\n", t_case[tynum].tst_name);
+       return (NOTOK);
+    }
+
+#if PRNT
+#define print(tynum, x)        \
+    prnt_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, (int *) 0, (char **)0)
+
+    (void) printf("\n\"%s\" t_test = %d\n", t_case[tynum].tst_name, t_test);
+    if (print(tynum, pe) == NOTOK) {
+           (void) printf("Print:failed on %s: %s\n", t_case[tynum].tst_name,
+                PY_pepy);
+           exit(2);
+    }
+#endif
+       
+
+
+#define fre_space(tynum, parm) \
+       fre_obj(parm, _ZT1_mod.md_dtab[t_case[tynum].tst_entry], &_ZT1_mod, 1)
+
+    if (fre_space(tynum, parm1) != OK)
+       return (NOTOK);
+    if (fre_space(tynum, parm2) != OK)
+       return (NOTOK);
+
+    if (pe)
+       pe_free(pe);
+
+    return (OK);
+}
+
+    /*SUPPRESS 218*/
+/*
+ * fill in some test data for the given type
+ */
+char   *
+fill(tynum)
+int    tynum;
+{
+    char       *parm;
+    static int count;
+    int                i;
+    char       *p;
+
+    if ((parm = calloc(1, t_case[tynum].tst_size)) == NULL) {
+       ferr(1, "calloc did not work\n");
+    }
+
+    switch (tynum) {
+    case TY_MPDU:
+#define Xparm ((struct type_T1_MPDU *)parm)
+       if ((Xparm->a__seq = new(struct element_T1_1)) == NULL) {
+               (void) printf("calloc did not work\n");
+               return NULL;
+       }
+       Xparm->a__seq->fred = 10;
+       Xparm->a__seq->george = 1;
+       break;
+#undef Xparm
+    
+    case TY_EMBEDDED:
+#define Xparm ((struct type_T1_Embedded *)parm)
+       Xparm->anMPDU = (struct type_T1_MPDU *)fill(TY_MPDU);
+       Xparm->ei = 6966;
+       break;
+#undef Xparm
+
+    case TY_STRINGS:
+#define Xparm  ((struct type_T1_Strings *)parm)
+       Xparm->ostring = str2qb("12\376\0\377a6", 7, 1);
+       Xparm->bstring = strb2bitstr("\270\017\010\020\040\100", 50, 0, 0);
+       Xparm->nstring = str2qb("123456", 6, 1);
+       Xparm->pstring = str2qb("hello, world", 12, 1);
+       Xparm->tstring = str2qb("teletex", 7, 1);
+       Xparm->t61string = str2qb("T.61", 4, 1);
+       Xparm->vstring = str2qb("visible", 7, 1);
+       Xparm->vis__string = str2qb("visible again", 13, 1);
+       Xparm->i646string = str2qb("who knows what this is", 22, 1);
+       Xparm->ia5string = str2qb("This is ASCII\n\r", 15, 1);
+       Xparm->graphstring = str2qb("This is a graphic string", 24, 1);
+       Xparm->genstring = str2qb("This is a general string", 24, 1);
+       break;
+#undef Xparm
+
+    case TY_EMB_STRINGS:
+#define Xparm  ((struct type_T1_Emb__Strings *)parm)
+       Xparm->atest = 2001;
+       Xparm->ctest = strb2bitstr("\03\010\252\125", 24, 0, 0);
+       Xparm->btest = str2qb("Good bye", 8, 1);
+       Xparm->big__test = (struct type_T1_Strings *)fill(TY_STRINGS);
+       if ((Xparm->emb__test = new(struct element_T1_0)) == NULL) {
+               (void) printf("calloc did not work\n");
+               return NULL;
+       }
+       Xparm->emb__test->em__int = -101;
+       Xparm->emb__test->em__oct = str2qb("Embedded octet string", 21, 1);
+       Xparm->emb__test->em__bit = strb2bitstr("\377\252\125\370\01", 40, 0,0);
+       break;
+#undef Xparm
+
+    case TY_IMPLICIT:
+#define Xparm  ((struct type_T1_Impl__Tags *)parm)
+       Xparm->i__impl = -1;
+       Xparm->o__impl = str2qb("I'm an implicit tagged octet string", 36, 1);
+       Xparm->b__impl = strb2bitstr("\0\0\01\230\01", 40, 0, 0);
+       Xparm->f__impl = 0xff; /* True */
+       Xparm->obj__impl = (struct type_T1_Emb__Strings *)fill(TY_EMB_STRINGS);
+       if ((Xparm->i__emb__test = new(struct element_T1_2)) == NULL) {
+               (void) printf("calloc did not work\n");
+               return NULL;
+       }
+       Xparm->i__emb__test->i__em__int = -101;
+       Xparm->i__emb__test->i__em__oct = str2qb("Implicit Embedded", 18, 1);
+       Xparm->i__emb__test->i__em__bit = strb2bitstr("\200\200\200\200", 32, 0, 0);
+#undef Xparm
+       break;
+
+    case TY_EXPLICIT:
+#define Xparm  ((struct type_T1_Expl__Tags *)parm)
+       Xparm->i__expl = 35051;
+       Xparm->o__expl = str2qb("explicit tagged octet string", 28, 1);
+       Xparm->b__expl = strb2bitstr("\070\070\070\077", 32, 0, 0);
+       Xparm->f__expl = 0xf0; /* True */
+       Xparm->obj__expl = (struct type_T1_Emb__Strings *)fill(TY_EMB_STRINGS);
+       if ((Xparm->i__exp__test = new(struct element_T1_3)) == NULL) {
+               (void) printf("calloc did not work\n");
+               return NULL;
+       }
+       Xparm->i__exp__test->i__ex__int = -9;
+       Xparm->i__exp__test->i__ex__oct = str2qb("Explicit Embedded", 18, 1);
+       Xparm->i__exp__test->i__ex__bit = strb2bitstr("\03\03\03\03\277", 40, 0, 0);
+#undef Xparm
+       break;
+       
+    case TY_SEQOF:
+#define Xparm  ((struct type_T1_Seqof__Test *)parm)
+    count = 2;
+    Xparm->sqof__test1 = (struct element_T1_4 *) fill(TY_ELEMENT4);
+    count = 2;
+    Xparm->stof__test1 = (struct member_T1_2 *) fill(TY_MEMBER2);
+    Xparm->i__test1 = 33;
+    count = 2;
+    Xparm->sqof__test2 = (struct element_T1_6 *) fill(TY_ELEMENT6);
+    count = 2;
+    Xparm->stof__test2 = (struct member_T1_4 *) fill(TY_MEMBER4);
+    Xparm->i__test2 = 99;
+    break;
+#undef Xparm
+       
+    case TY_ELEMENT4:
+#define Xparm  ((struct element_T1_4 *)parm)
+    Xparm->element_T1_5 = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
+    if (count-- > 0)
+       Xparm->next = (struct element_T1_4 *) fill(TY_ELEMENT4);
+    else
+       Xparm->next = NULL;
+    break;
+#undef Xparm
+       
+    case TY_MEMBER2:
+#define Xparm  ((struct member_T1_2 *)parm)
+    Xparm->member_T1_3 = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
+    if (count-- > 0)
+       Xparm->next = (struct member_T1_2 *) fill(TY_MEMBER2);
+    else
+       Xparm->next = NULL;
+    break;
+#undef Xparm
+
+    case TY_ELEMENT6:
+#define Xparm  ((struct element_T1_6 *)parm)
+    Xparm->element_T1_7 = (struct element_T1_8 *)fill(TY_ELEMENT8);
+    if (count-- > 0)
+       Xparm->next = (struct element_T1_6 *) fill(TY_ELEMENT6);
+    else
+       Xparm->next = NULL;
+    break;
+#undef Xparm
+
+    case TY_ELEMENT8:
+#define Xparm  ((struct element_T1_8 *)parm)
+    Xparm->sqof__in = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
+    Xparm->sqof__i = 212121;
+    Xparm->sqof__o = str2qb("Element8 Embedded", 18, 1);
+    break;
+#undef Xparm
+
+    case TY_MEMBER4:
+#define Xparm  ((struct member_T1_4 *)parm)
+    Xparm->member_T1_5 = (struct element_T1_9 *)fill(TY_ELEMENT9);
+    if (count-- > 0)
+       Xparm->next = (struct member_T1_4 *) fill(TY_MEMBER4);
+    else
+       Xparm->next = NULL;
+    break;
+#undef Xparm
+
+    case TY_ELEMENT9:
+#define Xparm  ((struct element_T1_9 *)parm)
+       Xparm->stof__in = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
+       Xparm->stof__i = -12345;
+       Xparm->stof__o = str2qb("XYZabcde Embedded", 18, 1);
+    break;
+#undef Xparm
+
+    case TY_CHOICE:
+#define Xparm  ((struct type_T1_Choice__Test *)parm)
+       Xparm->c1 = (struct choice_T1_0 *) fill(TY_CHOICE0);
+       Xparm->c2 = (struct choice_T1_1 *) fill(TY_CHOICE1);
+       Xparm->c3 = (struct choice_T1_2 *) fill(TY_CHOICE2);
+       Xparm->c4 = (struct element_T1_11 *) fill(TY_ELEMENT11);
+       break;
+#undef Xparm
+
+    case TY_CHOICE0:
+#define Xparm  ((struct choice_T1_0 *)parm)
+       
+       switch (Xparm->offset = (t_test + 10)%choice_T1_0_obj__c1 + 1) {
+       case choice_T1_0_i__c1:
+           Xparm->un.i__c1 = 10101;
+           break;
+       
+       case choice_T1_0_o__c1:
+           Xparm->un.o__c1 = str2qb("Andrew Worsley!!!", 18, 1);
+           break;
+       
+       case choice_T1_0_b__c1:
+           Xparm->un.b__c1 = strb2bitstr("\02\02\02\07\077", 40, 0, 0);
+           break;
+       
+       case choice_T1_0_f__c1:
+           Xparm->un.f__c1 = 0x11;
+           break;
+       
+       case choice_T1_0_obj__c1:
+           Xparm->un.obj__c1 = (struct type_T1_Emb__Strings *) fill(TY_EMB_STRINGS);
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE0:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+    case TY_CHOICE1:
+#define Xparm  ((struct choice_T1_1 *)parm)
+       
+       switch (Xparm->offset = (t_test + 11)%choice_T1_1_obj__c2 + 1) {
+       case choice_T1_1_i__c2:
+           Xparm->un.i__c2 = 1212;
+           break;
+       
+       case choice_T1_1_o__c2:
+           Xparm->un.o__c2 = str2qb("Richard Worsley!!", 18, 1);
+           break;
+       
+       case choice_T1_1_b__c2:
+           Xparm->un.b__c2 = strb2bitstr("\02\01\01\07\077", 40, 0, 0);
+           break;
+       
+       case choice_T1_1_f__c2:
+           Xparm->un.f__c2 = 0x12;
+           break;
+       
+       case choice_T1_1_obj__c2:
+           Xparm->un.obj__c2 = (struct type_T1_Emb__Strings *) fill(TY_EMB_STRINGS);
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE1:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+    case TY_CHOICE2:
+#define Xparm  ((struct choice_T1_2 *)parm)
+       
+       switch (Xparm->offset = (t_test + 12)%choice_T1_2_i__c3 + 1) {
+       case choice_T1_2_i__c3:
+           Xparm->un.i__c3 = 689364;
+           break;
+       
+       case choice_T1_2_seq__c3:
+           Xparm->un.seq__c3 = (struct element_T1_10 *) fill(TY_ELEMENT10);
+           break;
+       
+       case choice_T1_2_set__c3:
+           Xparm->un.set__c3 = (struct member_T1_6 *) fill(TY_MEMBER6);
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE2:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+    case TY_CHOICE3:
+#define Xparm  ((struct choice_T1_3 *)parm)
+       
+       switch (Xparm->offset = (t_test + 13)%choice_T1_3_sc__b__i + 1) {
+       case choice_T1_3_sc__a__i:
+           Xparm->un.sc__a__i = 16891;
+           break;
+       
+       case choice_T1_3_sc__b__i:
+           Xparm->un.sc__b__i = 13151;
+           break;
+       
+       case choice_T1_3_c4__i:
+           Xparm->un.c4__i = 10938;
+           break;
+       
+       case choice_T1_3_c4__obj:
+           Xparm->un.c4__obj = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE3:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+    case TY_ELEMENT10:
+#define Xparm  ((struct element_T1_10 *)parm)
+       Xparm->seq__c3__in = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
+       Xparm->seq__c3__i = 40938;
+       Xparm->seq__c3__o = str2qb("James Worsley!!!!", 18, 1);
+       break;
+#undef Xparm
+
+    case TY_MEMBER6:
+#define Xparm  ((struct member_T1_6 *)parm)
+       Xparm->set__c3__in = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
+       Xparm->set__c3__i = 0x40938;
+       Xparm->set__c3__o = str2qb("Patrick Worsley!!", 18, 1);
+       break;
+#undef Xparm
+
+    case TY_ELEMENT11:
+#define Xparm  ((struct element_T1_11 *)parm)
+       Xparm->c4__choice = (struct choice_T1_3 *) fill(TY_CHOICE3);
+       break;
+#undef Xparm
+
+    case TY_OPTIONAL:
+#define Xparm  ((struct type_T1_Opt__Strings *)parm)
+        if (t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->optionals |= opt_T1_Opt__Strings_a__opt;
+           Xparm->a__opt = 192837;
+       }
+        if (t_test & opt_T1_Opt__Strings_d__opt) {
+           Xparm->optionals |= opt_T1_Opt__Strings_d__opt;
+           Xparm->d__opt = 1;
+       }
+       Xparm->b__opt = str2qb("Susan Hannah Sibel", 19, 1);
+        if (t_test*(t_test + 1) & opt_T1_Opt__Strings_d__opt) {
+           Xparm->c__opt = strb2bitstr("\012\017\02\07\077", 40, 0, 0);
+       }
+        if (t_test & opt_T1_Opt__Strings_e__opt) {
+           Xparm->optionals |= opt_T1_Opt__Strings_e__opt;
+           Xparm->e__opt = 0;
+       }
+        if ((t_test + 12)*t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->big__opt = (struct type_T1_Strings *) fill(TY_STRINGS);
+       }
+        if ((t_test + 2)*t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->emb__opt = (struct element_T1_12 *) fill(TY_ELEMENT12);
+       }
+        if ((t_test + 4)*t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->st__opt = (struct member_T1_7 *) fill(TY_MEMBER7);
+       }
+        if ((t_test + 8)*t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->obj__opt = (struct type_T1_MPDU *) fill(TY_MPDU);
+       }
+        if (t_test & opt_T1_Opt__Strings_etag__opt) {
+           Xparm->optionals |= opt_T1_Opt__Strings_etag__opt;
+           Xparm->etag__opt = 2983461;
+       }
+        if ((t_test + 6)*t_test & opt_T1_Opt__Strings_a__opt) {
+           Xparm->ch__opt = (struct choice_T1_4 *) fill(TY_CHOICE4);
+       }
+       break;
+#undef Xparm
+
+     case TY_ELEMENT12:
+#define Xparm  ((struct element_T1_12 *)parm)
+        if ((t_test + 10)*t_test & opt_T1_element_T1_12_oem__int) {
+           Xparm->optionals |= opt_T1_element_T1_12_oem__int;
+           Xparm->oem__int = 197336;
+       }
+        if (t_test*(t_test + 22) & opt_T1_Opt__Strings_a__opt) {
+           Xparm->oem__oct = str2qb("Ling Worsley", 13, 1);
+       }
+        if (t_test*(t_test + 16) & opt_T1_Opt__Strings_d__opt) {
+           Xparm->oem__bit = strb2bitstr("\0142\0117\02\017\07", 40, 0, 0);
+       }
+        break;
+#undef Xparm
+
+     case TY_MEMBER7:
+#define Xparm  ((struct member_T1_7 *)parm)
+        if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int0) {
+           Xparm->optionals |= opt_T1_member_T1_7_st__int0;
+           Xparm->st__int0 = 85659;
+       }
+        if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int1) {
+           Xparm->optionals |= opt_T1_member_T1_7_st__int1;
+           Xparm->st__int1 = 664388;
+       }
+        if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int2) {
+           Xparm->optionals |= opt_T1_member_T1_7_st__int2;
+           Xparm->st__int2 = 967768;
+       }
+        break;
+#undef Xparm
+
+    case TY_CHOICE4:
+#define Xparm  ((struct choice_T1_4 *)parm)
+       
+       switch (Xparm->offset = (t_test + 14)%choice_T1_4_ch__2 + 1) {
+       case choice_T1_4_ch__1:
+           Xparm->un.ch__1 = 74576;
+           break;
+       
+       case choice_T1_4_ch__2:
+           Xparm->un.ch__2 = 28828;
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE4:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+     case TY_EXTREF:
+#define Xparm  ((struct type_T1_E__ref *)parm)
+       Xparm->a__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
+       Xparm->b__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
+       Xparm->c__ref = (struct type_T1_Choice__Test *) fill(TY_CHOICE);
+        if ((t_test + 20)*t_test & 0x2) {
+           Xparm->d__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
+       }
+        if ((t_test + 20)*t_test & 0x1) {
+           Xparm->e__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
+       }
+        break;
+#undef Xparm
+
+     case TY_T2_INFO:
+#define Xparm  ((struct type_T2_Info *)parm)
+       Xparm->a1 = 101910;
+       Xparm->a2 = -304985;
+       Xparm->a3 = 13;
+       Xparm->a4 = (struct type_T2_MPDU *) fill(TY_T2_MPDU);
+        break;
+#undef Xparm
+
+     case TY_T2_MPDU:
+#define Xparm  ((struct type_T2_MPDU *)parm)
+       Xparm->a__seq = (struct element_T2_0 *) fill(TY_T2_ELEM0);
+        break;
+#undef Xparm
+
+     case TY_T2_ELEM0:
+#define Xparm  ((struct element_T2_0 *)parm)
+       Xparm->fred = 998877;
+        break;
+#undef Xparm
+
+     case TY_OPTIMISED:
+#define Xparm  ((struct type_T1_Optimised *)parm)
+       Xparm->o1 = strb2bitstr("\0241\0227\032\011\0237", 40, 0, 0);
+       Xparm->o2 = str2qb("Peckling Worsley!!!!", 20, 1);
+       Xparm->o3 = (struct type_T1_MPDU *) fill(TY_MPDU);
+       Xparm->o4 = (PE ) mkpelist(t_test);
+       Xparm->element_T1_14  = (struct member_T1_9 *) fill(TY_MEMBER9);
+       break;
+#undef Xparm
+
+     case TY_MEMBER9:
+#define Xparm  ((struct member_T1_9 *)parm)
+       Xparm->o5 = mkpelist(t_test);
+       Xparm->o6 = mkpelist(t_test);
+       Xparm->o7 = mkoid(t_test);
+       break;
+#undef Xparm
+
+    case TY_EXTERNAL:
+#define Xparm  ((struct type_T1_Ext__typ *)parm)
+        Xparm->ext = mkext(t_test*8 + 1);
+        Xparm->a__ny = mkpe(t_test*8 + 1);
+        Xparm->ext__impl = mkext(t_test*6 + 1);
+        Xparm->any__impl = mkpe(t_test*8 + 3);
+        Xparm->ext__expl = mkext(t_test*4 + 1);
+        Xparm->any__expl = mkpe(t_test*8 + 5);
+       break;
+#undef Xparm
+
+    case TY_SEXTERNAL:
+#define Xparm  ((struct type_T1_SExt *)parm)
+       free(parm);     /* don't need it */
+       Xparm = mkext(21);
+       break;
+#undef Xparm
+
+    case TY_ETAGOBJ:
+#define Xparm  ((struct type_T1_Etags *)parm)
+       switch (Xparm->offset = (t_test + 4)%type_T1_Etags_bE + 1) {
+       case type_T1_Etags_aE:
+           Xparm->un.aE = 10283;
+           break;
+       
+       case type_T1_Etags_bE:
+           Xparm->un.bE = 40986;
+           break;
+       
+       default:
+           ferrd(1, "TY_ETAGOBJ:illegal offset %d\n", Xparm->offset);
+       }
+       break;
+#undef Xparm
+
+/* This has to be changed when posy is upgraded to handle DEFAULTS properly */
+    case TY_DEFAULT:
+#define Xparm  ((struct type_T1_Def__Strings *)parm)
+       if (t_test*t_test & 2)
+           Xparm->a__def = int_T1_a__def_a__def__0;
+       else
+           Xparm->a__def = int_T1_a__def_a__def__1;
+       if (t_test*t_test & 4)
+           Xparm->b__def = str2qb("Susan Sibel !!!!", 17, 1);
+       else if (t_test*t_test & 8)
+           Xparm->b__def = str2qb("hello, world", 12, 1);
+       else
+           Xparm->b__def = NULLQB;
+       if (t_test*t_test & 8)
+           Xparm->c__def = strb2bitstr(int2strb(bit_T1_c__def_c__def__two, 9),
+               9, 0, 0);
+       else
+           Xparm->c__def = NULLPE;
+       if (t_test*t_test & 0x10)
+           Xparm->okay = 0;
+       else
+           Xparm->okay = 1;
+       if (t_test*t_test & 0x20)
+           Xparm->e__def = 0;
+       else
+           Xparm->e__def = 1;
+       Xparm->big__def = (struct type_T1_Strings *) fill(TY_STRINGS);
+       if (t_test*t_test*t_test & 0x10)
+           Xparm->emb__def = NULL;
+       else
+           Xparm->emb__def = (struct element_T1_13 *) fill(TY_ELEMENT13);
+       if (t_test*t_test*t_test & 0x20)
+           Xparm->st__def = NULL;
+       else
+           Xparm->st__def = (struct member_T1_8 *) fill(TY_MEMBER8);
+       break;
+#undef Xparm
+
+    case TY_ELEMENT13:
+#define Xparm ((struct element_T1_13 *)parm)
+       if (t_test*t_test*t_test & 1)
+           Xparm->colour = int_T1_colour_green;
+       else
+           Xparm->colour = int_T1_colour_red;
+       if (t_test*t_test & 040)
+           Xparm->oem__oct = str2qb("Julia Dzuikas !!!!", 19, 1);
+       else
+           Xparm->oem__oct = NULLQB;
+       if (t_test*t_test*t_test & 2)
+           Xparm->version = strb2bitstr(int2strb((1 << bit_T1_version_basic)
+                                            |(1 << bit_T1_version_patch1), 3),
+                                            3, 0, 0);
+       else
+           Xparm->version = strb2bitstr(int2strb((1 << bit_T1_version_basic),
+                                                   3), 3, 0, 0);
+       break;
+#undef Xparm
+
+    case TY_MEMBER8:
+#define Xparm ((struct member_T1_8 *)parm)
+       if (t_test*t_test*t_test & 4)
+           Xparm->wine = int_T1_wine_burgundy;
+       else
+           Xparm->wine = int_T1_wine_claret;
+       if (t_test*t_test*t_test & 010)
+           Xparm->beer = int_T1_beer_vb;
+       else
+           Xparm->beer = int_T1_beer_hieneken;
+       if (t_test*t_test*t_test & 020)
+           Xparm->spirit = int_T1_spirit_vodka;
+       else
+           Xparm->spirit = int_T1_spirit_brandy;
+       break;
+#undef Xparm
+
+    case TY_STEST:
+#define Xparm ((struct type_T1_Stest *)parm)
+       if (t_test*(t_test + 2)*t_test & 4)
+           Xparm->st1 = (struct type_T1_Sint *)fill(TY_SINT);
+       else
+           Xparm->st1 = (struct type_T1_Sint *)NULL;
+       if (t_test*(t_test + 2)*t_test & 010)
+           Xparm->st2 = str2qb("goodbye, world", 14, 1);
+       else
+           Xparm->st2 = str2qb("xxxxxxx, world", 14, 1);
+       break;
+#undef Xparm
+
+    case TY_SINT:
+#define Xparm ((struct type_T1_Sint *)parm)
+       if (t_test*(t_test + 4)*t_test & 4)
+           Xparm->parm = 33;
+       else
+           Xparm->parm = 44;
+       break;
+#undef Xparm
+
+    case TY_ETYPE:
+#define Xparm ((struct type_T1_Enum__type *)parm)
+       switch (t_test & 3) {
+       case 0:
+           Xparm->parm = int_T1_Enum__type_pork;
+           break;
+
+       case 1:
+           Xparm->parm = int_T1_Enum__type_beef;
+           break;
+
+
+       case 2:
+           Xparm->parm = int_T1_Enum__type_chicken;
+           break;
+
+
+       case 3:
+           Xparm->parm = int_T1_Enum__type_lamb;
+           break;
+
+       default:
+           ferrd(1, "fill:ETYPE: Self consistency failure\n", t_test);
+       }
+       break;
+#undef Xparm
+
+    case TY_ENUM_TEST:
+#define Xparm ((struct type_T1_T__enum *)parm)
+       i = t_test;
+       Xparm->ae1 = (struct type_T1_Enum__type *)fill(TY_ETYPE);
+       t_test++;
+       Xparm->ae2 = (struct type_T1_Enum__type *)fill(TY_ETYPE);
+       t_test++;
+       Xparm->ae3 = (struct type_T1_Enum__type *)fill(TY_ETYPE);
+       t_test++;
+       if (t_test & 1)
+           Xparm->ae5 = (struct type_T1_Enum__type *)fill(TY_ETYPE);
+       Xparm->ae4 = (struct type_T1_Enum__type *)fill(TY_ETYPE);
+       t_test++;
+       if (t_test & 2)
+           Xparm->ae4->parm = int_T1_Enum__type_chicken; /* Default */
+       t_test = i;
+       break;
+#undef Xparm
+
+#ifdef PEPSY_REALS
+    case TY_REAL:
+#define Xparm  ((struct type_T1_Real *)parm)
+       switch (t_test % 3) {
+       case 0:
+           Xparm->parm = -2.28789;
+           break;
+       
+       case 1:
+           Xparm->parm = 927639.98009;
+           break;
+
+       case 2:
+           Xparm->parm = 0.0;
+           break;
+
+       default:
+       ferrd(1, "fill:TY_REAL:Internal error %d\n", t_test);
+        }
+        break;
+#undef Xparm
+
+    case TY_REAL_TEST:
+#define Xparm  ((struct type_T1_T__real *)parm)
+       i = t_test;
+        Xparm->r1 = (struct type_T1_Real *) fill(TY_REAL);
+       t_test++;
+        Xparm->r2 = (struct type_T1_Real *) fill(TY_REAL);
+       t_test++;
+        Xparm->r3 = (struct type_T1_Real *) fill(TY_REAL);
+       t_test++;
+
+       Xparm->r4 = (struct type_T1_Real *) fill(TY_REAL);
+       t_test++;
+       if (i & 1)      /* Default */
+           Xparm->r4->parm = 3.1415962;
+
+       if (i & 2) {    /* Optional */
+           Xparm->r5 = (struct type_T1_Real *) fill(TY_REAL);
+       }
+       t_test = i;
+       break;
+#undef Xparm
+
+/* all strings have to be malloc'ed out ! */
+    case TY_OPTPEPY:
+    case TY_DEFPEPY:
+#define Xparm  ((struct pepy_refs1 *)parm)
+        Xparm->t_int = 12354 + t_test;
+        Xparm->t_int1 = 12354 + t_test;
+        Xparm->t_enum = t_test + 1;
+        Xparm->t_enum1 = t_test + 1;
+        Xparm->t_qbuf = str2qb("Some is out there!", 18, 1);
+        Xparm->t_qbuf1 = str2qb("Some is out there!", 18, 1);
+        Xparm->t_string = strdup("hello, world\n");
+        Xparm->t_string1 = strdup("hello, world\n");
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_ostring = p;
+        Xparm->t_olen = t_test + 4;
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_ostring1 = p;
+        Xparm->t_olen1 = t_test + 4;
+        Xparm->t_bool = t_test % 2;
+        Xparm->t_bool1 = t_test % 2;
+        Xparm->t_real = sqrt(t_test * 3.1415962);
+        Xparm->t_real1 = sqrt(t_test * 3.1415962);
+        Xparm->t_oid = mkoid(t_test);
+       if (tynum != TY_OPTPEPY)
+           Xparm->t_oid1 = mkoid(t_test);
+       Xparm->t_pe = strb2bitstr("\0221\0327\052\211\0237\200", 41, 0, 0);
+       Xparm->t_pe1 = strb2bitstr("\0221\0327\052\211\0237\200", 41, 0, 0);
+        Xparm->t_any = mkpe(t_test*8 + 3);
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_bstring = p;
+        Xparm->t_blen = t_test*8 + 8;
+       break;
+#undef Xparm
+
+    case TY_PEPY:
+#define Xparm  ((struct pepy_refs *)parm)
+        Xparm->t_int = 12354 + t_test;
+        Xparm->t_enum = t_test + 1;
+        Xparm->t_qbuf = str2qb("Some is out there!", 18, 1);
+        Xparm->t_string = strdup("hello, world\n");
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_ostring = p;
+        Xparm->t_olen = t_test + 4;
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_bstring = p;
+        Xparm->t_blen = t_test*8 + 4;
+        Xparm->t_bool = t_test % 2;
+        Xparm->t_real = sqrt(t_test * 3.1415962);
+        Xparm->t_oid = mkoid(t_test);
+       Xparm->t_pe = strb2bitstr("\0221\0327\052\011\0237\200", 41, 0, 0);
+        Xparm->t_any = mkpe(t_test*8 + 3);
+        Xparm->t_def = (struct pepy_refs1 *)fill(TY_DEFPEPY);
+        Xparm->t_opt = (struct pepy_refs1 *)fill(TY_OPTPEPY);
+       for (i = NUMOPT - 1; i >= 0; i--)
+            if ((t_test + i) % 2 == 1)
+                BITSET(Xparm->t_opt->opt_set, i);
+            else
+                BITCLR(Xparm->t_opt->opt_set, i);
+       break;
+#undef Xparm
+
+    case TY_S_COMPD:
+#define Xparm  ((struct pepy_refs1 *)parm)
+        Xparm->t_int = 12354 + t_test;
+        Xparm->t_enum = t_test + 1;
+        Xparm->t_int1 = 12354 + t_test;
+        Xparm->t_enum1 = t_test + 1;
+       for (i = NUMOPT - 1; i >= 0; i--) {
+           if (i != OPT_INT1 && i != OPT_INT2
+           && i != OPT_ENUM1 && i != OPT_ENUM2)
+               continue;
+
+            if ((t_test + i) % 2 == 1)
+                BITSET(Xparm->opt_set, i);
+            else
+                BITCLR(Xparm->opt_set, i);
+       }
+       break;
+#undef Xparm
+
+#endif
+
+    case TY_ACTION:
+    case TY_REPEAT:
+#define Xparm  ((struct repeats *)parm)
+       Xparm->rp_sq1 = mkrep_int(t_test - 1);
+       Xparm->rp_sq2 = mkrep_elem(t_test - 1);
+       Xparm->rp_st1 = mkrep_int(t_test - 1);
+       Xparm->rp_st2 = mkrep_elem(2*t_test - 1);
+       switch (t_test % 3) {
+       case 0:
+           Xparm->rp_choice = RP_INT;
+           Xparm->rp_int = t_test*t_test - 10;
+           break;
+
+       case 1:
+           Xparm->rp_choice = RP_BOOL;
+           Xparm->rp_bool = (t_test + 1) % 2;
+           break;
+
+       case 2:
+           Xparm->rp_choice = RP_OSTRING;
+           Xparm->rp_ostring = strdup("lets go home");
+           Xparm->rp_int = strlen(Xparm->rp_ostring);
+           break;
+
+       default:
+           ferrd(1, "fill:TY_REPEAT:Internal error %d\n", t_test);
+       }
+       break;
+#undef Xparm
+
+    case TY_VPDEFINED:
+#define Xparm  ((struct pepy_refs *)parm)
+        Xparm->t_int = 9354 + t_test;
+        Xparm->t_enum = t_test + 1;
+        Xparm->t_qbuf = str2qb("Some one is out there!", 22, 1);
+        Xparm->t_string = strdup("hello there, world\n");
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_ostring = p;
+        Xparm->t_olen = t_test + 4;
+       p = malloc(30);
+       bcopy("\0001234567890", p, 30);
+        Xparm->t_bstring = p;
+        Xparm->t_blen = t_test*8 + 4;
+       Xparm->t_pe = strb2bitstr("\0221\0327\052\211\0237\200", t_test + 33, 0, 0);
+        Xparm->t_bool = t_test % 2;
+        Xparm->t_real = sqrt((float )t_test);
+        Xparm->t_oid = mkoid(t_test);
+        Xparm->t_any = mkpe(t_test*7 + 3);
+       break;
+#undef Xparm
+
+    case TY_FUNC:
+#define Xparm  ((struct codedata *)parm)
+        Xparm->cd_a = mkpe(t_test + 2);
+        Xparm->cd_b = mkpe(t_test + 3);
+        Xparm->cd_c = mkpe(t_test + 5);
+        Xparm->cd_d = mkpe(t_test + 7);
+        Xparm->cd_int = t_test - 1;
+       if (t_test % 2)
+           Xparm->cd_string = strdup("hello there, world\n");
+       else
+           Xparm->cd_string = strdup("hello world\n");
+       for (i = NCD_OPT - 1; i >= 0; i--) {
+            if ((t_test + i) % 2 == 1)
+                BITSET(Xparm->cd_opt_set, i);
+            else
+                BITCLR(Xparm->cd_opt_set, i);
+       }
+       Xparm->cd_left = (struct codedata *)fill(TY_OPTFUNC);
+       Xparm->cd_right = (struct codedata *)fill(TY_DFTFUNC);
+       break;
+#undef Xparm
+
+    case TY_OPTFUNC:
+#define Xparm  ((struct codedata *)parm)
+       if ((t_test + 2) % 3)
+           Xparm->cd_a = mkpe(t_test + 2);
+       if ((t_test + 1) % 3)
+           Xparm->cd_b = mkpe(t_test + 3);
+       Xparm->cd_c = mkpe(t_test + 5);
+       Xparm->cd_d = mkpe(t_test + 7);
+        Xparm->cd_int = t_test - 1;
+       if (t_test % 2)
+           Xparm->cd_string = strdup("hello there, world\n");
+       else
+           Xparm->cd_string = NULLCP;
+       for (i = NCD_OPT - 1; i >= 0; i--) {
+            if ((t_test + i) % 2 == 1)
+                BITSET(Xparm->cd_opt_set, i);
+            else
+                BITCLR(Xparm->cd_opt_set, i);
+       }
+       break;
+#undef Xparm
+
+    case TY_DFTFUNC:
+#define Xparm  ((struct codedata *)parm)
+       if ((t_test + 2) % 3)
+           Xparm->cd_a = mkpe(t_test*2 + 1);
+       if ((t_test + 1) % 3)
+           Xparm->cd_b = mkpe(t_test*2 + 2);
+        Xparm->cd_c = mkpe(t_test*2 + 3);
+        Xparm->cd_d = mkpe(t_test*2 + 4);
+        Xparm->cd_int = t_test - 2;
+       if (t_test % 2)
+           Xparm->cd_string = strdup("hello there, world\n");
+       else
+           Xparm->cd_string = strdup("Some is out");
+       for (i = NCD_OPT - 1; i >= 0; i--) {
+            if ((t_test + i) % 2 == 1)
+                BITSET(Xparm->cd_opt_set, i);
+            else
+                BITCLR(Xparm->cd_opt_set, i);
+       }
+       break;
+#undef Xparm
+
+#ifdef PEPSY_REALS
+    case TY_ASIMPLE:
+#define Xparm  ((struct codedata *)parm)
+        Xparm->cd_a = mkpe(t_test + 2);
+        Xparm->cd_int = 2*t_test - 1;
+        Xparm->cd_int1 = 2*t_test - 1;
+        Xparm->cd_int2 = 2*t_test - 1;
+       if (t_test % 2)
+           Xparm->cd_string = strdup("hello there, world\n");
+       else
+           Xparm->cd_string = strdup("hello world\n");
+       Xparm->cd_string1 = strdup("hello world\n");
+       Xparm->cd_string2 = strdup("hello world\n");
+       Xparm->cd_bool = t_test % 2;
+       Xparm->cd_real = t_test * 3.1415962;
+       Xparm->cd_oid = mkoid(t_test*2);
+       Xparm->cd_oid1 = mkoid(t_test*2);
+       Xparm->cd_oid2 = mkoid(t_test*2);
+       Xparm->cd_bit = strb2bitstr("\0221\0327\052\211\0237\200", t_test + 30,
+                                   0, 0);
+       Xparm->cd_right = (struct codedata *)fill(TY_DFTFUNC);
+       break;
+#undef Xparm
+#endif
+
+    default:
+       ferrd(1, "fill:unknown type %d\n", tynum);
+    }
+
+    return (parm);
+}
+
+/*
+ * compare two structures for differences of fields indicating an
+ * error
+ */
+tcmp(tynum, parm1, parm2)
+int    tynum;
+char   *parm1, *parm2;
+{
+    int        d;
+    int        i;
+
+    d = 0;
+
+    switch (tynum) {
+    case TY_MPDU:
+#define Xparm1 ((struct type_T1_MPDU *)parm1)
+#define Xparm2 ((struct type_T1_MPDU *)parm2)
+       if (Xparm1->a__seq && !Xparm2->a__seq
+         || !Xparm1->a__seq && Xparm2->a__seq) {
+           (void) printf("a__seq missing/present\n");
+           d++;
+       }
+       if (Xparm1->a__seq && Xparm2->a__seq) {
+           if (Xparm1->a__seq->fred != Xparm2->a__seq->fred) {
+               (void) printf("%s->a__seq->fred %d != %d\n",  
+                   Xparm1->a__seq->fred, Xparm2->a__seq->fred);
+               d++;
+           }
+           if (Xparm1->a__seq->george != Xparm2->a__seq->george) {
+               (void) printf("%s a__seq->george %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->a__seq->george, Xparm2->a__seq->george);
+               d++;
+           }
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_EMBEDDED:
+#define Xparm1 ((struct type_T1_Embedded *)parm1)
+#define Xparm2 ((struct type_T1_Embedded *)parm2)
+       if (Xparm1->anMPDU && !Xparm2->anMPDU ||!Xparm1->anMPDU && Xparm2->anMPDU) {
+           (void) printf("anMPDU missing/present\n");
+           d++;
+       }
+       if (Xparm1->anMPDU && Xparm2->anMPDU) {
+               d += tcmp(TY_MPDU, (char *)Xparm1->anMPDU, (char *)Xparm2->anMPDU);
+       }
+       if (Xparm1->ei != Xparm2->ei) {
+           (void) printf("%s ei %d != %d\n",  
+               t_case[tynum].tst_name, Xparm1->ei, Xparm2->ei);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_STRINGS:
+#define Xparm1 ((struct type_T1_Strings *)parm1)
+#define Xparm2 ((struct type_T1_Strings *)parm2)
+       if (qb_cmp(Xparm1->ostring, Xparm2->ostring)) {
+               (void) printf("ostring octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->bstring, Xparm2->bstring)) {
+           (void) printf("bstring bitstring different\n");
+           d++;
+       }
+       if (qb_cmp(Xparm1->nstring, Xparm2->nstring)) {
+               (void) printf("nstring octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->pstring, Xparm2->pstring)) {
+               (void) printf("pstring octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->tstring, Xparm2->tstring)) {
+               (void) printf("tstring octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->t61string, Xparm2->t61string)) {
+               (void) printf("t61string octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->vstring, Xparm2->vstring)) {
+               (void) printf("vstring octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->vis__string, Xparm2->vis__string)) {
+               (void) printf("vis__string octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->i646string, Xparm2->i646string)) {
+               (void) printf("i646string octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->ia5string, Xparm2->ia5string)) {
+               (void) printf("ia5string octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->graphstring, Xparm2->graphstring)) {
+               (void) printf("graphstring octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->genstring, Xparm2->genstring)) {
+               (void) printf("genstring octet string different\n");
+               d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_EMB_STRINGS:
+#define Xparm1 ((struct type_T1_Emb__Strings *)parm1)
+#define Xparm2 ((struct type_T1_Emb__Strings *)parm2)
+       if (qb_cmp(Xparm1->btest, Xparm2->btest)) {
+               (void) printf("btest octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->ctest, Xparm2->ctest)) {
+           (void) printf("ctest bitstring different\n");
+           d++;
+       }
+       if (Xparm1->atest != Xparm2->atest) {
+               (void) printf("atest integers different\n");
+               d++;
+       }
+       if (Xparm1->big__test && Xparm2->big__test) {
+               d += tcmp(TY_STRINGS, (char *)Xparm1->big__test, (char *)Xparm2->big__test);
+       } else if (Xparm1->big__test || Xparm2->big__test) {
+               (void) printf("big__test one Strings missing!\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->emb__test->em__oct, Xparm2->emb__test->em__oct)) {
+               (void) printf("emb__test->em__oct octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->emb__test->em__bit, Xparm2->emb__test->em__bit)) {
+           (void) printf("emb__test->em__bit bitstring different\n");
+           d++;
+       }
+       if (Xparm1->emb__test->em__int != Xparm2->emb__test->em__int) {
+               (void) printf("emb__test->em__int integers different\n");
+               d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_IMPLICIT:
+#define Xparm1 ((struct type_T1_Impl__Tags *)parm1)
+#define Xparm2 ((struct type_T1_Impl__Tags *)parm2)
+       if (qb_cmp(Xparm1->o__impl, Xparm2->o__impl)) {
+               (void) printf("o__impl octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->b__impl, Xparm2->b__impl)) {
+           (void) printf("b__impl bitstring different\n");
+           d++;
+       }
+       if (Xparm1->i__impl != Xparm2->i__impl) {
+               (void) printf("i__impl integers different\n");
+               d++;
+       }
+       if (Xparm1->obj__impl && Xparm2->obj__impl) {
+               d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->obj__impl, (char *)Xparm2->obj__impl);
+       } else if (Xparm1->obj__impl || Xparm2->obj__impl) {
+               (void) printf("obj__impl one Embedded Strings missing!\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->i__emb__test->i__em__oct, Xparm2->i__emb__test->i__em__oct)) {
+               (void) printf("i__emb__test->i__em__oct octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->i__emb__test->i__em__bit, Xparm2->i__emb__test->i__em__bit)) {
+           (void) printf("i__emb__test->i__em__bit bitstring different\n");
+           d++;
+       }
+       if (Xparm1->i__emb__test->i__em__int != Xparm2->i__emb__test->i__em__int) {
+               (void) printf("i__emb__test->i__em__int integers different\n");
+               d++;
+       }
+#undef Xparm1
+#undef Xparm2
+       break;
+       
+    case TY_EXPLICIT:
+#define Xparm1 ((struct type_T1_Expl__Tags *)parm1)
+#define Xparm2 ((struct type_T1_Expl__Tags *)parm2)
+       if (qb_cmp(Xparm1->o__expl, Xparm2->o__expl)) {
+               (void) printf("o__expl octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->b__expl, Xparm2->b__expl)) {
+           (void) printf("b__expl bitstring different\n");
+           d++;
+       }
+       if (Xparm1->i__expl != Xparm2->i__expl) {
+               (void) printf("i__expl integers different\n");
+               d++;
+       }
+       if (Xparm1->obj__expl && Xparm2->obj__expl) {
+               d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->obj__expl, (char *)Xparm2->obj__expl);
+       } else if (Xparm1->obj__expl || Xparm2->obj__expl) {
+               (void) printf("obj__expl one Embedded Strings missing!\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->i__exp__test->i__ex__oct, Xparm2->i__exp__test->i__ex__oct)) {
+               (void) printf("i__exp__test->i__ex__oct octet string different\n");
+               d++;
+       }
+       if (bit_cmp(Xparm1->i__exp__test->i__ex__bit, Xparm2->i__exp__test->i__ex__bit)) {
+           (void) printf("i__exp__test->i__ex__bit bitstring different\n");
+           d++;
+       }
+       if (Xparm1->i__exp__test->i__ex__int != Xparm2->i__exp__test->i__ex__int) {
+               (void) printf("i__exp__test->i__ex__int integers different\n");
+               d++;
+       }
+#undef Xparm1
+#undef Xparm2
+       break;
+       
+
+    case TY_SEQOF:
+#define Xparm1 ((struct type_T1_Seqof__Test *)parm1)
+#define Xparm2 ((struct type_T1_Seqof__Test *)parm2)
+    if (Xparm1->sqof__test1 && Xparm2->sqof__test1) {
+       d += tcmp(TY_ELEMENT4, (char *)Xparm1->sqof__test1, (char *)Xparm2->sqof__test1);
+    } else if (Xparm1->sqof__test1 || Xparm2->sqof__test1) {
+       (void) printf("sqof__test1 one missing");
+       d++;
+    }
+    if (Xparm1->stof__test1 && Xparm2->stof__test1) {
+       d += tcmp(TY_MEMBER2, (char *)Xparm1->stof__test1, (char *)Xparm2->stof__test1);
+    } else if (Xparm1->stof__test1 || Xparm2->stof__test1) {
+       (void) printf("stof__test1 one missing");
+       d++;
+    }
+    if (Xparm1->i__test1 != Xparm2->i__test1) {
+       (void) printf("i__test1 integers different\n");
+       d++;
+    }
+    if (Xparm1->sqof__test2 && Xparm2->sqof__test2) {
+       d += tcmp(TY_ELEMENT6, (char *)Xparm1->sqof__test2, (char *)Xparm2->sqof__test2);
+    } else if (Xparm1->sqof__test2 || Xparm2->sqof__test2) {
+       (void) printf("sqof__test2 one missing");
+       d++;
+    }
+    if (Xparm1->stof__test2 && Xparm2->stof__test2) {
+       d += tcmp(TY_MEMBER4, (char *)Xparm1->stof__test2, (char *)Xparm2->stof__test2);
+    } else if (Xparm1->stof__test2 || Xparm2->stof__test2) {
+       (void) printf("stof__test2 one missing");
+       d++;
+    }
+    if (Xparm1->i__test2 != Xparm2->i__test2) {
+       (void) printf("i__test2 integers different\n");
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+       
+    case TY_ELEMENT4:
+#define Xparm1 ((struct element_T1_4 *)parm1)
+#define Xparm2 ((struct element_T1_4 *)parm2)
+    if (Xparm1->element_T1_5 && Xparm2->element_T1_5) {
+       d += tcmp(TY_EXPLICIT, (char *)Xparm1->element_T1_5, (char *)Xparm2->element_T1_5);
+    } else if (Xparm1->element_T1_5 || Xparm2->element_T1_5) {
+       (void) printf("element_T1_5 one missing");
+       d++;
+    }
+    if (Xparm1->next && Xparm2->next) {
+       d += tcmp(TY_ELEMENT4, (char *)Xparm1->next, (char *)Xparm2->next);
+    } else if (Xparm1->next || Xparm2->next) {
+       (void) printf("%s: next one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+       
+    case TY_MEMBER2:
+#define Xparm1 ((struct member_T1_2 *)parm1)
+#define Xparm2 ((struct member_T1_2 *)parm2)
+    if (Xparm1->member_T1_3 && Xparm2->member_T1_3) {
+       d += tcmp(TY_EXPLICIT, (char *)Xparm1->member_T1_3, (char *)Xparm2->member_T1_3);
+    } else if (Xparm1->member_T1_3 || Xparm2->member_T1_3) {
+       (void) printf("%s: member_T1_3 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->next && Xparm2->next) {
+       d += tcmp(TY_MEMBER2, (char *)Xparm1->next, (char *)Xparm2->next);
+    } else if (Xparm1->next || Xparm2->next) {
+       (void) printf("%s: next one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT6:
+#define Xparm1 ((struct element_T1_6 *)parm1)
+#define Xparm2 ((struct element_T1_6 *)parm2)
+    if (Xparm1->element_T1_7 && Xparm2->element_T1_7) {
+       d += tcmp(TY_ELEMENT8, (char *)Xparm1->element_T1_7, (char *)Xparm2->element_T1_7);
+    } else if (Xparm1->element_T1_7 || Xparm2->element_T1_7) {
+       (void) printf("%s: element_T1_7 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->next && Xparm2->next) {
+       d += tcmp(TY_ELEMENT6, (char *)Xparm1->next, (char *)Xparm2->next);
+    } else if (Xparm1->next || Xparm2->next) {
+       (void) printf("%s: next one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT8:
+#define Xparm1 ((struct element_T1_8 *)parm1)
+#define Xparm2 ((struct element_T1_8 *)parm2)
+    if (Xparm1->sqof__in && Xparm2->sqof__in) {
+       d += tcmp(TY_EXPLICIT, (char *)Xparm1->sqof__in, (char *)Xparm2->sqof__in);
+    } else if (Xparm1->sqof__in || Xparm2->sqof__in) {
+       (void) printf("%s: sqof__in one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->sqof__i != Xparm2->sqof__i) {
+       (void) printf("sqof__i integers different\n");
+       d++;
+    }
+    if (qb_cmp(Xparm1->sqof__o, Xparm2->sqof__o)) {
+       (void) printf("sqof__o octet string different\n");
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_MEMBER4:
+#define Xparm1 ((struct member_T1_4 *)parm1)
+#define Xparm2 ((struct member_T1_4 *)parm2)
+    if (Xparm1->member_T1_5 && Xparm2->member_T1_5) {
+       d += tcmp(TY_ELEMENT9, (char *)Xparm1->member_T1_5, (char *)Xparm2->member_T1_5);
+    } else if (Xparm1->member_T1_5 || Xparm2->member_T1_5) {
+       (void) printf("%s: member_T1_5 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->next && Xparm2->next) {
+       d += tcmp(TY_MEMBER4, (char *)Xparm1->next, (char *)Xparm2->next);
+    } else if (Xparm1->next || Xparm2->next) {
+       (void) printf("%s: next one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT9:
+#define Xparm1 ((struct element_T1_9 *)parm1)
+#define Xparm2 ((struct element_T1_9 *)parm2)
+    if (Xparm1->stof__in && Xparm2->stof__in) {
+       d += tcmp(TY_EXPLICIT, (char *)Xparm1->stof__in, (char *)Xparm2->stof__in);
+    } else if (Xparm1->stof__in || Xparm2->stof__in) {
+       (void) printf("%s: stof__in one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->stof__i != Xparm2->stof__i) {
+       (void) printf("stof__i integers different\n");
+       d++;
+    }
+    if (qb_cmp(Xparm1->stof__o, Xparm2->stof__o)) {
+       (void) printf("stof__o octet string different\n");
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE:
+#define Xparm1 ((struct type_T1_Choice__Test *)parm1)
+#define Xparm2 ((struct type_T1_Choice__Test *)parm2)
+    if (Xparm1->c1 && Xparm2->c1) {
+       d += tcmp(TY_CHOICE0, (char *)Xparm1->c1, (char *)Xparm2->c1);
+    } else if (Xparm1->c1 || Xparm2->c1) {
+       (void) printf("%s: c1 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->c2 && Xparm2->c2) {
+       d += tcmp(TY_CHOICE1, (char *)Xparm1->c2, (char *)Xparm2->c2);
+    } else if (Xparm1->c2 || Xparm2->c2) {
+       (void) printf("%s: c2 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->c3 && Xparm2->c3) {
+       d += tcmp(TY_CHOICE2, (char *)Xparm1->c3, (char *)Xparm2->c3);
+    } else if (Xparm1->c3 || Xparm2->c3) {
+       (void) printf("%s: c3 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    if (Xparm1->c4 && Xparm2->c4) {
+       d += tcmp(TY_ELEMENT11, (char *)Xparm1->c4, (char *)Xparm2->c4);
+    } else if (Xparm1->c4 || Xparm2->c4) {
+       (void) printf("%s: c4 one missing", t_case[tynum].tst_name);
+       d++;
+    }
+    break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE0:
+#define Xparm1 ((struct choice_T1_0 *)parm1)
+#define Xparm2 ((struct choice_T1_0 *)parm2)
+       if (Xparm1->offset != Xparm2->offset) {
+           d++;
+           (void) printf("%s: offset mismatch %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->offset, Xparm2->offset);
+           break;
+       }
+       switch (Xparm1->offset) {
+       case choice_T1_0_i__c1:
+           if (Xparm1->un.i__c1 != Xparm2->un.i__c1) {
+               d++;
+               (void) printf("%s: i__c1 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.i__c1, Xparm2->un.i__c1);
+           }
+           break;
+       
+       case choice_T1_0_o__c1:
+           if (qb_cmp(Xparm1->un.o__c1, Xparm2->un.o__c1)) {
+               (void) printf("o__c1 octet string different\n");
+               d++;
+           }
+           break;
+       
+       case choice_T1_0_b__c1:
+           if (bit_cmp(Xparm1->un.b__c1, Xparm2->un.b__c1)) {
+               (void) printf("un.b__c1 bitstring different\n");
+               d++;
+           }
+           break;
+       
+       case choice_T1_0_f__c1:
+           if (Xparm1->un.f__c1 && !Xparm2->un.f__c1
+             || !Xparm1->un.f__c1 && Xparm2->un.f__c1) {
+               (void) printf("f__c1 Boolean different\n");
+               d++;
+           }
+           break;
+       
+       case choice_T1_0_obj__c1:
+           if (Xparm1->un.obj__c1 && Xparm2->un.obj__c1) {
+               d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->un.obj__c1,
+                 (char *)Xparm2->un.obj__c1);
+           } else if (Xparm1->un.obj__c1 || Xparm2->un.obj__c1) {
+               (void) printf("%s: un.obj__c1 one missing", t_case[tynum].tst_name);
+               d++;
+           }
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE0:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE1:
+#define Xparm1 ((struct choice_T1_1 *)parm1)
+#define Xparm2 ((struct choice_T1_1 *)parm2)
+       
+       if (Xparm1->offset != Xparm2->offset) {
+           d++;
+           (void) printf("%s: offset mismatch %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->offset, Xparm2->offset);
+           break;
+       }
+       switch (Xparm1->offset) {
+       case choice_T1_1_i__c2:
+           if (Xparm1->un.i__c2 != Xparm2->un.i__c2) {
+               d++;
+               (void) printf("%s: i__c2 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.i__c2, Xparm2->un.i__c2);
+           }
+           break;
+       
+       case choice_T1_1_o__c2:
+           if (qb_cmp(Xparm1->un.o__c2, Xparm2->un.o__c2)) {
+               (void) printf("o__c2 octet string different\n");
+               d++;
+           }
+           break;
+       
+       case choice_T1_1_b__c2:
+           if (bit_cmp(Xparm1->un.b__c2, Xparm2->un.b__c2)) {
+               (void) printf("un.b__c2 bitstring different\n");
+               d++;
+           }
+           break;
+       
+       case choice_T1_1_f__c2:
+           if (Xparm1->un.f__c2 && !Xparm2->un.f__c2
+             || !Xparm1->un.f__c2 && Xparm2->un.f__c2) {
+               d++;
+               (void) printf("%s: f__c2 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.f__c2, Xparm2->un.f__c2);
+           }
+           break;
+       
+       case choice_T1_1_obj__c2:
+           if (Xparm1->un.obj__c2 && Xparm2->un.obj__c2) {
+               d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->un.obj__c2,
+                 (char *)Xparm2->un.obj__c2);
+           } else if (Xparm1->un.obj__c2 || Xparm2->un.obj__c2) {
+               (void) printf("%s: un.obj__c2 one missing", t_case[tynum].tst_name);
+               d++;
+           }
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE1:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE2:
+#define Xparm1 ((struct choice_T1_2 *)parm1)
+#define Xparm2 ((struct choice_T1_2 *)parm2)
+       
+       switch (Xparm1->offset) {
+       case choice_T1_2_i__c3:
+           if (Xparm1->un.i__c3 != Xparm2->un.i__c3) {
+               d++;
+               (void) printf("%s: i__c3 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.i__c3, Xparm2->un.i__c3);
+           }
+           break;
+       
+       case choice_T1_2_seq__c3:
+           if (Xparm1->un.seq__c3 && Xparm2->un.seq__c3) {
+               d += tcmp(TY_ELEMENT10, (char *)Xparm1->un.seq__c3, (char *)Xparm2->un.seq__c3);
+           } else if (Xparm1->un.seq__c3 || Xparm2->un.seq__c3) {
+               (void) printf("%s: un.seq__c3 one missing", t_case[tynum].tst_name);
+               d++;
+           }
+           break;
+       
+       case choice_T1_2_set__c3:
+           if (Xparm1->un.set__c3 && Xparm2->un.set__c3) {
+               d += tcmp(TY_MEMBER6, (char *)Xparm1->un.set__c3, (char *)Xparm2->un.set__c3);
+           } else if (Xparm1->un.set__c3 || Xparm2->un.set__c3) {
+               (void) printf("%s: un.set__c3 one missing", t_case[tynum].tst_name);
+               d++;
+           }
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE2:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE3:
+#define Xparm1 ((struct choice_T1_3 *)parm1)
+#define Xparm2 ((struct choice_T1_3 *)parm2)
+       
+       switch (Xparm1->offset) {
+       case choice_T1_3_sc__a__i:
+           if (Xparm1->un.sc__a__i != Xparm2->un.sc__a__i) {
+               d++;
+               (void) printf("%s: sc__a__i mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.sc__a__i, Xparm2->un.sc__a__i);
+           }
+           break;
+       
+       case choice_T1_3_sc__b__i:
+           if (Xparm1->un.sc__b__i != Xparm2->un.sc__b__i) {
+               d++;
+               (void) printf("%s: sc__b__i mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.sc__b__i, Xparm2->un.sc__b__i);
+           }
+           break;
+       
+       case choice_T1_3_c4__i:
+           if (Xparm1->un.c4__i != Xparm2->un.c4__i) {
+               d++;
+               (void) printf("%s: c4__i mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.c4__i, Xparm2->un.c4__i);
+           }
+           break;
+       
+       case choice_T1_3_c4__obj:
+           if (Xparm1->un.c4__obj && Xparm2->un.c4__obj) {
+               d += tcmp(TY_EXPLICIT, (char *)Xparm1->un.c4__obj, (char *)Xparm2->un.c4__obj);
+           } else if (Xparm1->un.c4__obj || Xparm2->un.c4__obj) {
+               (void) printf("%s: un.c4__obj one missing", t_case[tynum].tst_name);
+               d++;
+           }
+           break;
+       
+       default:
+           ferrd(1, "TY_CHOICE3:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT10:
+#define Xparm1 ((struct element_T1_10 *)parm1)
+#define Xparm2 ((struct element_T1_10 *)parm2)
+       if (Xparm1->seq__c3__in && Xparm2->seq__c3__in) {
+           d += tcmp(TY_EXPLICIT, (char *)Xparm1->seq__c3__in, (char *)Xparm2->seq__c3__in);
+       } else if (Xparm1->seq__c3__in || Xparm2->seq__c3__in) {
+           (void) printf("%s: seq__c3__in one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->seq__c3__i != Xparm2->seq__c3__i) {
+           d++;
+           (void) printf("%s: seq__c3__i mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->seq__c3__i, Xparm2->seq__c3__i);
+       }
+       if (qb_cmp(Xparm1->seq__c3__o, Xparm2->seq__c3__o)) {
+           (void) printf("seq__c3__o octet string different\n");
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_MEMBER6:
+#define Xparm1 ((struct member_T1_6 *)parm1)
+#define Xparm2 ((struct member_T1_6 *)parm2)
+       if (Xparm1->set__c3__in && Xparm2->set__c3__in) {
+           d += tcmp(TY_EXPLICIT, (char *)Xparm1->set__c3__in, (char *)Xparm2->set__c3__in);
+       } else if (Xparm1->set__c3__in || Xparm2->set__c3__in) {
+           (void) printf("%s: set__c3__in one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->set__c3__i != Xparm2->set__c3__i) {
+           d++;
+           (void) printf("%s: set__c3__i mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->set__c3__i, Xparm2->set__c3__i);
+       }
+       if (qb_cmp(Xparm1->set__c3__o, Xparm2->set__c3__o)) {
+           (void) printf("set__c3__o octet string different\n");
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT11:
+#define Xparm1 ((struct element_T1_11 *)parm1)
+#define Xparm2 ((struct element_T1_11 *)parm2)
+       if (Xparm1->c4__choice && Xparm2->c4__choice) {
+           d += tcmp(TY_CHOICE3, (char *)Xparm1->c4__choice, (char *)Xparm2->c4__choice);
+       } else if (Xparm1->c4__choice || Xparm2->c4__choice) {
+           (void) printf("%s: c4__choice one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_OPTIONAL:
+#define Xparm1 ((struct type_T1_Opt__Strings *)parm1)
+#define Xparm2 ((struct type_T1_Opt__Strings *)parm2)
+        if (Xparm1->optionals & opt_T1_Opt__Strings_a__opt) {
+           if (Xparm1->a__opt != Xparm2->a__opt) {
+               d++;
+               (void) printf("%s: a__opt mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->a__opt, Xparm2->a__opt);
+           }
+       }
+        if (Xparm1->optionals & opt_T1_Opt__Strings_d__opt) {
+           if (Xparm1->d__opt && !Xparm2->d__opt
+             || !Xparm1->d__opt && Xparm2->d__opt) {
+               d++;
+               (void) printf("%s: d__opt mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->d__opt, Xparm2->d__opt);
+           }
+       }
+       if (Xparm1->b__opt != NULLQB && Xparm2->b__opt != NULLQB) {
+           if (qb_cmp(Xparm1->b__opt, Xparm2->b__opt)) {
+               (void) printf("b__opt octet string different\n");
+               d++;
+           }
+       }
+       if (Xparm1->b__opt != NULLQB && Xparm2->b__opt == NULLQB
+        || Xparm1->b__opt == NULLQB && Xparm2->b__opt != NULLQB) {
+           (void) printf("%s: b__opt one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->c__opt != NULLPE && Xparm2->c__opt != NULLPE) {
+           if (bit_cmp(Xparm1->c__opt, Xparm2->c__opt)) {
+               (void) printf("%s:c__opt bitstring different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+        if (Xparm1->optionals & opt_T1_Opt__Strings_e__opt) {
+           if (Xparm1->e__opt && !Xparm2->e__opt
+           || !Xparm1->e__opt && Xparm2->e__opt) {
+               d++;
+               (void) printf("%s: e__opt mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->e__opt, Xparm2->e__opt);
+           }
+       }
+       if (Xparm1->big__opt && Xparm2->big__opt) {
+           d += tcmp(TY_STRINGS, (char *)Xparm1->big__opt,
+              (char *)Xparm2->big__opt);
+       } else if (Xparm1->big__opt && !Xparm2->big__opt
+              || !Xparm1->big__opt && Xparm2->big__opt) {
+           (void) printf("%s: big__opt one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->emb__opt && Xparm2->emb__opt) {
+           d += tcmp(TY_ELEMENT12, (char *)Xparm1->emb__opt,
+              (char *)Xparm2->emb__opt);
+       } else if (Xparm1->emb__opt && !Xparm2->emb__opt
+              || !Xparm1->emb__opt && Xparm2->emb__opt) {
+           (void) printf("%s: emb__opt one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->st__opt && Xparm2->st__opt) {
+           d += tcmp(TY_MEMBER7, (char *)Xparm1->st__opt,
+              (char *)Xparm2->st__opt);
+       } else if (Xparm1->st__opt && !Xparm2->st__opt
+              || !Xparm1->st__opt && Xparm2->st__opt) {
+           (void) printf("%s: st__opt one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->obj__opt && Xparm2->obj__opt) {
+           d += tcmp(TY_MPDU, (char *)Xparm1->obj__opt,
+              (char *)Xparm2->obj__opt);
+       } else if (Xparm1->obj__opt && !Xparm2->obj__opt
+              || !Xparm1->obj__opt && Xparm2->obj__opt) {
+           (void) printf("%s: obj__opt one missing", t_case[tynum].tst_name);
+           d++;
+       }
+        if (Xparm1->optionals & opt_T1_Opt__Strings_etag__opt) {
+           if (Xparm1->etag__opt != Xparm2->etag__opt) {
+               d++;
+               (void) printf("%s: etag__opt mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->etag__opt, Xparm2->etag__opt);
+           }
+       }
+       if (Xparm1->ch__opt && Xparm2->ch__opt) {
+           d += tcmp(TY_CHOICE4, (char *)Xparm1->ch__opt,
+              (char *)Xparm2->ch__opt);
+       } else if (Xparm1->ch__opt && !Xparm2->ch__opt
+              || !Xparm1->ch__opt && Xparm2->ch__opt) {
+           (void) printf("%s: ch__opt one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_ELEMENT12:
+#define Xparm1 ((struct element_T1_12 *)parm1)
+#define Xparm2 ((struct element_T1_12 *)parm2)
+        if (Xparm1->optionals & opt_T1_element_T1_12_oem__int) {
+           if (Xparm1->oem__int != Xparm2->oem__int) {
+               d++;
+               (void) printf("%s: oem__int mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->oem__int, Xparm2->oem__int);
+           }
+       }
+       if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct != NULLQB) {
+           if (qb_cmp(Xparm1->oem__oct, Xparm2->oem__oct)) {
+               (void) printf("oem__oct octet string different\n");
+               d++;
+           }
+       }
+       if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct == NULLQB
+        || Xparm1->oem__oct == NULLQB && Xparm2->oem__oct != NULLQB) {
+           (void) printf("%s: oem__oct one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->oem__bit != NULLPE && Xparm2->oem__bit != NULLPE) {
+           if (bit_cmp(Xparm1->oem__bit, Xparm2->oem__bit)) {
+               (void) printf("%s:oem__bit bitstring different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_MEMBER7:
+#define Xparm1 ((struct member_T1_7 *)parm1)
+#define Xparm2 ((struct member_T1_7 *)parm2)
+        if (Xparm1->optionals & opt_T1_member_T1_7_st__int0) {
+           if (Xparm1->st__int0 != Xparm2->st__int0) {
+               d++;
+               (void) printf("%s: st__int0 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->st__int0, Xparm2->st__int0);
+           }
+       }
+        if (Xparm1->optionals & opt_T1_member_T1_7_st__int1) {
+           if (Xparm1->st__int1 != Xparm2->st__int1) {
+               d++;
+               (void) printf("%s: st__int1 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->st__int1, Xparm2->st__int1);
+           }
+       }
+        if (Xparm1->optionals & opt_T1_member_T1_7_st__int2) {
+           if (Xparm1->st__int2 != Xparm2->st__int2) {
+               d++;
+               (void) printf("%s: st__int2 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->st__int2, Xparm2->st__int2);
+           }
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_CHOICE4:
+#define Xparm1 ((struct choice_T1_4 *)parm1)
+#define Xparm2 ((struct choice_T1_4 *)parm2)
+       if (Xparm1->offset != Xparm2->offset) {
+           d++;
+           (void) printf("%s: offset mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->offset, Xparm2->offset);
+           break;
+       }
+       switch (Xparm1->offset) {
+       case choice_T1_4_ch__1:
+           if (Xparm1->un.ch__1 != Xparm2->un.ch__1) {
+               d++;
+               (void) printf("%s: ch__1 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.ch__1, Xparm2->un.ch__1);
+           }
+           break;
+       
+       case choice_T1_4_ch__2:
+           if (Xparm1->un.ch__2 != Xparm2->un.ch__2) {
+               d++;
+               (void) printf("%s: ch__2 mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.ch__2, Xparm2->un.ch__2);
+           }
+           break;
+       
+       default:
+           ferrd(1, "tcmp:TY_CHOICE4:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_EXTREF:
+#define Xparm1 ((struct type_T1_E__ref *)parm1)
+#define Xparm2 ((struct type_T1_E__ref *)parm2)
+       if (Xparm1->a__ref && Xparm2->a__ref) {
+           d += tcmp(TY_T2_INFO, (char *)Xparm1->a__ref,
+              (char *)Xparm2->a__ref);
+       } else if (Xparm1->a__ref == NULL || Xparm2->a__ref == NULL) {
+           (void) printf("%s: a__ref one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->b__ref && Xparm2->b__ref) {
+           d += tcmp(TY_T2_INFO, (char *)Xparm1->b__ref,
+              (char *)Xparm2->b__ref);
+       } else if (Xparm1->b__ref == NULL || Xparm2->b__ref == NULL) {
+           (void) printf("%s: b__ref one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->c__ref && Xparm2->c__ref) {
+           d += tcmp(TY_CHOICE, (char *)Xparm1->c__ref,
+              (char *)Xparm2->c__ref);
+       } else if (Xparm1->c__ref == NULL || Xparm2->c__ref == NULL) {
+           (void) printf("%s: c__ref one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->d__ref && Xparm2->d__ref) {
+           d += tcmp(TY_T2_INFO, (char *)Xparm1->d__ref,
+              (char *)Xparm2->d__ref);
+       } else if (Xparm1->d__ref && !Xparm2->d__ref
+              || !Xparm1->d__ref && Xparm2->d__ref) {
+           (void) printf("%s: d__ref one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->e__ref && Xparm2->e__ref) {
+           d += tcmp(TY_T2_INFO, (char *)Xparm1->e__ref,
+              (char *)Xparm2->e__ref);
+       } else if (Xparm1->e__ref && !Xparm2->e__ref
+              || !Xparm1->e__ref && Xparm2->e__ref) {
+           (void) printf("%s: e__ref one missing", t_case[tynum].tst_name);
+           d++;
+       }
+        break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_T2_INFO:
+#define Xparm1 ((struct type_T2_Info *)parm1)
+#define Xparm2 ((struct type_T2_Info *)parm2)
+       if (Xparm1->a1 != Xparm2->a1) {
+           d++;
+           (void) printf("%s: a1 mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->a1, Xparm2->a1);
+       }
+       if (Xparm1->a2 != Xparm2->a2) {
+           d++;
+           (void) printf("%s: a2 mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->a2, Xparm2->a2);
+       }
+       if (Xparm1->a3 != Xparm2->a3) {
+           d++;
+           (void) printf("%s: a3 mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->a3, Xparm2->a3);
+       }
+       if (Xparm1->a4 && Xparm2->a4) {
+           d += tcmp(TY_T2_MPDU, (char *)Xparm1->a4, (char *)Xparm2->a4);
+       } else if (Xparm1->a4 == NULL || Xparm2->a4 == NULL) {
+           (void) printf("%s: a4 one missing", t_case[tynum].tst_name);
+           d++;
+       }
+        break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_T2_MPDU:
+#define Xparm1 ((struct type_T2_MPDU *)parm1)
+#define Xparm2 ((struct type_T2_MPDU *)parm2)
+       if (Xparm1->a__seq && Xparm2->a__seq) {
+           d += tcmp(TY_T2_ELEM0, (char *)Xparm1->a__seq,
+              (char *)Xparm2->a__seq);
+       } else if (Xparm1->a__seq == NULL || Xparm2->a__seq == NULL) {
+           (void) printf("%s: a__seq one missing", t_case[tynum].tst_name);
+           d++;
+       }
+        break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_T2_ELEM0:
+#define Xparm1 ((struct element_T2_0 *)parm1)
+#define Xparm2 ((struct element_T2_0 *)parm2)
+       if (Xparm1->fred != Xparm2->fred) {
+           d++;
+           (void) printf("%s: fred mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->fred, Xparm2->fred);
+       }
+        break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_OPTIMISED:
+#define Xparm1 ((struct type_T1_Optimised *)parm1)
+#define Xparm2 ((struct type_T1_Optimised *)parm2)
+       if (Xparm1->o1 == NULLPE || Xparm2->o1 == NULLPE) {
+           (void) printf("%s: o1 one missing\n", t_case[tynum].tst_name);
+           d++;
+       } else if (bit_cmp(Xparm1->o1, Xparm2->o1)) {
+               (void) printf("%s:o1 bitstring different\n",
+                   t_case[tynum].tst_name);
+               d++;
+       }
+       if (Xparm1->o2 != NULLQB && Xparm2->o2 != NULLQB) {
+           if (qb_cmp(Xparm1->o2, Xparm2->o2)) {
+               (void) printf("o2 octet string different\n");
+               d++;
+           }
+       } else {
+           (void) printf("%s: o2 one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->o3 && Xparm2->o3) {
+           d += tcmp(TY_MPDU, (char *)Xparm1->o3, (char *)Xparm2->o3);
+       } else if (Xparm1->o3 == NULL || Xparm2->o3 == NULL) {
+           (void) printf("%s: o3 one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->o4 != NULLPE && Xparm2->o4 == NULLPE
+        || Xparm1->o4 == NULLPE && Xparm2->o4 != NULLPE) {
+           (void) printf("%s: o4 one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->o4 != NULLPE && Xparm2->o4 != NULLPE) {
+           if (pe_cmp(Xparm1->o4, Xparm2->o4)) {
+               (void) printf("%s:o4 SET of ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       if (Xparm1->element_T1_14 && Xparm2->element_T1_14) {
+           d += tcmp(TY_MEMBER9, (char *)Xparm1->element_T1_14,
+           (char *)Xparm2->element_T1_14);
+       } else if (Xparm1->element_T1_14 == NULL
+                || Xparm2->element_T1_14 == NULL) {
+           (void) printf("%s: element_T1_14 one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+     case TY_MEMBER9:
+#define Xparm1 ((struct member_T1_9 *)parm1)
+#define Xparm2 ((struct member_T1_9 *)parm2)
+       if (Xparm1->o5 != NULLPE && Xparm2->o5 != NULLPE) {
+           if (pe_cmp(Xparm1->o5, Xparm2->o5)) {
+               (void) printf("%s:o5 SET of ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: o5 one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->o6 != NULLPE && Xparm2->o6 != NULLPE) {
+           if (pe_cmp(Xparm1->o6, Xparm2->o6)) {
+               (void) printf("%s:o6 SET of ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: o6 one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->o7 != NULLOID && Xparm2->o7 != NULLOID) {
+           if (oid_cmp(Xparm1->o7, Xparm2->o7)) {
+               (void) printf("%s:o7 OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: o7 one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_EXTERNAL:
+#define Xparm1 ((struct type_T1_Ext__typ *)parm1)
+#define Xparm2 ((struct type_T1_Ext__typ *)parm2)
+       if (Xparm1->ext != NULL && Xparm2->ext != NULL) {
+           if (ext_cmp(Xparm1->ext, Xparm2->ext)) {
+               (void) printf("%s:ext EXTERNAL different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: ext one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->a__ny != NULLPE && Xparm2->a__ny != NULLPE) {
+           if (pe_cmp(Xparm1->a__ny, Xparm2->a__ny)) {
+               (void) printf("%s:a__ny ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: a__ny one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->ext__impl != NULL && Xparm2->ext__impl != NULL) {
+           if (ext_cmp(Xparm1->ext__impl, Xparm2->ext__impl)) {
+               (void) printf("%s:ext__impl EXTERNAL different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: ext__impl one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->any__impl != NULLPE && Xparm2->any__impl != NULLPE) {
+           if (pe_cmp(Xparm1->any__impl, Xparm2->any__impl)) {
+               (void) printf("%s:any__impl ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: any__impl one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->ext__expl != NULL && Xparm2->ext__expl != NULL) {
+           if (ext_cmp(Xparm1->ext__expl, Xparm2->ext__expl)) {
+               (void) printf("%s:ext__expl EXTERNAL different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: ext__expl one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->any__expl != NULLPE && Xparm2->any__expl != NULLPE) {
+           if (pe_cmp(Xparm1->any__expl, Xparm2->any__expl)) {
+               (void) printf("%s:any__expl ANY different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: any__expl one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_SEXTERNAL:
+#define Xparm1 ((struct type_T1_SExt *)parm1)
+#define Xparm2 ((struct type_T1_SExt *)parm2)
+       if (Xparm1 != NULL && Xparm2 != NULL) {
+           if (ext_cmp(Xparm1, Xparm2)) {
+               (void) printf("%s:ext EXTERNAL different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: ext one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+
+    case TY_ETAGOBJ:
+#define Xparm1 ((struct type_T1_Etags *)parm1)
+#define Xparm2 ((struct type_T1_Etags *)parm2)
+       if (Xparm1->offset != Xparm2->offset) {
+           d++;
+           (void) printf("%s: offset mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->offset, Xparm2->offset);
+           break;
+       }
+       switch (Xparm1->offset) {
+       case type_T1_Etags_aE:
+           if (Xparm1->un.aE != Xparm2->un.aE) {
+               d++;
+               (void) printf("%s: un.aE mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.aE, Xparm2->un.aE);
+           }
+           break;
+       
+       case type_T1_Etags_bE:
+           if (Xparm1->un.bE != Xparm2->un.bE) {
+               d++;
+               (void) printf("%s: un.bE mismatch %d != %d", t_case[tynum].tst_name,
+                   Xparm1->un.bE, Xparm2->un.bE);
+           }
+           break;
+       
+       default:
+           ferrd(1, "TY_ETAGOBJ:illegal offset %d\n", Xparm1->offset);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+/* This has to be changed when posy is upgraded to handle DEFAULTS properly */
+    case TY_DEFAULT:
+#define Xparm1 ((struct type_T1_Def__Strings *)parm1)
+#define Xparm2 ((struct type_T1_Def__Strings *)parm2)
+       if (Xparm1->a__def != Xparm2->a__def) {
+           d++;
+           (void) printf("%s: a__def mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->a__def, Xparm2->a__def);
+       }
+       if (Xparm1->b__def != NULLQB && Xparm2->b__def != NULLQB) {
+           if (qb_cmp(Xparm1->b__def, Xparm2->b__def)) {
+               (void) printf("b__def octet string different\n");
+               d++;
+           }
+       } else if (Xparm2->b__def == NULLQB) {
+           (void) printf("%s: b__def one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->c__def != NULLPE && Xparm2->c__def != NULLPE) {
+           if (bit_cmp(Xparm1->c__def, Xparm2->c__def)) {
+                   (void) printf("%s:c__def bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->c__def == NULLPE) {
+           (void) printf("%s: c__def restored version missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->okay != Xparm2->okay) {
+           d++;
+           (void) printf("%s: okay mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->okay, Xparm2->okay);
+       }
+       /* Can't test NULL ....
+       if (Xparm1->e__opt != Xparm2->e__opt) {
+           d++;
+           (void) printf("%s: e__opt mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->e__opt, Xparm2->e__opt);
+       }
+       */
+       if (Xparm1->big__def && Xparm2->big__def) {
+           d += tcmp(TY_STRINGS, (char *)Xparm1->big__def,
+           (char *)Xparm2->big__def);
+       } else {
+           (void) printf("%s: big__def one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->emb__def && Xparm2->emb__def) {
+           d += tcmp(TY_ELEMENT13, (char *)Xparm1->emb__def,
+           (char *)Xparm2->emb__def);
+       } else if (Xparm1->emb__def != NULL || Xparm2->emb__def != NULL) {
+           (void) printf("%s: emb__def one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->st__def && Xparm2->st__def) {
+           d += tcmp(TY_MEMBER8, (char *)Xparm1->st__def,
+           (char *)Xparm2->st__def);
+       } else if (Xparm1->st__def != NULL || Xparm2->st__def != NULL) {
+           (void) printf("%s: st__def one missing", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ELEMENT13:
+#define Xparm1 ((struct element_T1_13 *)parm1)
+#define Xparm2 ((struct element_T1_13 *)parm2)
+       if (Xparm1->colour != Xparm2->colour) {
+           d++;
+           (void) printf("%s: colour mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->colour, Xparm2->colour);
+       }
+       if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct != NULLQB) {
+           if (qb_cmp(Xparm1->oem__oct, Xparm2->oem__oct)) {
+               (void) printf("oem__oct octet string different\n");
+               d++;
+           }
+       } else if (Xparm1->oem__oct != NULLQB || Xparm2->oem__oct != NULLQB) {
+           (void) printf("oem__oct: one missing 0x%x, 0x%x\n", Xparm1->oem__oct,
+           Xparm1->oem__oct);
+           d++;
+       }
+       if (Xparm1->version != NULLPE && Xparm2->version != NULLPE) {
+           if (bit_cmp(Xparm1->version, Xparm2->version)) {
+                   (void) printf("%s:version bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->version == NULLPE) {
+           (void) printf("%s: version decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_MEMBER8:
+#define Xparm1 ((struct member_T1_8 *)parm1)
+#define Xparm2 ((struct member_T1_8 *)parm2)
+       if (Xparm1->wine != Xparm2->wine) {
+           d++;
+           (void) printf("%s: wine mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->wine, Xparm2->wine);
+       }
+       if (Xparm1->beer != Xparm2->beer) {
+           d++;
+           (void) printf("%s: beer mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->beer, Xparm2->beer);
+       }
+       if (Xparm1->spirit != Xparm2->spirit) {
+           d++;
+           (void) printf("%s: spirit mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->spirit, Xparm2->spirit);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_STEST:
+#define Xparm1 ((struct type_T1_Stest *)parm1)
+#define Xparm2 ((struct type_T1_Stest *)parm2)
+       if (Xparm1->st1 != NULL && Xparm2->st1 != NULL) {
+           d += tcmp(TY_SINT, (char *)Xparm1->st1, (char *)Xparm2->st1);
+       } else if (Xparm2->st1 == NULL) {
+           d++;
+           (void) printf("%s: missing", t_case[tynum].tst_name);
+       }
+       if (Xparm1->st2 != NULL && Xparm2->st2 != NULL) {
+           if (qb_cmp(Xparm1->st2, Xparm2->st2)) {
+               (void) printf("%s:st2 octet string different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else if (Xparm2->st2 == NULL) {
+           d++;
+           (void) printf("%s: missing", t_case[tynum].tst_name);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_SINT:
+#define Xparm1 ((struct type_T1_Sint *)parm1)
+#define Xparm2 ((struct type_T1_Sint *)parm2)
+       if (Xparm1->parm != Xparm2->parm) {
+           (void) printf("%s:parm %d != %d\n", t_case[tynum].tst_name, Xparm1->parm,
+               Xparm2->parm);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ETYPE:
+#define Xparm1 ((struct type_T1_Enum__type *)parm1)
+#define Xparm2 ((struct type_T1_Enum__type *)parm2)
+       if (Xparm1->parm != Xparm2->parm) {
+           (void) printf("%s:parm %d != %d\n", t_case[tynum].tst_name, Xparm1->parm,
+               Xparm2->parm);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_ENUM_TEST:
+#define Xparm1 ((struct type_T1_T__enum *)parm1)
+#define Xparm2 ((struct type_T1_T__enum *)parm2)
+       if (Xparm1->ae1 && Xparm2->ae1 ) {
+           d += tcmp(TY_ETYPE, (char *)Xparm1->ae1, (char *)Xparm2->ae1);
+       } else {
+           d++;
+           (void) printf("%s:ae1 missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->ae2 && Xparm2->ae2 ) {
+           d += tcmp(TY_ETYPE, (char *)Xparm1->ae2, (char *)Xparm2->ae2);
+       } else {
+           d++;
+           (void) printf("%s:ae2 missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->ae3 && Xparm2->ae3 ) {
+           d += tcmp(TY_ETYPE, (char *)Xparm1->ae3, (char *)Xparm2->ae3);
+       } else {
+           d++;
+           (void) printf("%s:ae3 missing\n", t_case[tynum].tst_name);
+       }
+       /* Default */
+       if (Xparm1->ae4 && Xparm2->ae4 ) {
+           d += tcmp(TY_ETYPE, (char *)Xparm1->ae4, (char *)Xparm2->ae4);
+       } else {
+           d++;
+           (void) printf("%s:ae4 missing\n", t_case[tynum].tst_name);
+       }
+       /* Optional */
+       if (Xparm1->ae5 && Xparm2->ae5 ) {
+           d += tcmp(TY_ETYPE, (char *)Xparm1->ae5, (char *)Xparm2->ae5);
+       } else if (Xparm1->ae5 || Xparm2->ae5) {
+           d++;
+           (void) printf("%s:ae5 missing\n", t_case[tynum].tst_name);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+#ifdef PEPSY_REALS
+    case TY_REAL:
+#define Xparm1 ((struct type_T1_Real *)parm1)
+#define Xparm2 ((struct type_T1_Real *)parm2)
+       /* Horrible floating point test for roughly equal */
+       if (fabs(Xparm1->parm) < F_SMALL/2) {
+            if (fabs(Xparm1->parm - Xparm2->parm) > F_SMALL) {
+               (void) printf("%s:parm %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->parm, Xparm2->parm);
+               d++;
+           }
+       } else if (fabs((Xparm1->parm - Xparm2->parm)/Xparm1->parm) > F_SMALL) {
+           (void) printf("%s:parm %f != %f\n", t_case[tynum].tst_name, Xparm1->parm,
+               Xparm2->parm);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_REAL_TEST:
+#define Xparm1 ((struct type_T1_T__real *)parm1)
+#define Xparm2 ((struct type_T1_T__real *)parm2)
+       if (Xparm1->r1 && Xparm2->r1 ) {
+           d += tcmp(TY_REAL, (char *)Xparm1->r1, (char *)Xparm2->r1);
+       } else {
+           d++;
+           (void) printf("%s:r1 missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->r2 && Xparm2->r2 ) {
+           d += tcmp(TY_REAL, (char *)Xparm1->r2, (char *)Xparm2->r2);
+       } else {
+           d++;
+           (void) printf("%s:r2 missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->r3 && Xparm2->r3 ) {
+           d += tcmp(TY_REAL, (char *)Xparm1->r3, (char *)Xparm2->r3);
+       } else {
+           d++;
+           (void) printf("%s:r3 missing\n", t_case[tynum].tst_name);
+       }
+       /* Default */
+       if (Xparm1->r4 && Xparm2->r4 ) {
+           d += tcmp(TY_REAL, (char *)Xparm1->r4, (char *)Xparm2->r4);
+       } else {
+           d++;
+           (void) printf("%s:r4 missing\n", t_case[tynum].tst_name);
+       }
+       /* Optional */
+       if (Xparm1->r5 && Xparm2->r5 ) {
+           d += tcmp(TY_REAL, (char *)Xparm1->r5, (char *)Xparm2->r5);
+       } else if (Xparm1->r5 || Xparm2->r5) {
+           d++;
+           (void) printf("%s:r5 missing\n", t_case[tynum].tst_name);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_PEPY:
+#define Xparm1 ((struct pepy_refs *)parm1)
+#define Xparm2 ((struct pepy_refs *)parm2)
+       if (Xparm1->t_int != Xparm2->t_int) {
+           d++;
+           (void) printf("%s: t_int mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_int, Xparm2->t_int);
+       }
+
+       if (Xparm1->t_enum != Xparm2->t_enum) {
+           d++;
+           (void) printf("%s:t_enum mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_enum, Xparm2->t_enum);
+       }
+
+       if (qb_cmp(Xparm1->t_qbuf, Xparm2->t_qbuf)) {
+               (void) printf("t_qbuf octet string different\n");
+               d++;
+       }
+
+       if (Xparm1->t_bool != Xparm2->t_bool) {
+           d++;
+           (void) printf("%s:t_bool mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_bool, Xparm2->t_bool);
+       }
+
+#ifdef PEPSY_REALS
+       /* Horrible floating point test for roughly equal */
+       if (fabs(Xparm1->t_real) < F_SMALL/2) {
+            if (fabs(Xparm1->t_real - Xparm2->t_real) > F_SMALL) {
+               (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->t_real, Xparm2->t_real);
+               d++;
+           }
+       } else if (fabs((Xparm1->t_real - Xparm2->t_real)/Xparm1->t_real) > F_SMALL) {
+           (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+               Xparm1->t_real, Xparm2->t_real);
+           d++;
+       }
+#endif
+       if (Xparm1->t_any != NULLPE && Xparm2->t_any != NULLPE) {
+           if (pe_cmp(Xparm1->t_any, Xparm2->t_any)) {
+               (void) printf("%s:t_any different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       if (Xparm1->t_oid != NULLOID && Xparm2->t_oid != NULLOID) {
+           if (oid_cmp(Xparm1->t_oid, Xparm2->t_oid)) {
+               (void) printf("%s:t_oid OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: t_oid one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_bstring != NULLCP && Xparm2->t_bstring != NULLCP) {
+           if (bitstr_cmp(Xparm1->t_bstring, Xparm1->t_blen,
+               Xparm2->t_bstring, Xparm2->t_blen)) {
+                   (void) printf("%s:t_blen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_bstring == NULLCP) {
+           (void) printf("%s: t_bstring decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_ostring != NULLCP && Xparm2->t_ostring != NULLCP) {
+           if (Xparm1->t_olen != Xparm2->t_olen) {
+                   (void) printf("%s:t_olen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           } else if (bcmp(Xparm1->t_ostring, Xparm2->t_ostring,
+               Xparm1->t_olen)) {
+                   (void) printf("%s:t_ostring string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_ostring == NULLCP) {
+           (void) printf("%s: t_ostring decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_string != NULLCP && Xparm2->t_string != NULLCP) {
+           if (strcmp(Xparm1->t_string, Xparm2->t_string)) {
+                   (void) printf("%s:t_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_string == NULLCP) {
+           (void) printf("%s: t_string decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_pe != NULLPE && Xparm2->t_pe != NULLPE) {
+           if (bit_cmp(Xparm1->t_pe, Xparm2->t_pe)) {
+                   (void) printf("%s:t_pe bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_pe == NULLPE) {
+           (void) printf("%s: t_pe decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_def && Xparm2->t_def ) {
+           d += tcmp(TY_DEFPEPY, (char *)Xparm1->t_def, (char *)Xparm2->t_def);
+       } else if (Xparm1->t_def || Xparm2->t_def) {
+           d++;
+           (void) printf("%s:t_def missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->t_opt && Xparm2->t_opt ) {
+           d += tcmp(TY_OPTPEPY, (char *)Xparm1->t_opt, (char *)Xparm2->t_opt);
+           for (i = NUMOPT - 1; i >= 0; i--)
+                if (BITTEST(Xparm1->t_opt->opt_set, i)
+                    != BITTEST(Xparm2->t_opt->opt_set, i)) {
+                   d++;
+                   (void) printf("%s:t_opt missing optional %d\n",
+                       t_case[tynum].tst_name, i);
+                }
+       } else if (Xparm1->t_opt || Xparm2->t_opt) {
+           d++;
+           (void) printf("%s:t_opt missing\n", t_case[tynum].tst_name);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_DEFPEPY:
+    case TY_OPTPEPY:
+#define Xparm1 ((struct pepy_refs1 *)parm1)
+#define Xparm2 ((struct pepy_refs1 *)parm2)
+       if (tynum == TY_DEFPEPY || (BITTEST(Xparm1->opt_set, OPT_INT1) != 0
+            && BITTEST(Xparm2->opt_set, OPT_INT1) != 0)) {
+           if (Xparm1->t_int != Xparm2->t_int) {
+               d++;
+               (void) printf("%s: t_int mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_int, Xparm2->t_int);
+           }
+       }
+       if (tynum == TY_DEFPEPY || (BITTEST(Xparm1->opt_set, OPT_INT2) != 0
+            && BITTEST(Xparm2->opt_set, OPT_INT2) != 0)) {
+           if (Xparm1->t_int1 != Xparm2->t_int1) {
+               d++;
+               (void) printf("%s: t_int1 mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_int1, Xparm2->t_int1);
+           }
+       }
+
+       if (tynum == TY_DEFPEPY || (BITTEST(Xparm1->opt_set, OPT_ENUM1) != 0
+            && BITTEST(Xparm2->opt_set, OPT_ENUM1) != 0)) {
+           if (Xparm1->t_enum != Xparm2->t_enum) {
+               d++;
+               (void) printf("%s:t_enum mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_enum, Xparm2->t_enum);
+           }
+       }
+       if (tynum == TY_DEFPEPY || (BITTEST(Xparm1->opt_set, OPT_ENUM2) != 0
+            && BITTEST(Xparm2->opt_set, OPT_ENUM2) != 0)) {
+           if (Xparm1->t_enum1 != Xparm2->t_enum1) {
+               d++;
+               (void) printf("%s:t_enum1 mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_enum1, Xparm2->t_enum1);
+           }
+       }
+
+       if (qb_cmp(Xparm1->t_qbuf, Xparm2->t_qbuf)) {
+               (void) printf("t_qbuf octet string different\n");
+               d++;
+       }
+       if (qb_cmp(Xparm1->t_qbuf1, Xparm2->t_qbuf1)) {
+               (void) printf("t_qbuf1 octet string different\n");
+               d++;
+       }
+
+       if (tynum == TY_DEFPEPY || (BITTEST(Xparm1->opt_set, OPT_BOOL1) != 0
+            && BITTEST(Xparm2->opt_set, OPT_BOOL1) != 0)) {
+           if (Xparm1->t_bool != Xparm2->t_bool) {
+               d++;
+               (void) printf("%s:t_bool mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_bool, Xparm2->t_bool);
+           }
+       }
+       if (tynum == TY_OPTPEPY) {
+           if (BITTEST(Xparm1->opt_set, OPT_BOOL2) != 0
+            && BITTEST(Xparm2->opt_set, OPT_BOOL2) != 0) {
+               if (Xparm1->t_bool1 != Xparm2->t_bool1) {
+                   d++;
+                   (void) printf("%s:t_bool1 mismatch %d != %d\n", t_case[tynum].tst_name,
+                       Xparm1->t_bool1, Xparm2->t_bool1);
+               }
+           } else if (BITTEST(Xparm1->opt_set, OPT_BOOL2) != 0
+                   || BITTEST(Xparm2->opt_set, OPT_BOOL2) != 0) {
+               d++;
+               (void) printf("%s: t_bool1 missing %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->opt_set, Xparm2->opt_set);
+           }
+       }
+
+#ifdef PEPSY_REALS
+       /* Horrible floating point test for roughly equal */
+       if (fabs(Xparm1->t_real) < F_SMALL/2) {
+            if (fabs(Xparm1->t_real - Xparm2->t_real) > F_SMALL) {
+               (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->t_real, Xparm2->t_real);
+               d++;
+           }
+       } else if (tynum == TY_DEFPEPY 
+           && fabs((Xparm1->t_real - Xparm2->t_real)/Xparm1->t_real) > F_SMALL) {
+           (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+               Xparm1->t_real, Xparm2->t_real);
+           d++;
+       }
+       if (fabs(Xparm1->t_real1) < F_SMALL/2) {
+            if (fabs(Xparm1->t_real1 - Xparm2->t_real1) > F_SMALL) {
+               (void) printf("%s:t_real1 %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->t_real1, Xparm2->t_real1);
+               d++;
+           }
+       } else if (tynum == TY_DEFPEPY 
+           && fabs((Xparm1->t_real1 - Xparm2->t_real1)/Xparm1->t_real1) > F_SMALL) {
+           (void) printf("%s:t_real1 %f != %f\n", t_case[tynum].tst_name,
+               Xparm1->t_real1, Xparm2->t_real1);
+           d++;
+       }
+#endif
+       if (Xparm1->t_any != NULLPE && Xparm2->t_any != NULLPE) {
+           if (pe_cmp(Xparm1->t_any, Xparm2->t_any)) {
+               (void) printf("%s:t_any different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+
+       if (Xparm1->t_oid != NULLOID && Xparm2->t_oid != NULLOID) {
+           if (oid_cmp(Xparm1->t_oid, Xparm2->t_oid)) {
+               (void) printf("%s:t_oid OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: t_oid one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_oid1 != NULLOID && Xparm2->t_oid1 != NULLOID) {
+           if (oid_cmp(Xparm1->t_oid1, Xparm2->t_oid1)) {
+               (void) printf("%s:t_oid1 OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+
+       if (Xparm1->t_bstring != NULLCP && Xparm2->t_bstring != NULLCP) {
+           if (bitstr_cmp(Xparm1->t_bstring, Xparm1->t_blen,
+               Xparm2->t_bstring, Xparm2->t_blen)) {
+                   (void) printf("%s:t_blen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_bstring == NULLCP) {
+           (void) printf("%s: t_bstring decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_bstring1 != NULLCP && Xparm2->t_bstring1 != NULLCP) {
+           if (bitstr_cmp(Xparm1->t_bstring1, Xparm1->t_blen1,
+               Xparm2->t_bstring1, Xparm2->t_blen1)) {
+                   (void) printf("%s:t_blen1 string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (tynum == TY_DEFPEPY && Xparm2->t_bstring1 == NULLCP) {
+           (void) printf("%s: t_bstring1 decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+
+       if (Xparm1->t_ostring != NULLCP && Xparm2->t_ostring != NULLCP) {
+           if (Xparm1->t_olen != Xparm2->t_olen) {
+                   (void) printf("%s:t_olen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           } else if (bcmp(Xparm1->t_ostring, Xparm2->t_ostring,
+               Xparm1->t_olen)) {
+                   (void) printf("%s:t_ostring string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_ostring == NULLCP) {
+           (void) printf("%s: t_ostring decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_ostring1 != NULLCP && Xparm2->t_ostring1 != NULLCP) {
+           if (Xparm1->t_olen1 != Xparm2->t_olen1) {
+                   (void) printf("%s:t_olen1 string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           } else if (bcmp(Xparm1->t_ostring1, Xparm2->t_ostring1,
+               Xparm1->t_olen1)) {
+                   (void) printf("%s:t_ostring string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_ostring1 == NULLCP) {
+           (void) printf("%s: t_ostring1 decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+
+       if (Xparm1->t_string != NULLCP && Xparm2->t_string != NULLCP) {
+           if (strcmp(Xparm1->t_string, Xparm2->t_string)) {
+                   (void) printf("%s:t_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_string == NULLCP) {
+           (void) printf("%s: t_string decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_string1 != NULLCP && Xparm2->t_string1 != NULLCP) {
+           if (strcmp(Xparm1->t_string1, Xparm2->t_string1)) {
+                   (void) printf("%s:t_string1 string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_string1 == NULLCP) {
+           (void) printf("%s: t_string1 decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+
+       if (Xparm1->t_pe != NULLPE && Xparm2->t_pe != NULLPE) {
+           if (bit_cmp(Xparm1->t_pe, Xparm2->t_pe)) {
+                   (void) printf("%s:t_pe bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_pe == NULLPE) {
+           (void) printf("%s: t_pe decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_pe1 != NULLPE && Xparm2->t_pe1 != NULLPE) {
+           if (bit_cmp(Xparm1->t_pe1, Xparm2->t_pe1)) {
+                   (void) printf("%s:t_pe1 bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_pe1 == NULLPE) {
+           (void) printf("%s: t_pe1 decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_S_COMPD:
+#define Xparm1 ((struct pepy_refs1 *)parm1)
+#define Xparm2 ((struct pepy_refs1 *)parm2)
+       if (BITTEST(Xparm1->opt_set, OPT_INT1) != 0
+        && BITTEST(Xparm2->opt_set, OPT_INT1) != 0) {
+           if (Xparm1->t_int != Xparm2->t_int) {
+               d++;
+               (void) printf("%s: t_int mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_int, Xparm2->t_int);
+           }
+       } else if (BITTEST(Xparm1->opt_set, OPT_INT1) != 0
+               || BITTEST(Xparm2->opt_set, OPT_INT1) != 0) {
+           d++;
+           (void) printf("%s: t_int missing %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->opt_set, Xparm2->opt_set);
+       }
+
+       if (BITTEST(Xparm1->opt_set, OPT_INT2) != 0
+        && BITTEST(Xparm2->opt_set, OPT_INT2) != 0) {
+           if (Xparm1->t_int1 != Xparm2->t_int1) {
+               d++;
+               (void) printf("%s: t_int1 mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_int1, Xparm2->t_int1);
+           }
+       } else if (BITTEST(Xparm1->opt_set, OPT_INT2) != 0
+               || BITTEST(Xparm2->opt_set, OPT_INT2) != 0) {
+           d++;
+           (void) printf("%s: t_int1 missing %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->opt_set, Xparm2->opt_set);
+       }
+
+       if (BITTEST(Xparm1->opt_set, OPT_ENUM1) != 0
+        && BITTEST(Xparm2->opt_set, OPT_ENUM1) != 0) {
+           if (Xparm1->t_enum != Xparm2->t_enum) {
+               d++;
+               (void) printf("%s:t_enum mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_enum, Xparm2->t_enum);
+           }
+       } else if (BITTEST(Xparm1->opt_set, OPT_ENUM1) != 0
+               || BITTEST(Xparm2->opt_set, OPT_ENUM1) != 0) {
+           d++;
+           (void) printf("%s: t_int missing %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->opt_set, Xparm2->opt_set);
+       }
+
+       if (BITTEST(Xparm1->opt_set, OPT_ENUM2) != 0
+        && BITTEST(Xparm2->opt_set, OPT_ENUM2) != 0) {
+           if (Xparm1->t_enum1 != Xparm2->t_enum1) {
+               d++;
+               (void) printf("%s:t_enum1 mismatch %d != %d\n", t_case[tynum].tst_name,
+                   Xparm1->t_enum1, Xparm2->t_enum1);
+           }
+       } else if (BITTEST(Xparm1->opt_set, OPT_ENUM2) != 0
+               || BITTEST(Xparm2->opt_set, OPT_ENUM2) != 0) {
+           d++;
+           (void) printf("%s: t_int missing %d != %d\n", t_case[tynum].tst_name,
+               Xparm1->opt_set, Xparm2->opt_set);
+       }
+
+       for (i = NUMOPT - 1; i >= 0; i--) {
+           if (i != OPT_INT1 && i != OPT_INT2
+           && i != OPT_ENUM1 && i != OPT_ENUM2)
+               continue;
+
+            if (BITTEST(Xparm1->opt_set, i) != BITTEST(Xparm2->opt_set, i)) {
+               d++;
+               (void) printf("%s:t_opt missing optional %d\n",
+                   t_case[tynum].tst_name, i);
+            }
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+#endif
+
+    case TY_ACTION:
+    case TY_REPEAT:
+#define Xparm1 ((struct repeats *)parm1)
+#define Xparm2 ((struct repeats *)parm2)
+       if (ri_cmp(Xparm1->rp_sq1, Xparm2->rp_sq1)) {
+           d++;
+           (void) printf("%s:rp_sq1 mangled\n", t_case[tynum].tst_name);
+       }
+       if (re_cmp(Xparm1->rp_sq2, Xparm2->rp_sq2)) {
+           d++;
+           (void) printf("%s:rp_sq2 mangled\n", t_case[tynum].tst_name);
+       }
+       if (ri_cmp(Xparm1->rp_st1, Xparm2->rp_st1)) {
+           d++;
+           (void) printf("%s:rp_st1 mangled\n", t_case[tynum].tst_name);
+       }
+       if (re_cmp(Xparm1->rp_st2, Xparm2->rp_st2)) {
+           d++;
+           (void) printf("%s:rp_st2 mangled\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->rp_choice != Xparm2->rp_choice) {
+           d++;
+           (void) printf("%s:rp_choice wrong %d != %d\n",
+           t_case[tynum].tst_name, Xparm1->rp_choice, Xparm2->rp_choice);
+       }
+       switch (Xparm1->rp_choice) {
+       case RP_INT:
+           if (Xparm1->rp_int != Xparm2->rp_int) {
+               d++;
+               (void) printf("%s:rp_int wrong %d != %d\n",
+               t_case[tynum].tst_name, Xparm1->rp_int, Xparm2->rp_int);
+           }
+           break;
+
+       case RP_BOOL:
+           if (Xparm1->rp_bool && !Xparm2->rp_bool
+            || !Xparm1->rp_bool && Xparm2->rp_bool) {
+               d++;
+               (void) printf("%s:RP_BOOL wrong %d != %d\n",
+               t_case[tynum].tst_name, Xparm1->rp_bool, Xparm2->rp_bool);
+           }
+           break;
+
+       case RP_OSTRING:
+           if (!Xparm1->rp_ostring) {
+               d++;
+               (void) printf("%s:initial rp_ostring missing\n",
+                   t_case[tynum].tst_name);
+           }
+           if (!Xparm2->rp_ostring) {
+               d++;
+               (void) printf("%s:final rp_ostring missing\n",
+                   t_case[tynum].tst_name);
+           }
+           if (strcmp(Xparm1->rp_ostring, Xparm2->rp_ostring)) {
+               d++;
+               (void) printf("%s:rp_ostring not equal %s != %s\n",
+               t_case[tynum].tst_name, Xparm1->rp_ostring, Xparm2->rp_ostring);
+           }
+           break;
+
+       default:
+               d++;
+               (void) printf("%s:bad choice found\n", t_case[tynum].tst_name);
+               break;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_VPDEFINED:
+#define Xparm1 ((struct pepy_refs *)parm1)
+#define Xparm2 ((struct pepy_refs *)parm2)
+       if (Xparm1->t_int != Xparm2->t_int) {
+           d++;
+           (void) printf("%s: t_int mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_int, Xparm2->t_int);
+       }
+
+       if (Xparm1->t_enum != Xparm2->t_enum) {
+           d++;
+           (void) printf("%s:t_enum mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_enum, Xparm2->t_enum);
+       }
+
+       if (qb_cmp(Xparm1->t_qbuf, Xparm2->t_qbuf)) {
+               (void) printf("t_qbuf octet string different\n");
+               d++;
+       }
+
+       if (Xparm1->t_bool != Xparm2->t_bool) {
+           d++;
+           (void) printf("%s:t_bool mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->t_bool, Xparm2->t_bool);
+       }
+
+#ifdef PEPSY_REALS
+       /* Horrible floating point test for roughly equal */
+       if (fabs(Xparm1->t_real) < F_SMALL/2) {
+            if (fabs(Xparm1->t_real - Xparm2->t_real) > F_SMALL) {
+               (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->t_real, Xparm2->t_real);
+               d++;
+           }
+       } else if (fabs((Xparm1->t_real - Xparm2->t_real)/Xparm1->t_real) > F_SMALL) {
+           (void) printf("%s:t_real %f != %f\n", t_case[tynum].tst_name,
+               Xparm1->t_real, Xparm2->t_real);
+           d++;
+       }
+#endif
+       if (Xparm1->t_any != NULLPE && Xparm2->t_any != NULLPE) {
+           if (pe_cmp(Xparm1->t_any, Xparm2->t_any)) {
+               (void) printf("%s:t_any different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       if (Xparm1->t_oid != NULLOID && Xparm2->t_oid != NULLOID) {
+           if (oid_cmp(Xparm1->t_oid, Xparm2->t_oid)) {
+               (void) printf("%s:t_oid OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: t_oid one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_bstring != NULLCP && Xparm2->t_bstring != NULLCP) {
+           if (bitstr_cmp(Xparm1->t_bstring, Xparm1->t_blen,
+               Xparm2->t_bstring, Xparm2->t_blen)) {
+                   (void) printf("%s:t_blen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_bstring == NULLCP) {
+           (void) printf("%s: t_bstring decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_pe != NULLPE && Xparm2->t_pe != NULLPE) {
+           if (bit_cmp(Xparm1->t_pe, Xparm2->t_pe)) {
+                   (void) printf("%s:t_pe bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->t_pe == NULLPE) {
+           (void) printf("%s: t_pe decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_ostring != NULLCP && Xparm2->t_ostring != NULLCP) {
+           if (Xparm1->t_olen != Xparm2->t_olen) {
+                   (void) printf("%s:t_olen string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           } else if (bcmp(Xparm1->t_ostring, Xparm2->t_ostring,
+               Xparm1->t_olen)) {
+                   (void) printf("%s:t_ostring string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else {
+           (void) printf("%s: t_ostring missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->t_string != NULLCP && Xparm2->t_string != NULLCP) {
+           if (strcmp(Xparm1->t_string, Xparm2->t_string)) {
+                   (void) printf("%s:t_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else {
+           (void) printf("%s: t_string decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_FUNC:
+#define Xparm1 ((struct codedata *)parm1)
+#define Xparm2 ((struct codedata *)parm2)
+       if (Xparm1->cd_a != NULLPE && Xparm2->cd_a != NULLPE) {
+           if (pe_cmp(Xparm1->cd_a, Xparm2->cd_a)) {
+               (void) printf("%s:cd_a different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_a missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_b != NULLPE && Xparm2->cd_b != NULLPE) {
+           if (pe_cmp(Xparm1->cd_b, Xparm2->cd_b)) {
+               (void) printf("%s:cd_b different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_b missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_c != NULLPE && Xparm2->cd_c != NULLPE) {
+           if (pe_cmp(Xparm1->cd_c, Xparm2->cd_c)) {
+               (void) printf("%s:cd_c different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_c missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_d != NULLPE && Xparm2->cd_d != NULLPE) {
+           if (pe_cmp(Xparm1->cd_d, Xparm2->cd_d)) {
+               (void) printf("%s:cd_d different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_d missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_int != Xparm2->cd_int) {
+           d++;
+           (void) printf("%s:cd_int mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->cd_int, Xparm2->cd_int);
+       }
+
+       if (Xparm1->cd_string != NULLCP && Xparm2->cd_string != NULLCP) {
+           if (strcmp(Xparm1->cd_string, Xparm2->cd_string)) {
+                   (void) printf("%s:cd_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else {
+           (void) printf("%s: cd_string missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_left && Xparm2->cd_left ) {
+           d += tcmp(TY_OPTFUNC, (char *)Xparm1->cd_left,
+               (char *)Xparm2->cd_left);
+       } else if (Xparm1->cd_left || Xparm2->cd_left) {
+           d++;
+           (void) printf("%s:cd_left missing\n", t_case[tynum].tst_name);
+       }
+       if (Xparm1->cd_right && Xparm2->cd_right ) {
+           d += tcmp(TY_DFTFUNC, (char *)Xparm1->cd_right,
+               (char *)Xparm2->cd_right);
+       } else if (Xparm1->cd_right || Xparm2->cd_right) {
+           d++;
+           (void) printf("%s:cd_right missing\n", t_case[tynum].tst_name);
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_OPTFUNC:
+#define Xparm1 ((struct codedata *)parm1)
+#define Xparm2 ((struct codedata *)parm2)
+       if (Xparm1->cd_a != NULLPE && Xparm2->cd_a != NULLPE) {
+           if (pe_cmp(Xparm1->cd_a, Xparm2->cd_a)) {
+               (void) printf("%s:cd_a different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else if (Xparm1->cd_a != NULLPE || Xparm2->cd_a != NULLPE) {
+           (void) printf("%s: cd_a missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_b != NULLPE && Xparm2->cd_b != NULLPE) {
+           if (pe_cmp(Xparm1->cd_b, Xparm2->cd_b)) {
+               (void) printf("%s:cd_b different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else if (Xparm1->cd_b != NULLPE || Xparm2->cd_b != NULLPE) {
+           (void) printf("%s: cd_b missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       for (i = NCD_OPT - 1; i >= 0; i--) {
+            if (BITTEST(Xparm1->cd_opt_set, i)
+              != BITTEST(Xparm2->cd_opt_set, i)) {
+               d++;
+               (void) printf("%s: flag bit %d differs\n",
+                       t_case[tynum].tst_name, i);
+            }
+       }
+       if (BITTEST(Xparm1->cd_opt_set, CD_C)) {
+           if (Xparm1->cd_c != NULLPE && Xparm2->cd_c != NULLPE) {
+               if (pe_cmp(Xparm1->cd_c, Xparm2->cd_c)) {
+                   (void) printf("%s:cd_c different\n",t_case[tynum].tst_name);
+                   d++;
+               }
+           } else {
+               (void) printf("%s: cd_c missing\n", t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       if (BITTEST(Xparm1->cd_opt_set, CD_D)) {
+           if (Xparm1->cd_d != NULLPE && Xparm2->cd_d != NULLPE) {
+               if (pe_cmp(Xparm1->cd_d, Xparm2->cd_d)) {
+                   (void) printf("%s:cd_d different\n",t_case[tynum].tst_name);
+                   d++;
+               }
+           } else {
+               (void) printf("%s: cd_d missing\n", t_case[tynum].tst_name);
+               d++;
+           }
+       }
+
+       if (BITTEST(Xparm1->cd_opt_set, CD_INT)) {
+           if (Xparm1->cd_int != Xparm2->cd_int) {
+               d++;
+               (void) printf("%s:cd_int mismatch %d != %d",
+                   t_case[tynum].tst_name, Xparm1->cd_int, Xparm2->cd_int);
+           }
+       }
+
+       if (Xparm1->cd_string != NULLCP && Xparm2->cd_string != NULLCP) {
+           if (strcmp(Xparm1->cd_string, Xparm2->cd_string)) {
+                   (void) printf("%s:cd_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm1->cd_string != NULLCP || Xparm2->cd_string != NULLCP) {
+           (void) printf("%s: cd_string missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+    case TY_DFTFUNC:
+#define Xparm1 ((struct codedata *)parm1)
+#define Xparm2 ((struct codedata *)parm2)
+       if (Xparm1->cd_a != NULLPE && Xparm2->cd_a != NULLPE) {
+           if (pe_cmp(Xparm1->cd_a, Xparm2->cd_a)) {
+               (void) printf("%s:cd_a different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else if (Xparm1->cd_a != NULLPE || Xparm2->cd_a != NULLPE) {
+           (void) printf("%s: cd_a missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_b != NULLPE && Xparm2->cd_b != NULLPE) {
+           if (pe_cmp(Xparm1->cd_b, Xparm2->cd_b)) {
+               (void) printf("%s:cd_b different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else if (Xparm1->cd_b != NULLPE || Xparm2->cd_b != NULLPE) {
+           (void) printf("%s: cd_b missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       for (i = NCD_OPT - 1; i >= 0; i--) {
+           if (i == CD_INT)
+               continue;
+
+           if (BITTEST(Xparm1->cd_opt_set,i) !=BITTEST(Xparm2->cd_opt_set,i)) {
+               d++;
+               (void) printf("%s: flag bit %d differs\n",
+                   t_case[tynum].tst_name,i);
+           }
+       }
+       if (BITTEST(Xparm1->cd_opt_set, CD_C)) {
+           if (Xparm1->cd_c != NULLPE && Xparm2->cd_c != NULLPE) {
+               if (pe_cmp(Xparm1->cd_c, Xparm2->cd_c)) {
+                   (void) printf("%s:cd_c different\n",t_case[tynum].tst_name);
+                   d++;
+               }
+           } else {
+               (void) printf("%s: cd_c missing\n", t_case[tynum].tst_name);
+               d++;
+           }
+       }
+       if (BITTEST(Xparm1->cd_opt_set, CD_D)) {
+           if (Xparm1->cd_d != NULLPE && Xparm2->cd_d != NULLPE) {
+               if (pe_cmp(Xparm1->cd_d, Xparm2->cd_d)) {
+                   (void) printf("%s:cd_d different\n",t_case[tynum].tst_name);
+                   d++;
+               }
+           } else {
+               (void) printf("%s: cd_d missing\n", t_case[tynum].tst_name);
+               d++;
+           }
+       }
+
+       if (Xparm1->cd_int != Xparm2->cd_int) {
+           d++;
+           (void) printf("%s:cd_int mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->cd_int, Xparm2->cd_int);
+       }
+
+       if (Xparm1->cd_string != NULLCP && Xparm2->cd_string != NULLCP) {
+           if (strcmp(Xparm1->cd_string, Xparm2->cd_string)) {
+                   (void) printf("%s:cd_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else {
+           (void) printf("%s: cd_string missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+
+#ifdef PEPSY_REALS
+    case TY_ASIMPLE:
+#define Xparm1 ((struct codedata *)parm1)
+#define Xparm2 ((struct codedata *)parm2)
+       if (Xparm1->cd_a != NULLPE && Xparm2->cd_a != NULLPE) {
+           if (pe_cmp(Xparm1->cd_a, Xparm2->cd_a)) {
+               (void) printf("%s:cd_a different\n", t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_a missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_int != Xparm2->cd_int) {
+           d++;
+           (void) printf("%s:cd_int mismatch %d != %d", t_case[tynum].tst_name,
+               Xparm1->cd_int, Xparm2->cd_int);
+       }
+
+       if (Xparm1->cd_string != NULLCP && Xparm2->cd_string != NULLCP) {
+           if (strcmp(Xparm1->cd_string, Xparm2->cd_string)) {
+                   (void) printf("%s:cd_string string different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else {
+           (void) printf("%s: cd_string missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_bool && !Xparm2->cd_bool
+        || !Xparm1->cd_bool && Xparm2->cd_bool) {
+           d++;
+           (void) printf("%s:cd_bool wrong %d != %d\n",
+               t_case[tynum].tst_name, Xparm1->cd_bool, Xparm2->cd_bool);
+       }
+       /* Horrible floating point test for roughly equal */
+       if (fabs(Xparm1->cd_real) < F_SMALL/2) {
+            if (fabs(Xparm1->cd_real - Xparm2->cd_real) > F_SMALL) {
+               (void) printf("%s:cd_real %f != %f\n", t_case[tynum].tst_name,
+                   Xparm1->cd_real, Xparm2->cd_real);
+               d++;
+           }
+       } else if (fabs((Xparm1->cd_real - Xparm2->cd_real)/Xparm1->cd_real)
+               > F_SMALL) {
+           (void) printf("%s:cd_real %f != %f\n", t_case[tynum].tst_name,
+               Xparm1->cd_real, Xparm2->cd_real);
+           d++;
+       }
+       if (Xparm1->cd_oid != NULLOID && Xparm2->cd_oid != NULLOID) {
+           if (oid_cmp(Xparm1->cd_oid, Xparm2->cd_oid)) {
+               (void) printf("%s:cd_oid OID different\n",
+                   t_case[tynum].tst_name);
+               d++;
+           }
+       } else {
+           (void) printf("%s: cd_oid one missing\n", t_case[tynum].tst_name);
+           d++;
+       }
+       if (Xparm1->cd_bit != NULLPE && Xparm2->cd_bit != NULLPE) {
+           if (bit_cmp(Xparm1->cd_bit, Xparm2->cd_bit)) {
+                   (void) printf("%s:cd_bit bitstring different\n",
+                       t_case[tynum].tst_name);
+                   d++;
+           }
+       } else if (Xparm2->cd_bit == NULLPE) {
+           (void) printf("%s: cd_bit decoded version missing\n",
+               t_case[tynum].tst_name);
+           d++;
+       }
+       break;
+#undef Xparm1
+#undef Xparm2
+#endif
+
+    default:
+       ferrd(1, "tcmp:unknown type %d\n", tynum);
+    }
+    if (d) {
+           (void) printf("tcmp:failed on %s\n", t_case[tynum].tst_name);
+    }
+    return (d);
+}
+
+/*
+ * Compare two possible null qbuf lists and return non zero if they are
+ * different
+ * Pretty complex to allow for all sorts of weird cases
+ * Doesn't work for a qbuf which doesn't have a head ! Don't really know what
+ * is the proper form of a queue buf. MArshall's doco doesn't say
+ */
+qb_cmp(qb1, qb2)
+struct qbuf    *qb1, *qb2;
+{
+    struct     qbuf    *qp1, *qp2;
+    char       *po1, *po2;
+    int        len1, len2;
+
+    if (qb1 == NULL && qb2 == NULL)
+       return (0);
+    
+    if (qb1 == NULL || qb2 == NULL)
+       return (1);
+
+    qp1 = qb1->qb_forw;
+    qp2 = qb2->qb_forw;
+    po1 = qp1->qb_data;
+    po2 = qp2->qb_data;
+    len1 = qp1->qb_len;
+    len2 = qp2->qb_len;
+
+    while (qp1 != qb1 && qp2 != qb2) {
+       if (len1 < len2) {
+           if (bcmp(po1, po2, len1))
+                   return (1);
+           len2 -= len1;
+           po2 += len1;
+           qp1 = qp1->qb_forw;
+           po1 = qp1->qb_data;
+           len1 = qp1->qb_len;
+       } else {
+           if (bcmp(po1, po2, len1))
+                   return (1);
+           len1 -= len2;
+           po1 += len2;
+           qp2 = qp2->qb_forw;
+           po2 = qp2->qb_data;
+           len2 = qp2->qb_len;
+       }
+    }
+
+    if (len1 == 0)
+           qp1 = qp1->qb_forw;
+    if (len2 == 0)
+           qp2 = qp2->qb_forw;
+    while (qp1 != qb1 && qp1->qb_len == 0)
+           qp1 = qp1->qb_forw;
+    while (qp2 != qb2 && qp2->qb_len == 0)
+           qp2 = qp2->qb_forw;
+    if (qp1 == qb1 && qp2 == qb2)
+       return (0);     /* perfect match */
+
+    return (1);
+}
+
+/*
+ * compare two bitstrings. Including the little bits left at the end but
+ * not the bits not in the strings
+ */
+bit_cmp(b1, b2)
+PE     b1, b2;
+{
+       int     len1, len2;
+       register char   *cp1, *cp2;
+
+       if (b1 == NULLPE && b2 == NULLPE)
+           return (0);
+       if (b1 == NULLPE || b2 == NULLPE)
+           goto fail;
+
+       if ((cp1 = bitstr2strb(b1, &len1)) == NULL)
+           goto fail;
+       if ((cp2 = bitstr2strb(b2, &len2)) == NULL) {
+           free(cp1);
+           goto fail;
+       }
+
+       if (len1 != len2 || bcmp(cp1, cp2, len1/8)) {
+           free(cp1);
+           free(cp2);
+           goto fail;
+       }
+
+       if (len1 % 8) {
+               int i;
+               int     mask;
+
+               /* Check those last few bits */
+               i = len1/8;
+               mask = (0xff00 >> len1 % 8) & 0xff;
+               if ((cp1[i] & mask) != (cp2[i] & mask)) {
+                   free(cp1);
+                   free(cp2);
+                   goto fail;
+               }
+       }
+
+       free(cp1);
+       free(cp2);
+       return (0);
+
+    fail:
+       return (1);
+}
+
+/*
+ * compare to strings of given number of bits for equality
+ */
+bitstr_cmp(cp1, len1, cp2, len2)
+char   *cp1, *cp2;
+int    len1, len2;
+{
+    int i;
+    int        mask;
+
+    if (len1 != len2 || bcmp(cp1, cp2, len1/8))
+       return (1);
+    
+    if (len1 % 8) {
+
+       /* Check those last few bits */
+       i = len1/8;
+       mask = (0xff00 >> len1 % 8) & 0xff;
+       if ((cp1[i] & mask) != (cp2[i] & mask)) {
+           return (1);
+       }
+    }
+    return (0);
+}
+
+#define MKMASK 0x7
+#define MKSHIFT 6
+/*
+ * Generate a randomish list of PElement s for use as ANY or SET  OF ANY ....
+ */
+PE
+mkpelist(i)
+{
+    PE pe, fpe = NULL;
+
+    fpe = pe_alloc(PE_CLASS_PRIV, PE_FORM_CONS, (PElementID ) i);
+    while (i > 0) {
+       pe = mkpe(i);
+       pe->pe_next = fpe->pe_cons;
+       fpe->pe_cons = pe;
+       i--;
+    }
+    return (fpe);
+}
+
+/*
+ * generate a randomish PElement
+ */
+PE
+mkpe(i)
+int    i;
+{
+    int        id, class;
+    PE         pe;
+
+    id = i * i + 1;
+    class = PE_CLASS_PRIV;
+    switch ((i*i >> MKSHIFT) & MKMASK) {
+    case 5:
+    case 0:
+       pe = flag2prim(i & 0x1, (PElementClass ) class, (PElementID ) id);
+       break;
+    
+    case 6:
+    case 1:
+       pe = num2prim((integer )i, (PElementClass ) class, (PElementID ) id);
+       break;
+
+    case 7:
+    case 2:
+       pe = str2prim("mkpelist:testdata", 17, (PElementClass ) class,
+       (PElementID ) id);
+       break;
+
+    case 3:
+       pe = strb2bitstr("\021\0245\375\0124", 4,
+           (PElementClass ) class, (PElementID ) id);
+       break;
+    
+    case 4:
+       pe = mkpelist(i - 1);
+       break;
+
+    default:
+       ferrd(1, "mkpelist:internal error %d case not handled\n",
+           (i*i >> MKSHIFT) & MKMASK);
+    }
+
+    return (pe);
+}
+
+#define OID_SIZE       6
+/*
+ * make an OID for testing
+ */
+OID
+mkoid(i)
+int    i;
+{
+    OID        oid;
+    int        oid_cnt = i % OID_SIZE;
+
+    if ((oid = new(struct OIDentifier)) == NULL) {
+       (void) printf("mkoid:calloc did not work\n");
+       return NULL;
+    }
+    if (oid_cnt < 2)
+       oid_cnt = 2;    /* At least two integers long */
+    oid->oid_nelem = oid_cnt;
+    if ((oid->oid_elements =
+        (unsigned int *)calloc((unsigned ) oid_cnt, sizeof (int))) == NULL) {
+       (void) printf("mkoid:calloc 2 did not work\n");
+       return NULL;
+    }
+    while (oid_cnt > 2) {
+       oid->oid_elements[oid_cnt - 1] = oid_cnt*i + 33;
+        oid_cnt--;
+    }
+
+    oid->oid_elements[0] = 1;
+    oid->oid_elements[1] = 17;
+
+
+    return (oid);
+}
+
+/*
+ * Produce an External structure initialised to test values
+ * for testing EXTERNAL encoding routines
+ */
+struct type_UNIV_EXTERNAL *
+mkext(i)
+int    i;
+{
+    int        k;
+    struct type_UNIV_EXTERNAL *p;
+
+    k = i + 2;
+    k *= k;    /* generate a more random looking number */
+    k %= 51; /* Keep it in a reasonable bounds to avoid overflow */
+    if ((p = new(struct type_UNIV_EXTERNAL)) == NULL
+    || (p->encoding = new(struct choice_UNIV_0)) == NULL)
+       ferr(1, "mkext:malloc:out of memory\n");
+    
+    if (i & 0x1)
+       p->direct__reference = mkoid(i*3);
+    
+    p->indirect__reference = k & 0x7c;
+
+    p->data__value__descriptor = str2qb("A very wild type of data", 25, 1);
+
+    switch (p->encoding->offset = (k % choice_UNIV_0_arbitrary) + 1) {
+
+    case choice_UNIV_0_arbitrary:
+       p->encoding->un.single__ASN1__type = mkpe(k % 7);
+       break;
+
+    case choice_UNIV_0_single__ASN1__type:
+       p->encoding->un.single__ASN1__type = mkpe(k % 5);
+       break;
+
+    case choice_UNIV_0_octet__aligned:
+       p->encoding->un.octet__aligned = str2qb("Some test data", 15, 1);
+       break;
+
+    default:
+       ferrd(1, "mkext:internal error: bad offset %d\n", p->encoding->offset);
+
+    }
+
+    return (p);
+}
+
+/*
+ * compare two external types to see if they are identical - return zero if
+ * they are and non zero if they are different
+ */
+ext_cmp(e1, e2)
+register struct      type_UNIV_EXTERNAL *e1, *e2;
+{
+     if (e1->direct__reference != NULLOID && e2->direct__reference != NULLOID) {
+        if (oid_cmp(e1->direct__reference, e2->direct__reference))
+               return (1);
+    } else {
+       if (e1->direct__reference != NULLOID || e2->direct__reference != NULLOID)
+           return (1);
+       if (e1->indirect__reference != e2->indirect__reference)
+           return (1);
+    }
+     if (e1->data__value__descriptor != NULLQB
+     && e2->data__value__descriptor != NULLQB) {
+        if (qb_cmp(e1->data__value__descriptor, e2->data__value__descriptor))
+               return (1);
+    } else if (e1->data__value__descriptor != NULLQB
+       || e2->data__value__descriptor != NULLQB)
+           return (1);
+    if (e1->encoding == NULL || e2->encoding == NULL)
+       return (1);
+    if (e1->encoding->offset != e2->encoding->offset)
+       return (1);
+    switch (e1->encoding->offset) {
+    case choice_UNIV_0_single__ASN1__type:
+        if (e1->encoding->un.single__ASN1__type == NULLPE
+        || e2->encoding->un.single__ASN1__type == NULLPE)
+            return (1);
+        if (pe_cmp(e1->encoding->un.single__ASN1__type,
+            e2->encoding->un.single__ASN1__type))
+           return (1);
+       break;
+
+    case choice_UNIV_0_octet__aligned:
+        if (e1->encoding->un.octet__aligned == NULLQB
+        || e2->encoding->un.octet__aligned == NULLQB)
+            return (1);
+        if (qb_cmp(e1->encoding->un.octet__aligned,
+            e2->encoding->un.octet__aligned))
+           return (1);
+       break;
+
+    case choice_UNIV_0_arbitrary:
+        if (e1->encoding->un.arbitrary == NULLPE
+        || e2->encoding->un.arbitrary == NULLPE)
+            return (1);
+        if (pe_cmp(e1->encoding->un.arbitrary,
+            e2->encoding->un.arbitrary))
+           return (1);
+       break;
+
+    default:
+       ferrd(1, "ext_cmp:illegal offset value %d\n", e1->encoding->offset);
+    }
+
+    return (0);
+}
+/*
+ * print the PE structure pointed to by pe
+ */
+print_pe(pe, n)
+PE      pe;
+int     n;
+{
+
+    if (pe == NULL)
+       return;
+    (void) printf("%*s", 4 * n, "");
+    if (pe->pe_errno)
+       (void) printf(" errno = %d", pe->pe_errno);
+    if (pe->pe_class == PE_CLASS_UNIV)
+       (void) printf(" %s", idname( (int )pe->pe_id));
+    else if (pe->pe_class == PE_CLASS_CONT)
+       (void) printf("[%d]", pe->pe_id);
+    else
+       (void) printf("[%s %d]", clname( (int )pe->pe_class), pe->pe_id);
+
+    (void) printf("\n");
+
+    if (pe->pe_form != 0x0) {
+       if (pe->pe_cons != NULLPE)
+           print_pe(pe->pe_cons, n + 1);
+    } else {
+       (void) printf("%*s", 4 * n, "");
+       switch (pe->pe_id) {
+       case PE_PRIM_BOOL:
+           (void) printf("%d", prim2flag(pe));
+           break;
+
+       case PE_PRIM_INT:
+           (void) printf(" %d", prim2num(pe));
+           break;
+       case PE_PRIM_BITS:
+           prntbits(pe);
+           break;
+
+       case PE_PRIM_OCTS:
+           (void) prntos(pe);
+           break;
+
+       case PE_PRIM_NULL:
+           break;
+
+
+       case PE_DEFN_NUMS:
+       case PE_DEFN_PRTS:
+       case PE_DEFN_T61S:
+       case PE_DEFN_VTXS:
+       case PE_DEFN_IA5S:
+       case PE_DEFN_GFXS:
+       case PE_DEFN_VISS:
+       case PE_DEFN_GENS:
+       case PE_DEFN_CHRS:
+           (void) prntstr(pe);
+           break;
+
+
+       case PE_PRIM_OID:
+       case PE_CONS_EXTN:
+       case PE_PRIM_REAL:
+       case PE_PRIM_ENUM:
+       case PE_PRIM_ENCR:
+
+       case PE_CONS_SEQ:
+       case PE_CONS_SET:
+
+       case PE_DEFN_UTCT:
+       case PE_DEFN_GENT:
+       default:
+           (void) printf("Unimplemented %d ", pe->pe_id);
+           break;
+       }
+       (void) printf("\n");
+    }
+    if (pe->pe_next != NULLPE) {
+       (void) printf("%*s", 4 * n, "pe_next:\n");
+       print_pe(pe->pe_next, n);
+    }
+}
+
+/*
+ * return the string describing that class
+ */
+static char   *
+clname(cl)
+int     cl;
+{
+    char   *p;
+    static char buf[30];
+
+    switch (cl) {
+    case PE_CLASS_UNIV:
+       p = "Universal";
+       break;
+
+    case PE_CLASS_APPL:
+       p = "Application";
+       break;
+
+    case PE_CLASS_CONT:
+       p = "Context";
+       break;
+
+    case PE_CLASS_PRIV:
+       p = "Private";
+       break;
+
+    default:
+       (void) sprintf(buf, "Unknown Class %d", cl);
+       p = buf;
+       break;
+    }
+    return (p);
+}
+
+
+/*
+ * return the string describing that identity or the number itself
+ * Assuming a Universal class
+ */
+static char   *
+idname(id)
+int     id;
+{
+    char   *p;
+    static char buf[40];
+
+    switch (id) {
+    case PE_PRIM_BOOL:
+       p = "Boolean";
+       break;
+
+    case PE_PRIM_INT:
+       p = "Integer";
+       break;
+
+    case PE_PRIM_BITS:
+       p = "Bit String";
+       break;
+
+    case PE_PRIM_OCTS:
+       p = "Octet String";
+       break;
+
+    case PE_PRIM_NULL:
+       p = "Null";
+       break;
+
+    case PE_PRIM_OID:
+       p = "Object Descriptor";
+       break;
+
+    case PE_CONS_EXTN:
+       p = "External";
+       break;
+
+    case PE_PRIM_REAL:
+       p = "Real";
+       break;
+
+    case PE_PRIM_ENUM:
+       p = "Enumerated Type";
+       break;
+
+    case PE_PRIM_ENCR:
+       p = "Encrypted Type";
+       break;
+
+    case PE_CONS_SEQ:
+       p = "Sequence";
+       break;
+
+    case PE_CONS_SET:
+       p = "Set";
+       break;
+
+    case PE_DEFN_NUMS:
+       p = "Numeric String";
+       break;
+
+    case PE_DEFN_PRTS:
+       p = "Printable String";
+       break;
+
+    case PE_DEFN_T61S:
+       p = "T.61 String";
+       break;
+
+    case PE_DEFN_VTXS:
+       p = "Videotex String";
+       break;
+
+    case PE_DEFN_IA5S:
+       p = "IA5 String";
+       break;
+
+    case PE_DEFN_UTCT:
+       p = "UTC Time";
+       break;
+
+    case PE_DEFN_GENT:
+       p = "Generalised Time";
+       break;
+
+    case PE_DEFN_GFXS:
+       p = "Graphics String";
+       break;
+
+    case PE_DEFN_VISS:
+       p = "Visable String";
+       break;
+
+    case PE_DEFN_GENS:
+       p = "General String";
+       break;
+
+    case PE_DEFN_CHRS:
+       p = "Character String";
+       break;
+
+    default:
+       (void) sprintf(buf, "Unknown Universal %d", id);
+       p = buf;
+       break;
+    }
+    return (p);
+}
+/*
+ * Print out the value of a bits string
+ */
+static prntbits(pe)
+PE      pe;
+{
+    int     len, i;
+
+    if ((len = pe->pe_nbits) < 0) {
+       (void) printf("prntbits:Bad bistring\n");
+       return;
+    }
+    (void) printf("Bits:");
+    for (i = 0; i < len; i++)
+       if (bit_test(pe, i))
+           (void) printf(" %d", i);
+
+    (void) putchar('\n');
+}
+
+/*
+ * Dump a bunch of hex digits printing out those that are printable
+ * Print out a given length of octets as hex (with the ASCII
+ * characters given if they have any
+ */
+static pclen(s, len)
+register char *s;
+register int len;
+{
+    register int cnt = 0;
+
+    while (len-- > 0) {
+       if (cnt % 8 == 0)
+           (void) printf("\n%d:", cnt / 8 + 1);
+       if (isprint(*s & 0x7f))
+           (void) printf("\t%02x(%c)", *s & 0xff, *s & 0x7f);
+       else
+           (void) printf("\t%02x", *s & 0xff);
+       s++;
+       cnt++;
+    }
+    (void) putchar('\n');
+}
+
+/*
+ * print out an octet string
+ */
+static prntos(pe)
+PE      pe;
+{
+    struct qbuf *qb;
+
+    if ((qb = prim2qb(pe)) == NULL) {
+bad:
+       (void) printf("prntos:bad octet string\n");
+       return (NOTOK);
+    }
+    if (qb_pullup(qb) == NOTOK)
+       goto bad;
+
+    if (qb->qb_forw->qb_data == NULL || qb->qb_forw->qb_len < 0)
+       goto bad;
+
+    pclen(qb->qb_forw->qb_data, qb->qb_forw->qb_len);
+    return (OK);
+}
+
+/*
+ * print out a string which should be printable
+ */
+static prntstr(pe)
+PE      pe;
+{
+    struct qbuf *qb;
+
+    if ((qb = prim2qb(pe)) == NULL) {
+bad:
+       (void) printf("prntstr:bad string\n");
+       return (NOTOK);
+    }
+    if (qb_pullup(qb) == NOTOK)
+       goto bad;
+
+    if (qb->qb_forw->qb_data == NULL || qb->qb_forw->qb_len < 0)
+       goto bad;
+
+    (void) printf("\"%s\"", qb->qb_forw->qb_data);
+    return (OK);
+}
+
+/*
+ * build a link list of struct rep_int containing the speicified number of
+ * elements
+ */
+struct rep_int *
+mkrep_int(cnt)
+int    cnt;
+{
+    struct rep_int     *hd, *tl, *p;
+
+    for (hd = NULLREP_INT, tl = NULL; cnt-- > 0; ) {
+       if ((p = new(struct rep_int)) == NULLREP_INT)
+           ferr(1, "mkrep_int:malloc failed\n");
+       
+       p->i = t_test*cnt + 3;
+       if (tl) {
+           tl->r = p;
+           tl = p;
+       } else
+           hd = tl = p;
+    }
+
+    return (hd);
+}
+
+static char *test_str[] = { "The quick", "brown", "fox jumps over",
+                           "The Lazy", "dog", 0 };
+
+/*
+ * build a link list of struct rep_elem containing the speicified number of
+ * elements
+ */
+struct rep_elem        *
+mkrep_elem(cnt)
+int    cnt;
+{
+    struct rep_elem    *hd, *tl, *p;
+    char       **str;
+
+    for (str = test_str, hd = NULLREP_ELEM, tl = NULL; cnt-- > 0; ) {
+       if ((p = new(struct rep_elem)) == NULLREP_ELEM)
+           ferr(1, "mkrep_elem:malloc failed\n");
+       
+       if (*str == NULLCP)
+           str = test_str;
+       
+       p->r_int = t_test + cnt + 3;
+       p->r_ostring = strdup(*str++);
+       p->r_bstring = strdup("1234567890abcdefghijklmnopqrstuvwxyz");
+       if (tl) {
+           tl->r_next = p;
+           tl = p;
+       } else
+           hd = tl = p;
+    }
+
+    return (hd);
+}
+
+/*
+ * return non zero if the to lists are different - also
+ * prints a message about the difference found
+ */
+ri_cmp(p1, p2)
+struct rep_int *p1, *p2;
+{
+    int        cnt;
+
+
+    for (cnt = 1; p1 && p2; cnt++) {
+       if (p1->i != p2->i) {
+           (void) printf("ri_cmp: Integers differ in %d item (%d != %d)\n",
+               cnt, p1->i, p2->i);
+           return (1);
+       }
+       p1 = p1->r;
+       p2 = p2->r;
+    }
+    if (p1) {
+       (void) printf("ri_cmp: 1st list has more items (> %d)\n", cnt);
+       return(1);
+    }
+    if (p2) {
+       (void) printf("ri_cmp: 2nd list has more items (> %d)\n", cnt);
+       return(1);
+    }
+
+    return (0);
+}
+
+/*
+ * return non zero if the to lists are different - also
+ * prints a message about the difference found
+ */
+re_cmp(p1, p2)
+struct rep_elem        *p1, *p2;
+{
+    int        cnt;
+
+
+    for (cnt = 1; p1 && p2; cnt++) {
+       if (p1->r_int != p2->r_int) {
+           (void) printf("re_cmp: Integers differ in %d item (%d != %d)\n",
+               cnt, p1->r_int, p2->r_int);
+           return (1);
+       }
+       if (strcmp(p1->r_ostring, p2->r_ostring)) {
+           (void) printf("re_cmp: strings differ in %d item (%s != %s)\n",
+               cnt, p1->r_ostring, p2->r_ostring);
+           return (1);
+       }
+       if (bitscmp(p1->r_bstring, p2->r_bstring, p1->r_int)) {
+           (void) printf("re_cmp: bit strings differ in %d item\n", cnt);
+           return (1);
+       }
+       p1 = p1->r_next;
+       p2 = p2->r_next;
+    }
+    if (p1) {
+       (void) printf("re_cmp: 1st list has more items (> %d)\n", cnt);
+       return(1);
+    }
+    if (p2) {
+       (void) printf("re_cmp: 2nd list has more items (> %d)\n", cnt);
+       return(1);
+    }
+
+    return (0);
+}
diff --git a/usr/src/contrib/isode/pepsy/pass2.c b/usr/src/contrib/isode/pepsy/pass2.c
new file mode 100644 (file)
index 0000000..8afc045
--- /dev/null
@@ -0,0 +1,1468 @@
+/* pass2.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/pass2.c,v 7.10 91/02/22 09:49:18 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/pass2.c,v 7.10 91/02/22 09:49:18 mrose Interim $
+ *
+ *
+ * $Log:       pass2.c,v $
+ * Revision 7.10  91/02/22  09:49:18  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.9  91/01/08  12:49:45  mrose
+ * update
+ * 
+ * Revision 7.8  90/12/23  17:24:52  mrose
+ * patches
+ * 
+ * Revision 7.7  90/12/11  10:33:43  mrose
+ * sync
+ * 
+ * Revision 7.6  90/11/20  15:27:14  mrose
+ * update
+ * 
+ * Revision 7.5  90/11/11  10:53:58  mrose
+ * update
+ * 
+ * Revision 7.4  90/11/04  19:18:57  mrose
+ * update
+ * 
+ * Revision 7.3  90/08/08  14:02:27  mrose
+ * stuff
+ * 
+ * Revision 7.2  90/07/27  08:49:22  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/01  20:00:32  mrose
+ * update
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include "pepsydefs.h"
+#include "pass2.h"
+#include "mine.h"
+#include "sym.h"
+
+extern int doexternals;
+extern int sflag, mflag;
+
+extern char *eval;
+
+extern int Aflag;
+extern SY mysymbols;
+extern char *modsym();
+extern char *my_strcat();
+extern char *notidtoid();
+extern char    *rm_indirect();
+extern char    *getid();
+extern char    *getidordot();
+extern char    *getfield();
+extern char    *sym2type();
+extern YP      lookup_type();
+
+char   *tab;   /* mymodule - with - changed to _ */
+
+Action start_action, final_action;
+int    e_actions, d_actions, p_actions; /* number of actions of each type */
+
+FILE   *ffopen();
+
+peri_pass2()
+{
+    char *inc; /* *_pre_defs.h file */
+
+    if (!sflag)
+       (void) fflush(stderr);
+
+    tab = notidtoid(mymodule);
+
+    if (strcmp(mymodule, "UNIV"))
+       (void) lookup_module("UNIV", NULLOID);
+
+    inc = my_strcat (mymodule, HFILE2);
+
+    gen_typesfile(inc);
+
+    gen_tablefile(inc);
+
+}
+
+/*
+ * generate the table file which contains:
+ * #include types file
+ * #include - types files for other (external) modules referenced
+ * definitions of data structures used: strings and stuff for defaults
+ *             declaractions of functions referenced.
+ *             tpe tables - one per type assignment for each of
+ *                     encoding, decoding and printing
+ *             tables of pointers to all the above tpe tables - one for
+ *                     type of tpe table
+ *             pointer table - used to hold pointers as tpe table cannot
+ *                hold pointers but only integers which index into this table
+ *             module definition - the key to all the data structures os this
+ *                     module. contains references to all the tables.
+ *             lint declaractions for the "pepy" functions
+ */
+gen_tablefile(inc)
+char   *inc;
+{
+
+    int     nentries;
+    int     encflag = 1, decflag = 1, prntflag = 1;
+    char   *buf, *act;
+    SY      sy;
+    YP      yp;
+    FILE   *fphh, *fptab;
+
+    fptab = ffopen(my_strcat(mymodule, TBLNAME));
+
+    /* Only need two files <stdio.h> and our types file which includes
+     * everything else we need
+     * Assumption. types file in the same directory as the _tables
+     */
+    (void) fprintf(fptab, "#include <stdio.h>\n");
+    (void) fprintf(fptab, "#include \"%s%s\"\n\n", mymodule, GENTYPES);
+
+
+
+#ifdef ACT_CODE
+    (void) fprintf(fptab, "#include \"%s\"\n", act);
+#endif
+    
+    if (start_action) {
+       (void) fprintf (fptab, "\n# line %d \"%s\"\n", start_action->a_line, sysin);
+       fputs (start_action->a_data, fptab);
+    }
+
+
+    /*
+     * loop through and generate all the default values definitions
+     * and what ever else needs to be processed for all the entries
+     * e.g. external module references and coding function declarations
+     */
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       yp = sy->sy_type;
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (yp->yp_direction & (YP_ENCODER | YP_DECODER | YP_PRINTER)
+           || Aflag) {
+           gen_dflts(fptab, sy->sy_type, sy->sy_name);
+       }
+    }
+
+    (void) fprintf(fptab, "\n#define OFFSET(t,f)\t((int ) &(((t *)0)->f))\n\n");
+    (void) fprintf(fptab, "\n#define AOFFSET(t,f)\t((int ) (((t *)0)->f))\n\n");
+    nentries = 0;
+    /*
+     * generate tpe tables
+     */
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       yp = sy->sy_type;
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (yp->yp_direction & YP_ENCODER || Aflag) {
+           nentries++;
+           gen_enctbl(fptab, sy);
+       }
+    }
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       yp = sy->sy_type;
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (yp->yp_direction & YP_DECODER || Aflag)
+           gen_dectbl(fptab, sy);
+    }
+
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       yp = sy->sy_type;
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (yp->yp_direction & YP_PRINTER || Aflag)
+           gen_prnttbl(fptab, sy);
+    }
+
+    fphh = ffopen(inc);
+    (void) fprintf(fphh, "\nextern modtyp      %s%s%s;\n",
+           PREFIX, tab, MODTYP_SUFFIX);
+    out_final_defs(fphh);
+    close(fphh);
+
+    gen_actfunct(fptab);
+
+    gen_tpe(fptab);  /* generate table of pointers to tpe tables */
+
+    gen_modtype(fptab, nentries, encflag, decflag, prntflag);
+
+    if (final_action) {
+       (void) fprintf (fptab, "\n# line %d \"%s\"\n", final_action->a_line, sysin);
+       fputs (final_action->a_data, fptab);
+    }
+
+   gen_lint(fptab);
+
+   fclose(fptab);
+}
+
+/*
+ * generate the *-types.h file
+ */
+gen_typesfile(inc)
+char   *inc;
+{
+    int     encflag = 1, decflag = 1, prntflag = 1;
+    char   *buf, *act;
+    SY      sy;
+    YP      yp;
+    FILE   *fph, *fpe, *fpd, *fpp;
+    FILE   *fpa;
+
+    fph = ffopen(my_strcat(mymodule, HFILE1));
+    if (mflag) {
+       (void) fprintf (fph, "#ifndef\tPEPYPATH\n");
+       (void) fprintf (fph, "#include <isode/pepsy/%s>\n", inc);
+       (void) fprintf (fph, "#else\n");
+       (void) fprintf (fph, "#include \"%s\"\n", inc);
+       (void) fprintf (fph, "#endif\n\n\n");
+    }
+    else {
+       if (is_stand (inc))
+           (void) fprintf (fph, "#include <isode/pepsy/%s>\n", inc);
+       else
+           (void) fprintf (fph, "#include \"%s\"\n", inc);
+    }
+
+#ifdef ACT_CODE
+    act = my_strcat(mymodule, ACTIONDEFS);
+
+    fpe = ffopen(my_strcat(mymodule, ENCFILENAME));
+    file_header(fpe, act);
+    fpd = ffopen(my_strcat(mymodule, DECFILENAME));
+    file_header(fpd, act);
+    fpp = ffopen(my_strcat(mymodule, PRNTFILENAME));
+    file_header(fpp, act);
+    fpa = ffopen(act);
+#endif
+
+    /* define the macros to support posy functions */
+
+    fprintf(fph, "\n#ifndef\tlint\n");
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       eval = sy->sy_name;
+       yp = sy->sy_type;
+
+       if (sy->sy_module == NULLCP)
+           yyerror("no module name associated with symbol");
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (strcmp(sy->sy_module, mymodule)) {
+           fprintf(stderr, "mymodule unsuitable for module name e.g %s and %s(mymodule)\n", sy->sy_module, mymodule);
+           exit(1);
+       }
+       if (yp->yp_direction & YP_ENCODER || Aflag) {
+           buf = modsym (sy -> sy_module, sy -> sy_name, yyencdflt);
+           fprintf(fph, "#define %s", buf);
+           fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
+           fprintf(fph, "    %s(%s%s, ", ENCFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+           fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+           fprintf(fph, "pe, top, len, buffer, (char *) parm)\n\n");
+#ifdef ACT_CODE
+           if (encflag) {
+               fprintf(fpe, "%s%s", ENC_FNCNAME, tab);
+               open_func(fpe);
+               encflag--;
+           }
+#endif
+           if (bflag)
+               init_new_file();
+           if (bflag)
+               end_file();
+       }
+       if (yp->yp_direction & YP_DECODER || Aflag) {
+           buf = modsym (sy -> sy_module, sy -> sy_name, yydecdflt);
+           if (bflag)
+               init_new_file();
+           fprintf(fph, "#define %s", buf);
+           fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
+           fprintf(fph, "    %s(%s%s, ", DECFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+           fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+           fprintf(fph, "pe, top, len, buffer, (char **) parm)\n\n");
+#if ACT_CODE
+           if (decflag) {
+               fprintf(fpd, "%s%s", DEC_FNCNAME, tab);
+               open_func(fpd);
+               decflag--;
+           }
+#endif
+           if (bflag)
+               end_file();
+       }
+       if (yp->yp_direction & YP_PRINTER || Aflag) {
+           buf = modsym (sy -> sy_module, sy -> sy_name, yyprfdflt);
+           if (bflag)
+               init_new_file();
+           fprintf(fph, "#define %s", buf);
+           fprintf(fph, "(pe, top, len, buffer, parm) \\\n");
+           fprintf(fph, "    %s(%s%s, ", PRNTFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+           fprintf(fph, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+           fprintf(fph, "pe, top, len, buffer)\n");
+           fprintf(fph, "#define %s_P", buf);
+           fprintf(fph, "    %s%s, ", PREFIX,
+                   proc_name(sy->sy_name, 1));
+           fprintf(fph, "&%s%s%s\n\n", PREFIX, tab, MODTYP_SUFFIX);
+#ifdef  ACT_CODE
+           if (prntflag) {
+               fprintf(fpp, "%s%s", PRNT_FNCNAME, tab);
+               open_func(fpp);
+               prntflag--;
+           }
+#endif
+           if (bflag)
+               end_file();
+       }
+       if (!bflag && ferror(stdout))
+           myyerror("write error - %s", sys_errname(errno));
+    }
+    fprintf(fph, "\n#endif   /* lint */\n");
+
+#ifdef ACT_CODE
+    if (!encflag) {
+       close_func(fpe);
+    }
+    if (!decflag) {
+       close_func(fpd);
+    }
+    if (!prntflag) {
+       close_func(fpp);
+    }
+#endif
+
+    close(fph);
+#ifdef ACT_CODE
+    close(fpe);
+    close(fpd);
+    close(fpp);
+    close(fpa);
+#endif
+}
+
+
+gen_enctbl(fp, sy)
+FILE   *fp;
+SY      sy;
+{
+    YP yp;
+
+    yp = sy->sy_type;
+    fprintf(fp,"static tpe %s%s[] = {\n", ETABLE, proc_name(sy->sy_name, 0));
+    fprintf(fp, "\t{ PE_START, 0, 0, 0 },\n");
+
+    tenc_typ(fp, yp, sy->sy_name, NULLCP);
+
+    fprintf(fp, "\t{ PE_END, 0, 0, 0 }\n");
+    fprintf(fp, "\t};\n");
+    fprintf(fp, "\n");
+}
+
+gen_dectbl(fp, sy)
+FILE   *fp;
+SY      sy;
+{
+    YP yp;
+
+    yp = sy->sy_type;
+    fprintf(fp,"static tpe %s%s[] = {\n", DTABLE, proc_name(sy->sy_name, 0));
+    fprintf(fp, "\t{ PE_START, 0, 0, 0 },\n");
+
+    tdec_typ(fp, sy->sy_type, sy->sy_name, NULLCP);
+
+    fprintf(fp, "\t{ PE_END, 0, 0, 0 }\n");
+    fprintf(fp, "\t};\n");
+    fprintf(fp, "\n");
+}
+
+
+gen_prnttbl(fp, sy)
+FILE   *fp;
+SY      sy;
+{
+    YP yp;
+
+    yp = sy->sy_type;
+
+    fprintf(fp,"static ptpe %s%s[] = {\n",PTABLE, proc_name(sy->sy_name, 0));
+    fprintf(fp, "\t{ PE_START, 0, 0, 0, \"%s\" },\n", sy->sy_name);
+
+    tprnt_typ(fp, sy->sy_type, sy->sy_name, NULLCP);
+
+    fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL }\n");
+    fprintf(fp, "\t};\n");
+    fprintf(fp, "\n");
+}
+
+
+/*
+ * define the tpe index tables and the pointer table
+ */
+gen_tpe(fp)
+FILE   *fp;
+{
+    SY      sy;
+
+    fprintf(fp, "static tpe *etabl[] = {\n");
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       if (sy->sy_type->yp_flags & YP_IMPORTED)
+           continue;
+       if (sy->sy_type->yp_direction & YP_ENCODER || Aflag)
+           fprintf(fp, "\t%s%s,\n", ETABLE, proc_name(sy->sy_name, 0));
+    }
+    fprintf(fp, "\t};\n\n");
+
+    fprintf(fp, "static tpe *dtabl[] = {\n");
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       if (sy->sy_type->yp_flags & YP_IMPORTED)
+           continue;
+       if (sy->sy_type->yp_direction & YP_DECODER || Aflag)
+           fprintf(fp, "\t%s%s,\n", DTABLE, proc_name(sy->sy_name, 0));
+    }
+    fprintf(fp, "\t};\n\n");
+
+    fprintf(fp, "static ptpe *ptabl[] = {\n");
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       if (sy->sy_type->yp_flags & YP_IMPORTED)
+           continue;
+       if (sy->sy_type->yp_direction & YP_PRINTER || Aflag)
+           fprintf(fp, "\t%s%s,\n", PTABLE, proc_name(sy->sy_name, 0));
+    }
+    fprintf(fp, "\t};\n\n");
+
+    /* produce pointer table */
+    dump_ptrtab(fp);
+}
+
+/*
+ * output the module structure for this module
+ */
+gen_modtype(fp, no, f1, f2, f3)
+FILE   *fp;
+int     no;
+int     f1, f2, f3;
+{
+    if (!f1)
+       fprintf(fp, "extern PE\t%s%s();\n", ENC_FNCNAME, tab);
+    if (!f2)
+       fprintf(fp, "extern PE\t%s%s();\n", DEC_FNCNAME, tab);
+    if (!f3)
+       fprintf(fp, "extern PE\t%s%s();\n", PRNT_FNCNAME, tab);
+    fprintf(fp, "\n");
+    fprintf(fp, "modtyp %s%s%s = {\n", PREFIX, tab, MODTYP_SUFFIX);
+    fprintf(fp, "\t\"%s\",\n", mymodule);      /* name */
+    fprintf(fp, "\t%d,\n", no);                /* number of entries */
+                                       /* coding tables */
+    fprintf(fp, "\tetabl,\n");
+    fprintf(fp, "\tdtabl,\n");
+    fprintf(fp, "\tptabl,\n");
+                                       /* action tables */
+    if (e_actions > 0)
+       fprintf(fp, "\tefn_%s,\n", tab);
+    else
+       fprintf(fp, "\t0,\n");  /* no action code */
+
+    if (d_actions > 0)
+       fprintf(fp, "\tdfn_%s,\n", tab);
+    else
+       fprintf(fp, "\t0,\n");  /* no action code */
+
+    if (p_actions > 0)
+       fprintf(fp, "\tpfn_%s,\n", tab);
+    else
+       fprintf(fp, "\t0,\n");  /* no action code */
+
+    fprintf(fp, "\t%s%s%s,\n", PREFIX, PTR_TABNAME, tab);
+    fprintf(fp, "\t};\n\n");
+}
+
+/*
+ * open a file called name
+ */
+FILE   *
+ffopen(name)
+char   *name;
+{
+    FILE   *fp;
+
+    if ((fp = fopen(name, "w")) == NULL) {
+       fprintf(stderr, "Can't create the file %s", name);
+       exit(1);
+    }
+    return fp;
+}
+
+#ifdef ACT_CODE
+/*
+ * output the file prologue to the file specified by fp
+ */
+file_header(fp, act)
+FILE   *fp;
+char   *act;
+{
+    fprintf(fp, "#include %s\n", PSAP_DOT_H);
+    fprintf(fp, "#include \"%s\"\n", INCFILE1);
+    fprintf(fp, "#include \"%s\"\n", act);
+    fprintf(fp, "#include \"%s%s\"\n\n", mymodule, GENTYPES);
+    fprintf(fp, "#ifndef PEPYPARM\n");
+    fprintf(fp, "#define PEPYPARM char *\n");
+    fprintf(fp, "#endif\n");
+    fprintf(fp, "extern PEPYPARM NullParm;\n\n");
+}
+
+#endif
+
+/*
+ * output the function prologue to the file specified by fp
+ */
+open_func(fp)
+FILE   *fp;
+{
+
+    fprintf(fp, "(pe, parm, p, mod)\n");
+    fprintf(fp, "PE\tpe;\n");
+    fprintf(fp, "PEPYPARM\tparm;\n");
+    fprintf(fp, "tpe\t*p;\n");
+    fprintf(fp, "modtyp\t*mod;\n");
+    fprintf(fp, "{\n");
+    /* action 0 ???? */
+    fprintf(fp, "\tswitch (p->pe_ucode) {\n");
+}
+
+/*
+ * output the function epilogue to the file specified by fp
+ */
+close_func(fp)
+FILE   *fp;
+{
+    fprintf(fp, "\t\tdefault:\n");
+    fprintf(fp, "\t\t\tbreak;\n");
+    fprintf(fp, "\t}\n");
+    fprintf(fp, "\treturn OK;\n}\n\n");
+}
+
+/*
+ * print the table id_table
+ */
+print_table()
+{
+    int     i;
+    id_entry *t;
+
+    for (i = 0; i < TABLESIZE; i++) {
+       for (t = id_table[i]; t != NULL; t = t->next)
+           (void) printf("%s(%d) -->   ", t->r_value, t->def_value);
+       if (id_table[i] != NULL)
+           (void) printf("NULL -- %d\n", i);
+    }
+}
+static struct univ_typ univ_tab[] = {
+    {"EXTERNAL", "struct       type_UNIV_EXTERNAL      *", "EXTERNAL", 8, 0,
+    "UNIV", UNF_EXTMOD|UNF_HASDATA, YP_SEQLIST, },
+    {"GeneralString", "struct  qbuf    *", "OCTETSTRING", 27, 0,
+    "UNIV", 0, YP_OCT, },
+    {"GeneralisedTime", "struct        qbuf    *", "OCTETSTRING", 24, 0,
+    "UNIV", 0, YP_OCT, },
+    {"GeneralizedTime", "struct        qbuf    *", "OCTETSTRING", 24, 0,
+    "UNIV", 0, YP_OCT, },
+    {"GraphicString", "struct  qbuf    *", "OCTETSTRING", 25, 0,
+    "UNIV", 0, YP_OCT, },
+    {"IA5String", "struct      qbuf    *", "OCTETSTRING", 22, 0,
+    "UNIV", 0, YP_OCT, },
+    {"ISO646String", "struct   qbuf    *", "OCTETSTRING", 26, 0,
+    "UNIV", 0, YP_OCT, },
+    {"NumericString", "struct  qbuf    *", "OCTETSTRING", 18, 0,
+    "UNIV", 0, YP_OCT, },
+    {"PrintableString", "struct        qbuf    *", "OCTETSTRING", 19, 0,
+    "UNIV", 0, YP_OCT, },
+    {"TeletexString", "struct  qbuf    *", "OCTETSTRING", 20, 0,
+    "UNIV", 0, YP_OCT, },
+    {"T61String", "struct      qbuf    *", "OCTETSTRING", 20, 0,
+    "UNIV", 0, YP_OCT, },
+    {"UTCTime", "struct        qbuf    *", "OCTETSTRING", 23, 0,
+    "UNIV", 0, YP_OCT, },
+    {"UniversalTime", "struct  qbuf    *", "OCTETSTRING", 23, 0,
+    "UNIV", 0, YP_OCT, },
+    {"VideotexString", "struct qbuf    *", "OCTETSTRING", 21, 0,
+    "UNIV", 0, YP_OCT, },
+    {"VisibleString", "struct  qbuf    *", "OCTETSTRING", 26, 0,
+    "UNIV", 0, YP_OCT, },
+};
+
+extern struct univ_typ *simptyp();
+
+/*
+ * Determine wether the type name matches one of the Universal types
+ * which are to be treated specially. If so return a pointer to the
+ * data structure which contains the parameters describing how it
+ * should be processed
+ */
+struct univ_typ *
+univtyp(name)
+char   *name;
+{
+    int     low, high, i;
+    struct univ_typ *p;
+
+    low = 0;
+    high = NENTRIES(univ_tab) - 1;
+    while (low <= high) {
+       p = univ_tab + (low + high) / 2;
+       if ((i = scmp(name, p->univ_name)) == 0)
+           return (p);
+       if (low == high)
+           return (NULL);
+       if (i < 0)
+           high = p - univ_tab - 1;
+       else
+           low = p - univ_tab + 1;
+    }
+
+#if OPTIMISED
+    if ((p = simptyp(name)) == NULL)
+       return (p);
+#endif
+
+    return (NULL);
+}
+
+/*
+ * Compare two strings returning a number representing the character
+ * where they differ or 0 if are the same - I wrote this because I
+ * couldn't trust strcmp to work the same way between numbers and
+ * letters everywhere. longer strings are greater shorter strings
+ * numbers are greater then all letters lower case are greater then
+ * upper case There must be a better way !
+ */
+scmp(s1, s2)
+char   *s1, *s2;
+{
+    while (*s1 == *s2 && *s2)
+       s1++, s2++;
+    if (*s1 == '\0' && *s2 == '\0')
+       return (0);
+    if (*s1 == '\0')
+       return (-1);
+    if (*s2 == '\0')
+       return (1);
+    if (isalpha(*s1) && isalpha(*s2)) {
+       if (isupper(*s1) && isupper(*s2))
+           return (*s1 - *s2);
+       if (islower(*s1) && islower(*s1))
+           return (*s1 - *s2);
+       if (isupper(*s1))
+           return (-1);
+       if (islower(*s1))
+           return (1);
+    }
+    if (isdigit(*s1) && isdigit(*s2))
+       return (*s1 - *s2);
+    if (isdigit(*s1))
+       return (1);
+    if (isdigit(*s2))
+       return (-1);
+    return (*s1 - *s2);
+}
+
+/*
+ * lookup a symbol and return a pointer to it
+ */
+SY
+syfind(name)
+char   *name;
+{
+    SY      sy;
+
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       if (sy->sy_type->yp_flags & YP_IMPORTED)
+           continue;
+       if (strcmp(name, sy->sy_name) == 0)
+           return (sy);
+    }
+    return (NULL);
+}
+/*
+ * determine if the symbol is a simple type that is optimised
+ */
+struct univ_typ *
+simptyp(yp)
+YP      yp;
+{
+    struct univ_typ *p;
+    YP      y;
+
+    static struct univ_typ bitstring =
+    {"Bitstring", "struct      PElement        *", "BITSTRING", 3, 0},
+            octetstring =
+    {"GeneralString", "struct  qbuf    *", "OCTETSTRING", 4, 0},
+            oid =
+    {"Object Identifier", "struct      OIDentifier     *", "OBJIDENT", 6, 0},
+            obj =
+    {"Module", "struct OIDentifier     *",
+    "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 27, 0};
+
+#define MSTRING 30             /* number of Xs in the above string */
+
+    switch (yp->yp_code) {
+    case YP_BIT:
+    case YP_BITLIST:
+       return (&bitstring);
+
+    case YP_SEQ:
+    case YP_SET:
+    case YP_ANY:
+       return (&bitstring);
+
+    case YP_OCT:
+       return (&octetstring);
+
+    case YP_OID:
+       return (&oid);
+
+    case YP_IDEFINED:
+       strncpy(p->univ_tab, yp->yp_identifier, MSTRING);
+       return (&obj);
+
+
+    case YP_SEQLIST:
+    case YP_SETLIST:
+    case YP_CHOICE:
+
+    default:
+       return (NULL);
+    }
+}
+
+/*
+ * lookup a type name until you get something that is not a name
+ */
+YP
+lkup(yp)
+YP     yp;
+{
+    YP yp1;
+
+    if (yp == NULLYP)
+       return (yp);
+    
+    while (yp->yp_code == YP_IDEFINED) {
+        if ((yp1 = lookup_type(yp->yp_module, yp->yp_identifier)) == NULLYP)
+           return (yp);
+       yp = yp1;
+    }
+
+    return (yp);
+}
+/*
+ * compute the type of tag it should be given the tag and the type it is
+ * being applied to
+ */
+comptag(tag, yp)
+int    tag;
+YP     yp;
+{
+    static int warned = 0;
+    YP yp1;
+    struct univ_typ    *p;
+    int        code;
+
+    if (tag == 0)
+       return (0);
+    
+    yp1 = lkup(yp);
+
+    if (yp1->yp_code == YP_IDEFINED) {
+       if ((p = univtyp(yp1->yp_identifier)) == NULL
+         || p->univ_type <= YP_UNDF) {
+               switch (chkil(yp1->yp_identifier)) {
+               case ER_NORMAL:
+                   return (tag);
+
+               case ER_EXPLICIT:
+                   return (0);
+
+               default:
+                   break;
+               }
+                   
+           if (warned++ <= 3) {
+               ferrs(0, "\ncomptag:warning implicit tag of unknown type %s\n",
+                   yp1->yp_identifier);
+               ferr(0, "\tcomptag:treated as implicit\n");
+           }
+           return (tag);
+       }
+       code = p->univ_type;
+    } else {
+       code = yp1->yp_code;
+       if (code == YP_ANY && yp1->yp_flags & YP_WANTIMPLICIT)
+           return (tag);
+    }
+
+    if (code == YP_CHOICE || code == YP_ANY)
+       return (0);
+
+    return (tag);
+}
+
+/*
+ * Generate function definitions for all the macros so that lint
+ * can type check all thier uses
+ */
+gen_lint(fp)
+FILE   *fp;
+{
+    char   *buf; 
+    SY      sy;
+    YP      yp;
+
+    fprintf(fp, "\n#ifdef\tlint\n");
+    for (sy = mysymbols; sy; sy = sy->sy_next) {
+       eval = sy->sy_name;
+       yp = sy->sy_type;
+
+       if (sy->sy_module == NULLCP)
+           yyerror("no module name associated with symbol");
+       if (yp->yp_flags & YP_IMPORTED)
+           continue;
+       if (strcmp(sy->sy_module, mymodule)) {
+           fprintf(stderr,
+             "mymodule unsuitable for module name e.g %s and %s(mymodule)\n",
+             sy->sy_module, mymodule);
+           exit(1);
+       }
+       /* Encoding routine */
+       buf = modsym (sy -> sy_module, sy -> sy_name, yyencdflt);
+       fprintf(fp, "\n#undef %s\n", buf);
+       fprintf(fp, "int        %s", buf);
+       fprintf(fp, "(pe, top, len, buffer, parm)\n");
+       fprintf(fp, "PE     *pe;\n");
+       fprintf(fp, "int\ttop,\n\tlen;\n");
+       fprintf(fp, "char   *buffer;\n");
+       fprintf(fp, "%s *parm;\n", sym2type(sy));
+       fprintf(fp, "{\n  return (%s(%s%s, ",
+           ENCFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+       fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+       fprintf(fp, "pe, top, len, buffer,\n\t\t(char *) parm));\n}\n");
+
+       /* Decoding routine */
+       buf = modsym (sy -> sy_module, sy -> sy_name, yydecdflt);
+       fprintf(fp, "\n#undef %s\n", buf);
+       fprintf(fp, "int        %s", buf);
+       fprintf(fp, "(pe, top, len, buffer, parm)\n");
+       fprintf(fp, "PE\tpe;\n");
+       fprintf(fp, "int\ttop,\n       *len;\n");
+       fprintf(fp, "char  **buffer;\n");
+       fprintf(fp, "%s **parm;\n", sym2type(sy));
+       fprintf(fp, "{\n  return (%s(%s%s, ",
+           DECFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+       fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+       fprintf(fp, "pe, top, len, buffer,\n\t\t(char **) parm));\n}\n");
+
+       /* Printing routine */
+       buf = modsym (sy -> sy_module, sy -> sy_name, yyprfdflt);
+       fprintf(fp, "\n#undef %s\n/* ARGSUSED */\n", buf);
+       fprintf(fp, "int        %s", buf);
+       fprintf(fp, "(pe, top, len, buffer, parm)\n");
+       fprintf(fp, "PE\tpe;\n");
+       fprintf(fp, "int\ttop,\n       *len;\n");
+       fprintf(fp, "char  **buffer;\n");
+       fprintf(fp, "%s *parm;\n", sym2type(sy));
+       fprintf(fp, "{\n  return (%s(%s%s, ",
+           PRNTFNCNAME, PREFIX, proc_name(sy->sy_name, 1));
+       fprintf(fp, "&%s%s%s, ", PREFIX, tab, MODTYP_SUFFIX);
+       fprintf(fp, "pe, top, len, buffer));\n}\n");
+
+       if (ferror(fp))
+           myyerror("write error - %s", sys_errname(errno));
+    }
+    fprintf(fp, "\n#endif\t/* lint */\n");
+}
+
+/*
+ * pointer table support routines
+ */
+static char    *ptr_tab[MAXPTRS];      /* reference of the pointer */
+static int     ptr_cnt = 0;
+
+/*
+ * add the given pointer to the pointer table and return its index
+ */
+addptr(p)
+char   *p;
+{
+    int        ind;
+    register int i;
+    register char *s;
+
+    /*
+     * try to eliminate common pointers by returning a ponter if it matches
+     * previously
+     */
+    for (i = 0; i < ptr_cnt; i++)
+       if (strcmp(p, ptr_tab[i]) == 0)
+            return (i);
+
+    if (ptr_cnt >= MAXPTRS) {
+       fprintf(stderr, "\npointer table overflow %d\n", ptr_cnt);
+       exit(1);
+    }
+
+    if ((s = malloc ((unsigned) (strlen (p) + 1))) == NULLCP) {
+       fprintf(stderr, "\naddptr:out of memory\n");
+       exit(1);
+    }
+    (void) strcpy (s, p);
+
+    ptr_tab[ind = ptr_cnt++] = s;
+
+    return (ind);
+}
+
+
+dump_ptrtab(fp)
+FILE   *fp;
+{
+    int                i;
+
+
+    fprintf(fp, "\n/* Pointer table %d entries */\n", ptr_cnt);
+    fprintf(fp, "static caddr_t %s%s%s[] = {\n", PREFIX, PTR_TABNAME, tab);
+
+    for (i = 0; i < ptr_cnt; i++)
+       fprintf(fp, "    (caddr_t ) %s,\n", ptr_tab[i]);
+    
+    if (ptr_cnt <= 0)
+       fprintf(fp, "    (caddr_t ) 0,\n");     /* for fussy C compilers */
+
+    fprintf(fp, "};\n");
+}
+
+/*
+ * routines to parse and analyse C types to support the pepy-like extensions
+ * of pepsy
+ */
+
+/*
+ * remove a level of indirection from the given type. If possible. if not
+ * return NULLCP, otherwise return the new type in a temporary buffer
+ */
+char   *
+rm_indirect(p)
+char   *p;
+{
+    static char        buf[STRSIZE];
+    int                i;
+
+    if (p == NULLCP || *p == '\0' || (i = strlen(p)) >= STRSIZE)
+       return (NULLCP);
+
+    strncpy(buf, p, STRSIZE);
+
+    for (; i >= 0; i--) {
+       if (buf[i] == '*') {
+           buf[i] = '\0';
+           return (buf);
+       }
+    }
+
+    return (NULLCP);
+
+}
+
+/*
+ * extract the field from the C arguement and the following constant
+ * expression for the bit number. 
+ * if it fails return NULLCP
+ */
+char   *
+getfldbit(p, pstr)
+register char *p;
+char **pstr;
+{
+    static char buf[STRSIZE];
+
+    if (p == NULLCP || pstr == (char **)0)
+       return (NULLCP);
+
+    if ((p = getidordot(p, buf, STRSIZE)) == NULLCP)
+       return (NULLCP);
+
+    while (*p && isspace(*p))
+       p++;
+    
+    if (*p != '$') {   /* must be a -> */
+
+       if (strncmp(p, "->", 2) != 0)
+           return (NULLCP);
+       
+       p += 2;
+
+       if ((p = getidordot(p, buf, STRSIZE)) == NULLCP)
+           return (NULLCP);
+
+       while (*p && isspace(*p))
+           p++;
+       
+       if (*p != '$')
+           return (NULLCP);
+    }
+
+    *pstr = p + 1;     /* have to leave it up to the compiler to verify the
+                        * constant expression for the bit number
+                        */
+    return (buf);
+}
+
+/* return a pointer after the current batch of white space if any */
+char   *
+skipspace(p)
+char   *p;
+{
+    if (p == NULLCP)
+        return (NULLCP);
+
+    while (*p && isspace(*p))
+       p++;
+
+    return (p);
+}
+
+/*
+ * extract the field from the C arguement and return it in a static buffer
+ * else return NULLCP
+ */
+char   *
+getfield(p)
+register char *p;
+{
+    static char buf[STRSIZE];
+    char       *buf1;
+
+    if (p == NULLCP)
+       return (NULLCP);
+
+    while (*p && isspace(*p))
+       p++;
+    
+    if (*p == '*')     /* to support *parm field */
+       return (p);
+
+    if ((p = getidordot(p, buf, STRSIZE)) == NULLCP)
+       return (NULLCP);
+
+    while (*p && isspace(*p))
+       p++;
+    
+    if (*p == '\0')
+       return (buf);
+
+    if (strncmp(p, "->", 2) != 0)
+       return (NULLCP);
+    
+    p += 2;
+
+    /* if we have an & keep it on the field */
+    if (*buf == '&')
+       buf1 = buf + 1;
+    else
+       buf1 = buf;
+
+    if ((p = getidordot(p, buf1, STRSIZE)) == NULLCP)
+       return (NULLCP);
+
+    while (*p && isspace(*p))
+       p++;
+    
+    if (*p == '\0')
+       return (buf);
+
+    return (NULLCP);
+}
+
+/*
+ * get an identifier into the given buffer [A-Za-z_] are legal chars
+ */
+char   *
+getid(p, buf, len)
+register char  *p;
+register char  *buf;
+register int   len;
+{
+    char       *fbuf;
+
+    fbuf = buf;
+
+    while (*p && isspace(*p))
+       p++;
+    
+    while (*p && (isalnum(*p) || *p == '_')) {
+       if (len-- >= 0)
+           *buf++ = *p;
+       p++;
+    }
+
+    if (fbuf == buf)
+       return (NULLCP);
+
+    *buf = '\0';
+
+    return (p);
+
+}
+
+/*
+ * get an identifier into the given buffer - '.' are considered part of an 
+ * identifier - should really be called get field reference
+ */
+char   *
+getidordot(p, buf, len)
+register char  *p;
+register char  *buf;
+register int   len;
+{
+    char       *fbuf;
+
+    fbuf = buf;
+
+    while (*p && isspace(*p))
+       p++;
+    
+    if (*p == '&') {
+       len--;
+       *buf++ = *p++;
+
+       while (*p && isspace(*p))
+           p++;
+    }
+
+    while (*p && (isalnum(*p) || *p == '_' || *p == '.')) {
+       if (len-- >= 0)
+           *buf++ = *p;
+       p++;
+    }
+
+    if (fbuf == buf)
+       return (NULLCP);
+
+    *buf = '\0';
+
+    return (p);
+
+}
+static char *noindstr[] = {
+       "*", "*parm", "&", "&parm",
+       NULLCP
+       };
+
+/*
+ * determine if the given field means no indirection wanted and so return 1
+ * else return 0
+ */
+noindirect(f)
+char   *f;
+{
+    char *p, **ps;
+    int                l;
+
+    if (f == NULLCP)
+       return (1);
+
+    f = skipspace(f);
+
+    if (f == NULLCP)
+       return (1);
+
+    if (*f == '&')
+       return (1);
+
+    for (p = f; *p && !isspace(*p); p++)
+       ;
+    l = p - f;
+
+    for (ps = noindstr; *ps; ps++)
+       if (l == strlen(*ps) && strncmp(f, *ps, l) == 0)
+           return (1);
+    
+    return (0);
+}
+
+/*
+ * process the T - the Type and field specifier
+ * the given YP to the appropriate values for VALTYPE string
+ * Namely the yp_parm_type to contain the (Parameter) type string.
+ * then if there is a $ the yp_parm to the part after the $, the field
+ */
+setvaltype(yp, str)
+YP     yp;
+char   *str;
+{
+    char *p;
+
+    if (str == NULLCP || *(str = skipspace(str)) == '\0')
+       return (0);
+    
+    if (p = index(str, '$')) {
+       *p++ = '\0';
+       p = skipspace(p);
+       yp->yp_parm = strdup(p);
+       yp->yp_flags |= YP_PARMVAL;
+    }
+
+    yp->yp_param_type = strdup(str);
+
+    return (1);
+
+}
+
+
+/*
+ * generate the functions that carry out the action statements
+ */
+gen_actfunct(fp)
+FILE   *fp;
+{
+    SY sy;
+    YP yp;
+    Action     act;
+
+    if (e_actions > 0) {
+       (void) fprintf(fp, "\n/*VARARGS*/");
+       (void) fprintf(fp, "\nstatic\tint\nefn_%s(__p, ppe, _Zp)\ncaddr_t       __p;\n", tab);
+       (void) fprintf(fp, "PE  *ppe;\ntpe      *_Zp;\n{\n");
+       (void) fprintf(fp, "\t\t\n\t/* %d cases */\n    switch(_Zp->pe_ucode) {\n",
+           e_actions);
+       for (sy = mysymbols; sy; sy = sy->sy_next) {
+           yp = sy->sy_type;
+           if (yp->yp_flags & YP_IMPORTED)
+               continue;
+           
+           if (yp->yp_direction & YP_ENCODER || Aflag)
+               gen_actions(fp, yp, G_ENC);
+
+       }
+       (void) fprintf(fp,
+"    default:\n        return (pepsylose(NULLMODTYP, _Zp, *ppe, \"enf_%s:Bad table entry: %%d\",\n             _Zp->pe_ucode));\n",
+               tab);
+       (void) fprintf(fp, "\t\t}\t/* switch */\n    return (OK);\n}\n");
+    }
+    if (d_actions > 0) {
+       (void) fprintf(fp, "\n/*VARARGS*/");
+       (void) fprintf(fp, "\nstatic\tint\ndfn_%s(__p, pe, _Zp, _val)\ncaddr_t  __p;\n", tab);
+       (void) fprintf(fp, "PE  pe;\ntpe        *_Zp;\nint _val;\n{\n");
+       (void) fprintf(fp, "\t\t\n\t/* %d cases */\n    switch(_Zp->pe_ucode) {\n",
+           d_actions);
+       for (sy = mysymbols; sy; sy = sy->sy_next) {
+           yp = sy->sy_type;
+           if (yp->yp_flags & YP_IMPORTED)
+               continue;
+           
+            if (yp->yp_direction & YP_DECODER || Aflag)
+                gen_actions(fp, yp, G_DEC);
+
+       }
+       (void) fprintf(fp,
+"    default:\n        return (pepsylose(NULLMODTYP, _Zp, pe, \"dnf_%s:Bad table entry: %%d\",\n            _Zp->pe_ucode));\n",
+               tab);
+       (void) fprintf(fp, "\t\t}\t/* switch */\n    return (OK);\n}\n");
+    }
+    if (p_actions > 0) {
+       (void) fprintf(fp, "\n/*VARARGS*/");
+       (void) fprintf(fp, "\nstatic\tint\npfn_%s(pe, _Zp)\n", tab);
+       (void) fprintf(fp, "PE  pe;\ntpe        *_Zp;\n{\n");
+       (void) fprintf(fp, "\t\t\n\t/* %d cases */\n    switch(_Zp->pe_ucode) {\n",
+           p_actions);
+       for (sy = mysymbols; sy; sy = sy->sy_next) {
+           yp = sy->sy_type;
+
+           if (yp->yp_flags & YP_IMPORTED)
+               continue;
+           
+           if (yp->yp_direction & YP_PRINTER || Aflag)
+               gen_actions(fp, yp, G_PNT);
+
+       }
+       (void) fprintf(fp,
+"    default:\n        return (pepsylose(NULLMODTYP, _Zp, NULLPE, \"pnf_%s:Bad table entry: %%d\",\n            _Zp->pe_ucode));\n",
+               tab);
+       (void) fprintf(fp, "\t\t}\t/* switch */\n    return (OK);\n}\n");
+    }
+}
+
+#define GEN_RETURN 1
+#define GEN_ASSIGN 2
+/*
+ * generate the actions for this YP unit and all its children
+ */
+gen_actions(fp, oyp, form)
+FILE   *fp;
+YP     oyp;
+int    form;   /* what type of action is it */
+{
+    register YP        yp;
+    register YAL       yal;
+    register Action    act;
+
+    for (yp = oyp; yp; yp = yp->yp_next) {
+
+       /* do its actions first then any of its children */
+       if (yal = yp->yp_bef_alist)
+           dumpact(fp, yal, form, 0);
+       if (yal = yp->yp_aft_alist)
+           dumpact(fp, yal, form, 0);
+       if (yal = yp -> yp_control_act) {
+           if (form == G_ENC)
+               dumpact (fp, yal,form, GEN_RETURN);
+           else if (form == G_DEC)
+               dumpact (fp, yal, form, GEN_ASSIGN);
+       }
+       if (yal = yp -> yp_optional_act) {
+           if (form == G_ENC)
+               dumpact (fp, yal,form, GEN_RETURN);
+           else if (form == G_DEC)
+               dumpact (fp, yal, form, 0);
+       }
+
+       switch (yp->yp_code) {
+       case YP_SEQTYPE:
+       case YP_SEQLIST:
+       case YP_SETTYPE:
+       case YP_SETLIST:
+       case YP_CHOICE:
+           gen_actions(fp, yp->yp_type, form);
+           break;
+
+       default:
+          break;
+       }
+    }
+}
+/*
+ * dump out a single action
+ */
+dumpact(fp, yal, form, ret)
+FILE   *fp;
+YAL    yal;
+int    form;
+int    ret;
+{
+    char       *comm = yal->yal_comment;
+    char       *type = yal->yal_type;
+    Action     act;
+    char       buf[STRSIZE];
+
+    if (strlen(type) > STRSIZE)
+       ferr(1, "dumpact:type too big \"%s\"\n bye\n", type);
+    strncpy(buf, type, STRSIZE);
+    if (form != G_DEC)
+       strncat(buf, "*", STRSIZE);
+    else
+       strncat(buf, "**", STRSIZE);
+    type = buf;
+    switch (form) {
+    case G_ENC:
+       act = yal->yal_enc;
+       break;
+    case G_DEC:
+       act = yal->yal_dec;
+       break;
+    case G_PNT:
+       act = yal->yal_prn;
+       break;
+    }
+
+    /* can't tell wether this table has the UCODE till here */
+    if (act == NULLAction || act -> a_line == -1)
+       return;
+
+    if (form != G_PNT)
+       (void) fprintf(fp, "\n#define parm      ((%s )__p)\n\tcase %d: /* %s */\n",
+                   type, act->a_num, comm ? comm : "");
+    else 
+       (void) fprintf(fp, "\n\tcase %d: /* %s */\n", act->a_num, comm ? comm : "");
+
+    (void) fprintf(fp, "\t\t{\n# line %d \"%s\"\n", act->a_line, sysin);
+
+    switch (ret) {
+    case GEN_ASSIGN:
+       if (control_act (act) == -1)
+           fprintf (fp, "\t\t/* ignored - empty expression */\n");
+       else fprintf (fp, "\t\t(%s) = _val;\n", act -> a_data);
+       break;
+    case GEN_RETURN:
+       fprintf (fp, "\t\treturn (%s);\n",act -> a_data);
+       break;
+    default:
+       fputs (act -> a_data, fp);
+       putc (';', fp);
+       break;
+    }
+
+    (void) fprintf(fp, "\n\t\t}\n\t    break;\n");
+
+    if (form != G_PNT)
+       (void) fprintf(fp, "\n#undef parm\n");
+    act -> a_line = -1;                /* mark as done */
+}
+
+/*
+ * produce a temporary copy of the type specified in the ParameterType
+ * specification
+ * i.e. a [[ P type ]] specification
+ */
+char   *
+partyp2str(yp)
+YP     yp;
+{
+    char *p;
+
+    if (yp->yp_param_type == NULLCP) {
+       fprintf(stderr, "\npartyp2str no param_type field\n");
+       exit(1);
+    }
+
+    if ((p = rm_indirect(yp->yp_param_type)) == NULLCP) {
+       fprintf(stderr, "\npartyp2str can't extract direct type from %s\n",
+           yp->yp_param_type);
+       exit(1);
+    }
+
+    return (p);
+}
+/*
+ * produce a string giving the type of a symbol, in a static buffer
+ */
+char   *
+sym2type(sy)
+SY     sy;
+{
+    static char buffer[STRSIZE];
+
+    if (sy->sy_type && sy->sy_type->yp_param_type)
+       return (partyp2str(sy->sy_type));
+
+    sprintf(buffer, "struct %s", modsym(sy->sy_module, sy->sy_name, "type"));
+
+    return (buffer);
+}
diff --git a/usr/src/contrib/isode/pepsy/pep.output b/usr/src/contrib/isode/pepsy/pep.output
new file mode 100644 (file)
index 0000000..f0f8f9f
--- /dev/null
@@ -0,0 +1,7842 @@
+before encoding INTEGER 7
+before encoding OCTET STRING "The quick"
+before encoding BIT STRING: 0011000
+After Bitstring encoding:'0011000'B
+After Sequence encoding:
+{
+   7,
+   "The quick",
+   '0011000'B
+}
+before encoding INTEGER 6
+before encoding OCTET STRING "brown"
+before encoding BIT STRING: 001100
+After Bitstring encoding:'001100'B
+After Sequence encoding:
+{
+   6,
+   "brown",
+   '001100'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 10
+before encoding OCTET STRING "The quick"
+before encoding BIT STRING: 0011000100
+After Bitstring encoding:'0011000100'B
+After Sequence encoding:
+{
+   10,
+   "The quick",
+   '0011000100'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 9
+before encoding OCTET STRING "brown"
+before encoding BIT STRING: 001100010
+After Bitstring encoding:'001100010'B
+After Sequence encoding:
+{
+   9,
+   "brown",
+   '001100010'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 8
+before encoding OCTET STRING "fox jumps over"
+before encoding BIT STRING: 00110001
+After Bitstring encoding:'00110001'B
+After Sequence encoding:
+{
+   8,
+   "fox jumps over",
+   '00110001'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 7
+before encoding OCTET STRING "The Lazy"
+before encoding BIT STRING: 0011000
+After Bitstring encoding:'0011000'B
+After Sequence encoding:
+{
+   7,
+   "The Lazy",
+   '0011000'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 6
+before encoding OCTET STRING "dog"
+before encoding BIT STRING: 001100
+After Bitstring encoding:'001100'B
+After Sequence encoding:
+{
+   6,
+   "dog",
+   '001100'B
+}
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 7
+r_ostring "The quick"
+r_bstring: 0011000
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 6
+r_ostring "brown"
+r_bstring: 001100
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 10
+r_ostring "The quick"
+r_bstring: 0011000100
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 9
+r_ostring "brown"
+r_bstring: 001100010
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 8
+r_ostring "fox jumps over"
+r_bstring: 00110001
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 7
+r_ostring "The Lazy"
+r_bstring: 0011000
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 6
+r_ostring "dog"
+r_bstring: 001100
+After Decoding CHOICE: chosen 1
+After Decoding UAction
+
+"Action Statements" t_test = 3
+{
+   a {
+      6,
+      3
+   },
+   b {
+      {
+         a 7,
+         b "The quick",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "brown",
+         c '001100'B
+      }
+   },
+   c {
+      6,
+      3
+   },
+   d {
+      {
+         a 10,
+         b "The quick",
+         c '0011000100'B
+      },
+      {
+         a 9,
+         b "brown",
+         c '001100010'B
+      },
+      {
+         a 8,
+         b "fox jumps over",
+         c '00110001'B
+      },
+      {
+         a 7,
+         b "The Lazy",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "dog",
+         c '001100'B
+      }
+   },
+   e {
+      -1
+   }
+}
+before encoding INTEGER 5
+before encoding OCTET STRING "The quick"
+before encoding BIT STRING: 00110
+After Bitstring encoding:'00110'B
+After Sequence encoding:
+{
+   5,
+   "The quick",
+   '00110'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 7
+before encoding OCTET STRING "The quick"
+before encoding BIT STRING: 0011000
+After Bitstring encoding:'0011000'B
+After Sequence encoding:
+{
+   7,
+   "The quick",
+   '0011000'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 6
+before encoding OCTET STRING "brown"
+before encoding BIT STRING: 001100
+After Bitstring encoding:'001100'B
+After Sequence encoding:
+{
+   6,
+   "brown",
+   '001100'B
+}
+encoding SET OF Rep-action
+before encoding INTEGER 5
+before encoding OCTET STRING "fox jumps over"
+before encoding BIT STRING: 00110
+After Bitstring encoding:'00110'B
+After Sequence encoding:
+{
+   5,
+   "fox jumps over",
+   '00110'B
+}
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 5
+r_ostring "The quick"
+r_bstring: 00110
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 7
+r_ostring "The quick"
+r_bstring: 0011000
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 6
+r_ostring "brown"
+r_bstring: 001100
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 5
+r_ostring "fox jumps over"
+r_bstring: 00110
+After Decoding CHOICE: chosen 3
+After Decoding UAction
+
+"Action Statements" t_test = 2
+{
+   a {
+      3
+   },
+   b {
+      {
+         a 5,
+         b "The quick",
+         c '00110'B
+      }
+   },
+   c {
+      3
+   },
+   d {
+      {
+         a 7,
+         b "The quick",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "brown",
+         c '001100'B
+      },
+      {
+         a 5,
+         b "fox jumps over",
+         c '00110'B
+      }
+   },
+   e {
+      "lets go home"
+   }
+}
+encoding SET OF Rep-action
+before encoding INTEGER 4
+before encoding OCTET STRING "The quick"
+before encoding BIT STRING: 0011
+After Bitstring encoding:'0011'B
+After Sequence encoding:
+{
+   4,
+   "The quick",
+   '0011'B
+}
+encoding Boolean 0
+Before Decoding Rep-action
+After Decoding Rep-action:
+rp_int 4
+r_ostring "The quick"
+r_bstring: 0011
+Decoding Boolean
+After Decoding CHOICE: chosen 2
+After Decoding UAction
+
+"Action Statements" t_test = 1
+{
+   a {},
+   b {},
+   c {},
+   d {
+      {
+         a 4,
+         b "The quick",
+         c '0011'B
+      }
+   },
+   e {
+      FALSE
+   }
+}
+
+"All Simple Types" t_test = 3
+{
+   a {
+      a 'ff'H,
+      b "\b",
+      d "\n",
+      "hello there, world\n"
+   },
+   b 5,
+   c 5,
+   d 5,
+   e "hello there, world\n",
+   f "hello world\n",
+   g "hello world\n",
+   h 1.17,
+   i 1.17,
+   j 1.17,
+   k 'ff'H,
+   l '000100100011000100011010001101110'B,
+   m 9.42479,
+   n TRUE
+}
+
+"All Simple Types" t_test = 2
+{
+   a {
+      a 'ff'H,
+      c 'ff'H,
+      e 0
+   },
+   b 3,
+   c 3,
+   d 3,
+   e "hello world\n",
+   f "hello world\n",
+   g "hello world\n",
+   h 1.17.45.49,
+   i 1.17.45.49,
+   j 1.17.45.49,
+   k '00'H,
+   l '00010010001100010001101000110111'B,
+   m 6.28319,
+   n FALSE
+}
+
+"All Simple Types" t_test = 1
+{
+   a {
+      b '00'H,
+      d '00'H,
+      e -1,
+      "hello there, world\n"
+   },
+   b 1,
+   c 1,
+   d 1,
+   e "hello there, world\n",
+   f "hello world\n",
+   g "hello world\n",
+   h 1.17,
+   i 1.17,
+   j 1.17,
+   k 'ff'H,
+   l '0001001000110001000110100011011'B,
+   m 3.1416,
+   n TRUE
+}
+
+"function calling code" t_test = 3
+{
+   a 'ff'H,
+   b '00'H,
+   c "\b",
+   d "\n",
+   e 2,
+   f "hello there, world\n",
+   left {
+      a 'ff'H,
+      b '00'H,
+      d "\n",
+      e 2,
+      "hello there, world\n"
+   },
+   right {
+      a 'ff'H,
+      b "\b",
+      d "\n",
+      "hello there, world\n"
+   }
+}
+
+"function calling code" t_test = 2
+{
+   a '00'H,
+   b 'ff'H,
+   c 'ff'H,
+   d "\t",
+   f "hello world\n",
+   left {
+      a '00'H,
+      c 'ff'H
+   },
+   right {
+      a 'ff'H,
+      c 'ff'H,
+      e 0
+   }
+}
+
+"function calling code" t_test = 1
+{
+   a 'ff'H,
+   b '00'H,
+   c '00'H,
+   d "\b",
+   e 0,
+   f "hello there, world\n",
+   left {
+      b '00'H,
+      d "\b",
+      e 0,
+      "hello there, world\n"
+   },
+   right {
+      b '00'H,
+      d '00'H,
+      e -1,
+      "hello there, world\n"
+   }
+}
+
+"Value Passing Defined types" t_test = 3
+{
+   "hello there, world\n",
+   b "Some one is out there!",
+   '00313233343536'H,
+   '0000000000110001001100100011'B,
+   [PRIVATE 577] '18'H,
+   '000100100011000100011010001101110010'B,
+   9357,
+   1.73205,
+   1.17.42,
+   TRUE,
+   4
+}
+
+"Value Passing Defined types" t_test = 2
+{
+   "hello there, world\n",
+   b "Some one is out there!",
+   '003132333435'H,
+   '00000000001100010011'B,
+   [PRIVATE 16] {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H,
+      [PRIVATE 50] 'ff'H,
+      [PRIVATE 65] "\b",
+      [PRIVATE 82] "\t",
+      [PRIVATE 101] "\n",
+      [PRIVATE 122] '0b'H,
+      [PRIVATE 145] "mkpelist:testdata",
+      [PRIVATE 170] "mkpelist:testdata",
+      [PRIVATE 197] '0010'H,
+      [PRIVATE 226] '0010'H,
+      [PRIVATE 15] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H
+      }
+   },
+   '00010010001100010001101000110111001'B,
+   9356,
+   1.41421,
+   1.17,
+   FALSE,
+   3
+}
+
+"Value Passing Defined types" t_test = 1
+{
+   "hello there, world\n",
+   b "Some one is out there!",
+   '0031323334'H,
+   '000000000011'B,
+   [PRIVATE 101] "\n",
+   '0001001000110001000110100011011100'B,
+   9355,
+   1,
+   1.17,
+   TRUE,
+   2
+}
+
+"Repeating pepy elements" t_test = 3
+{
+   a {
+      6,
+      3
+   },
+   b {
+      {
+         a 7,
+         b "The quick",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "brown",
+         c '001100'B
+      }
+   },
+   c {
+      6,
+      3
+   },
+   d {
+      {
+         a 10,
+         b "The quick",
+         c '0011000100'B
+      },
+      {
+         a 9,
+         b "brown",
+         c '001100010'B
+      },
+      {
+         a 8,
+         b "fox jumps over",
+         c '00110001'B
+      },
+      {
+         a 7,
+         b "The Lazy",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "dog",
+         c '001100'B
+      }
+   },
+   e {
+      -1
+   }
+}
+
+"Repeating pepy elements" t_test = 2
+{
+   a {
+      3
+   },
+   b {
+      {
+         a 5,
+         b "The quick",
+         c '00110'B
+      }
+   },
+   c {
+      3
+   },
+   d {
+      {
+         a 7,
+         b "The quick",
+         c '0011000'B
+      },
+      {
+         a 6,
+         b "brown",
+         c '001100'B
+      },
+      {
+         a 5,
+         b "fox jumps over",
+         c '00110'B
+      }
+   },
+   e {
+      "lets go home"
+   }
+}
+
+"Repeating pepy elements" t_test = 1
+{
+   a {},
+   b {},
+   c {},
+   d {
+      {
+         a 4,
+         b "The quick",
+         c '0011'B
+      }
+   },
+   e {
+      FALSE
+   }
+}
+
+"Compound S-types" t_test = 3
+{
+   a {},
+   b {
+      [2] 12357
+   },
+   c {},
+   d {
+      [4] 4
+   }
+}
+
+"Compound S-types" t_test = 2
+{
+   a {
+      12356
+   },
+   b {},
+   c {
+      3
+   },
+   d {}
+}
+
+"Compound S-types" t_test = 1
+{
+   a {},
+   b {
+      [2] 12355
+   },
+   c {},
+   d {
+      [4] 2
+   }
+}
+
+"Pepy Stuff" t_test = 3
+{
+   12357,
+   4,
+   "Some is out there!",
+   "hello, world\n",
+   '00313233343536'H,
+   '00010010001100010001101000110111001010100'B,
+   '0000000000110001001100100011'B,
+   TRUE,
+   1.17.42,
+   3.06998,
+   [PRIVATE 730] '0010'H,
+   {
+      [1] 12357,
+      12357,
+      4,
+      [4] 4,
+      "hello, world\n",
+      [8] "hello, world\n",
+      '00313233343536'H,
+      [10] '00313233343536'H,
+      1.17.42,
+      [18] 1.17.42,
+      3.06998,
+      [20] 3.06998,
+      [21] '0010'H
+   },
+   [13] {
+      [2] 12357,
+      [4] 4,
+      "Some is out there!",
+      [6] "Some is out there!",
+      "hello, world\n",
+      [8] "hello, world\n",
+      '00313233343536'H,
+      [10] '00313233343536'H,
+      '00010010001100010001101000110111001010101'B,
+      [12] '00010010001100010001101000110111001010101'B,
+      '00000000001100010011001000110011'B,
+      [16] TRUE,
+      1.17.42,
+      3.06998,
+      [PRIVATE 730] '0010'H
+   }
+}
+
+"Pepy Stuff" t_test = 2
+{
+   12356,
+   3,
+   "Some is out there!",
+   "hello, world\n",
+   '003132333435'H,
+   '00010010001100010001101000110111001010100'B,
+   '00000000001100010011'B,
+   FALSE,
+   1.17,
+   2.50663,
+   [PRIVATE 362] 'ff'H,
+   {
+      [1] 12356,
+      12356,
+      "hello, world\n",
+      [8] "hello, world\n",
+      '003132333435'H,
+      [10] '003132333435'H,
+      '000000000011000100110010'B,
+      FALSE,
+      [16] FALSE,
+      1.17,
+      [18] 1.17,
+      2.50663,
+      [20] 2.50663,
+      [21] 'ff'H
+   },
+   [13] {
+      12356,
+      3,
+      "Some is out there!",
+      [6] "Some is out there!",
+      "hello, world\n",
+      [8] "hello, world\n",
+      '003132333435'H,
+      [10] '003132333435'H,
+      '00010010001100010001101000110111001010101'B,
+      [12] '00010010001100010001101000110111001010101'B,
+      '000000000011000100110010'B,
+      FALSE,
+      1.17,
+      [19] 2.50663,
+      [PRIVATE 362] 'ff'H
+   }
+}
+
+"Pepy Stuff" t_test = 1
+{
+   12355,
+   2,
+   "Some is out there!",
+   "hello, world\n",
+   '0031323334'H,
+   '00010010001100010001101000110111001010100'B,
+   '000000000011'B,
+   TRUE,
+   1.17,
+   1.77245,
+   [PRIVATE 122] '0b'H,
+   {
+      [1] 12355,
+      12355,
+      2,
+      [4] 2,
+      "hello, world\n",
+      [8] "hello, world\n",
+      '0031323334'H,
+      [10] '0031323334'H,
+      '0000000000110001'B,
+      1.17,
+      [18] 1.17,
+      1.77245,
+      [20] 1.77245,
+      [21] '0b'H
+   },
+   [13] {
+      [2] 12355,
+      [4] 2,
+      "Some is out there!",
+      [6] "Some is out there!",
+      "hello, world\n",
+      [8] "hello, world\n",
+      '0031323334'H,
+      [10] '0031323334'H,
+      '00010010001100010001101000110111001010101'B,
+      [12] '00010010001100010001101000110111001010101'B,
+      '0000000000110001'B,
+      [16] TRUE,
+      1.17,
+      1.77245,
+      [PRIVATE 122] '0b'H
+   }
+}
+
+"Tests of Real type" t_test = 4
+{
+   r1 927640,
+   r2 0,
+   r3 -2.28789,
+   r4 927640
+}
+
+"Tests of Real type" t_test = 3
+{
+   r1 -2.28789,
+   r2 927640,
+   r3 0,
+   r4 3.1416,
+   r5 927640
+}
+
+"Tests of Real type" t_test = 2
+{
+   r1 0,
+   r2 -2.28789,
+   r3 927640,
+   r4 0,
+   r5 -2.28789
+}
+
+"Tests of Real type" t_test = 1
+{
+   r1 927640,
+   r2 0,
+   r3 -2.28789,
+   r4 3.1416
+}
+
+"Real" t_test = 3
+-2.28789
+
+"Real" t_test = 2
+0
+
+"Real" t_test = 1
+927640
+
+"Tests of Enumerated type" t_test = 4
+{
+   ae1 0,
+   ae2 1,
+   ae3 3,
+   ae4 -1,
+   ae5 -1
+}
+
+"Tests of Enumerated type" t_test = 3
+{
+   ae1 -1,
+   ae2 0,
+   ae3 1,
+   ae4 3
+}
+
+"Tests of Enumerated type" t_test = 2
+{
+   ae1 3,
+   ae2 -1,
+   ae3 0,
+   ae4 3,
+   ae5 1
+}
+
+"Tests of Enumerated type" t_test = 1
+{
+   ae1 1,
+   ae2 3,
+   ae3 -1,
+   ae4 0
+}
+
+"Enumerated Type" t_test = 4
+0
+
+"Enumerated Type" t_test = 3
+-1
+
+"Enumerated Type" t_test = 2
+3
+
+"Enumerated Type" t_test = 1
+1
+
+"Single Objects" t_test = 4
+{
+   st2 "xxxxxxx, world"
+}
+
+"Single Objects" t_test = 3
+{}
+
+"Single Objects" t_test = 2
+{
+   st2 "xxxxxxx, world"
+}
+
+"Single Objects" t_test = 1
+{
+   st2 "xxxxxxx, world"
+}
+
+"Explicit Tagged Objects" t_test = 3
+{
+   bE 40986
+}
+
+"Explicit Tagged Objects" t_test = 2
+{
+   aE 10283
+}
+
+"Explicit Tagged Objects" t_test = 1
+{
+   bE 40986
+}
+
+"Single EXTERNAL" t_test = 1
+{
+   direct-reference 1.17.222,
+   indirect-reference 16,
+   data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+   encoding {
+      octet-aligned '536f6d652074657374206461746100'H
+   }
+}
+
+"EXTERNAL" t_test = 6
+{
+   ext {
+      direct-reference 1.17.474,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   a-ny 'ff'H,
+   ext-impl {
+      direct-reference 1.17.366,
+      indirect-reference 40,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   any-impl 'ff'H,
+   ext-expl {
+      direct-reference 1.17.258,
+      indirect-reference 12,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   any-expl '0010'H
+}
+
+"EXTERNAL" t_test = 5
+{
+   ext {
+      direct-reference 1.17.402,
+      indirect-reference 12,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   a-ny "mkpelist:testdata",
+   ext-impl {
+      direct-reference 1.17.312,
+      indirect-reference 16,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type 'ff'H
+      }
+   },
+   any-impl {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H,
+      [PRIVATE 50] 'ff'H,
+      [PRIVATE 65] "\b",
+      [PRIVATE 82] "\t",
+      [PRIVATE 101] "\n",
+      [PRIVATE 122] '0b'H,
+      [PRIVATE 145] "mkpelist:testdata",
+      [PRIVATE 170] "mkpelist:testdata",
+      [PRIVATE 197] '0010'H,
+      [PRIVATE 226] '0010'H,
+      [PRIVATE 15] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H
+      },
+      [PRIVATE 16] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H,
+         [PRIVATE 15] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H
+         }
+      },
+      [PRIVATE 325] '00'H,
+      [PRIVATE 362] 'ff'H,
+      [PRIVATE 401] '14'H,
+      [PRIVATE 442] '15'H,
+      [PRIVATE 485] "mkpelist:testdata",
+      [PRIVATE 530] 'ff'H,
+      [PRIVATE 577] '18'H,
+      [PRIVATE 626] '19'H,
+      [PRIVATE 677] "mkpelist:testdata",
+      [PRIVATE 730] '0010'H,
+      [PRIVATE 27] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H,
+         [PRIVATE 15] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H
+         },
+         [PRIVATE 16] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H,
+            [PRIVATE 15] {
+               [PRIVATE 2] 'ff'H,
+               [PRIVATE 5] '00'H,
+               [PRIVATE 10] 'ff'H,
+               [PRIVATE 17] '00'H,
+               [PRIVATE 26] 'ff'H,
+               [PRIVATE 37] '00'H,
+               [PRIVATE 50] 'ff'H,
+               [PRIVATE 65] "\b",
+               [PRIVATE 82] "\t",
+               [PRIVATE 101] "\n",
+               [PRIVATE 122] '0b'H,
+               [PRIVATE 145] "mkpelist:testdata",
+               [PRIVATE 170] "mkpelist:testdata",
+               [PRIVATE 197] '0010'H,
+               [PRIVATE 226] '0010'H
+            }
+         },
+         [PRIVATE 325] '00'H,
+         [PRIVATE 362] 'ff'H,
+         [PRIVATE 401] '14'H,
+         [PRIVATE 442] '15'H,
+         [PRIVATE 485] "mkpelist:testdata",
+         [PRIVATE 530] 'ff'H,
+         [PRIVATE 577] '18'H,
+         [PRIVATE 626] '19'H,
+         [PRIVATE 677] "mkpelist:testdata",
+         [PRIVATE 730] '0010'H
+      },
+      [PRIVATE 842] 'ff'H,
+      [PRIVATE 901] '1e'H,
+      [PRIVATE 962] "mkpelist:testdata",
+      [PRIVATE 1025] '00'H,
+      [PRIVATE 1090] "!",
+      [PRIVATE 1157] "mkpelist:testdata",
+      [PRIVATE 1226] '0010'H,
+      [PRIVATE 35] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H,
+         [PRIVATE 15] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H
+         },
+         [PRIVATE 16] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H,
+            [PRIVATE 15] {
+               [PRIVATE 2] 'ff'H,
+               [PRIVATE 5] '00'H,
+               [PRIVATE 10] 'ff'H,
+               [PRIVATE 17] '00'H,
+               [PRIVATE 26] 'ff'H,
+               [PRIVATE 37] '00'H,
+               [PRIVATE 50] 'ff'H,
+               [PRIVATE 65] "\b",
+               [PRIVATE 82] "\t",
+               [PRIVATE 101] "\n",
+               [PRIVATE 122] '0b'H,
+               [PRIVATE 145] "mkpelist:testdata",
+               [PRIVATE 170] "mkpelist:testdata",
+               [PRIVATE 197] '0010'H,
+               [PRIVATE 226] '0010'H
+            }
+         },
+         [PRIVATE 325] '00'H,
+         [PRIVATE 362] 'ff'H,
+         [PRIVATE 401] '14'H,
+         [PRIVATE 442] '15'H,
+         [PRIVATE 485] "mkpelist:testdata",
+         [PRIVATE 530] 'ff'H,
+         [PRIVATE 577] '18'H,
+         [PRIVATE 626] '19'H,
+         [PRIVATE 677] "mkpelist:testdata",
+         [PRIVATE 730] '0010'H,
+         [PRIVATE 27] {
+            [PRIVATE 2] 'ff'H,
+            [PRIVATE 5] '00'H,
+            [PRIVATE 10] 'ff'H,
+            [PRIVATE 17] '00'H,
+            [PRIVATE 26] 'ff'H,
+            [PRIVATE 37] '00'H,
+            [PRIVATE 50] 'ff'H,
+            [PRIVATE 65] "\b",
+            [PRIVATE 82] "\t",
+            [PRIVATE 101] "\n",
+            [PRIVATE 122] '0b'H,
+            [PRIVATE 145] "mkpelist:testdata",
+            [PRIVATE 170] "mkpelist:testdata",
+            [PRIVATE 197] '0010'H,
+            [PRIVATE 226] '0010'H,
+            [PRIVATE 15] {
+               [PRIVATE 2] 'ff'H,
+               [PRIVATE 5] '00'H,
+               [PRIVATE 10] 'ff'H,
+               [PRIVATE 17] '00'H,
+               [PRIVATE 26] 'ff'H,
+               [PRIVATE 37] '00'H,
+               [PRIVATE 50] 'ff'H,
+               [PRIVATE 65] "\b",
+               [PRIVATE 82] "\t",
+               [PRIVATE 101] "\n",
+               [PRIVATE 122] '0b'H,
+               [PRIVATE 145] "mkpelist:testdata",
+               [PRIVATE 170] "mkpelist:testdata",
+               [PRIVATE 197] '0010'H,
+               [PRIVATE 226] '0010'H
+            },
+            [PRIVATE 16] {
+               [PRIVATE 2] 'ff'H,
+               [PRIVATE 5] '00'H,
+               [PRIVATE 10] 'ff'H,
+               [PRIVATE 17] '00'H,
+               [PRIVATE 26] 'ff'H,
+               [PRIVATE 37] '00'H,
+               [PRIVATE 50] 'ff'H,
+               [PRIVATE 65] "\b",
+               [PRIVATE 82] "\t",
+               [PRIVATE 101] "\n",
+               [PRIVATE 122] '0b'H,
+               [PRIVATE 145] "mkpelist:testdata",
+               [PRIVATE 170] "mkpelist:testdata",
+               [PRIVATE 197] '0010'H,
+               [PRIVATE 226] '0010'H,
+               [PRIVATE 15] {
+                  [PRIVATE 2] 'ff'H,
+                  [PRIVATE 5] '00'H,
+                  [PRIVATE 10] 'ff'H,
+                  [PRIVATE 17] '00'H,
+                  [PRIVATE 26] 'ff'H,
+                  [PRIVATE 37] '00'H,
+                  [PRIVATE 50] 'ff'H,
+                  [PRIVATE 65] "\b",
+                  [PRIVATE 82] "\t",
+                  [PRIVATE 101] "\n",
+                  [PRIVATE 122] '0b'H,
+                  [PRIVATE 145] "mkpelist:testdata",
+                  [PRIVATE 170] "mkpelist:testdata",
+                  [PRIVATE 197] '0010'H,
+                  [PRIVATE 226] '0010'H
+               }
+            },
+            [PRIVATE 325] '00'H,
+            [PRIVATE 362] 'ff'H,
+            [PRIVATE 401] '14'H,
+            [PRIVATE 442] '15'H,
+            [PRIVATE 485] "mkpelist:testdata",
+            [PRIVATE 530] 'ff'H,
+            [PRIVATE 577] '18'H,
+            [PRIVATE 626] '19'H,
+            [PRIVATE 677] "mkpelist:testdata",
+            [PRIVATE 730] '0010'H
+         },
+         [PRIVATE 842] 'ff'H,
+         [PRIVATE 901] '1e'H,
+         [PRIVATE 962] "mkpelist:testdata",
+         [PRIVATE 1025] '00'H,
+         [PRIVATE 1090] "!",
+         [PRIVATE 1157] "mkpelist:testdata",
+         [PRIVATE 1226] '0010'H
+      },
+      [PRIVATE 1370] 'ff'H,
+      [PRIVATE 1445] "&",
+      [PRIVATE 1522] "mkpelist:testdata",
+      [PRIVATE 1601] "(",
+      [PRIVATE 1682] "mkpelist:testdata",
+      [PRIVATE 1765] '0010'H
+   },
+   ext-expl {
+      direct-reference 1.17.222,
+      indirect-reference 16,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   any-expl "mkpelist:testdata"
+}
+
+"EXTERNAL" t_test = 4
+{
+   ext {
+      direct-reference 1.17.330,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   a-ny "!",
+   ext-impl {
+      direct-reference 1.17.258,
+      indirect-reference 12,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   any-impl '0010'H,
+   ext-expl {
+      direct-reference 1.17.186,
+      indirect-reference 4,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   any-expl 'ff'H
+}
+
+"EXTERNAL" t_test = 3
+{
+   ext {
+      direct-reference 1.17.258,
+      indirect-reference 12,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   a-ny '19'H,
+   ext-impl {
+      direct-reference 1.17.204,
+      indirect-reference 32,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type 'ff'H
+      }
+   },
+   any-impl '0010'H,
+   ext-expl {
+      direct-reference 1.17.150,
+      indirect-reference 20,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type 'ff'H
+      }
+   },
+   any-expl 'ff'H
+}
+
+"EXTERNAL" t_test = 2
+{
+   ext {
+      direct-reference 1.17.186,
+      indirect-reference 4,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   a-ny {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H,
+      [PRIVATE 50] 'ff'H,
+      [PRIVATE 65] "\b",
+      [PRIVATE 82] "\t",
+      [PRIVATE 101] "\n",
+      [PRIVATE 122] '0b'H,
+      [PRIVATE 145] "mkpelist:testdata",
+      [PRIVATE 170] "mkpelist:testdata",
+      [PRIVATE 197] '0010'H,
+      [PRIVATE 226] '0010'H,
+      [PRIVATE 15] {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b",
+         [PRIVATE 82] "\t",
+         [PRIVATE 101] "\n",
+         [PRIVATE 122] '0b'H,
+         [PRIVATE 145] "mkpelist:testdata",
+         [PRIVATE 170] "mkpelist:testdata",
+         [PRIVATE 197] '0010'H,
+         [PRIVATE 226] '0010'H
+      }
+   },
+   ext-impl {
+      direct-reference 1.17.150,
+      indirect-reference 20,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type 'ff'H
+      }
+   },
+   any-impl 'ff'H,
+   ext-expl {
+      direct-reference 1.17.114,
+      indirect-reference 16,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   any-expl '15'H
+}
+
+"EXTERNAL" t_test = 1
+{
+   ext {
+      direct-reference 1.17.114,
+      indirect-reference 16,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   a-ny "\t",
+   ext-impl {
+      direct-reference 1.17.96,
+      indirect-reference 28,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         single-ASN1-type '00'H
+      }
+   },
+   any-impl '0b'H,
+   ext-expl {
+      direct-reference 1.17.78,
+      indirect-reference 48,
+      data-value-descriptor '4120766572792077696c642074797065206f66206461746100'H,
+      encoding {
+         octet-aligned '536f6d652074657374206461746100'H
+      }
+   },
+   any-expl "mkpelist:testdata"
+}
+
+"Optimised" t_test = 8
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H,
+      [PRIVATE 50] 'ff'H,
+      [PRIVATE 65] "\b"
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b"
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H,
+         [PRIVATE 65] "\b"
+      },
+      o7 1.17
+   }
+}
+
+"Optimised" t_test = 7
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H,
+      [PRIVATE 50] 'ff'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H,
+         [PRIVATE 50] 'ff'H
+      },
+      o7 1.17
+   }
+}
+
+"Optimised" t_test = 6
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H,
+      [PRIVATE 37] '00'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H,
+         [PRIVATE 37] '00'H
+      },
+      o7 1.17
+   }
+}
+
+"Optimised" t_test = 5
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H,
+      [PRIVATE 26] 'ff'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H,
+         [PRIVATE 26] 'ff'H
+      },
+      o7 1.17.48.53.58
+   }
+}
+
+"Optimised" t_test = 4
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H,
+      [PRIVATE 17] '00'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H,
+         [PRIVATE 17] '00'H
+      },
+      o7 1.17.45.49
+   }
+}
+
+"Optimised" t_test = 3
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H,
+      [PRIVATE 10] 'ff'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H,
+         [PRIVATE 10] 'ff'H
+      },
+      o7 1.17.42
+   }
+}
+
+"Optimised" t_test = 2
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H,
+      [PRIVATE 5] '00'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H,
+         [PRIVATE 5] '00'H
+      },
+      o7 1.17
+   }
+}
+
+"Optimised" t_test = 1
+{
+   o1 '0001010000110001000100100011011100011010'B,
+   o2 "Peckling Worsley!!!!",
+   o3 {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   o4 {
+      [PRIVATE 2] 'ff'H
+   },
+   {
+      o5 {
+         [PRIVATE 2] 'ff'H
+      },
+      o6 {
+         [PRIVATE 2] 'ff'H
+      },
+      o7 1.17
+   }
+}
+
+"External References" t_test = 6
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         o-c1 '416e6472657720576f72736c657921212100'H
+      },
+      c2 {
+         b-c2 '0000001000000001000000010000011100111111'B
+      },
+      c3 {
+         seq-c3 {
+            seq-c3-in {
+               i-expl 35051,
+               o-expl "explicit tagged octet string",
+               b-expl '00111000001110000011100000111111'B,
+               f-expl TRUE,
+               obj-expl {
+                  atest 2001,
+                  btest "Good bye",
+                  ctest '000000110000100010101010'B,
+                  big-test {
+                     ostring '3132fe00ff6136'H,
+                     bstring '10111000000011110000100000010000001000000100000000'B,
+                     nstring "123456",
+                     pstring "hello, world",
+                     tstring "teletex",
+                     t61string "T.61",
+                     vstring "visible",
+                     vis-string "visible again",
+                     i646string "who knows what this is",
+                     ia5string "This is ASCII\n\r",
+                     graphstring "This is a graphic string",
+                     genstring "This is a general string"
+                  },
+                  emb-test {
+                     em-int -101,
+                     em-oct "Embedded octet string",
+                     em-bit '1111111110101010010101011111100000000001'B
+                  }
+               },
+               i-exp-test {
+                  i-ex-int -9,
+                  i-ex-oct '4578706c6963697420456d62656464656400'H,
+                  i-ex-bit '0000001100000011000000110000001110111111'B
+               }
+            },
+            seq-c3-i 40938,
+            seq-c3-o '4a616d657320576f72736c65792121212100'H
+         }
+      },
+      c4 {
+         c4-choice {
+            sc-b-i 13151
+         }
+      }
+   }
+}
+
+"External References" t_test = 5
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         i-c1 10101
+      },
+      c2 {
+         o-c2 '5269636861726420576f72736c6579212100'H
+      },
+      c3 {
+         i-c3 689364
+      },
+      c4 {
+         c4-choice {
+            sc-a-i 16891
+         }
+      }
+   },
+   e-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   }
+}
+
+"External References" t_test = 4
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         obj-c1 {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         }
+      },
+      c2 {
+         i-c2 1212
+      },
+      c3 {
+         set-c3 {
+            set-c3-in {
+               i-expl 35051,
+               o-expl "explicit tagged octet string",
+               b-expl '00111000001110000011100000111111'B,
+               f-expl TRUE,
+               obj-expl {
+                  atest 2001,
+                  btest "Good bye",
+                  ctest '000000110000100010101010'B,
+                  big-test {
+                     ostring '3132fe00ff6136'H,
+                     bstring '10111000000011110000100000010000001000000100000000'B,
+                     nstring "123456",
+                     pstring "hello, world",
+                     tstring "teletex",
+                     t61string "T.61",
+                     vstring "visible",
+                     vis-string "visible again",
+                     i646string "who knows what this is",
+                     ia5string "This is ASCII\n\r",
+                     graphstring "This is a graphic string",
+                     genstring "This is a general string"
+                  },
+                  emb-test {
+                     em-int -101,
+                     em-oct "Embedded octet string",
+                     em-bit '1111111110101010010101011111100000000001'B
+                  }
+               },
+               i-exp-test {
+                  i-ex-int -9,
+                  i-ex-oct '4578706c6963697420456d62656464656400'H,
+                  i-ex-bit '0000001100000011000000110000001110111111'B
+               }
+            },
+            set-c3-i 264504,
+            set-c3-o '5061747269636b20576f72736c6579212100'H
+         }
+      },
+      c4 {
+         c4-choice {
+            c4-obj {
+               i-expl 35051,
+               o-expl "explicit tagged octet string",
+               b-expl '00111000001110000011100000111111'B,
+               f-expl TRUE,
+               obj-expl {
+                  atest 2001,
+                  btest "Good bye",
+                  ctest '000000110000100010101010'B,
+                  big-test {
+                     ostring '3132fe00ff6136'H,
+                     bstring '10111000000011110000100000010000001000000100000000'B,
+                     nstring "123456",
+                     pstring "hello, world",
+                     tstring "teletex",
+                     t61string "T.61",
+                     vstring "visible",
+                     vis-string "visible again",
+                     i646string "who knows what this is",
+                     ia5string "This is ASCII\n\r",
+                     graphstring "This is a graphic string",
+                     genstring "This is a general string"
+                  },
+                  emb-test {
+                     em-int -101,
+                     em-oct "Embedded octet string",
+                     em-bit '1111111110101010010101011111100000000001'B
+                  }
+               },
+               i-exp-test {
+                  i-ex-int -9,
+                  i-ex-oct '4578706c6963697420456d62656464656400'H,
+                  i-ex-bit '0000001100000011000000110000001110111111'B
+               }
+            }
+         }
+      }
+   }
+}
+
+"External References" t_test = 3
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         f-c1 TRUE
+      },
+      c2 {
+         obj-c2 {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         }
+      },
+      c3 {
+         seq-c3 {
+            seq-c3-in {
+               i-expl 35051,
+               o-expl "explicit tagged octet string",
+               b-expl '00111000001110000011100000111111'B,
+               f-expl TRUE,
+               obj-expl {
+                  atest 2001,
+                  btest "Good bye",
+                  ctest '000000110000100010101010'B,
+                  big-test {
+                     ostring '3132fe00ff6136'H,
+                     bstring '10111000000011110000100000010000001000000100000000'B,
+                     nstring "123456",
+                     pstring "hello, world",
+                     tstring "teletex",
+                     t61string "T.61",
+                     vstring "visible",
+                     vis-string "visible again",
+                     i646string "who knows what this is",
+                     ia5string "This is ASCII\n\r",
+                     graphstring "This is a graphic string",
+                     genstring "This is a general string"
+                  },
+                  emb-test {
+                     em-int -101,
+                     em-oct "Embedded octet string",
+                     em-bit '1111111110101010010101011111100000000001'B
+                  }
+               },
+               i-exp-test {
+                  i-ex-int -9,
+                  i-ex-oct '4578706c6963697420456d62656464656400'H,
+                  i-ex-bit '0000001100000011000000110000001110111111'B
+               }
+            },
+            seq-c3-i 40938,
+            seq-c3-o '4a616d657320576f72736c65792121212100'H
+         }
+      },
+      c4 {
+         c4-choice {
+            c4-i 10938
+         }
+      }
+   },
+   e-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   }
+}
+
+"External References" t_test = 2
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         b-c1 '0000001000000010000000100000011100111111'B
+      },
+      c2 {
+         f-c2 TRUE
+      },
+      c3 {
+         i-c3 689364
+      },
+      c4 {
+         c4-choice {
+            sc-b-i 13151
+         }
+      }
+   }
+}
+
+"External References" t_test = 1
+{
+   a-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   b-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   },
+   c-ref {
+      c1 {
+         o-c1 '416e6472657720576f72736c657921212100'H
+      },
+      c2 {
+         b-c2 '0000001000000001000000010000011100111111'B
+      },
+      c3 {
+         set-c3 {
+            set-c3-in {
+               i-expl 35051,
+               o-expl "explicit tagged octet string",
+               b-expl '00111000001110000011100000111111'B,
+               f-expl TRUE,
+               obj-expl {
+                  atest 2001,
+                  btest "Good bye",
+                  ctest '000000110000100010101010'B,
+                  big-test {
+                     ostring '3132fe00ff6136'H,
+                     bstring '10111000000011110000100000010000001000000100000000'B,
+                     nstring "123456",
+                     pstring "hello, world",
+                     tstring "teletex",
+                     t61string "T.61",
+                     vstring "visible",
+                     vis-string "visible again",
+                     i646string "who knows what this is",
+                     ia5string "This is ASCII\n\r",
+                     graphstring "This is a graphic string",
+                     genstring "This is a general string"
+                  },
+                  emb-test {
+                     em-int -101,
+                     em-oct "Embedded octet string",
+                     em-bit '1111111110101010010101011111100000000001'B
+                  }
+               },
+               i-exp-test {
+                  i-ex-int -9,
+                  i-ex-oct '4578706c6963697420456d62656464656400'H,
+                  i-ex-bit '0000001100000011000000110000001110111111'B
+               }
+            },
+            set-c3-i 264504,
+            set-c3-o '5061747269636b20576f72736c6579212100'H
+         }
+      },
+      c4 {
+         c4-choice {
+            sc-a-i 16891
+         }
+      }
+   },
+   e-ref {
+      a1 101910,
+      a2 -304985,
+      a3 13,
+      a4 {
+         a-seq {
+            fred 998877
+         }
+      }
+   }
+}
+
+"Default test" t_test = 12
+{
+   a-def 1,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      colour 1,
+      version { basic }
+   },
+   st-def {
+      beer 2,
+      spirit 0
+   }
+}
+
+"Default test" t_test = 11
+{
+   a-def 1,
+   c-def '100000000'B,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   }
+}
+
+"Default test" t_test = 10
+{
+   a-def 1,
+   b-def '537573616e20536962656c202121212100'H,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      colour 1,
+      oem-oct '4a756c696120447a75696b6173202121212100'H,
+      version { basic }
+   }
+}
+
+"Default test" t_test = 9
+{
+   a-def 1,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   st-def {}
+}
+
+"Default test" t_test = 8
+{
+   a-def 1,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      colour 1,
+      version { basic }
+   },
+   st-def {
+      beer 2,
+      spirit 0
+   }
+}
+
+"Default test" t_test = 7
+{
+   a-def 1,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   st-def {
+      wine 2,
+      beer 2
+   }
+}
+
+"Default test" t_test = 6
+{
+   a-def 1,
+   b-def '537573616e20536962656c202121212100'H,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   st-def {}
+}
+
+"Default test" t_test = 5
+{
+   a-def 1,
+   c-def '100000000'B,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   }
+}
+
+"Default test" t_test = 4
+{
+   a-def 1,
+   okay FALSE,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      colour 1,
+      version { basic }
+   },
+   st-def {
+      beer 2,
+      spirit 0
+   }
+}
+
+"Default test" t_test = 3
+{
+   a-def 1,
+   c-def '100000000'B,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   st-def {}
+}
+
+"Default test" t_test = 2
+{
+   a-def 1,
+   b-def '537573616e20536962656c202121212100'H,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      colour 1,
+      version { basic }
+   },
+   st-def {
+      spirit 0
+   }
+}
+
+"Default test" t_test = 1
+{
+   a-def 1,
+   big-def {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-def {
+      version { basic }
+   },
+   st-def {
+      beer 2,
+      spirit 0
+   }
+}
+
+"Optional test" t_test = 8
+{
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   etag-opt 2983461
+}
+
+"Optional test" t_test = 7
+{
+   a-opt 192837,
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   d-opt TRUE,
+   e-opt NULL,
+   big-opt {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-opt {
+      oem-int 197336,
+      oem-oct '4c696e6720576f72736c657900'H
+   },
+   st-opt {
+      st-int0 85659,
+      st-int2 967768
+   },
+   obj-opt {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   ch-opt {
+      ch-2 28828
+   }
+}
+
+"Optional test" t_test = 6
+{
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   c-opt '0000101000001111000000100000011100111111'B,
+   d-opt TRUE,
+   e-opt NULL
+}
+
+"Optional test" t_test = 5
+{
+   a-opt 192837,
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   c-opt '0000101000001111000000100000011100111111'B,
+   e-opt NULL,
+   big-opt {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-opt {
+      oem-int 197336,
+      oem-oct '4c696e6720576f72736c657900'H
+   },
+   st-opt {
+      st-int0 85659,
+      st-int2 967768
+   },
+   obj-opt {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   ch-opt {
+      ch-2 28828
+   }
+}
+
+"Optional test" t_test = 4
+{
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   e-opt NULL
+}
+
+"Optional test" t_test = 3
+{
+   a-opt 192837,
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   d-opt TRUE,
+   big-opt {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-opt {
+      oem-int 197336,
+      oem-oct '4c696e6720576f72736c657900'H
+   },
+   st-opt {
+      st-int0 85659,
+      st-int2 967768
+   },
+   obj-opt {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   ch-opt {
+      ch-2 28828
+   }
+}
+
+"Optional test" t_test = 2
+{
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   c-opt '0000101000001111000000100000011100111111'B,
+   d-opt TRUE
+}
+
+"Optional test" t_test = 1
+{
+   a-opt 192837,
+   b-opt '537573616e2048616e6e616820536962656c00'H,
+   c-opt '0000101000001111000000100000011100111111'B,
+   big-opt {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-opt {
+      oem-int 197336,
+      oem-oct '4c696e6720576f72736c657900'H
+   },
+   st-opt {
+      st-int0 85659,
+      st-int2 967768
+   },
+   obj-opt {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   ch-opt {
+      ch-2 28828
+   }
+}
+
+"Choice" t_test = 7
+{
+   c1 {
+      b-c1 '0000001000000010000000100000011100111111'B
+   },
+   c2 {
+      f-c2 TRUE
+   },
+   c3 {
+      set-c3 {
+         set-c3-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         set-c3-i 264504,
+         set-c3-o '5061747269636b20576f72736c6579212100'H
+      }
+   },
+   c4 {
+      c4-choice {
+         c4-i 10938
+      }
+   }
+}
+
+"Choice" t_test = 6
+{
+   c1 {
+      o-c1 '416e6472657720576f72736c657921212100'H
+   },
+   c2 {
+      b-c2 '0000001000000001000000010000011100111111'B
+   },
+   c3 {
+      seq-c3 {
+         seq-c3-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         seq-c3-i 40938,
+         seq-c3-o '4a616d657320576f72736c65792121212100'H
+      }
+   },
+   c4 {
+      c4-choice {
+         sc-b-i 13151
+      }
+   }
+}
+
+"Choice" t_test = 5
+{
+   c1 {
+      i-c1 10101
+   },
+   c2 {
+      o-c2 '5269636861726420576f72736c6579212100'H
+   },
+   c3 {
+      i-c3 689364
+   },
+   c4 {
+      c4-choice {
+         sc-a-i 16891
+      }
+   }
+}
+
+"Choice" t_test = 4
+{
+   c1 {
+      obj-c1 {
+         atest 2001,
+         btest "Good bye",
+         ctest '000000110000100010101010'B,
+         big-test {
+            ostring '3132fe00ff6136'H,
+            bstring '10111000000011110000100000010000001000000100000000'B,
+            nstring "123456",
+            pstring "hello, world",
+            tstring "teletex",
+            t61string "T.61",
+            vstring "visible",
+            vis-string "visible again",
+            i646string "who knows what this is",
+            ia5string "This is ASCII\n\r",
+            graphstring "This is a graphic string",
+            genstring "This is a general string"
+         },
+         emb-test {
+            em-int -101,
+            em-oct "Embedded octet string",
+            em-bit '1111111110101010010101011111100000000001'B
+         }
+      }
+   },
+   c2 {
+      i-c2 1212
+   },
+   c3 {
+      set-c3 {
+         set-c3-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         set-c3-i 264504,
+         set-c3-o '5061747269636b20576f72736c6579212100'H
+      }
+   },
+   c4 {
+      c4-choice {
+         c4-obj {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         }
+      }
+   }
+}
+
+"Choice" t_test = 3
+{
+   c1 {
+      f-c1 TRUE
+   },
+   c2 {
+      obj-c2 {
+         atest 2001,
+         btest "Good bye",
+         ctest '000000110000100010101010'B,
+         big-test {
+            ostring '3132fe00ff6136'H,
+            bstring '10111000000011110000100000010000001000000100000000'B,
+            nstring "123456",
+            pstring "hello, world",
+            tstring "teletex",
+            t61string "T.61",
+            vstring "visible",
+            vis-string "visible again",
+            i646string "who knows what this is",
+            ia5string "This is ASCII\n\r",
+            graphstring "This is a graphic string",
+            genstring "This is a general string"
+         },
+         emb-test {
+            em-int -101,
+            em-oct "Embedded octet string",
+            em-bit '1111111110101010010101011111100000000001'B
+         }
+      }
+   },
+   c3 {
+      seq-c3 {
+         seq-c3-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         seq-c3-i 40938,
+         seq-c3-o '4a616d657320576f72736c65792121212100'H
+      }
+   },
+   c4 {
+      c4-choice {
+         c4-i 10938
+      }
+   }
+}
+
+"Choice" t_test = 2
+{
+   c1 {
+      b-c1 '0000001000000010000000100000011100111111'B
+   },
+   c2 {
+      f-c2 TRUE
+   },
+   c3 {
+      i-c3 689364
+   },
+   c4 {
+      c4-choice {
+         sc-b-i 13151
+      }
+   }
+}
+
+"Choice" t_test = 1
+{
+   c1 {
+      o-c1 '416e6472657720576f72736c657921212100'H
+   },
+   c2 {
+      b-c2 '0000001000000001000000010000011100111111'B
+   },
+   c3 {
+      set-c3 {
+         set-c3-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         set-c3-i 264504,
+         set-c3-o '5061747269636b20576f72736c6579212100'H
+      }
+   },
+   c4 {
+      c4-choice {
+         sc-a-i 16891
+      }
+   }
+}
+
+"SEQ OF and SET OF" t_test = 10
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 9
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 8
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 7
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 6
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 5
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 4
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 3
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 2
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"SEQ OF and SET OF" t_test = 1
+{
+   sqof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   stof-test1 {
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      },
+      {
+         i-expl 35051,
+         o-expl "explicit tagged octet string",
+         b-expl '00111000001110000011100000111111'B,
+         f-expl TRUE,
+         obj-expl {
+            atest 2001,
+            btest "Good bye",
+            ctest '000000110000100010101010'B,
+            big-test {
+               ostring '3132fe00ff6136'H,
+               bstring '10111000000011110000100000010000001000000100000000'B,
+               nstring "123456",
+               pstring "hello, world",
+               tstring "teletex",
+               t61string "T.61",
+               vstring "visible",
+               vis-string "visible again",
+               i646string "who knows what this is",
+               ia5string "This is ASCII\n\r",
+               graphstring "This is a graphic string",
+               genstring "This is a general string"
+            },
+            emb-test {
+               em-int -101,
+               em-oct "Embedded octet string",
+               em-bit '1111111110101010010101011111100000000001'B
+            }
+         },
+         i-exp-test {
+            i-ex-int -9,
+            i-ex-oct '4578706c6963697420456d62656464656400'H,
+            i-ex-bit '0000001100000011000000110000001110111111'B
+         }
+      }
+   },
+   i-test1 33,
+   sqof-test2 {
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      },
+      {
+         sqof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         sqof-i 212121,
+         sqof-o '456c656d656e743820456d62656464656400'H
+      }
+   },
+   stof-test2 {
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      },
+      {
+         stof-in {
+            i-expl 35051,
+            o-expl "explicit tagged octet string",
+            b-expl '00111000001110000011100000111111'B,
+            f-expl TRUE,
+            obj-expl {
+               atest 2001,
+               btest "Good bye",
+               ctest '000000110000100010101010'B,
+               big-test {
+                  ostring '3132fe00ff6136'H,
+                  bstring '10111000000011110000100000010000001000000100000000'B,
+                  nstring "123456",
+                  pstring "hello, world",
+                  tstring "teletex",
+                  t61string "T.61",
+                  vstring "visible",
+                  vis-string "visible again",
+                  i646string "who knows what this is",
+                  ia5string "This is ASCII\n\r",
+                  graphstring "This is a graphic string",
+                  genstring "This is a general string"
+               },
+               emb-test {
+                  em-int -101,
+                  em-oct "Embedded octet string",
+                  em-bit '1111111110101010010101011111100000000001'B
+               }
+            },
+            i-exp-test {
+               i-ex-int -9,
+               i-ex-oct '4578706c6963697420456d62656464656400'H,
+               i-ex-bit '0000001100000011000000110000001110111111'B
+            }
+         },
+         stof-i -12345,
+         stof-o '58595a616263646520456d62656464656400'H
+      }
+   },
+   i-test2 99
+}
+
+"Explicit tags" t_test = 1
+{
+   i-expl 35051,
+   o-expl "explicit tagged octet string",
+   b-expl '00111000001110000011100000111111'B,
+   f-expl TRUE,
+   obj-expl {
+      atest 2001,
+      btest "Good bye",
+      ctest '000000110000100010101010'B,
+      big-test {
+         ostring '3132fe00ff6136'H,
+         bstring '10111000000011110000100000010000001000000100000000'B,
+         nstring "123456",
+         pstring "hello, world",
+         tstring "teletex",
+         t61string "T.61",
+         vstring "visible",
+         vis-string "visible again",
+         i646string "who knows what this is",
+         ia5string "This is ASCII\n\r",
+         graphstring "This is a graphic string",
+         genstring "This is a general string"
+      },
+      emb-test {
+         em-int -101,
+         em-oct "Embedded octet string",
+         em-bit '1111111110101010010101011111100000000001'B
+      }
+   },
+   i-exp-test {
+      i-ex-int -9,
+      i-ex-oct '4578706c6963697420456d62656464656400'H,
+      i-ex-bit '0000001100000011000000110000001110111111'B
+   }
+}
+
+"Implicit tags" t_test = 1
+{
+   i-impl -1,
+   o-impl '49276d20616e20696d706c6963697420746167676564206f6374657420737472696e6700'H,
+   b-impl '0000000000000000000000011001100000000001'B,
+   f-impl TRUE,
+   obj-impl {
+      atest 2001,
+      btest "Good bye",
+      ctest '000000110000100010101010'B,
+      big-test {
+         ostring '3132fe00ff6136'H,
+         bstring '10111000000011110000100000010000001000000100000000'B,
+         nstring "123456",
+         pstring "hello, world",
+         tstring "teletex",
+         t61string "T.61",
+         vstring "visible",
+         vis-string "visible again",
+         i646string "who knows what this is",
+         ia5string "This is ASCII\n\r",
+         graphstring "This is a graphic string",
+         genstring "This is a general string"
+      },
+      emb-test {
+         em-int -101,
+         em-oct "Embedded octet string",
+         em-bit '1111111110101010010101011111100000000001'B
+      }
+   },
+   i-emb-test {
+      i-em-int -101,
+      i-em-oct '496d706c6963697420456d62656464656400'H,
+      i-em-bit '10000000100000001000000010000000'B
+   }
+}
+
+"Embedded Strings" t_test = 1
+{
+   atest 2001,
+   btest "Good bye",
+   ctest '000000110000100010101010'B,
+   big-test {
+      ostring '3132fe00ff6136'H,
+      bstring '10111000000011110000100000010000001000000100000000'B,
+      nstring "123456",
+      pstring "hello, world",
+      tstring "teletex",
+      t61string "T.61",
+      vstring "visible",
+      vis-string "visible again",
+      i646string "who knows what this is",
+      ia5string "This is ASCII\n\r",
+      graphstring "This is a graphic string",
+      genstring "This is a general string"
+   },
+   emb-test {
+      em-int -101,
+      em-oct "Embedded octet string",
+      em-bit '1111111110101010010101011111100000000001'B
+   }
+}
+
+"Strings" t_test = 1
+{
+   ostring '3132fe00ff6136'H,
+   bstring '10111000000011110000100000010000001000000100000000'B,
+   nstring "123456",
+   pstring "hello, world",
+   tstring "teletex",
+   t61string "T.61",
+   vstring "visible",
+   vis-string "visible again",
+   i646string "who knows what this is",
+   ia5string "This is ASCII\n\r",
+   graphstring "This is a graphic string",
+   genstring "This is a general string"
+}
+
+"Embedded" t_test = 1
+{
+   anMPDU {
+      a-seq {
+         fred 10,
+         george TRUE
+      }
+   },
+   ei 6966
+}
+
+"MPDU" t_test = 1
+{
+   a-seq {
+      fred 10,
+      george TRUE
+   }
+}
+Total 107  = 107 successes 0 failures
diff --git a/usr/src/contrib/isode/pepsy/pepsy.c b/usr/src/contrib/isode/pepsy/pepsy.c
new file mode 100644 (file)
index 0000000..6fdfb6b
--- /dev/null
@@ -0,0 +1,3690 @@
+/* pepsy.c - table driven posy/pepy replacement system */
+
+/* OPEN QUESTIONS:
+
+       How to do smarter DEFAULT determination for the other types and NULLs
+
+       Perhaps pull-up primitive IDentifiers
+
+       Abort a CHOICE encoding if the structure is empty
+
+
+                                 HEURISTICS
+
+   1. LANGUAGE SIMPLIFICATIONS:
+
+
+       Pull-up uni-member SEQUENCEs/SETs/CHOICEs
+
+
+   2. LANGUAGE ASSUMPTIONS:
+
+       Unique tags to avoid conflicts for internal structures (-h1 option)
+
+
+   3. STYLE ISSUES:
+
+       SEQUENCE/SET OF Type should have Type be an ID for nicer naming
+ */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/pepsy.c,v 7.12 91/02/22 09:49:38 mrose Interim $";
+#endif
+
+/*
+ * $Header: /f/osi/pepsy/RCS/pepsy.c,v 7.12 91/02/22 09:49:38 mrose Interim $
+ *
+ *
+ * $Log:       pepsy.c,v $
+ * Revision 7.12  91/02/22  09:49:38  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.11  91/01/24  14:51:00  mrose
+ * update
+ * 
+ * Revision 7.10  91/01/08  12:50:24  mrose
+ * update
+ * 
+ * Revision 7.9  90/12/23  17:24:58  mrose
+ * patches
+ * 
+ * Revision 7.8  90/12/11  10:33:57  mrose
+ * sync
+ * 
+ * Revision 7.7  90/11/20  15:27:21  mrose
+ * update
+ * 
+ * Revision 7.6  90/11/11  10:54:05  mrose
+ * update
+ * 
+ * Revision 7.5  90/11/04  19:17:13  mrose
+ * update
+ * 
+ * Revision 7.4  90/10/23  20:43:04  mrose
+ * update
+ * 
+ * Revision 7.3  90/09/07  17:34:20  mrose
+ * touch-up
+ * 
+ * Revision 7.2  90/08/08  14:14:28  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:52:50  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:25  mrose
+ * *** empty log message ***
+ * 
+ * Revision 7.3  90/02/23  17:50:09  mrose
+ * update
+ * 
+ * Revision 7.2  90/02/19  13:09:35  mrose
+ * update
+ * 
+ * Revision 7.1  90/01/11  18:37:05  mrose
+ * real-sync
+ * 
+ * Revision 7.0  89/11/23  22:11:59  mrose
+ * Release 6.0
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <varargs.h>
+#include "pepsydefs.h"
+#include "pass2.h"
+
+
+#define        SVAL(s)         ((s) ? (s) : "")
+#define PARVAL(s)      ((s) ? (s) : "parm")
+
+/* \f   DATA */
+
+static int aflag = 0;
+int    Aflag = 0;      /* Don't so all modes by default */
+int    Cflag = 0;              /* posy */
+int    dflag = 0;
+int    Pflag = 0;              /* pepy compat ... */
+char    *bflag = NULL;         /*  .. */
+char   *iflag = NULL;          /* -i file => #include users file */
+char    *module_actions = NULL;
+int    pepydebug = 0;
+int    doexternals = 1;
+static int fflag = 0;
+static int linepos = 0;
+int mflag = 0;
+int sflag = 0;
+
+int p_debug = 3;
+int options[NOPTIONS];
+
+char *eval = NULLCP;
+
+char   *mymodule = "";
+OID    mymoduleid = NULLOID;
+static char modulename[BUFSIZ];
+
+int yysection = YP_DECODER;
+char *yyencpref = "encode";
+char *yydecpref = "decode";
+char *yyprfpref = "print";
+char *yyencdflt = "encode";
+char *yydecdflt = "decode";
+char *yyprfdflt = "print";
+
+static char *classes[] = {
+    "UNIVERSAL ",
+    "APPLICATION ",
+    "",
+    "PRIVATE "
+};
+
+static char *tags[] = {
+    "", "BOOLEAN", "INTEGER", "INTEGER", "BIT STRING", "BIT STRING",
+    "OCTET STRING", "NULL", "SEQUENCE", "SEQUENCE OF", "SEQUENCE",  "SET",
+    "SET OF", "SET", "CHOICE", "ANY", "OBJECT IDENTIFIER", "", "ENUMERATED",
+    "REAL", "",
+
+    NULL
+};
+
+struct tuple tuples[] = {
+       YP_BOOL, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_BOOL",
+               PE_CLASS_UNIV, PE_PRIM_BOOL,
+       YP_INT, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_INT",
+               PE_CLASS_UNIV, PE_PRIM_INT,
+       YP_INTLIST, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_INT",
+               PE_CLASS_UNIV, PE_PRIM_INT,
+       YP_BIT, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_BITS",
+               PE_CLASS_UNIV, PE_PRIM_BITS,
+       YP_BITLIST, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_BITS",
+               PE_CLASS_UNIV, PE_PRIM_BITS,
+       YP_OCT, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_OCTS",
+               PE_CLASS_UNIV, PE_PRIM_OCTS,
+       YP_NULL, "PE_CLASS_UNIV", NULLCP, "PE_PRIM_NULL",
+               PE_CLASS_UNIV, PE_PRIM_NULL,
+       YP_OID, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_OID",
+               PE_CLASS_UNIV, PE_PRIM_OID,
+       YP_SEQ, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ",
+               PE_CLASS_UNIV, PE_CONS_SEQ,
+       YP_SEQTYPE, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ",
+               PE_CLASS_UNIV, PE_CONS_SEQ,
+       YP_SEQLIST, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SEQ",
+               PE_CLASS_UNIV, PE_CONS_SEQ,
+       YP_SET, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET",
+               PE_CLASS_UNIV, PE_CONS_SET,
+       YP_SETTYPE, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET",
+               PE_CLASS_UNIV, PE_CONS_SET,
+       YP_SETLIST, "PE_CLASS_UNIV", "PE_FORM_CONS", "PE_CONS_SET",
+               PE_CLASS_UNIV, PE_CONS_SET,
+       YP_ENUMLIST, "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_ENUM",
+               PE_CLASS_UNIV, PE_PRIM_ENUM,
+       YP_REAL,     "PE_CLASS_UNIV", "PE_FORM_PRIM", "PE_PRIM_REAL",
+               PE_CLASS_UNIV, PE_PRIM_REAL,
+
+       YP_UNDF
+};
+
+
+static char autogen[BUFSIZ];
+
+char   *sysin = NULLCP;
+static char sysout[BUFSIZ];
+static char sysdef[BUFSIZ];
+static char sysact[BUFSIZ];
+
+static FILE *fdef;
+
+typedef struct modlist {
+    char   *md_module;
+    OID    md_oid;
+    int           md_flags;
+#define MDF_SEEN               1       /* Seen this module */
+
+    struct modlist *md_next;
+}              modlist, *MD;
+#define        NULLMD  ((MD) 0)
+
+static  MD     mymodules = NULLMD;
+
+typedef struct symlist {
+    char   *sy_encpref;
+    char   *sy_decpref;
+    char   *sy_prfpref;
+    char   *sy_module;
+    char   *sy_name;
+
+    YP     sy_type;
+
+    struct symlist *sy_next;
+}              symlist, *SY;
+#define        NULLSY  ((SY) 0)
+
+SY     mysymbols = NULLSY;
+
+
+char   *gensym (), *modsym (), *array ();
+extern char    *my_strcat(), *gfree(), *concat(), *my_new_str();
+extern char    *getid();
+MD     lookup_module ();
+SY     new_symbol (), add_symbol ();
+static double val2real ();
+static void prime_default ();
+
+extern void exit();    /* to keep lint happy */
+
+FILE   *open_ph_file ();
+
+YP     lookup_type ();
+
+YT  lookup_tag ();
+
+/* \f   MAIN */
+
+/* ARGSUSED */
+
+main (argc, argv, envp)
+int    argc;
+char  **argv,
+      **envp;
+{
+    int            i;
+    register char  *cp,
+                  *dp;
+
+    dp = pepsyversion + strlen ("pepsy ");
+    (void) fprintf (stderr, "pepsy %s\n", dp);
+
+    sysout[0] = sysdef[0] = sysact[0] = NULL;
+    for (argc--, argv++; argc > 0; argc--, argv++) {
+       cp = *argv;
+
+       if (strcmp (cp, "-A") == 0) {
+           Aflag++;
+           continue;
+       }
+       if (strcmp (cp, "-a") == 0) {
+           aflag++;
+           continue;
+       }
+       if (strcmp (cp, "-d") == 0) {
+           dflag++;
+           continue;
+       }
+       if (strcmp (cp, "-f") == 0) {
+           dflag++, fflag++;
+           continue;
+       }
+       if (strncmp (cp, "-h", 2) == 0) {
+           if (cp[2] == NULL) {
+               hflag++;
+               continue;
+           }
+           if (sscanf (cp + 2, "%d", &i) != 1 || i >= NOPTIONS)
+               goto usage;
+           hflag++, options[i]++;
+           continue;
+       }
+       if (strcmp (cp, "-m") == 0) {
+           mflag++;
+           continue;
+       }
+       if (strcmp (cp, "-s") == 0) {
+           sflag++;
+           continue;
+       }
+       if (strcmp (cp, "-i") == 0) {
+           argv++;
+           if (argc-- > 0)
+               iflag = *argv;
+           continue;
+       }
+
+       if (sysin) {
+    usage:  ;
+           (void) fprintf (stderr,
+                   "usage: pepsy [-A] [-a] [-d] [-f] [-h] [-s] module.py\n");
+           exit (1);
+       }
+
+       if (*cp == '-') {
+           if (*++cp != NULL)
+               goto usage;
+           sysin = "";
+       }
+       sysin = cp;
+    }
+
+    switch (pepydebug = (cp = getenv ("PEPSYTEST")) && *cp ? atoi (cp) : 0) {
+       case 2: 
+           yydebug++;          /* fall */
+       case 1: 
+           sflag++;            /*   .. */
+       case 0: 
+           break;
+    }
+
+    if (sysin == NULLCP)
+       sysin = "";
+
+    if (*sysin && freopen (sysin, "r", stdin) == NULL) {
+       (void) fprintf (stderr, "unable to read "), perror (sysin);
+       exit (1);
+    }
+
+    if (strcmp (sysout, "-") == 0)
+       sysout[0] = NULL;
+    if (*sysout && freopen (sysout, "w", stdout) == NULL) {
+       (void) fprintf (stderr, "unable to write "), perror (sysout);
+       exit (1);
+    }
+
+    if (cp = index (dp, ')')) {
+       for (cp++; *cp != ' '; cp++)
+           if (*cp == NULL)
+               break;
+       if (*cp == NULL)
+           cp = NULL;
+    }
+    if (cp == NULL)
+       cp = dp + strlen (dp);
+    (void) sprintf (autogen, "pepsy %*.*s", cp - dp, cp - dp, dp);
+
+    initoidtbl ();
+
+    exit (yyparse ());         /* NOTREACHED */
+}
+
+/* \f   ERRORS */
+
+yyerror (s)
+register char   *s;
+{
+    yyerror_aux (s);
+
+    if (*sysout)
+       (void) unlink (sysout);
+    if (*sysdef)
+       (void) unlink (sysdef);
+    if (*sysact)
+       (void) unlink (sysact);
+
+    exit (1);
+}
+
+#ifndef lint
+warning (va_alist)
+va_dcl
+{
+    char       buffer[BUFSIZ];
+    char       buffer2[BUFSIZ];
+    char       *cp;
+    va_list    ap;
+
+    va_start (ap);
+
+    _asprintf (buffer, NULLCP, ap);
+
+    va_end (ap);
+
+    (void) sprintf (buffer2, "Warning: %s", buffer);
+    yyerror_aux (buffer2);
+}
+
+#else
+
+/* VARARGS1 */
+warning (fmt)
+char   *fmt;
+{
+    warning (fmt);
+}
+#endif
+
+static yyerror_aux (s)
+register char   *s;
+{
+    if (linepos)
+       (void) fprintf (stderr, "\n"), linepos = 0;
+
+    if (eval)
+       (void) fprintf (stderr, "type %s: ", eval);
+    else
+       (void) fprintf (stderr, "line %d: ", yylineno);
+    (void) fprintf (stderr, "%s\n", s);
+    if (!eval)
+       (void) fprintf (stderr, "last token read was \"%s\"\n", yytext);
+}
+
+/* \f */
+
+#ifndef        lint
+myyerror (va_alist)
+va_dcl
+{
+    char    buffer[BUFSIZ];
+    va_list ap;
+
+    va_start (ap);
+
+    _asprintf (buffer, NULLCP, ap);
+
+    va_end (ap);
+
+    yyerror (buffer);
+}
+#else
+/* VARARGS */
+
+myyerror (fmt)
+char   *fmt;
+{
+    myyerror (fmt);
+}
+#endif
+
+
+#ifndef        lint
+static pyyerror (va_alist)
+va_dcl
+{
+    char    buffer[BUFSIZ];
+    register YP        yp;
+    va_list    ap;
+
+    va_start (ap);
+
+    yp = va_arg (ap, YP);
+
+    _asprintf (buffer, NULLCP, ap);
+
+    va_end (ap);
+
+    yyerror_aux (buffer);
+    print_type (yp, 0);
+
+
+    if (*sysout)
+       (void) unlink (sysout);
+    if (*sysdef)
+       (void) unlink (sysdef);
+    if (*sysact)
+       (void) unlink (sysact);
+
+    exit (1);
+}
+#else
+/* VARARGS */
+
+static pyyerror (yp, fmt)
+YP     yp;
+char   *fmt;
+{
+    pyyerror (yp, fmt);
+}
+#endif
+
+/* \f */
+
+yywrap () {
+    if (linepos)
+       (void) fprintf (stderr, "\n"), linepos = 0;
+
+    return 1;
+}
+
+/* \f */
+
+/* ARGSUSED */
+
+yyprint (s, f, top)
+char    *s;
+int    f;
+int    top;
+{
+    int     len;
+    static int  nameoutput = 0;
+    static int  outputlinelen = 79;
+    static int didf = 0;
+
+    if (sflag || !s)
+       return;
+
+    if (f && didf == 0) {
+       if (linepos)
+           fprintf (stderr, "\n\n");
+       else fprintf (stderr, "\n");
+
+        fprintf (stderr, "%s includes:", mymodule);
+        linepos = (nameoutput = strlen (mymodule) + 10) + 1;
+
+        didf = 1;
+    }
+
+    if (!nameoutput || top) {
+       if (linepos)
+           (void) fprintf (stderr, "\n\n");
+
+       (void) fprintf (stderr, "%s", mymodule);
+       nameoutput = (linepos = strlen (mymodule)) + 1;
+
+#define section(flag,prefix) \
+        if (yysection & (flag)) { \
+            fprintf (stderr, " %s", (prefix)); \
+            linepos += strlen (prefix) + 1; \
+        } \
+        else \
+            fprintf (stderr, " none"), linepos += 5
+        section (YP_ENCODER, yyencpref);
+        section (YP_DECODER, yydecpref);
+        section (YP_PRINTER, yyprfpref);
+
+
+       (void) fprintf (stderr, ":");
+       linepos += 2;
+
+       if (top)
+           return;
+    }
+
+    len = strlen (s) + (f ? 2 : 0);
+    if (linepos != nameoutput)
+       if (len + linepos + 1 > outputlinelen)
+           (void) fprintf (stderr, "\n%*s", linepos = nameoutput, "");
+       else
+           (void) fprintf (stderr, " "), linepos++;
+    (void) fprintf (stderr, f ? "(%s)" : "%s", s);
+    linepos += len;
+}
+
+/* \f   PASS1 */
+
+pass1 ()
+{
+}
+
+/* \f */
+
+pass1_type (encpref, decpref, prfpref, mod, id, yp)
+register char  *encpref,
+              *decpref,
+              *prfpref,
+              *mod,
+              *id;
+register YP    yp;
+{
+    register SY            sy;
+
+    if (lookup_type (mod, id)) /* no duplicate entries, please... */
+       return;
+
+    if (pepydebug) {
+       if (linepos)
+           (void) fprintf (stderr, "\n"), linepos = 0;
+
+       (void) fprintf (stderr, "%s.%s\n", mod ? mod : mymodule, id);
+       print_type (yp, 0);
+       (void) fprintf (stderr, "--------\n");
+    }
+    else
+       if (!(yp -> yp_flags & YP_IMPORTED))
+           yyprint (id, 0, 0);
+
+    sy = new_symbol (encpref, decpref, prfpref, mod, id, yp);
+    mysymbols = add_symbol (mysymbols, sy);
+}
+
+/* \f   PASS2 */
+
+pass2 () {
+    register SY            sy;
+    register YP            yp;
+
+
+    modsym_aux (mymodule, modulename);
+
+    (void) sprintf (sysdef, "%s-types.h", mymodule);
+    if ((fdef = fopen (sysdef, "w")) == NULL)
+       myyerror ("unable to write %s", sysdef);
+    (void) fprintf (fdef, "/* automatically generated by %s, do not edit! */\n\n",
+           autogen);
+    (void) fprintf (fdef, "#ifndef\t_module_%s_defined_\n", modulename);
+    (void) fprintf (fdef, "#define\t_module_%s_defined_\n\n", modulename);
+
+    (void) fprintf (fdef, "#ifndef\tPEPSY_VERSION\n");
+    (void) fprintf (fdef, "#define\tPEPSY_VERSION\t\t%d\n", PEPSY_VERSION_NUMBER);
+    (void) fprintf (fdef, "#endif\n\n");
+
+    {
+#define NFILES         5
+       char *files[NFILES];
+           /* { "psap.h", "pepsy.h", "UNIV-types.h", (char *)0 }; */
+
+       int last = 0;   /* last slot available in files */
+
+       files[last++] = "psap.h";
+       files[last++] = "pepsy.h";
+
+       if (strcmp (mymodule, "UNIV")) {
+           files[last++] = "pepsy/UNIV-types.h";
+       }
+
+        files[last++] = (char *)0;
+
+        doincl(fdef, files);
+
+#undef NFILES
+    }
+
+    if (mflag) {
+           (void) fprintf (fdef, "#ifndef\tPEPYPATH\n");
+           (void) fprintf (fdef, "#include <isode/pepsy/%s%s>\n", mymodule, HFILE1);
+           (void) fprintf (fdef, "#else\n");
+           (void) fprintf (fdef, "#include \"%s%s\"\n", mymodule, HFILE1);
+           (void) fprintf (fdef, "#endif\n");
+    }
+    else
+           (void) fprintf (fdef, "#include \"%s%s\"\n", mymodule, HFILE1);
+
+    /* User's #include file */
+    if (iflag) {
+       (void) fprintf (fdef, "#include \"%s\"\n", iflag);
+    }
+
+    /*
+     * pull up some symbols 
+     */
+    for (sy = mysymbols; sy; sy = sy -> sy_next) {
+       eval = sy -> sy_name;
+       yp = sy -> sy_type;
+       if (sy -> sy_module == NULLCP)
+           yyerror ("no module name associated with symbol");
+       if (yp -> yp_flags & YP_IMPORTED)
+           continue;
+
+       do_struct0 (yp, eval);
+       if (ferror (stdout) || ferror (fdef))
+           myyerror ("write error - %s", sys_errname (errno));
+    }
+    /* dump out the references to the external types */
+    proc_extmod(fdef);
+
+    /*
+     * generate the #define's for simple type definitions
+     */
+    for (sy = mysymbols; sy; sy = sy -> sy_next) {
+       eval = sy -> sy_name;
+       yp = sy -> sy_type;
+       if (yp -> yp_flags & YP_IMPORTED)
+           continue;
+
+       do_struct1 (yp, eval, NULLCP);
+       if (ferror (stdout) || ferror (fdef))
+           myyerror ("write error - %s", sys_errname (errno));
+    }
+
+    /*
+     * generate the C structure definitions
+     */
+    for (sy = mysymbols; sy; sy = sy -> sy_next) {
+       eval = sy -> sy_name;
+       yp = sy -> sy_type;
+       if (yp -> yp_flags & YP_IMPORTED)
+           continue;
+
+       do_struct2 (yp, eval, NULLCP);
+       if (ferror (stdout) || ferror (fdef))
+           myyerror ("write error - %s", sys_errname (errno));
+    }
+
+    peri_pass2();
+
+    (void) fprintf (fdef, "#endif\n");
+    (void) fflush (fdef);
+    (void) fflush (stdout);
+    if (ferror (stdout) || ferror (fdef))
+       myyerror ("write error - %s", sys_errname (errno));
+    (void) fclose (fdef);
+
+    write_ph_file();
+    if (!sflag) {
+       if (linepos) fprintf (stderr, "\n"), linepos = 0;
+       (void) fflush (stderr);
+    }
+}
+
+/* \f */
+
+/* ARGSUSED */
+
+static do_struct0 (yp, id)
+register YP    yp;
+char   *id;
+{
+    register YP            y;
+    MD md;
+
+    switch (yp -> yp_code) {
+       case YP_SEQLIST:
+       case YP_SETLIST:
+           components_pullup (yp);
+           break;
+
+       default:
+           break;
+    }
+
+    switch (yp -> yp_code) {
+       case YP_SEQTYPE: 
+       case YP_SETTYPE: 
+           do_struct0 (yp -> yp_type, id);
+           break;
+
+       case YP_CHOICE: 
+       case YP_SETLIST: 
+           choice_pullup (yp, yp -> yp_code == YP_CHOICE ? CH_FULLY
+                                                         : CH_PARTIAL);
+           /* and fall */
+       case YP_SEQLIST: 
+           for (y = yp -> yp_type; y; y = y -> yp_next)
+               do_struct0 (y, id);
+           break;
+
+       case YP_IDEFINED: 
+           if (yp -> yp_module && strcmp (yp -> yp_module, mymodule)) {
+               if ((md = lookup_module (yp -> yp_module, yp -> yp_modid))
+                 == NULLMD || (md->md_flags & MDF_SEEN) == 0) {
+                       addextmod(yp -> yp_module);
+                   if (md)
+                       md->md_flags |= MDF_SEEN;
+               }
+           }
+           /* correct for IMPLICIT Tag of a CHOICE or ANY if possible */
+           if ((yp->yp_flags & (YP_IMPLICIT|YP_TAG)) == (YP_IMPLICIT|YP_TAG)) {
+               yp->yp_flags &= ~YP_IMPLICIT; /* clear it */
+               yp->yp_flags |= comptag(YP_IMPLICIT, yp);
+           }
+           break;
+
+       default: 
+           break;
+    }
+}
+
+/* \f */
+
+static do_struct1 (yp, id, pullup)
+register YP    yp;
+char   *id,
+       *pullup;
+{
+    register int    i,
+                    j;
+    char    buf1[BUFSIZ];
+    register YP            y;
+    register YV            yv;
+
+    switch (yp -> yp_code) {
+       case YP_BIT: 
+       case YP_BITLIST: 
+       case YP_SEQ: 
+       case YP_SET: 
+       case YP_ANY: 
+           (void) fprintf (fdef, "\n");
+           if (aflag)
+               printag (yp, 4, pullup);
+           (void) fprintf (fdef, "#define\t%s\tPElement\n",
+                   modsym (mymodule, id, "type"));
+           if (yp -> yp_code == YP_BITLIST) {
+               i = -1;
+               for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+                   if ((j = val2int (yv)) < 0)
+                       pyyerror (yp, "invalid bit number in BIT STRING");
+                   else
+                       if (j > i)
+                           i = j;
+               if (i < sizeof (int) * 8) {     /* NBBY */
+                   (void) fprintf (fdef, "#define\t%s\t\"\\020",
+                           modsym (mymodule, eval, "bits"));
+                   for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+                       if (yv -> yv_flags & YV_NAMED)
+                           (void) fprintf (fdef, "\\0%o%s",
+                                   val2int (yv) + 1, yv -> yv_named);
+                       else
+                           (void) fprintf (fdef, "\\0%oBIT%d",
+                                   val2int (yv) + 1, val2int (yv));
+                   (void) fprintf (fdef, "\"\n");
+               }
+               for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
+                   modsym_aux (yv -> yv_named, buf1);
+                   (void) fprintf (fdef, "#define\t%s_%s\t%d\n",
+                           modsym (mymodule, eval, "bit"),
+                           buf1, val2int (yv));
+               }
+           }
+           if (fflag)
+               (void) fprintf (fdef, "#define\t%s\tpe_free\n",
+                       modsym (mymodule, id, "free"));
+           break;
+
+       case YP_OCT: 
+           (void) fprintf (fdef, "\n");
+           if (aflag)
+               printag (yp, 4, pullup);
+           (void) fprintf (fdef, "#define\t%s\tqbuf\n",
+                   modsym (mymodule, id, "type"));
+           if (fflag)
+               (void) fprintf (fdef, "#define\t%s\tqb_free\n",
+                       modsym (mymodule, id, "free"));
+           break;
+
+       case YP_OID: 
+           (void) fprintf (fdef, "\n");
+           if (aflag)
+               printag (yp, 4, pullup);
+           (void) fprintf (fdef, "#define\t%s\tOIDentifier\n",
+                   modsym (mymodule, id, "type"));
+           if (fflag)
+               (void) fprintf (fdef, "#define\t%s\toid_free\n",
+                       modsym (mymodule, id, "free"));
+           break;
+
+       case YP_IDEFINED: 
+           (void) fprintf (fdef, "\n");
+           if (aflag)
+               printag (yp, 4, pullup);
+           (void) fprintf (fdef, "#define\t%s\t",
+                   modsym (mymodule, id, "type"));
+           (void) fprintf (fdef, "%s\n",
+                   modsym (yp -> yp_module, yp -> yp_identifier, "type"));
+           if (fflag) {
+               (void) fprintf (fdef, "#define\t%s\t",
+                       modsym (mymodule, id, "free"));
+               (void) fprintf (fdef, "%s\n",
+                       modsym (yp -> yp_module, yp -> yp_identifier, "free"));
+           }
+           break;
+
+       case YP_SEQLIST: 
+       case YP_SETLIST: 
+       case YP_CHOICE: 
+           if (hflag && (y = yp -> yp_type) && !y -> yp_next) {
+               do_struct1 (y, id, tags[yp -> yp_code]);
+               break;
+           }
+       /* else fall */
+
+       default: 
+           break;
+    }
+}
+
+/* \f */
+
+static do_struct2 (yp, id, pullup)
+register YP    yp;
+char   *id,
+       *pullup;
+{
+    register YP            y;
+    int        flg = (yp -> yp_code == YP_SEQTYPE || yp -> yp_code == YP_SETTYPE);
+
+    switch (yp -> yp_code) {
+       case YP_BIT: 
+       case YP_BITLIST: 
+       case YP_SEQ: 
+       case YP_SET: 
+       case YP_ANY: 
+       case YP_OCT: 
+       case YP_OID: 
+       case YP_IDEFINED: 
+           break;
+
+       case YP_SEQLIST: 
+       case YP_SETLIST: 
+       case YP_CHOICE: 
+           if (hflag && (y = yp -> yp_type) && !y -> yp_next) {
+               do_struct2 (y, id, tags[yp -> yp_code]);
+               break;
+           }
+           /* else fall */
+
+       default: 
+           (void) fprintf (fdef, "\n");
+           if (aflag)
+               printag (yp, 4, pullup);
+           (void) fprintf (fdef, "struct %s {\n", modsym (mymodule, id, "type"));
+           pepsy (yp, 1, 1, "parm", id, "parm", flg && h2flag);
+           (void) fprintf (fdef, "};\n");
+           (void) fprintf (fdef, "#define\t%s(parm)\\\n\t%s\n", modsym (mymodule, id, "free"), gfree(mymodule, id, "parm"));
+               
+           break;
+    }
+}
+
+/* \f */
+
+/* ARGSUSED */
+
+static do_type1 (yp, top, level, id, var, action2, direction)
+register YP yp;
+int    top,
+       level;
+char   *id,
+       *var,
+       *action2;
+int    direction;
+{
+    int            i;
+    char   *cp,
+          *ep,
+           buffer[BUFSIZ],
+           varbuf[BUFSIZ];
+    register YP            y;
+    register YV            yv;
+    register YT            yt;
+
+    (void) printf ("%*s", level * 4, "");
+
+    if (yp -> yp_flags & YP_ID) {
+       (void) printf ("%s", yp -> yp_id);
+       if (!(yp -> yp_flags & YP_TAG))
+           (void) printf ("\n%*s", ++level * 4, "");
+    }
+
+    if (yp -> yp_flags & YP_TAG) {
+       yt = yp -> yp_tag;
+       (void) printf ("[%s%d]\n", classes[yt -> yt_class], val2int (yt -> yt_value));
+       level++;
+       (void) printf ("%*s", level * 4, "");
+    }
+    if (yp -> yp_flags & YP_OPTIONAL && yp -> yp_varexp) {
+       if ((ep = index (yp -> yp_varexp, ' ')) == NULL)
+           yyerror ("Bug in varexp!");
+
+       (void) sprintf (varbuf, "%*.*s", ep - yp -> yp_varexp,
+                       ep - yp -> yp_varexp, yp -> yp_varexp);
+    }
+
+    switch (yp -> yp_code) {
+       case YP_BOOL: 
+           if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
+               direction == YP_DECODER) {
+               if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
+                   (void) printf ("dummy-for-default\n%*s", ++level * 4, "");
+               if (yp -> yp_flags & YP_OPTIONAL)
+                   (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
+                           varbuf, yp -> yp_optcontrol, level * 4, "");
+               else
+                   (void) printf ("%%{ %s%s = %d; %%}\n%*s",
+                           var, SVAL (yp -> yp_varexp),
+                           val2int (yp -> yp_default) ? 1 : 0, level * 4, "");
+           }
+           break;
+
+       case YP_INT: 
+           if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
+               direction == YP_DECODER) {
+               if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
+                   (void) printf ("dummy-for-default\n%*s", ++level * 4, "");
+               if (yp -> yp_flags & YP_OPTIONAL)
+                   (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
+                           varbuf, yp -> yp_optcontrol, level * 4, "");
+               else
+                   (void) printf ("%%{ %s%s = %d; %%}\n%*s",
+                           var, SVAL (yp -> yp_varexp),
+                           val2int (yp -> yp_default), level * 4, "");
+           }
+           break;
+
+       case YP_INTLIST:
+       case YP_ENUMLIST:
+           if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
+               direction == YP_DECODER) {
+               if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
+                   (void) printf ("dummy-for-default\n%*s", ++level * 4, "");
+               if (yp -> yp_flags & YP_OPTIONAL)
+                   (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
+                           varbuf, yp -> yp_optcontrol, level * 4, "");
+               else
+                   (void) printf ("%%{ %s%s = %d; %%}\n%*s",
+                           var, SVAL (yp -> yp_varexp), dfl2int (yp),
+                           level * 4, "");
+           }
+           break;
+
+       case YP_REAL: 
+           if ((yp -> yp_flags & (YP_OPTIONAL|YP_DEFAULT)) &&
+               direction == YP_DECODER) {
+               if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
+                   (void) printf ("dummy-for-default\n%*s", ++level * 4, "");
+               if (yp -> yp_flags & YP_OPTIONAL)
+                   (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
+                           varbuf, yp -> yp_optcontrol, level * 4, "");
+               else
+                   (void) printf ("%%{ %s%s = %g; %%}\n%*s",
+                           var, SVAL (yp -> yp_varexp),
+                           val2real (yp -> yp_default), level * 4, "");
+           }
+           break;
+
+       case YP_NULL:
+           if ((yp -> yp_flags & YP_OPTIONAL) && direction == YP_DECODER) {
+               if (!top && !(yp -> yp_flags & (YP_ID | YP_TAG)))
+                   (void) printf ("dummy-for-default\n%*s", ++level * 4, "");
+               (void) printf ("%%{ %s -> optionals |= %s; %%}\n%*s",
+                       varbuf, yp -> yp_optcontrol, level * 4, "");
+           }
+           break;
+    }
+
+    if ((yp -> yp_flags & (YP_TAG | YP_IMPLICIT)) == (YP_TAG | YP_IMPLICIT))
+       (void) printf ("IMPLICIT ");
+    if (yp -> yp_flags & YP_BOUND)
+       (void) printf ("%s < ", yp -> yp_bound);
+    if (yp -> yp_flags & YP_COMPONENTS)
+       (void) printf ("COMPONENTS OF ");
+    if (yp -> yp_flags & YP_ENCRYPTED)
+       (void) printf ("ENCRYPTED ");
+
+    switch (yp -> yp_code) {
+       case YP_BOOL: 
+           (void) printf ("BOOLEAN");
+           switch (direction) {
+               case YP_ENCODER: 
+               case YP_DECODER: 
+                   (void) printf (top ? "\n%*s[[b %s -> %s ]]" : "\n%*s[[b %s%s ]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       case YP_INT: 
+           (void) printf ("INTEGER");
+           switch (direction) {
+               case YP_ENCODER: 
+               case YP_DECODER: 
+                   (void) printf (top ? "\n%*s[[i %s -> %s ]]" : "\n%*s[[i %s%s ]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       case YP_INTLIST:
+       case YP_ENUMLIST:
+           if (yp -> yp_code == YP_ENUMLIST)
+               (void) printf ("ENUMERATED");
+           else
+               (void) printf ("INTEGER");
+           switch (direction) {
+               case YP_ENCODER: 
+               case YP_DECODER: 
+                   (void) printf (top ? "\n%*s[[i %s -> %s ]]\n%*s{\n"
+                           : "\n%*s[[i %s%s ]]\n%*s{\n",
+                           level * 4, "", var, SVAL (yp -> yp_varexp),
+                           level * 4, "");
+                   break;
+
+               default: 
+                   (void) printf (" {\n");
+                   break;
+           }
+           level++;
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+               (void) printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named,
+                       val2int (yv), yv -> yv_next ? "," : "");
+           level--;
+           (void) printf ("%*s}", level * 4, "");
+           break;
+
+       case YP_BIT: 
+           (void) printf ("BIT STRING");
+           switch (direction) {
+               case YP_ENCODER: 
+                   (void) printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   (void) printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "",
+                           (level + 1) * 4, "");
+                   if (action2)
+                       (void) printf ("%*s%s\n", (level + 1) * 4, "", action2);
+                   (void) printf ("%*s%%}\n", level * 4, "");
+                   break;
+
+               case YP_DECODER: 
+                   balloc (yp, var, action2, level);
+                   break;
+           }
+           break;
+
+       case YP_BITLIST: 
+           (void) printf ("BIT STRING");
+           switch (direction) {
+               case YP_ENCODER: 
+                   (void) printf ("\n%*s[[x bit_parm = bitstr2strb (%s%s, &len) $ len]]\n%*s{\n",
+                           level * 4, "", var, SVAL (yp -> yp_varexp),
+                           level * 4, "");
+                   break;
+
+               case YP_DECODER: 
+               default: 
+                   (void) printf (" {\n");
+                   break;
+           }
+           level++;
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+               (void) printf ("%*s%s(%d)%s\n", level * 4, "", yv -> yv_named,
+                       val2int (yv), yv -> yv_next ? "," : "");
+           level--;
+           (void) printf ("%*s}", level * 4, "");
+           switch (direction) {
+               case YP_DECODER: 
+                   balloc (yp, var, action2, level);
+                   break;
+
+               case YP_ENCODER:
+                   (void) printf ("\n%*s%%{\n%*sfree (bit_parm);\n", level * 4, "",
+                           (level + 1) * 4, "");
+                   if (action2)
+                       (void) printf ("%*s%s\n", (level + 1) * 4, "", action2);
+                   (void) printf ("%*s%%}\n", level * 4, "");
+                   break;
+           }
+           break;
+
+       case YP_OCT: 
+           (void) printf ("OCTET STRING");
+           switch (direction) {
+               case YP_ENCODER: 
+                   (void) printf ("\n%*s[[q %s%s ]]", level * 4, "",
+                           var, SVAL (yp -> yp_varexp));
+                   break;
+
+               case YP_DECODER: 
+                   (void) printf ("\n%*s[[q %s%s ]]", level * 4, "",
+                           var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       case YP_REAL:
+           (void) printf ("REAL");
+           (void) printf (top ? "\n%*s[[r %s -> %s ]]" : "\n%*s[[r %s%s ]]",
+                   level * 4, "", var, SVAL (yp -> yp_varexp));
+           break;
+
+       case YP_NULL: 
+           (void) printf ("NULL");
+           break;
+
+       case YP_SEQ: 
+       case YP_SET:
+       case YP_ANY:
+           (void) printf ("%s", tags[yp -> yp_code]);
+           switch (direction) {
+               case YP_ENCODER:
+               case YP_DECODER:
+                       (void) printf ("\n%*s[[a %s%s ]]",
+                               level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       case YP_SEQTYPE: 
+       case YP_SETTYPE: 
+           ep = yp -> yp_code != YP_SETTYPE ? "element" : "member";
+           (void) printf ("%s\n", tags [yp -> yp_code]);
+           switch (direction) {
+               case YP_ENCODER: 
+                   if ((y = yp -> yp_type) -> yp_declexp) {
+                       (void) printf ("%*s%%{ %s = %s; %%}\n",
+                               (level + 1) * 4, "", y -> yp_declexp,
+                               SVAL (y -> yp_varexp));
+                   }
+                   if (h2flag) {
+                       if (top) {
+                           (void) printf ("%*s<<n_parm = 0; ", (level + 1) * 4, "");
+                           (void) printf ("n_parm < parm -> nelem; n_parm++>>\n");
+                       }
+                       else {
+                           (void) printf ("%*s<<n_%s = 0;\n%*sn_%s < %s -> nelem;\n",
+                                   (level + 1) * 4, "", yp -> yp_declexp,
+                                   (level + 3) * 4, "", yp -> yp_declexp,
+                                   yp -> yp_declexp);
+                           (void) printf ("%*sn_%s++>>\n",
+                                   (level + 3) * 4, "", yp -> yp_declexp);
+                       }
+                   }
+                   else {
+                       if (top)
+                           (void) printf ("%*s<<; parm; parm = parm -> next>>\n",
+                                   (level + 1) * 4, "");
+                       else
+                           (void) printf ("%*s<<%s = %s%s;\n%*s%s;\n%*s%s = %s -> next>>\n",
+                                   (level + 1) * 4, "", yp -> yp_declexp,
+                                   var, SVAL (yp -> yp_varexp),
+                                   (level + 3) * 4, "", yp -> yp_declexp,
+                                   (level + 3) * 4, "", yp -> yp_declexp,
+                                   yp -> yp_declexp);
+                   }
+                   break;
+
+               case YP_DECODER: 
+                   if (h2flag) {
+                       y = yp -> yp_type;
+                       xalloc (y, 0, level + 2, y -> yp_declexp,
+                               y -> yp_declexp, 1);
+                   }
+                   else
+                       xalloc (yp, 0, level + 1,
+                               top ? "parm" : yp -> yp_declexp,
+                               top ? modsym (mymodule, eval, "type")
+                               : yp -> yp_declexp, 1);
+                   break;
+           }
+           do_type1 (yp -> yp_type, 0, level + 1, ep, "", NULLCP, direction);
+           switch (direction) {
+               case YP_DECODER:
+                   (void) printf ("\n%*s%%{ ", (level + 1) * 4, "");
+                   if (h2flag)
+                       (void) printf ("n_%s++;", top ? "parm" : yp -> yp_declexp);
+                   else
+                       if (top)
+                           (void) printf ("parm = &((*parm) -> next);");
+                       else
+                           (void) printf ("%s = &((*%s) -> next);",
+                                   yp -> yp_declexp, yp -> yp_declexp);
+                   if (action2)
+                       (void) printf (" %s", action2);
+                   (void) printf (" %%}");
+                   break;
+           }
+           break;
+
+       case YP_SEQLIST: 
+       case YP_SETLIST: 
+           ep = yp -> yp_code != YP_SETLIST ? "element" : "member";
+           (void) printf ("%s", tags [yp -> yp_code]);
+           (void) printf ("\n%*s%%{\n", (level + 1) * 4, "");
+           if (direction == YP_DECODER)
+               xalloc (yp, 1, level + 2, yp -> yp_declexp,
+                       yp -> yp_declexp, 0);
+           for (y = yp -> yp_type; y; y = y -> yp_next) {
+               if (y -> yp_declexp)
+                   switch (direction) {
+                   case YP_ENCODER: 
+                       (void) printf ("%*s%s = %s;\n",
+                               (level + 2) * 4, "",
+                               y -> yp_declexp, y -> yp_varexp);
+                       break;
+
+                   case YP_DECODER:
+                       (void) printf ("%*s%s = &(%s);\n",
+                               (level + 2) * 4, "",
+                               y -> yp_declexp, y -> yp_varexp);
+                       break;
+                   }
+               if (direction == YP_DECODER &&
+                        y -> yp_flags & YP_DEFAULT) {
+                   prime_default (y, level + 2);
+               }
+           }
+           (void) printf ("%*s%%}\n%*s{\n", (level + 1) * 4, "",
+                   level * 4, "");
+           
+           if (!hflag || !(y = yp -> yp_type) || y -> yp_next) {
+               var = "";
+               top = 0;
+           }
+           for (y = yp -> yp_type; y; y = y -> yp_next) {
+               do_type1 (y, top,
+                       level + ((y -> yp_flags & (YP_ID | YP_TAG)) ? 1 : 2),
+                       ep, var, NULLCP, direction);
+               (void) printf ("%s\n", y -> yp_next ? ",\n" : "");
+           }
+           (void) printf ("%*s}", level * 4, "");
+           break;
+
+       case YP_CHOICE: 
+           (void) printf ("CHOICE");
+           if (!hflag || !(y = yp -> yp_type) || y -> yp_next)
+               var = "";
+           i = 0;
+           for (y = yp -> yp_type; y; y = y -> yp_next)
+               if (y -> yp_declexp)
+                   i++;
+           switch (direction) {
+               case YP_ENCODER: 
+                   if (i) {
+                       (void) printf ("\n%*s%%{\n", (level + 1) * 4, "");
+                       for (y = yp -> yp_type; y; y = y -> yp_next)
+                           if (y -> yp_declexp)
+                               (void) printf ("%*s%s = %s;\n", (level + 2) * 4, "",
+                                       y -> yp_declexp, y -> yp_varexp);
+                       (void) printf ("%*s%%}\n%*s", (level + 1) * 4, "",
+                               (level + 1) * 4 - 1, "" );
+                   }
+                   if (*var)
+                       (void) printf (" <<1>>");
+                   else
+                       if (top)
+                           (void) printf (" <<parm -> offset>>");
+                       else
+                           (void) printf (" <<%s -> offset>>",
+                                   yp -> yp_declexp);
+                   (void) printf (i ? "\n%*s{\n" : " {\n", level * 4, "");
+                   break;
+
+               case YP_DECODER: 
+                   (void) printf ("\n");
+                   xalloc (yp, 0, level + 1, yp -> yp_declexp,
+                           yp -> yp_declexp, 1);
+                   (void) printf ("%*s{\n", level * 4, "");
+                   break;
+
+               default: 
+                   (void) printf (" {\n");
+                   break;
+           }
+           if (direction == YP_DECODER) {
+               (void) sprintf (cp = buffer, "(*(%s)) -> offset = ",
+                           top ? "parm" : yp -> yp_declexp);
+               cp += strlen (cp);
+           }
+           else
+               cp = NULL;
+           if (!hflag || !(y = yp -> yp_type) || y -> yp_next)
+               top = 0;
+           else
+               if (top)
+                   cp = NULL;
+           for (y = yp -> yp_type; y; y = y -> yp_next) {
+               if (cp)
+                   (void) sprintf (cp, "%s;", y -> yp_offset);
+               do_type1 (y, top, level + 1, "choice", var,
+                       cp ? buffer : NULLCP, direction);
+               (void) printf ("%s\n", y -> yp_next ? ",\n" : "");
+           }
+           (void) printf ("%*s}", level * 4, "");
+           break;
+       
+       case YP_OID: 
+           (void) printf ("OBJECT IDENTIFIER");
+           switch (direction) {
+               case YP_ENCODER: 
+               case YP_DECODER: 
+                   (void) printf ("\n%*s[[O %s%s ]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       case YP_IDEFINED: 
+           if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
+               (void) printf ("%s.", yp -> yp_module);
+           (void) printf ("%s", yp -> yp_identifier);
+           switch (direction) {
+               case YP_ENCODER: 
+                   (void) printf ("\n%*s[[p %s%s ]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+
+               case YP_DECODER: 
+                   (void) printf ("\n%*s[[p &(%s%s)]]",
+                           level * 4, "", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+           break;
+
+       default: 
+           myyerror ("unknown type: %d", yp -> yp_code);
+    }
+
+    if (action2)
+       switch (yp -> yp_code) {
+           case YP_BIT:
+           case YP_BITLIST:
+               if (direction == YP_ENCODER)
+                   break;
+           case YP_SEQTYPE:
+           case YP_SETTYPE:
+               if (direction == YP_DECODER)
+                   break;
+               /* else fall */
+
+           default:            
+               (void) printf ("\n%*s%%{ %s %%}", level * 4, "", action2);
+               break;
+       }
+
+    if (yp -> yp_flags & YP_OPTIONAL) {
+       (void) printf ("\n%*sOPTIONAL", level * 4, "");
+
+       if (direction == YP_ENCODER)
+           switch (yp -> yp_code) {
+               case YP_BOOL: 
+               case YP_INT: 
+               case YP_INTLIST:
+               case YP_ENUMLIST:
+               case YP_NULL:
+               case YP_REAL:
+                   (void) printf (" <<%s -> optionals & %s >>",
+                           varbuf, yp -> yp_optcontrol);
+               default: 
+                   break;
+
+               case YP_BIT: 
+               case YP_BITLIST: 
+               case YP_OCT: 
+               case YP_SEQ: 
+               case YP_SEQTYPE: 
+               case YP_SEQLIST: 
+               case YP_SET: 
+               case YP_SETTYPE: 
+               case YP_SETLIST: 
+               case YP_CHOICE: 
+               case YP_ANY: 
+               case YP_OID: 
+               case YP_IDEFINED: 
+                   (void) printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp));
+                   break;
+           }
+    }
+    else
+       if (yp -> yp_flags & YP_DEFAULT) {
+           (void) printf ("\n%*sDEFAULT ", level * 4, "");
+           val2prf (yp -> yp_default, level + 2);
+
+           if (direction == YP_ENCODER)
+               switch (yp -> yp_code) {
+                   case YP_BOOL: 
+                       (void) printf (" <<%s%s%s>>",
+                               val2int (yp -> yp_default) ? "!" : "",
+                               var, SVAL (yp -> yp_varexp));
+                       break;
+
+                   case YP_INT: 
+                   case YP_INTLIST:
+                   case YP_ENUMLIST:
+                       (void) printf (" <<%s%s != %d>>", var, SVAL (yp -> yp_varexp),
+                               dfl2int (yp));
+                       break;
+
+                   case YP_REAL:
+                       (void) printf (" << %s%s != %g >>",
+                               var, SVAL (yp -> yp_varexp),
+                               val2real (yp -> yp_default));
+                       break;
+
+                   case YP_NULL: 
+                   default: 
+                       break;
+
+                   case YP_BIT: 
+                   case YP_BITLIST: 
+                   case YP_OCT: 
+                   case YP_SEQ: 
+                   case YP_SEQTYPE: 
+                   case YP_SEQLIST: 
+                   case YP_SET: 
+                   case YP_SETTYPE: 
+                   case YP_SETLIST: 
+                   case YP_CHOICE: 
+                   case YP_ANY: 
+                   case YP_OID: 
+                   case YP_IDEFINED: 
+                       (void) printf (" <<%s%s>>", var, SVAL (yp -> yp_varexp));
+                       break;
+               }
+       }
+
+    if (direction == YP_ENCODER
+           && yp -> yp_varexp
+           && (cp = index (yp -> yp_varexp, ' '))
+           && strncmp (cp + 1, "-> ", 3) == 0) {
+       *cp = NULL;
+       (void) sprintf (buffer, "(*%s) -> %s", yp -> yp_varexp, cp + 4);
+       yp -> yp_varexp = new_string (buffer);
+    }
+}
+
+/* \f   TYPE HANDLING */
+
+YP  lookup_type (mod, id)
+register char *mod,
+             *id;
+{
+    register SY            sy;
+
+    for (sy = mysymbols; sy; sy = sy -> sy_next) {
+       if (mod) {
+           if (strcmp (sy -> sy_module, mod))
+               continue;
+       }
+       else
+           if (strcmp (sy -> sy_module, mymodule)
+                   && strcmp (sy -> sy_module, "UNIV"))
+               continue;
+
+       if (strcmp (sy -> sy_name, id) == 0)
+           return sy -> sy_type;
+    }
+
+    return NULLYP;
+}
+
+/* \f */
+
+pepsy (yp, top, level, id, val, var, arrayflg)
+register YP    yp;
+int    top,
+       level,
+        arrayflg;
+char   *id,
+       *val,
+       *var;
+{
+    register int    i,
+                   j;
+    register char  *bp;
+    char   *cp,
+          *dp,
+           *ep,
+          *newid,
+            buf1[BUFSIZ],
+           buf2[BUFSIZ],
+           buf3[BUFSIZ];
+    register YP            y;
+    register YV            yv;
+
+    (void) strcpy (bp = buf2, var);
+    bp += strlen (bp);
+    /* Preserve the name of the field */
+    yp->yp_varexp = new_string(yp -> yp_ptrname ? yp -> yp_ptrname : id);
+
+    switch (yp -> yp_code) {
+       case YP_BOOL: 
+           if (aflag)
+               printag (yp, level + 4, NULLCP);
+           (void) fprintf (fdef, "%*schar    %s;\n", level * 4, "",
+                    array(id, arrayflg));
+           break;
+
+       case YP_INT: 
+       case YP_INTLIST:
+       case YP_ENUMLIST:
+           if (aflag)
+               printag (yp, level + 4, NULLCP);
+           (void) fprintf (fdef, "%*sinteger     %s;\n", level * 4, "",
+                    array(id, arrayflg));
+           if (yp -> yp_code == YP_INT)
+               break;
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
+               modsym_aux (yv -> yv_named, buf1);
+               (void) fprintf (fdef, "#define\t%s_%s\t%d\n",
+                       modsym (mymodule, top ? eval : id, "int"),
+                       buf1, val2int (yv));
+           }
+           break;
+
+       case YP_BIT: 
+       case YP_BITLIST: 
+           if (!top) {
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sPE      %s;\n", level * 4, "",
+                        array(id, arrayflg));
+           }
+           if (yp -> yp_code != YP_BITLIST)
+               break;
+           i = -1;
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+               if ((j = val2int (yv)) < 0)
+                   pyyerror (yp, "invalid bit number in BIT STRING");
+               else
+                   if (j > i)
+                       i = j;
+           if (i < sizeof (int) * 8) {         /* NBBY */
+               (void) fprintf (fdef, "#define\t%s\t\"\\020",
+                       modsym (mymodule, top ? eval : id, "bits"));
+               for (yv = yp -> yp_value; yv; yv = yv -> yv_next)
+                   if (yv -> yv_flags & YV_NAMED)
+                       (void) fprintf (fdef, "\\0%o%s",
+                               val2int (yv) + 1, yv -> yv_named);
+                   else
+                       (void) fprintf (fdef, "\\0%oBIT%d",
+                               val2int (yv) + 1, val2int (yv));
+               (void) fprintf (fdef, "\"\n");
+           }
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
+               modsym_aux (yv -> yv_named, buf1);
+               (void) fprintf (fdef, "#define\t%s_%s\t%d\n",
+                       modsym (mymodule, top ? eval : id, "bit"),
+                       buf1, val2int (yv));
+           }
+           break;
+
+       case YP_REAL: 
+           if (aflag)
+               printag (yp, level + 4, NULLCP);
+           (void) fprintf (fdef, "%*sdouble    %s;\n", level * 4, "",
+                    array(id, arrayflg));
+           yp -> yp_varexp = new_string (buf2);
+           break;
+
+       case YP_OCT: 
+           if (!top) {
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sstruct qbuf *%s;\n", level * 4, "",
+                        array(id, arrayflg));
+           }
+           break;
+
+       case YP_NULL: 
+           if (aflag)
+               printag (yp, level + 4, NULLCP);
+           (void) fprintf (fdef, "%*schar    %s;\n", level * 4, "",
+                    array(id, arrayflg));
+           break;
+
+       case YP_SEQ: 
+       case YP_SET: 
+       case YP_ANY: 
+           if (!top) {
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sPE      %s;\n", level * 4, "",
+                        array(id, arrayflg));
+           }
+           break;
+
+       case YP_SEQTYPE: 
+       case YP_SETTYPE: 
+           ep = yp -> yp_code != YP_SETTYPE ? "element" : "member";
+           if ((cp = rindex (buf2, ' ')) && *++cp) {
+               if ((dp = rindex (cp, '.')) && *++dp)
+                   cp = dp;
+               (void) sprintf (dp = buf1, "%*.*s",
+                       cp - buf2, cp - buf2, buf2);
+               dp += strlen (dp);
+           }
+           else {
+               (void) strcpy (buf1, buf2);
+               dp = NULL;
+           }
+           newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
+           if (h2flag && top)
+               (void) fprintf (fdef, "%*sinteger\tnelem;\n", level * 4, "");
+           if (!top) {
+               if (yp -> yp_structname)
+                   id = yp -> yp_structname;
+               else if (!Hflag)
+                   id = gensym (ep, NULLCP);
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
+               if (h2flag)
+                   (void) fprintf (fdef, "%*sinteger\tnelem;\n", (level + 1) * 4, "");
+           }
+           if (dp)
+               (void) strcpy (dp, newid);
+           (void) strcpy (bp = buf2, id);
+           bp += strlen (bp);
+
+           if (!top)
+               yp -> yp_declexp = new_string (id);
+
+           if (dp)
+               (void) strcpy (dp, newid);
+           if ((y = yp -> yp_type) -> yp_code == YP_IDEFINED && hflag) {
+               modsym_aux (y -> yp_identifier, cp = buf3);
+               if (h2flag) {
+                   cp += strlen(cp);
+                   (void) sprintf (cp, "[n_%s]", PARVAL (yp->yp_declexp));
+                   cp = buf3;
+               }
+           }
+           else {
+               switch (y -> yp_code) {
+               case YP_SEQLIST:
+               case YP_SETLIST:
+               case YP_SETTYPE:
+               case YP_SEQTYPE:
+               case YP_CHOICE:
+               case YP_IDEFINED:
+                   cp = gensym (ep, h2flag ? PARVAL(yp->yp_declexp) : NULLCP);
+                   break;
+               default:
+                   cp = gensym (ep, NULLCP);
+                   break;
+               }
+           }
+           (void) sprintf (bp, " -> %s", cp);
+           level++;
+           pepsy (y, 0, level, cp, ep, buf2, h2flag);
+           *bp = NULL;
+           if (y -> yp_code != YP_IDEFINED)
+               free (cp);
+           if (!h2flag)
+               (void) fprintf (fdef, "\n%*sstruct %s *next;\n", level * 4, "",
+                        top ? modsym (mymodule, val, "type") : id);
+
+           level--;
+
+           (void) strcpy (bp = buf2, var);
+           bp += strlen (bp);
+
+           if (!top) {
+               (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "",
+                        array(newid, arrayflg));
+               if (!Hflag)
+                   free (id);
+           }
+           break;
+
+       case YP_SEQLIST: 
+       case YP_SETLIST: 
+           ep = yp -> yp_code != YP_SETLIST ? "element" : "member";
+           if ((cp = rindex (buf2, ' ')) && *++cp) {
+               if ((dp = rindex (cp, '.')) && *++dp)
+                   cp = dp;
+               (void) sprintf (dp = buf1, "%*.*s",
+                       cp - buf2, cp - buf2, buf2);
+               dp += strlen (dp);
+           }
+           else {
+               (void) strcpy (buf1, buf2);
+               dp = NULL;
+           }
+           newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
+           if (!top) {
+               if (yp -> yp_structname)
+                   id = yp -> yp_structname;
+               else if (!Hflag)
+                   id = gensym (ep, NULLCP);
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
+
+               if (dp)
+                   (void) strcpy (dp, newid);
+
+               (void) strcpy (bp = buf2, id);
+               bp += strlen (bp);
+               yp -> yp_declexp = new_string (id);
+
+               level++;
+           }
+           if (dp)
+               (void) strcpy (dp, newid);
+           for (y = yp -> yp_type, i = 0; y; y = y -> yp_next) {
+               if (y -> yp_flags & YP_OPTIONAL)
+                   switch (y -> yp_code) {
+                       case YP_BOOL:
+                       case YP_INT:
+                       case YP_INTLIST:
+                       case YP_ENUMLIST:
+                       case YP_REAL:
+                       case YP_NULL:
+                           {
+                               char obuf[BUFSIZ];
+                               
+                               if (i == 0)
+                                   (void) fprintf (fdef, "%*sinteger     optionals;\n",
+                                            level * 4, "");
+                               if (y -> yp_flags & YP_ID)
+                                   modsym_aux (y -> yp_id, cp = buf1);
+                               else {
+                                   cp = gensym (ep, NULLCP);
+                                   (void) strcpy (buf1, cp);
+                                   free (cp);
+                                   cp = buf1;
+                               }
+                               (void) sprintf (obuf, "%s_%s",
+                                               modsym (mymodule,
+                                                       top ? eval : id,
+                                                       "opt"), cp);
+                               (void) fprintf (fdef, "#define\t%s (0%08o)\n", obuf,
+                                        1 << i);
+#ifdef ASN1_OUTPUT
+                               y -> yp_optcontrol = new_string (obuf);
+                               y -> yp_flags |= YP_OPTCONTROL;
+#endif
+
+                               i ++;
+                               if (i >= 8 * sizeof (int))
+                                   yyerror ("too many optionals in structure");
+                           }
+                           break;
+                       }
+           }
+           if (i > 0) (void) fprintf (fdef, "\n");
+
+           for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) {
+               if (y -> yp_flags & YP_ID)
+                   modsym_aux (y -> yp_id, cp = buf1);
+               else
+                   cp = gensym (ep, NULLCP);
+               (void) sprintf (bp, " -> %s", cp);
+               pepsy (y, 0, level, cp, ep, buf2, 0);
+               *bp = NULL;
+               if (!(y -> yp_flags & YP_ID))
+                   free (cp);
+               if (y -> yp_next)
+                   (void) fprintf (fdef, "\n");
+           }
+           if (i == 1)
+               (void) fprintf (fdef, "%*schar    dummy;\n", level * 4, "");
+           if (!top) {
+               level--;
+
+               (void) strcpy (bp = buf2, var);
+               bp += strlen (bp);
+
+               (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "",
+                        array(newid, arrayflg));
+               if (!Hflag)
+                   free (id);
+           }
+           break;
+
+       case YP_CHOICE: 
+           if ((cp = rindex (buf2, ' ')) && *++cp) {
+               if ((dp = rindex (cp, '.')) && *++dp)
+                   cp = dp;
+               (void) sprintf (dp = buf1, "%*.*s",
+                       cp - buf2, cp - buf2, buf2);
+               dp += strlen (dp);
+           }
+           else {
+               (void) strcpy (buf1, buf2);
+               dp = NULL;
+           }
+           newid = yp -> yp_ptrname ? yp -> yp_ptrname : id;
+           if (!top) {
+               if (yp -> yp_structname)
+                   id = yp -> yp_structname;
+               else if (!Hflag)
+                   id = gensym ("choice", NULLCP);
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sstruct %s {\n", level * 4, "", id);
+
+               if (dp)
+                   (void) strcpy (dp, newid);
+               (void) strcpy (bp = buf2, id);
+               bp += strlen (bp);
+               yp -> yp_declexp = new_string (id);
+
+               level++;
+           }
+           if (dp)
+               (void) strcpy (dp, newid);
+           (void) fprintf (fdef, "%*sint         offset;\n", level * 4, "");
+           if (top)
+               cp = modsym (mymodule, val, "type");
+           else
+               cp = id;
+           (void) sprintf (ep = buf1, "%s_", cp);
+           ep += strlen (ep);
+           for (y = yp -> yp_type, i = 1; y; y = y -> yp_next, i++) {
+               if (y -> yp_flags & YP_ID)
+                   modsym_aux (y -> yp_id, ep);
+               else
+                   (void) sprintf (ep, "%d", i);
+               y -> yp_offset = new_string (buf1);
+               (void) fprintf (fdef, "#define\t%s\t%d\n", y -> yp_offset, i);
+           }
+           (void) fprintf (fdef, "\n%*sunion {\n", level * 4, "");
+           level++;
+           for (y = yp -> yp_type; y; y = y -> yp_next) {
+               char    *t;
+
+               if (y -> yp_flags & YP_ID)
+                   modsym_aux (y -> yp_id, cp = buf1);
+               else
+                   cp = gensym ("choice", NULLCP);
+               (void) sprintf (bp, " -> un.%s", cp);
+               pepsy (y, 0, level, cp, "choice", buf2, 0);
+    /* prefix yp_varexp (field name) with un. so we will generate offsets that
+     * allow for the union all the CHOICE fields are imbedded in
+     */
+               t = y->yp_varexp;
+               y->yp_varexp = my_strcat("un.",  t);
+               free(t);
+
+               *bp = NULL;
+               if (!(y -> yp_flags & YP_ID))
+                   free (cp);
+               if (y -> yp_next)
+                   (void) fprintf (fdef, "\n");
+           }
+           level--;
+           (void) fprintf (fdef, "%*s}       un;\n", level * 4, "");
+           if (!top) {
+               level--;
+
+               (void) strcpy (bp = buf2, var);
+               bp += strlen (bp);
+
+               (void) fprintf (fdef, "%*s} *%s;\n", level * 4, "",
+                        array(newid, arrayflg));
+               if (!Hflag)
+                   free (id);
+           }
+           break;
+
+       case YP_OID: 
+           if (!top) {
+               if (aflag)
+                   printag (yp, level + 4, NULLCP);
+               (void) fprintf (fdef, "%*sOID     %s;\n", level * 4, "",
+                        array(id, arrayflg));
+           }
+           break;
+
+       case YP_IDEFINED: 
+           if (aflag)
+               printag (yp, level + 4, NULLCP);
+           {
+               /* Predefined Universal Type */
+               struct univ_typ *p;
+               if ((p = univtyp(yp->yp_identifier))) {
+                   (void) fprintf (fdef, "%*s%s%s;\n", level * 4, "",
+                       p->univ_data, array(id, arrayflg));
+                   /*
+                    if (fflag)
+                        ferr(1, "pepsy:YP_IDEFINED:fflag not implemented\n");
+                   */
+                   break;
+               }
+           }
+           (void) fprintf (fdef, "%*sstruct %s *%s;\n", level * 4, "",
+                   modsym (yp -> yp_module, yp -> yp_identifier, "type"),
+                   array(id, arrayflg));
+           break;
+
+       default: 
+           myyerror ("unknown type: %d", yp -> yp_code);
+    }
+}
+
+/* \f */
+
+static printag (yp, level, pullup)
+register YP    yp;
+int    level;
+char   *pullup;
+{
+    (void) fprintf (fdef, "%*s/* ", level * 4, "");
+    switch (yp -> yp_code) {
+       case YP_IDEFINED: 
+           if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
+               (void) fprintf (fdef, "%s.", yp -> yp_module);
+           (void) fprintf (fdef, "%s", yp -> yp_identifier);
+           break;
+
+       default: 
+           (void) fprintf (fdef, "%s", tags[yp -> yp_code]);
+           break;
+    }
+    if (pullup)
+       (void) fprintf (fdef, " pulled up from %s", pullup);
+    (void) fprintf (fdef, " */\n");
+}
+
+/* \f */
+
+static xalloc (yp, top, level, arg, type, brackets)
+register YP    yp;
+int    top,
+       level,
+       brackets;
+char   *arg,
+       *type;
+{
+    int            didone;
+    register YP            y;
+
+    if (hflag && !arg && !type)
+       return;
+
+    didone = 0;
+
+    if (arg && type) {
+       if (brackets && !didone) {
+           (void) printf ("%*s%%{\n", level * 4, "");
+           level++, didone++;
+       }
+
+       if (h2flag && (yp -> yp_code == YP_SEQTYPE ||
+                      yp -> yp_code == YP_SETTYPE)) {
+           (void) printf ("%*s{\n%*sPE      xx_pe = prim2%s ($$);\n\n",
+                   level * 4, "", (level +1) * 4, "",
+                   yp -> yp_code == YP_SEQTYPE ? "seq" : "set");
+           (void) printf ("%*sn_%s = xx_pe -> pe_cardinal > 0 ",
+                   (level + 1) * 4, "", arg);
+           (void) printf ("? xx_pe -> pe_cardinal : 0;\n%*s}\n", level * 4, "");
+           (void) printf ("%*sif ((*(%s) = (struct %s *)\n",
+                   level * 4, "", arg, type);
+           (void) printf ("%*scalloc (1 + (unsigned) n_%s, sizeof **(%s)",
+                   (level + 2) * 4, "", arg, arg);
+           (void) printf (")) == ((struct %s *) 0)) {\n", type);
+           (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n",
+                   (level + 1) * 4, "");
+           (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
+                   level * 4, "");
+           (void) printf ("%*s(*%s) -> nelem = n_%s;\n", level * 4, "", arg, arg);
+           (void) printf ("%*sn_%s = 0;\n", level * 4, "", arg);
+       } else {
+           (void) printf ("%*sif ((*(%s) = (struct %s *)\n",
+                   level * 4, "", arg, type);
+           (void) printf ("%*scalloc (1, sizeof **(%s))) == ((struct %s *) 0)) {\n",
+                   (level + 2) * 4, "", arg, type);
+           (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n",
+                   (level + 1) * 4, "");
+           (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "",
+                   level * 4, "");
+       }
+    }
+    switch (yp -> yp_code) {
+    case YP_SEQTYPE:
+    case YP_SETTYPE:
+       if (top) break;
+    case YP_CHOICE:
+    case YP_SEQLIST:
+    case YP_SETLIST:
+       for (y = yp -> yp_type; y; y = y -> yp_next)
+           switch (y -> yp_code) {
+           case YP_SEQTYPE: 
+           case YP_SETTYPE:
+               if (h2flag && (yp -> yp_code == YP_SETLIST ||
+                              yp -> yp_code == YP_SEQLIST)) {
+                   /* include allocation here - no chance later */
+                   if (brackets && !didone) {
+                       (void) printf ("%*s%%{\n", level * 4, "");
+                       level++, didone++;
+                   }
+                   if (y -> yp_declexp)
+                       (void) printf ("%*s%s = &(%s);\n", level * 4, "",
+                               y -> yp_declexp,
+                               y -> yp_varexp);
+                   xalloc (y, top, level, y -> yp_declexp,
+                           y -> yp_declexp, 0);
+               }
+               /* and continue ... */
+           case YP_SEQLIST: 
+           case YP_SETLIST: 
+           case YP_CHOICE:
+               if (brackets && !didone) {
+                   (void) printf ("%*s%%{\n", level * 4, "");
+                   level++, didone++;
+               }
+               (void) printf ("%*s%s = &(%s);\n",
+                       level * 4, "", y -> yp_declexp,
+                       y -> yp_varexp);
+               break;
+           }
+       break;
+    }
+
+    if (brackets && didone) {
+       level--;
+       (void) printf ("%*s%%}\n", level * 4, "");
+    }
+}
+
+
+static balloc (yp, var, action2, level)
+register YP    yp;
+char   *var, *action2;
+int    level;
+{
+    (void) printf ("\n%*s%%{\n", level * 4, "");
+    level++;
+
+    (void) printf ("%*sif ((%s%s = prim2bit (pe_cpy ($$))) == NULLPE) {\n",
+           level * 4, "", var, SVAL (yp -> yp_varexp));
+    (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, "");
+    (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, "");
+
+    if (action2)
+       (void) printf ("\n%*s%s\n", level * 4, "", action2);
+
+    level--;
+    (void) printf ("%*s%%}", level * 4, "");
+}
+
+#ifdef notdef
+static qalloc (yp, var, action2, level)
+register YP    yp;
+char   *var,
+       *action2;
+int    level;
+{
+    (void) printf ("\n%*s%%{\n", level * 4, "");
+    level++;
+
+    (void) printf ("%*sif ((%s%s = str2qb ($$, $$_len, 1)) == ((struct qbuf *) 0)) {\n",
+           level * 4, "", var, SVAL (yp -> yp_varexp));
+    (void) printf ("%*sadvise (NULLCP, \"%%s\", PEPY_ERR_NOMEM);\n", (level + 1) * 4, "");
+    (void) printf ("%*sreturn NOTOK;\n%*s}\n", (level + 1) * 4, "", level * 4, "");
+
+    if (action2)
+       (void) printf ("\n%*s%s\n", level * 4, "", action2);
+
+    level--;
+    (void) printf ("%*s%%}", level * 4, "");
+}
+#endif
+
+/* \f */
+
+/*
+ * now we don't pull up things if they have actions associated with them
+ * this should be okay for those who want exact posy equivalence and
+ * yet keep those who want the pepy support able to have multiple
+ * actions in CHOICE { CHOICE {} } and such like
+ */
+static choice_pullup (yp, partial)
+register YP    yp;
+int    partial;
+{
+    register YP           *x,
+                   y,
+                   z,
+                  *z1,
+                   z2,
+                   z3;
+
+    for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) {
+       if (y -> yp_flags & (YP_TAG | YP_BOUND))
+           continue;
+
+       switch (y -> yp_code) {
+           case YP_IDEFINED:
+               if ((z = lookup_type (y -> yp_module, y -> yp_identifier))
+                       == NULLYP
+                       || z -> yp_code != YP_CHOICE)
+                   continue;
+               if (z -> yp_control_act || z ->yp_bef_alist || z-> yp_aft_alist)
+                   continue;
+
+               choice_pullup (z2 = copy_type (z), CH_FULLY);
+               goto patch;
+
+           case YP_CHOICE:
+               if (y -> yp_control_act || y ->yp_bef_alist || y-> yp_aft_alist)
+                   continue;
+
+               choice_pullup (z2 = copy_type (y), CH_FULLY);
+patch: ;
+               if (partial) {
+                   *x = z2;
+                   z2 -> yp_next =  y -> yp_next;
+                   continue;
+               }
+               break;
+
+           default:
+               continue;
+       }
+       z = z3 = z2 -> yp_type;
+       for (z1 = &z -> yp_next; z2 = *z1; z1 = &z2 -> yp_next)
+           z3 = z2;
+       *z1 = y -> yp_next;
+       *x = z;
+       y = z3;
+    }
+}
+
+/* \f */
+
+static components_pullup (yp)
+register YP    yp;
+{
+    register YP    *x,
+                   y,
+                   z,
+                   z1,
+                   z2;
+
+    for (x = &yp -> yp_type; y = *x; x = &y -> yp_next) {
+       if (!(y -> yp_flags & YP_COMPONENTS))
+           continue;
+
+       switch (y -> yp_code) {
+           case YP_SEQLIST:
+           case YP_SETLIST:
+               z = y;
+               break;
+
+           case YP_IDEFINED:
+               if ((z = lookup_type (y -> yp_module, y -> yp_identifier))
+                       == NULLYP) {
+                   warning ("COMPONENTS OF target \"%s\" is undefined",
+                            y -> yp_identifier);
+                   continue;
+               }
+               break;
+       }
+       if (yp -> yp_code != z -> yp_code) {
+           warning ("COMPONENTS OF target \"%s\" is wrong type, should be %s",
+                    y -> yp_code == YP_IDEFINED ? y -> yp_identifier
+                                                : y -> yp_id ? y -> yp_id
+                                                : "",
+                    yp -> yp_code == YP_SEQLIST ? "SEQUENCE" : "SET");
+           continue;
+       }
+       if (z -> yp_type == NULLYP)
+           continue;
+       components_pullup (z = copy_type (z));
+       *x = z2 = z -> yp_type;
+       for (x = &z -> yp_type; z1 = *x; x = &z1 -> yp_next)
+           z2 = z1;
+       *x = y -> yp_next;
+       y = z2;
+    }
+}
+
+/* \f   VALUE HANDLING */
+
+static int  val2int (yv)
+register YV    yv;
+{
+    switch (yv -> yv_code) {
+       case YV_BOOL:
+       case YV_NUMBER:
+           return yv -> yv_number;
+
+       case YV_STRING:
+           yyerror ("need an integer, not a string");
+
+       case YV_IDEFINED:
+       case YV_IDLIST:
+           yyerror ("haven't written symbol table for values yet");
+
+       case YV_NULL:
+           yyerror ("need an integer, not NULL");
+
+       default:
+           myyerror ("unknown value: %d", yv -> yv_code);
+    }
+/* NOTREACHED */
+}
+
+static double  val2real (yv)
+register YV    yv;
+{
+    switch (yv -> yv_code) {
+       case YV_NUMBER:
+           return yv -> yv_number;
+
+       case YV_REAL:
+           return yv -> yv_real;
+
+       case YV_STRING:
+           yyerror ("need an integer, not a string");
+
+       case YV_IDEFINED:
+       case YV_IDLIST:
+           yyerror ("haven't written symbol table for values yet");
+
+       case YV_NULL:
+           yyerror ("need an integer, not NULL");
+
+       default:
+           myyerror ("unknown value: %d", yv -> yv_code);
+    }
+/* NOTREACHED */
+}
+
+/* \f */
+
+static val2prf (yv, level)
+register YV    yv;
+int    level;
+{
+    register YV    y;
+
+    if (yv -> yv_flags & YV_ID)
+       (void) printf ("%s ", yv -> yv_id);
+
+    if (yv -> yv_flags & YV_TYPE)      /* will this REALLY work??? */
+       do_type1 (yv -> yv_type, 0, level, NULLCP, NULLCP, NULLCP, NULL);
+
+    switch (yv -> yv_code) {
+       case YV_BOOL: 
+           (void) printf (yv -> yv_number ? "TRUE" : "FALSE");
+           break;
+
+       case YV_NUMBER: 
+           if (yv -> yv_named)
+               (void) printf ("%s", yv -> yv_named);
+           else
+               (void) printf ("%d", yv -> yv_number);
+           break;
+
+       case YV_REAL:
+           dump_real (yv -> yv_real);
+           break;
+
+       case YV_STRING: 
+           (void) printf ("\"%s\"", yv -> yv_string);
+           break;
+
+       case YV_IDEFINED: 
+           if (yv -> yv_module)
+               (void) printf ("%s.", yv -> yv_module);
+           (void) printf ("%s", yv -> yv_identifier);
+           break;
+
+       case YV_IDLIST: 
+       case YV_VALIST: 
+           (void) printf ("{");
+           for (y = yv -> yv_idlist; y; y = y -> yv_next) {
+               (void) printf (" ");
+               val2prf (y, level + 1);
+               (void) printf (y -> yv_next ? ", " : " ");
+           }
+           (void) printf ("}");
+           break;
+
+       case YV_NULL: 
+           (void) printf ("NULL");
+           break;
+
+       default: 
+           myyerror ("unknown value: %d", yv -> yv_code);
+       /* NOTREACHED */
+    }
+}
+static dump_real (r)
+double r;
+{
+#ifndef        BSD44
+       extern char *ecvt ();
+       char    *cp;
+       char    sbuf[128];
+       int     decpt, sign;
+
+       cp = ecvt (r, 20, &decpt, &sign);
+       (void) strcpy (sbuf, cp);       /* cp gets overwritten by printf */
+       (void) printf ("{ %s%s, 10, %d }", sign ? "-" : "", sbuf,
+               decpt - strlen (sbuf));
+#else
+    register char   *cp,
+                   *dp,
+                   *sp;
+    char    sbuf[128];
+
+    (void) sprintf (sbuf, "%.19e", r);
+    if (*(dp = sbuf) == '-')
+       sp = "-", dp++;
+    else
+       sp = "";
+    
+    if (dp[1] != '.' || (cp = index (dp, 'e')) == NULL) {
+       (void) printf ("{ 0, 10, 0 } -- %s --", sbuf);
+       return;
+    }
+    *cp++ = NULL;
+    (void) printf ("{ %s%c%s, 10, %d }",
+           sp, *dp, dp + 2, atoi (cp) - strlen (dp + 2));
+#endif
+}
+
+/* \f */
+
+static int  dfl2int (yp)
+register YP    yp;
+{
+    register YV            yv,
+                   y;
+
+    yv = yp -> yp_default;
+    switch (yv -> yv_code) {
+       case YV_BOOL:
+       case YV_NUMBER:
+           return yv -> yv_number;
+
+       case YV_STRING:
+           yyerror ("need an integer, not a string");
+
+       case YV_REAL:
+           yyerror ("need an integer, not a real");
+
+       case YV_IDEFINED:
+           for (y = yp -> yp_value; y; y = y -> yv_next)
+               if (y -> yv_code == YV_NUMBER
+                       && (y -> yv_flags & YV_NAMED)
+                       && strcmp (yv -> yv_identifier, y -> yv_named) == 0)
+                   return y -> yv_number;
+           /* and fall */
+
+       case YV_IDLIST:
+           yyerror ("haven't written symbol table for values yet");
+
+       case YV_NULL:
+           yyerror ("need an integer, not NULL");
+
+       default:
+           myyerror ("unknown value: %d", yv -> yv_code);
+    }
+/* NOTREACHED */
+}
+
+/* \f   DEBUG */
+
+print_type (yp, level)
+register YP    yp;
+register int   level;
+{
+    register YP            y;
+    register YV            yv;
+
+    if (yp == NULLYP)
+       return;
+
+    (void) fprintf (stderr, "%*scode=0x%x flags=%s direction=0x%x\n", level * 4, "",
+           yp -> yp_code, sprintb (yp -> yp_flags, YPBITS),
+           yp -> yp_direction);
+    (void) fprintf (stderr,
+           "%*sintexp=\"%s\" strexp=\"%s\" prfexp=0%o declexp=\"%s\" varexp=\"%s\"\n",
+           level * 4, "", yp -> yp_intexp, yp -> yp_strexp, yp -> yp_prfexp,
+           yp -> yp_declexp, yp -> yp_varexp);
+    if (yp -> yp_param_type)
+       (void) fprintf (stderr, "%*sparameter type=\"%s\"\n", level * 4, "",
+                yp -> yp_param_type);
+    if (yp -> yp_action0)
+       (void) fprintf (stderr, "%*saction0 at line %d=\"%s\"\n", level * 4, "",
+               yp -> yp_act0_lineno, yp -> yp_action0);
+    if (yp -> yp_action05)
+       (void) fprintf (stderr, "%*saction05 at line %d=\"%s\"\n", level * 4, "",
+               yp -> yp_act05_lineno, yp -> yp_action05);
+    if (yp -> yp_action1)
+       (void) fprintf (stderr, "%*saction1 at line %d=\"%s\"\n", level * 4, "",
+               yp -> yp_act1_lineno, yp -> yp_action1);
+    if (yp -> yp_action2)
+       (void) fprintf (stderr, "%*saction2 at line %d=\"%s\"\n", level * 4, "",
+               yp -> yp_act2_lineno, yp -> yp_action2);
+    if (yp -> yp_action3)
+       (void) fprintf (stderr, "%*saction3 at line %d=\"%s\"\n", level * 4, "",
+               yp -> yp_act3_lineno, yp -> yp_action3);
+
+    if (yp -> yp_flags & YP_TAG) {
+       (void) fprintf (stderr, "%*stag class=0x%x value=0x%x\n", level * 4, "",
+               yp -> yp_tag -> yt_class, yp -> yp_tag -> yt_value);
+       print_value (yp -> yp_tag -> yt_value, level + 1);
+    }
+
+    if (yp -> yp_flags & YP_DEFAULT) {
+       (void) fprintf (stderr, "%*sdefault=0x%x\n", level * 4, "", yp -> yp_default);
+       print_value (yp -> yp_default, level + 1);
+    }
+
+    if (yp -> yp_flags & YP_ID)
+       (void) fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yp -> yp_id);
+
+    if (yp -> yp_flags & YP_BOUND)
+       (void) fprintf (stderr, "%*sbound=\"%s\"\n", level * 4, "", yp -> yp_bound);
+
+    if (yp -> yp_offset)
+       (void) fprintf (stderr, "%*soffset=\"%s\"\n", level * 4, "", yp -> yp_offset);
+
+    switch (yp -> yp_code) {
+       case YP_INTLIST:
+        case YP_ENUMLIST:
+       case YP_BITLIST:
+           (void) fprintf (stderr, "%*svalue=0x%x\n", level * 4, "", yp -> yp_value);
+           for (yv = yp -> yp_value; yv; yv = yv -> yv_next) {
+               print_value (yv, level + 1);
+               (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
+           }
+           break;
+
+       case YP_SEQTYPE:
+       case YP_SEQLIST:
+       case YP_SETTYPE:
+       case YP_SETLIST:
+       case YP_CHOICE:
+           (void) fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yp -> yp_type);
+           for (y = yp -> yp_type; y; y = y -> yp_next) {
+               print_type (y, level + 1);
+               (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
+           }
+           break;
+
+       case YP_IDEFINED:
+           (void) fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n",
+                   level * 4, "", yp -> yp_module ? yp -> yp_module : "",
+                   yp -> yp_identifier);
+           break;
+
+       default:
+           break;
+    }
+}
+
+/* \f */
+
+static print_value (yv, level)
+register YV    yv;
+register int   level;
+{
+    register YV            y;
+
+    if (yv == NULLYV)
+       return;
+
+    (void) fprintf (stderr, "%*scode=0x%x flags=%s\n", level * 4, "",
+           yv -> yv_code, sprintb (yv -> yv_flags, YVBITS));
+
+    if (yv -> yv_action)
+       (void) fprintf (stderr, "%*saction at line %d=\"%s\"\n", level * 4, "",
+               yv -> yv_act_lineno, yv -> yv_action);
+
+    if (yv -> yv_flags & YV_ID)
+       (void) fprintf (stderr, "%*sid=\"%s\"\n", level * 4, "", yv -> yv_id);
+
+    if (yv -> yv_flags & YV_NAMED)
+       (void) fprintf (stderr, "%*snamed=\"%s\"\n", level * 4, "", yv -> yv_named);
+
+    if (yv -> yv_flags & YV_TYPE) {
+       (void) fprintf (stderr, "%*stype=0x%x\n", level * 4, "", yv -> yv_type);
+       print_type (yv -> yv_type, level + 1);
+    }
+
+    switch (yv -> yv_code) {
+       case YV_NUMBER:
+       case YV_BOOL:
+           (void) fprintf (stderr, "%*snumber=0x%x\n", level * 4, "",
+                   yv -> yv_number);
+           break;
+
+       case YV_STRING:
+           (void) fprintf (stderr, "%*sstring=\"%s\"\n", level * 4, "",
+                   yv -> yv_string);
+           break;
+
+       case YV_IDEFINED:
+           if (yv -> yv_flags & YV_BOUND)
+               (void) fprintf (stderr, "%*smodule=\"%s\" identifier=\"%s\"\n",
+                       level * 4, "", yv -> yv_module, yv -> yv_identifier);
+           else
+               (void) fprintf (stderr, "%*sbound identifier=\"%s\"\n",
+                       level * 4, "", yv -> yv_identifier);
+           break;
+
+       case YV_IDLIST:
+       case YV_VALIST:
+           for (y = yv -> yv_idlist; y; y = y -> yv_next) {
+               print_value (y, level + 1);
+               (void) fprintf (stderr, "%*s----\n", (level + 1) * 4, "");
+           }
+           break;
+
+       default:
+           break;
+    }
+}
+
+/* \f   SYMBOLS */
+
+static SY  new_symbol (encpref, decpref, prfpref, mod, id, type)
+register char  *encpref,
+              *decpref,
+              *prfpref,
+              *mod,
+              *id;
+register YP    type;
+{
+    register SY    sy;
+
+    if ((sy = (SY) calloc (1, sizeof *sy)) == NULLSY)
+       yyerror ("out of memory");
+    sy -> sy_encpref = encpref;
+    sy -> sy_decpref = decpref;
+    sy -> sy_prfpref = prfpref;
+    sy -> sy_module = mod;
+    sy -> sy_name = id;
+    sy -> sy_type = type;
+
+    return sy;
+}
+
+
+static SY  add_symbol (s1, s2)
+register SY    s1,
+               s2;
+{
+    register SY            sy;
+
+    if (s1 == NULLSY)
+       return s2;
+
+    for (sy = s1; sy -> sy_next; sy = sy -> sy_next)
+       continue;
+    sy -> sy_next = s2;
+
+    return s1;
+}
+
+/* \f   MODULES */
+
+MD  lookup_module (module, oid)
+char   *module;
+OID    oid;
+{
+    register MD            md;
+
+    for (md = mymodules; md; md = md -> md_next) {
+       if (module && md -> md_module && strcmp (md -> md_module, module) == 0)
+           return md;
+       if (oid && md -> md_oid && oid_cmp(oid, md->md_oid) == 0)
+           return md;
+    }
+
+    read_ph_file (module, oid);
+
+    if ((md = (MD) calloc (1, sizeof *md)) == NULLMD)
+       yyerror ("out of memory");
+    md -> md_module = new_string (module);
+    if (oid)
+       md -> md_oid = oid_cpy(oid);
+    else
+       md -> md_oid = NULLOID;
+
+    if (mymodules != NULLMD)
+       md -> md_next = mymodules;
+
+    return (mymodules = md);
+}
+
+/* \f   TYPES */
+
+YP     new_type (code, lineno)
+int    code;
+int    lineno;
+{
+    register YP    yp;
+
+    if ((yp = (YP) calloc (1, sizeof *yp)) == NULLYP)
+       yyerror ("out of memory");
+    yp -> yp_code = code;
+    yp -> yp_lineno = lineno;
+
+    return yp;
+}
+
+
+YP     add_type (y, z)
+register YP    y,
+               z;
+{
+    register YP            yp;
+
+    for (yp = y; yp -> yp_next; yp = yp -> yp_next)
+       continue;
+    yp -> yp_next = z;
+
+    return y;
+}
+
+/* \f */
+
+YP     copy_type (yp)
+register YP    yp;
+{
+    register YP            y;
+
+    if (yp == NULLYP)
+       return NULLYP;
+
+    y = new_type (yp -> yp_code, yp -> yp_lineno);
+    y -> yp_direction = yp -> yp_direction;
+
+    switch (yp -> yp_code) {
+       case YP_IDEFINED:
+           if (yp -> yp_module)
+               y -> yp_module = new_string (yp -> yp_module);
+           y -> yp_identifier = new_string (yp -> yp_identifier);
+           y -> yp_modid = oid_cpy (yp -> yp_modid);
+           break;
+
+       case YP_SEQTYPE:
+       case YP_SEQLIST:
+       case YP_SETTYPE:
+       case YP_SETLIST:
+       case YP_CHOICE:
+           y -> yp_type = copy_type (yp -> yp_type);
+           break;
+
+       case YP_INTLIST:
+       case YP_ENUMLIST:
+       case YP_BITLIST:
+           y -> yp_value = copy_value (yp -> yp_value);
+           break;
+
+       default:
+           break;
+    }
+
+    y -> yp_intexp = yp -> yp_intexp;
+    y -> yp_strexp = yp -> yp_strexp;
+    y -> yp_prfexp = yp -> yp_prfexp;
+
+    y -> yp_declexp = yp -> yp_declexp;
+    y -> yp_varexp = yp -> yp_varexp;
+
+    if (yp -> yp_structname)
+       y -> yp_structname = new_string (yp -> yp_structname);
+    if (yp -> yp_ptrname)
+       y -> yp_ptrname = new_string (yp -> yp_ptrname);
+
+    if (yp -> yp_param_type)
+       y -> yp_param_type = new_string (yp -> yp_param_type);
+
+    if (yp -> yp_action0) {
+       y -> yp_action0 = new_string (yp -> yp_action0);
+       y -> yp_act0_lineno = yp -> yp_act0_lineno;
+    }
+
+    if (yp -> yp_action05) {
+       y -> yp_action05 = new_string (yp -> yp_action05);
+       y -> yp_act05_lineno = yp -> yp_act05_lineno;
+    }
+
+    if (yp -> yp_action1) {
+       y -> yp_action1 = new_string (yp -> yp_action1);
+       y -> yp_act1_lineno = yp -> yp_act1_lineno;
+    }
+
+    if (yp -> yp_action2) {
+       y -> yp_action2 = new_string (yp -> yp_action2);
+       y -> yp_act2_lineno = yp -> yp_act2_lineno;
+    }
+
+    if (yp -> yp_action3) {
+       y -> yp_action3 = new_string (yp -> yp_action3);
+       y -> yp_act3_lineno = yp -> yp_act3_lineno;
+    }
+
+    y -> yp_flags = yp -> yp_flags;
+
+    if (yp -> yp_flags & YP_DEFAULT)
+       y -> yp_default = copy_value (yp -> yp_default);
+
+    if (yp -> yp_flags & YP_ID)
+       y -> yp_id = new_string (yp -> yp_id);
+
+    if (yp -> yp_flags & YP_TAG)
+       y -> yp_tag = copy_tag (yp -> yp_tag);
+
+    if (yp -> yp_flags & YP_BOUND)
+       y -> yp_bound = new_string (yp -> yp_bound);
+
+    if (yp -> yp_flags & YP_PARMVAL)
+       y -> yp_parm = new_string (yp -> yp_parm);
+
+    if (yp -> yp_flags & YP_CONTROLLED)
+        y -> yp_control = new_string (yp -> yp_control);
+
+    if (yp -> yp_flags & YP_OPTCONTROL)
+        y -> yp_optcontrol = new_string (yp -> yp_optcontrol);
+
+    if (yp -> yp_offset)
+       y -> yp_offset = new_string (yp -> yp_offset);
+
+    if (yp -> yp_control_act) {
+       y -> yp_control_act = yp -> yp_control_act;
+    }
+    if (yp -> yp_optional_act) {
+       y -> yp_optional_act = yp -> yp_optional_act;
+    }
+    if (yp -> yp_bef_alist) {
+       y -> yp_bef_alist = yp -> yp_bef_alist;
+    }
+    if (yp -> yp_aft_alist) {
+       y -> yp_aft_alist = yp -> yp_aft_alist;
+    }
+
+
+    if (yp -> yp_next)
+       y -> yp_next = copy_type (yp -> yp_next);
+
+    return y;
+}
+
+/* \f   VALUES */
+
+YV     new_value (code)
+int    code;
+{
+    register YV    yv;
+
+    if ((yv = (YV) calloc (1, sizeof *yv)) == NULLYV)
+       yyerror ("out of memory");
+    yv -> yv_code = code;
+
+    return yv;
+}
+
+
+YV     add_value (y, z)
+register YV    y,
+               z;
+{
+    register YV            yv;
+
+    for (yv = y; yv -> yv_next; yv = yv -> yv_next)
+       continue;
+    yv -> yv_next = z;
+
+    return y;
+}
+
+/* \f */
+
+YV     copy_value (yv)
+register YV    yv;
+{
+    register YV            y;
+
+    if (yv == NULLYV)
+       return NULLYV;
+
+    y = new_value (yv -> yv_code);
+    y -> yv_flags = yv -> yv_flags;
+
+    if (yv -> yv_action) {
+       y -> yv_action = new_string (yv -> yv_action);
+       y -> yv_act_lineno = yv -> yv_act_lineno;
+    }
+
+    if (yv -> yv_flags & YV_ID)
+       y -> yv_id = new_string (yv -> yv_id);
+
+    if (yv -> yv_flags & YV_NAMED)
+       y -> yv_named = new_string (yv -> yv_named);
+
+    if (yv -> yv_flags & YV_TYPE)
+       y -> yv_type = copy_type (yv -> yv_type);
+
+    switch (yv -> yv_code) {
+       case YV_NUMBER:
+       case YV_BOOL:
+           y -> yv_number = yv -> yv_number;
+           break;
+
+       case YV_STRING:
+           y -> yv_string = new_string (yv -> yv_string);
+           break;
+
+       case YV_IDEFINED:
+           if (yv -> yv_module)
+               y -> yv_module = new_string (yv -> yv_module);
+           y -> yv_identifier = new_string (yv -> yv_identifier);
+           break;
+
+       case YV_IDLIST:
+       case YV_VALIST:
+           y -> yv_idlist = copy_value (yv -> yv_idlist);
+           break;
+
+       default:
+           break;
+    }
+
+    if (yv -> yv_next)
+       y -> yv_next = copy_value (yv -> yv_next);
+
+    return y;
+}
+
+/* \f   TAGS */
+
+YT     new_tag (class)
+PElementClass  class;
+{
+    register YT    yt;
+
+    if ((yt = (YT) calloc (1, sizeof *yt)) == NULLYT)
+       yyerror ("out of memory");
+    yt -> yt_class = class;
+
+    return yt;
+}
+
+/* \f */
+
+YT     copy_tag (yt)
+register YT    yt;
+{
+    register YT            y;
+
+    if (yt == NULLYT)
+       return NULLYT;
+
+    y = new_tag (yt -> yt_class);
+
+    y -> yt_value = copy_value (yt -> yt_value);
+
+    return y;
+}
+
+/* \f   STRINGS */
+
+char   *new_string (s)
+register char  *s;
+{
+    register char  *p;
+
+    if (s == NULLCP)
+           return NULLCP;
+
+    if ((p = malloc ((unsigned) (strlen (s) + 1))) == NULLCP)
+       yyerror ("out of memory");
+
+    (void) strcpy (p, s);
+    return p;
+}
+
+/* \f   SYMBOLS */
+
+static struct triple {
+    char          *t_name;
+    PElementClass   t_class;
+    PElementID     t_id;
+}              triples[] = {
+    "IA5String", PE_CLASS_UNIV,        PE_DEFN_IA5S,
+    "ISO646String", PE_CLASS_UNIV, PE_DEFN_IA5S,
+    "NumericString", PE_CLASS_UNIV, PE_DEFN_NUMS,
+    "PrintableString", PE_CLASS_UNIV, PE_DEFN_PRTS,
+    "T61String", PE_CLASS_UNIV, PE_DEFN_T61S,
+    "TeletexString", PE_CLASS_UNIV, PE_DEFN_T61S,
+    "VideotexString", PE_CLASS_UNIV, PE_DEFN_VTXS,
+    "GeneralizedTime", PE_CLASS_UNIV, PE_DEFN_GENT,
+    "GeneralisedTime", PE_CLASS_UNIV, PE_DEFN_GENT,
+    "UTCTime", PE_CLASS_UNIV, PE_DEFN_UTCT,
+    "UniversalTime", PE_CLASS_UNIV, PE_DEFN_UTCT,
+    "GraphicString", PE_CLASS_UNIV, PE_DEFN_GFXS,
+    "VisibleString", PE_CLASS_UNIV, PE_DEFN_VISS,
+    "GeneralString", PE_CLASS_UNIV, PE_DEFN_GENS,
+    "EXTERNAL", PE_CLASS_UNIV, PE_CONS_EXTN,
+    "ObjectDescriptor", PE_CLASS_UNIV, PE_PRIM_ODE,
+
+    NULL
+};
+
+/* \f */
+
+char *modsym (module, id, prefix)
+register char  *module,
+              *id;
+char   *prefix;
+{
+    char    buf1[BUFSIZ],
+            buf2[BUFSIZ],
+            buf3[BUFSIZ];
+    register struct triple *t;
+    static char buffer[BUFSIZ];
+
+    if (module == NULLCP)
+       for (t = triples; t -> t_name; t++)
+           if (strcmp (t -> t_name, id) == 0) {
+               module = "UNIV";
+               break;
+           }
+
+    if (prefix)
+       modsym_aux (prefix, buf1);
+    modsym_aux (module ? module : mymodule, buf2);
+    modsym_aux (id, buf3);
+    if (prefix)
+       (void) sprintf (buffer, "%s_%s_%s", buf1, buf2, buf3);
+    else
+       (void) sprintf (buffer, "%s_%s", buf2, buf3);
+
+    return buffer;
+}
+
+
+static modsym_aux (name, bp)
+register char  *name,
+              *bp;
+{
+    register char   c;
+
+    while (c = *name++)
+       switch (c) {
+           case '-':
+               *bp++ = '_';
+               *bp++ = '_';
+               break;
+
+           default:
+               *bp++ = c;
+               break;
+       }
+
+    *bp = NULL;
+}
+
+/* \f */
+
+static char *gensym (s, a)
+char   *s, *a;
+{
+    int     i;
+    register char  *p;
+    char    buffer[BUFSIZ];
+    static int  cP = 0;
+    static int  eP = 0;
+    static int  mP = 0;
+
+    switch (*s) {
+       case 'c': 
+           i = cP++;
+           break;
+       case 'e': 
+           i = eP++;
+           break;
+       case 'm': 
+           i = mP++;
+           break;
+
+       default: 
+           myyerror ("unknown gensym argument \"%s\"", s);
+       /* NOTREACHED */
+    }
+    if (a)
+       (void) sprintf (buffer, "%s_%s_%d[n_%s]", s, modulename, i, a);
+    else
+       (void) sprintf (buffer, "%s_%s_%d", s, modulename, i);
+
+    if ((p = malloc ((unsigned) (strlen (buffer) + 11))) == NULLCP)
+       yyerror ("out of memory");
+
+    (void) strcpy (p, buffer);
+    return p;
+}
+
+/* pepy compatible routines - you know how it is ... */
+init_new_file () 
+{
+    ;
+}
+
+end_file ()
+{
+    ;
+}
+
+static char *array (s, flg)
+char   *s;
+int    flg;
+{
+    static char buf[BUFSIZ];
+    char       *p;
+
+    if (!flg) return s;
+
+    if (p = index (s, '[')) {
+       (void) sprintf (buf, "%*.*s[1]", p - s, p - s, s);
+       return buf;
+    }
+    return s;
+}
+
+static void prime_default (yp, level)
+YP     yp;
+int    level;
+{
+    switch (yp -> yp_code) {
+    case YP_BOOL:
+       (void) printf ("%*s%s = %d;\n", level * 4, "",
+               SVAL (yp->yp_varexp),
+               val2int (yp -> yp_default) ? 1 : 0);
+       break;
+
+    case YP_INT:
+       (void) printf ("%*s%s = %d;\n", level * 4, "",
+               SVAL (yp -> yp_varexp), val2int (yp -> yp_default));
+       break;
+
+    case YP_INTLIST:
+    case YP_ENUMLIST:
+       (void) printf ("%*s%s = %d;\n", level * 4, "",
+               SVAL (yp -> yp_varexp), dfl2int (yp));
+       break;
+
+    case YP_REAL:
+       (void) printf ("%*s%s = %g;\n", level * 4, "",
+               SVAL (yp -> yp_varexp),
+               val2real (yp -> yp_default));
+
+    default:
+       break;
+    }
+}
+/* PH FILES */
+
+/* really need much more information in the .ph file... */
+
+static read_ph_file (module, oid)
+register char *module;
+OID    oid;
+{
+    int     class,
+           value,
+           direction;
+    char    buffer[BUFSIZ],
+           file[BUFSIZ],
+           id[BUFSIZ],
+           encpref[BUFSIZ],
+           decpref[BUFSIZ],
+           printpref[BUFSIZ];
+    char    *p, *ep, *dp, *ppp;
+    register FILE  *fp;
+    register YP            yp;
+    register YT            yt;
+    register YV            yv;
+
+    (void) sprintf (file, "%s.ph", module);
+    if (oid)
+       (void) sprintf (p = buffer, "%s.ph", sprintoid(oid));
+    else
+       p = NULLCP;
+    if ((fp = open_ph_file (file, p, "r")) == NULL)
+    {
+       warning ("Can't find file %s%s%s failed\n",
+                    file, p ? "/" : "", p ? p : "");
+       return;
+    }
+
+    if (strcmp (module, "UNIV"))
+       yyprint (module, 1, 0);
+
+    while (fgets (buffer, sizeof buffer, fp)) {
+       if (sscanf (buffer, "%d/%d/%d: %s",
+                   &class, &value, &direction, id) !=4) {
+           myyerror ("bad external definition in %s: %s",
+                   file, buffer);
+           continue;
+       }
+       ppp = dp = ep = NULLCP;
+       if (p = index(buffer, '|')) {
+           if( sscanf (p+1, "%s %s %s\n", encpref, decpref, printpref) == 3) {
+               ppp = new_string (printpref);
+               dp = new_string (decpref);
+               ep = new_string (encpref);
+           }
+       }
+               
+       yp = new_type (class == -1 ? YP_ANY : YP_IMPTYPE, -1);
+       yp -> yp_flags = YP_IMPORTED;
+       if (class >= 0) {
+           yp -> yp_flags |= YP_TAG;
+           yp -> yp_tag = yt = new_tag ((PElementClass) class);
+           yt -> yt_value = yv = new_value (YV_NUMBER);
+           yv -> yv_number = value;
+       }
+       yp -> yp_direction = direction;
+       pass1_type (ep, dp, ppp, new_string (module),
+               new_string (id), yp);
+    }
+
+    (void) fclose (fp);
+}
+
+/* \f */
+
+static write_ph_file () {
+    int            msave;
+    char    file[BUFSIZ];
+    char    fileoid[BUFSIZ];
+    char       *cp;
+    register FILE  *fp;
+    register SY            sy;
+    register YT            yt;
+    register YP            yp;
+
+    (void) sprintf (file, "%s.ph", mymodule);
+    if (mymoduleid)
+       (void) sprintf (cp = fileoid, "%s.ph", sprintoid(mymoduleid));
+    else
+       cp = NULLCP;
+    msave = mflag, mflag = 0;
+    if ((fp = open_ph_file (file, cp, "w")) == NULL)
+       myyerror ("unable to write %s", file);
+    mflag = msave;
+
+    for (sy = mysymbols; sy; sy = sy -> sy_next) {
+       yp = sy -> sy_type;
+       if (yp -> yp_flags & YP_IMPORTED)
+           continue;
+       if (doexternals == 0 && (yp->yp_flags & YP_EXPORTED) == 0)
+           continue;
+
+       if (is_any_type (yp)) {
+           (void) fprintf (fp, "-1/0/%d: %s", yp -> yp_direction, sy -> sy_name);
+           (void) fprintf (fp, " |%s %s %s\n", yyencpref, yydecpref, yyprfpref);
+       }
+       else
+           if ((yt = lookup_tag (yp)) && yt -> yt_class != PE_CLASS_CONT) {
+               (void) fprintf (fp, "%d/%d/%d: %s", yt -> yt_class,
+                           val2int (yt -> yt_value), yp -> yp_direction,
+                           sy -> sy_name);
+               (void) fprintf (fp, " |%s %s %s\n", yyencpref, yydecpref, yyprfpref);
+           }
+    }
+
+    (void) fclose (fp);
+}
+
+/* \f */
+
+#ifndef        PEPSYPATH
+#define        PEPSYPATH       ""
+#endif
+
+
+static FILE *open_ph_file (fn, fnoid, mode)
+char *fn,
+     *fnoid,
+     *mode;
+{
+    register char  *dst,
+                  *path;
+    char    fnb[BUFSIZ];
+    register FILE  *fp;
+    static char *pepypath = NULL;
+
+    if (*fn == '/')
+       return fopen (fn, mode);
+
+    if (mflag) {       /* MOBY HACK */
+       if (fnoid && (fp = fopen (fnoid, mode)) != NULL)
+           return fp;
+       if ((fp = fopen (fn, mode)) != NULL)
+           return fp;
+
+       if (fnoid) {
+           (void) sprintf (fnb, "../pepy/%s", fnoid);
+           if ((fp = fopen (fnb, mode)) != NULL)
+               return fp;
+       }
+       (void) sprintf (fnb, "../pepy/%s", fn);
+       if ((fp = fopen (fnb, mode)) != NULL)
+           return fp;
+
+       if (fnoid) {
+           (void) sprintf (fnb, "../../pepy/%s", fnoid);
+           if ((fp = fopen (fnb, mode)) != NULL)
+               return fp;
+       }
+       (void) sprintf (fnb, "../../pepy/%s", fn);
+       return fopen (fnb, mode);
+    }
+
+    if (pepypath == NULL && (pepypath = getenv ("PEPSYPATH")) == NULL)
+       pepypath = PEPSYPATH;
+    path = pepypath;
+
+    do {
+       dst = fnb;
+       while (*path && *path != ':')
+           *dst++ = *path++;
+       if (dst != fnb)
+           *dst++ = '/';
+       if (fnoid) {
+           (void) strcpy (dst, fnoid);
+           if ((fp = fopen (fnb, mode)) != NULL)
+               break;
+       }
+       (void) strcpy (dst, fn);
+       if ((fp = fopen (fnb, mode)) != NULL)
+           break;
+    } while (*path++);
+
+    return fp;
+}
+
+YT  lookup_tag (yp)
+register YP     yp;
+{
+    register struct tuple *t;
+    static struct ypt ypts;
+    register YT     yt = &ypts;
+    static struct ypv ypvs;
+    register YV     yv = &ypvs;
+    register YP     z;
+
+    if (yp -> yp_flags & YP_TAG)
+        return yp -> yp_tag;
+
+    while (yp -> yp_code == YP_IDEFINED) {
+        if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
+            (void) lookup_module (yp -> yp_module, yp -> yp_modid);
+        if (z = lookup_type (yp -> yp_module, yp -> yp_identifier)) {
+            yp = z;
+            if (yp -> yp_flags & YP_TAG)
+                return yp -> yp_tag;
+            continue;
+        }
+        break;
+    }
+    for (t = tuples; t -> t_type != YP_UNDF; t++)
+        if (t -> t_type == yp -> yp_code) {
+            yt -> yt_class = t -> t_classnum;
+            yt -> yt_value = yv;
+            yv -> yv_code = YV_NUMBER;
+            yv -> yv_number = t -> t_idnum;
+            return yt;
+        }
+    return NULLYT;
+}
+int  is_any_type (yp)
+register YP     yp;
+{
+    register    YP z;
+
+    while (yp -> yp_code == YP_IDEFINED) {
+        if (yp -> yp_flags & YP_TAG)
+            return 0;
+
+        if (yp -> yp_module && strcmp (yp -> yp_module, mymodule))
+            (void) lookup_module (yp -> yp_module, yp -> yp_modid);
+
+        if (z = lookup_type (yp -> yp_module, yp -> yp_identifier)) {
+            yp = z;
+
+            continue;
+        }
+        break;
+    }
+    return (yp -> yp_code == YP_ANY && !(yp -> yp_flags & YP_TAG));
+}
+
+/*
+ * return a string with the leading pathname stripped off
+ */
+char *
+pstrip(p)
+char *p;
+{
+    char *p1;
+
+    if (p1 = rindex(p, '/'))
+       return (p1 + 1);
+    return (p);
+}
+
+/*
+ * produce a #include on the given file descriptor according to what ever
+ * rules are in fashion today. Unfortunately these keep changing so to
+ * minimise the effort involved in keeping up we put all the code to change
+ * in the one place, here. -- amrw
+ *
+ * actually, the rules have never changed, andrew just can't figure them out.
+ *     -- mtr
+ */
+doincl(fp, file)
+FILE   *fp;            /* where #include is to be written to */
+char   *file[];        /* files to be included */
+{
+    char       **p;
+
+    if (mflag) {
+       /* PEPYPATH version */
+
+       (void) fprintf (fp, "#ifndef    PEPYPATH\n");
+       for (p = file; *p; p++) {
+           if (is_stand(*p))
+               (void) fprintf (fp, "#include <isode/%s>\n", *p);
+           else
+               (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p));
+       }
+       (void) fprintf (fp, "#else\n");
+       for (p = file; *p; p++) {
+           (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p));
+       }
+       (void) fprintf (fp, "#endif\n\n");
+
+    }
+    else {
+       for (p = file; *p; p++) {
+           if (is_stand(*p))
+               (void) fprintf (fp, "#include <isode/%s>\n", *p);
+           else
+               (void) fprintf (fp, "#include \"%s\"\n", pstrip(*p));
+       }
+    }
+    (void) fprintf (fp, "\n");
+}
+
+/* standard files  - that should be found in the <isode> directory */
+static char *stand_f[] = {
+       "psap.h",
+       "pepsy.h",
+       "UNIV-types.h",
+       "UNIV_defs.h",
+       "UNIV_pre_defs.h",
+
+       (char *)0       /* terminating NULL pointer */
+       };
+
+
+/*
+ * determine if the given (after stripping any path) file is a standard
+ * include file which should be in the include/isode directory.
+ * return nonzero (true) if it is.
+ */
+is_stand(file)
+char *file;
+{
+    char       **p;
+    char       *f = pstrip (file);
+    for (p = stand_f; *p; p++) {
+       if (strcmp(f, pstrip(*p)) == 0)
+           return (1);
+    }
+
+    return (0);
+}
+
+/* Number of different external modules that can referenced */
+#define EXTMODSIZE     50
+
+/* table of external modules we reference */
+static char *extmodtab[EXTMODSIZE];
+static int   nextmod = 0;      /* next free slot in external module table */
+
+/*
+ * build up a list of external modules we have referenced
+ */
+addextmod(p)
+char   *p;     /* name of external module */
+{
+
+    if (nextmod >= EXTMODSIZE)
+       ferr(1, "Too many external modules reference, table overflow\n");
+
+    extmodtab[nextmod++] = p;
+}
+
+/*
+ * process all the external modules collected to produce the includes
+ * required
+ */
+proc_extmod(fp)
+FILE   *fp;
+{
+    char       **p;
+    char       *files[EXTMODSIZE + 1];
+    char       *buf;
+    char       *tail = "-types.h";
+    char       *prefix = "pepsy/";
+    int                last = 0;
+
+    if (nextmod <= 0)
+       return;         /* no external definitions */
+
+    for (p = extmodtab; p < extmodtab + nextmod; p++) {
+       if (last >= EXTMODSIZE)
+           ferr(1, "proc_extmod: too many external modules\n");
+
+       buf = concat(*p, tail);
+       if (mflag || is_stand(buf)) /* need to prepend a "pepsy/" */
+           files[last++] = my_strcat(prefix, buf);
+       else
+           files[last++] = my_new_str(buf);
+    }
+    files[last++] = (char *)0;
+
+    doincl(fp, files);
+
+    /* free up this memory */
+    --last; /* don't free the NULL pointer - can core dump */
+    while (last > 0)
+       free(files[--last]);
+
+}
+
+/*
+ * allocate a yfn structure and intialise it
+ */
+YFN
+new_yfn(efn, dfn, pfn, ffn)
+char   *efn, *dfn, *pfn, *ffn;
+{
+       
+    register YFN    fn;
+    char       buf[STRSIZE];
+
+    if ((fn = (YFN) calloc (1, sizeof *fn)) == NULLYFN)
+       yyerror ("out of memory");
+
+    if (efn) {
+        if (getid(efn, buf, STRSIZE) == NULLCP)
+           yyerror("Bad Encoding function\n");
+       fn -> yfn_enc = strdup(buf);
+       free(efn);
+    }
+
+    if (dfn) {
+        if (getid(dfn, buf, STRSIZE) == NULLCP)
+           yyerror("Bad Decoding function\n");
+       fn -> yfn_dec = strdup(buf);
+       free(dfn);
+    }
+
+    if (pfn) {
+        if (getid(pfn, buf, STRSIZE) == NULLCP)
+           yyerror("Bad Printing function\n");
+       fn -> yfn_prt = strdup(buf);
+       free(pfn);
+    }
+
+    if (ffn) {
+        if (getid(ffn, buf, STRSIZE) == NULLCP)
+           yyerror("Bad Printing function\n");
+       fn -> yfn_fre = strdup(buf);
+       free(ffn);
+    }
+
+    return fn;
+}
+
+/*
+ * support routine for action_t = allocate space for it and fill it in with
+ * the given yy_action field
+ */
+Action
+new_action_t(text, lineno, num)
+char   *text;
+int    lineno;
+{
+    Action     act;
+
+    if ((act = (Action) malloc(sizeof (action_t))) == NULLAction)
+       yyerror("out of memory\n");
+    
+    act->a_data = text;
+    act->a_line = lineno;
+    act->a_num = num;
+
+    return (act);
+}
+
+/*
+ * support routine for YAL = allocate space for it and make sure it is
+ * zero'd
+ */
+YAL
+new_yal()
+{
+    YAL        yal;
+
+    if ((yal = (YAL) calloc(1, sizeof (*yal))) == NULLYAL)
+       yyerror("out of memory\n");
+    
+    return (yal);
+}
+YAL
+yal_join(yal1, yal2)
+YAL    yal1, yal2;
+{
+    if (yal2 == NULLYAL)
+       return (yal1);
+    if (yal1 == NULLYAL)
+       return (yal2);
+
+    if (yal1->yal_enc == NULLAction && yal2->yal_enc != NULLAction)
+       yal1->yal_enc = yal2->yal_enc;
+    else if (yal1->yal_enc != NULLAction && yal2->yal_enc != NULLAction)
+       yyerror("two encoding actions in the same place\n merge into one\n");
+
+    if (yal1->yal_dec == NULLAction && yal2->yal_dec != NULLAction)
+       yal1->yal_dec = yal2->yal_dec;
+    else if (yal1->yal_dec != NULLAction && yal2->yal_dec != NULLAction)
+       yyerror("two decoding actions in the same place\n merge into one\n");
+
+    if (yal1->yal_prn == NULLAction && yal2->yal_prn != NULLAction)
+       yal1->yal_prn = yal2->yal_prn;
+    else if (yal1->yal_prn != NULLAction && yal2->yal_prn != NULLAction)
+       yyerror("two printing actions in the same place\n merge into one\n");
+
+    free((char *)yal2);
+    return (yal1);
+}
+/*
+ * join two yfn structures
+ */
+YFN
+join_yfn(fn1, fn2)
+register YFN   fn1, fn2;
+{
+       
+    if (fn2 == NULLYFN)
+       return (fn1);
+    if (fn1 == NULLYFN)
+       return (fn2);
+
+    if (fn1->yfn_enc == NULLCP && fn2->yfn_enc != NULLCP)
+       fn1->yfn_enc = fn2->yfn_enc;
+    else if (fn1->yfn_enc != NULLCP && fn2->yfn_enc != NULLCP)
+       yyerror("Illegal: two encoding functions for the same type\n");
+
+    if (fn1->yfn_dec == NULLCP && fn2->yfn_dec != NULLCP)
+       fn1->yfn_dec = fn2->yfn_dec;
+    else if (fn1->yfn_dec != NULLCP && fn2->yfn_dec != NULLCP)
+       yyerror("Illegal: two decoding functions for the same type\n");
+
+    if (fn1->yfn_prt == NULLCP && fn2->yfn_prt != NULLCP)
+       fn1->yfn_prt = fn2->yfn_prt;
+    else if (fn1->yfn_prt != NULLCP && fn2->yfn_prt != NULLCP)
+       yyerror("Illegal: two printing functions for the same type\n");
+
+    free((char *)fn2);
+
+    return (fn1);
+}
+
+/* \f */
+
+char   *strdup (s)
+char   *s;
+{
+    char   *p;
+
+    if ((p = malloc ((unsigned) (strlen (s) + 1))) == NULL)
+       abort ();
+
+    (void) strcpy (p, s);
+    return p;
+}
diff --git a/usr/src/contrib/isode/pepsy/pepsy_misc.c b/usr/src/contrib/isode/pepsy/pepsy_misc.c
new file mode 100644 (file)
index 0000000..1d38c3a
--- /dev/null
@@ -0,0 +1,380 @@
+/* pepy_misc.c - PE parser (yacc-based) misc routines */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/pepsy_misc.c,v 7.1 91/02/22 09:49:49 mrose Interim $";
+#endif
+
+/*
+ * $Header: /f/osi/pepsy/RCS/pepsy_misc.c,v 7.1 91/02/22 09:49:49 mrose Interim $
+ *
+ *
+ * $Log:       pepsy_misc.c,v $
+ * Revision 7.1  91/02/22  09:49:49  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.0  90/07/01  19:54:27  mrose
+ * *** empty log message ***
+ * 
+ * Revision 7.0  89/11/23  22:11:52  mrose
+ * Release 6.0
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include "pepsydefs.h"
+
+/* \f Oid manipulation */
+
+typedef struct oidlist {
+    OID                op_oid;
+    char       *op_name;
+    struct oidlist *op_next;
+} oidlist, *OP;
+#define NULLOP ((OP) 0)
+
+typedef struct symtable {
+    char       *sym_name;
+    char       *sym_module;
+    OID                sym_oid;
+    int                sym_type;
+    struct symtable *sym_next;
+} symtable, *SYM;
+#define NULLSYM ((SYM)0)
+
+
+static OP      myoids;
+static SYM     symtab[MAX_TBLS];
+
+
+OID    addoid (o1, o2)
+OID    o1, o2;
+{
+    OID                noid;
+
+    if (o1 == NULLOID || o2 == NULLOID)
+       return NULLOID;
+
+    noid = (OID) calloc (1, sizeof(*noid));
+    if (noid == NULLOID)
+       myyerror ("out of memory (%d needed)", sizeof(*noid));
+
+    noid -> oid_nelem = o1->oid_nelem + o2->oid_nelem;
+    noid -> oid_elements = (unsigned int *) calloc ((unsigned)noid->oid_nelem,
+                                                   sizeof(unsigned int));
+    if (noid -> oid_elements == NULL)
+       myyerror ("out of memory (%d needed)", noid->oid_nelem);
+
+    bcopy ((char *)o1->oid_elements, (char *)noid->oid_elements,
+          o1->oid_nelem * sizeof(unsigned int));
+    bcopy ((char *)o2 -> oid_elements,
+          (char *) &noid -> oid_elements[o1->oid_nelem],
+          o2 -> oid_nelem * sizeof(unsigned int));
+    return noid;
+}
+
+defineoid (name, oid)
+char   *name;
+OID    oid;
+{
+    register char      *p;
+    register OP                op;
+
+    if (oid == NULLOID) {
+       myyerror ("Warning Null oid in defineoid");
+       return;
+    }
+    for (op = myoids; op; op = op -> op_next)
+       if (strcmp (op -> op_name, name) == 0) {
+           if (oid_cmp(op->op_oid, oid) != 0) {
+               p = new_string(sprintoid (oid));
+               warning ("OID name clash %s => %s & %s",
+                         name, p, sprintoid(op->op_oid));
+               free (p);
+           }
+           else
+               return;
+       }
+    op = (OP) calloc (1, sizeof *op);
+    if (op == NULLOP)
+       myyerror ("out of memory (%d needed)", sizeof(*op));
+    op -> op_oid = oid_cpy(oid);
+    op -> op_name = new_string (name);
+    op -> op_next = myoids;
+    myoids = op;
+}
+
+OID    oidlookup (name)
+char   *name;
+{
+    OP op;
+
+    for (op = myoids; op; op = op -> op_next)
+       if (strcmp ( name, op->op_name) == 0)
+           return oid_cpy(op -> op_oid);
+
+    warning ("unknown Object Identifier '%s'", name);
+    return NULLOID;
+}
+
+char   *oidname (oid)
+OID    oid;
+{
+    OP op;
+
+    for (op = myoids; op; op = op -> op_next)
+       if (oid_cmp (op->op_oid, oid) == 0)
+           return op -> op_name;
+
+    return NULLCP;
+}
+
+OID    int2oid (n)
+int    n;
+{
+    OID                noid;
+
+    noid = (OID) calloc(1, sizeof(*noid));
+    if (noid == NULLOID)
+       myyerror ("out of memory (%d needed)", sizeof *noid);
+
+    noid -> oid_elements = (unsigned int *) calloc (1, sizeof(unsigned int));
+    if (noid -> oid_elements == NULL)
+       myyerror ("out of memory (%d needed)", sizeof(unsigned int));
+    noid -> oid_nelem = 1;
+    noid -> oid_elements[0] = n;
+    return noid;
+}
+
+/* \f */
+
+addtable (name, lt, typ)
+char   *name;
+int    lt;
+int    typ;    /* Does it allow implicit's to work or not */
+{
+    SYM                sp;
+
+    sp = (SYM)calloc (1, sizeof *sp);
+    sp -> sym_name = new_string (name);
+    sp -> sym_next = symtab[lt];
+    sp -> sym_type = typ;
+    symtab[lt] = sp;
+}
+
+addtableref (name, id, lt)
+char   *name;
+OID    id;
+int    lt;
+{
+    SYM                sp;
+    char       *nm;
+    OID                oid;
+
+    nm = name ? new_string (name) : NULLCP;
+    oid = id ? oid_cpy (id) : NULLOID;
+
+    for (sp = symtab[lt]; sp; sp = sp -> sym_next)
+       if (sp -> sym_module == NULLCP && sp -> sym_oid == NULLOID)
+       {
+           sp -> sym_module = nm;
+           sp -> sym_oid = oid;
+       }
+}
+
+print_expimp ()
+{
+    SYM                sp;
+    int                ind;
+    OID                oid;
+    char       *p;
+
+    if (sp = symtab[TBL_EXPORT])
+       (void) printf ("\nEXPORTS\n");
+       
+    for (ind = 0; sp; sp = sp->sym_next) {
+       if (ind == 0) {
+           (void) putchar('\t');
+           ind = 8;
+       }
+       (void) printf("%s", sp -> sym_name);
+       ind += strlen (sp -> sym_name);
+       if (sp -> sym_next){
+           (void) putchar (',');
+           ind ++;
+       }
+       else
+           (void) putchar (';');
+       if (ind > 72) {
+           (void) putchar ('\n');
+           ind = 0;
+       }
+       else {
+           (void) putchar (' ');
+           ind ++;
+       }
+    }
+    (void) putchar ('\n');
+
+    if (sp = symtab[TBL_IMPORT]) {
+       (void) printf ("\nIMPORTS\n");
+       p = sp -> sym_module;
+       oid = sp -> sym_oid;
+    }
+    for (ind = 0; sp; sp = sp -> sym_next) {
+       if (ind == 0) {
+           (void) putchar ('\t');
+           ind = 8;
+       }
+       (void) printf ("%s", sp -> sym_name);
+       ind += strlen (sp -> sym_name);
+       if (sp -> sym_next) {
+           if (strcmp (p, sp -> sym_next -> sym_module) == 0) {
+               (void) putchar (',');
+               ind ++;
+               if ( ind > 72) {
+                   (void) putchar ('\n');
+                   ind = 0;
+               }
+               else {
+                   (void) putchar (' ');
+                   ind ++;
+               }
+           }
+           else {
+               if (ind != 8)
+                   (void) printf ("\n\t\t");
+               else
+                   (void) putchar ('\t');
+               (void) printf ("FROM %s", p);
+               if (oid)
+                   (void) printf (" %s", oidprint (oid));
+               (void) printf ("\n\t");
+               ind = 8;
+               p = sp -> sym_next -> sym_module;
+               oid = sp -> sym_next -> sym_oid;
+           }
+       }
+       else {
+           if (ind != 8)
+               (void) printf ("\n\t\t");
+           else
+               (void) putchar ('\t');
+           (void) printf ("FROM %s", p);
+           if (oid)
+               (void) printf (" %s", oidprint (oid));
+           (void) printf (";\n");
+        }
+    }
+}
+
+check_impexp (yp)
+YP     yp;
+{
+    SYM                sp;
+
+    for (sp = symtab[TBL_EXPORT]; sp; sp = sp->sym_next)
+       if (strcmp (sp -> sym_name, yp -> yp_identifier) == 0)
+       {
+           yp -> yp_flags |= YP_EXPORTED;
+           break;
+       }
+
+    for (sp = symtab[TBL_IMPORT]; sp; sp = sp -> sym_next)
+       if (strcmp (sp -> sym_name, yp -> yp_identifier) == 0) {
+           if (yp->yp_flags & YP_EXPORTED)
+               myyerror ("Warning: %s imported & exported!", yp->yp_identifier);
+           yp -> yp_module = sp -> sym_module;
+           yp -> yp_modid = sp -> sym_oid;
+/*         yp -> yp_flags |= YP_IMPORTED;      */
+       }
+}
+static struct oidtbl {
+    char       *oid_name;
+    int                oid_value;
+} oidtable[] =  {
+                               /* Top level OIDS */
+    "ccitt",           0,
+    "iso",             1,
+    "joint-iso-ccitt", 2,
+
+    NULL,
+};
+
+initoidtbl ()
+{
+    struct oidtbl *op;
+    OID                oid;
+
+    for (op = oidtable; op -> oid_name; op++) {
+       defineoid (op->oid_name, oid = int2oid(op->oid_value));
+       oid_free (oid);
+    }
+}
+
+char   *oidprint (oid)
+OID    oid;
+{
+    static char buf[BUFSIZ];
+    char       *cp;
+    char       *p;
+    OID                o2;
+    unsigned int *ip;
+    int                i;
+
+    if (oid == NULLOID)
+       return "";
+
+    (void) strcpy (buf, "{ ");
+    cp = buf + strlen(buf);
+
+    i = oid->oid_nelem;
+    ip = oid->oid_elements;
+
+    p = oidname (o2 = int2oid((int)*ip));
+    oid_free (o2);
+    if (p) {
+       i --;
+       ip ++;
+       (void) sprintf (cp, "%s ", p);
+       cp += strlen(cp);
+    }
+
+    for (; i > 0; i--) {
+       (void) sprintf (cp, "%d ", *ip++);
+       cp += strlen (cp);
+    }
+
+    (void) strcat (cp, " }");
+    return buf;
+}
+
+/*
+ * look at import list and return any clue found as to handling implicit tags
+ * on that type
+ */
+chkil(id)
+char   *id;
+{
+    SYM sy;
+
+    for (sy = symtab[TBL_IMPORT]; sy; sy = sy->sym_next)
+       if (strcmp(sy->sym_name, id) == 0)
+               break;
+    if (sy)
+       return (sy->sym_type);
+
+    return (ER_UNKNOWN);
+
+}
diff --git a/usr/src/contrib/isode/pepsy/pepsydefs.h.gnrc b/usr/src/contrib/isode/pepsy/pepsydefs.h.gnrc
new file mode 100644 (file)
index 0000000..1d77306
--- /dev/null
@@ -0,0 +1,420 @@
+%BEGIN(PEPSY)%
+/* pepsydefs.h - definitions for pepsy */
+%END(PEPSY)%
+%BEGIN(PEPY)%
+/* pepy.h - definitions for pepy */
+%END(PEPY)%
+%BEGIN(ROSY)%
+/* rosy-defs.h - definitions for rosy */
+%END(ROSY)%
+%BEGIN(MOSY)%
+/* mosy-defs.h - definitions for mosy */
+%END(MOSY)%
+/* %WARNING% */
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/pepsydefs.h.gnrc,v 7.6 91/02/22 09:49:51 mrose Interim $
+ *
+ *
+ * $Log:       pepsydefs.h.gnrc,v $
+ * Revision 7.6  91/02/22  09:49:51  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.5  91/01/08  12:50:51  mrose
+ * update
+ * 
+ * Revision 7.4  90/12/23  17:25:17  mrose
+ * patches
+ * 
+ * Revision 7.3  90/12/11  10:41:06  mrose
+ * sync
+ * 
+ * Revision 7.2  90/11/11  10:54:16  mrose
+ * update
+ * 
+ * Revision 7.1  90/11/04  19:19:12  mrose
+ * update
+ * 
+ * Revision 7.0  90/07/01  19:54:38  mrose
+ * *** empty log message ***
+ * 
+ * Revision 7.0  89/11/23  22:11:48  mrose
+ * Release 6.0
+ * 
+ * Revision 6.1  89/07/30  12:16:16  mrose
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include "psap.h"
+
+struct tuple {
+    int     t_type;
+    char   *t_class;
+    char   *t_form;
+    char   *t_id;
+    PElementClass t_classnum;
+    int            t_idnum;
+};
+
+typedef struct ypv {
+    int     yv_code;
+#define        YV_UNDF         0x00    /* ??? */
+#define        YV_NUMBER       0x01    /* LITNUMBER */
+#define        YV_BOOL         0x02    /* TRUE | FALSE */
+#define        YV_STRING       0x03    /* LITSTRING */
+#define        YV_IDEFINED     0x04    /* ID */
+#define        YV_IDLIST       0x05    /* IdentifierList */
+#define        YV_VALIST       0x06    /* { Values } */
+#define        YV_NULL         0x07    /* NULL */
+#define YV_ABSENT      0x08    /* WITH COMPONENTS .. ABSENT */
+#define YV_PRESENT     0x09    /*  "   "          .. PRESENT */
+#define YV_INCLUDES    0x0a    /* INCLUDES ... */
+#define YV_WITHCOMPS   0x0b    /* WITH COMPONENTS */
+#define        YV_OIDLIST      0x0c    /* { object identifier } */
+#define YV_REAL                0x0d    /* real value */
+#define YV_HSTRING     0x0e    /* Hex String */
+#define YV_BSTRING     0x0f    /* Bit String */
+
+    union {
+       int         yv_un_number;               /* code = YV_NUMBER
+                                                  code = YV_BOOL */
+
+       double      yv_un_real;                 /* code = YV_REAL */
+
+       char       *yv_un_string;               /* code = YV_STRING */
+
+       struct {                                /* code = YV_IDEFINED */
+           char   *yv_st_module;
+           char   *yv_st_modid;
+           char   *yv_st_identifier;
+       }               yv_st;
+
+        struct ypv *yv_un_idlist;              /* code = YV_IDLIST
+                                                  code = YV_VALIST
+                                                  code = YV_OIDLIST */
+
+       struct {                                
+           char        *yv_sl_xstring;            
+           int         yv_sl_xlength;
+       }               yv_sl;                   /* code = YV_HSTRING
+                                                   code = YV_BSTRING */
+    }                   yv_un;
+#define        yv_number       yv_un.yv_un_number
+#define        yv_string       yv_un.yv_un_string
+#define        yv_identifier   yv_un.yv_st.yv_st_identifier
+#define        yv_module       yv_un.yv_st.yv_st_module
+#define yv_modid       yv_un.yv_st.yv_st_modid
+#define yv_idlist      yv_un.yv_un_idlist
+#define yv_real                yv_un.yv_un_real
+#define yv_xstring     yv_un.yv_sl.yv_sl_xstring
+#define yv_xlength     yv_un.yv_sl.yv_sl_xlength
+
+    char   *yv_action;
+    int            yv_act_lineno;
+
+    int            yv_flags;
+#define        YV_NOFLAGS      0x00    /* no flags */
+#define        YV_ID           0x01    /* ID Value */
+#define        YV_NAMED        0x02    /* NamedNumber */
+#define        YV_TYPE         0x04    /* TYPE Value */
+#define        YV_BOUND        0x08    /* named value */
+#define        YVBITS  "\020\01ID\02NAMED\03TYPE\04BOUND"
+
+    char   *yv_id;                             /* flags & YV_ID */
+
+    char   *yv_named;                          /* flags & YV_NAMED */
+
+    struct ype *yv_type;                       /* flags & YV_TYPE */
+
+    struct ypv *yv_next;
+}                      ypv, *YV;
+#define        NULLYV  ((YV) 0)
+
+YV     new_value (), add_value (), copy_value ();
+
+/* \f */
+
+typedef struct ypt {
+    PElementClass   yt_class;
+
+    YV             yt_value;
+}                      ypt, *YT;
+#define        NULLYT  ((YT) 0)
+
+YT     new_tag (), copy_tag ();
+
+%BEGIN(PEPSY)%
+/* Encoding functions definitions */
+typedef struct yfn {
+       char    *yfn_enc; /* Encoding function name */
+       char    *yfn_dec; /* Decoding function name */
+       char    *yfn_prt; /* Printing function name */
+       char    *yfn_fre; /* Freeing function name */
+}      yfn, *YFN;
+
+#define NULLYFN        ((YFN) 0)
+
+extern YFN new_yfn(), join_yfn();
+
+typedef struct action_t        {
+       char    *a_data;        /* actual C text of action statement */
+       int     a_line;         /* line number of input we came from */
+       int     a_num;          /* number for case statement */
+}      action_t, *Action;
+#define NULLAction     ((Action)0)
+
+extern Action  new_action_t();
+
+typedef struct yactlist        {
+       Action  yal_enc;
+       Action  yal_dec;
+       Action  yal_prn;
+       char    *yal_comment;   /* A comment as to where the line comes from */
+       char    *yal_type;      /* the C type of the parm used in this action */
+}   yactlist_t, *YAL;
+#define NULLYAL        ((YAL)0)
+
+extern YAL     new_yal(), yal_join();
+
+extern Action  start_action, final_action;
+
+extern int     e_actions, d_actions, p_actions;
+
+#define ER_UNKNOWN     0       /* Unknown what the type is - warn if used */
+#define ER_NORMAL      1       /* Implicit works normally */
+#define ER_EXPLICIT    2       /* Implicit should be translated to explicit */
+
+
+%END(PEPSY)%
+
+/* \f */
+
+typedef struct ype {
+    int     yp_code;
+#define        YP_UNDF         0x00    /* type not yet known */
+#define        YP_BOOL         0x01    /* BOOLEAN */
+#define        YP_INT          0x02    /* INTEGER */
+#define        YP_INTLIST      0x03    /* INTEGER [ NamedNumberList ] */
+#define        YP_BIT          0x04    /* BITSTRING */
+#define        YP_BITLIST      0x05    /* BITSTRING [ NamedNumberList ] */
+#define        YP_OCT          0x06    /* OCTETSTRING */
+#define        YP_NULL         0x07    /* NULL */
+#define        YP_SEQ          0x08    /* SEQUENCE */
+#define        YP_SEQTYPE      0x09    /* SEQUENCE OF Type */
+#define        YP_SEQLIST      0x0a    /* SEQUENCE [ ElementTypes ] */
+#define        YP_SET          0x0b    /* SET */
+#define        YP_SETTYPE      0x0c    /* SET OF Type */
+#define        YP_SETLIST      0x0d    /* SET [ MemberTypes ] */
+#define        YP_CHOICE       0x0e    /* CHOICE [ AlternativeTypeList ] */
+#define        YP_ANY          0x0f    /* ANY */
+#define        YP_OID          0x10    /* OBJECT IDENTIFIER */
+#define        YP_IDEFINED     0x11    /* identifier */
+#define YP_ENUMLIST    0x12    /* ENUMERATED */
+#define YP_REAL                0x13    /* Real (floating-point) */
+#define YP_IMPTYPE     0x14    /* Imported - real type unknown */
+
+    int     yp_direction;
+#define YP_DECODER     0x01
+#define YP_ENCODER     0x02
+#define        YP_PRINTER      0x04
+
+    union {
+       struct {                                /* code = YP_IDEFINED */
+           char   *yp_st_module;                   /* module name */
+           OID     yp_st_modid;                    /* module id */
+           char   *yp_st_identifier;               /* definition name */
+       }               yp_st;
+
+       struct ype *yp_un_type;                 /* code = YP_SEQTYPE
+                                                  code = YP_SEQLIST
+                                                  code = YP_SETTYPE
+                                                  code = YP_SETLIST
+                                                  code = YP_CHOICE */
+
+       YV          yp_un_value;                /* code = YP_INTLIST
+                                                  code = YP_BITLIST */
+    }                   yp_un;
+#define        yp_identifier   yp_un.yp_st.yp_st_identifier
+#define        yp_module       yp_un.yp_st.yp_st_module
+#define yp_modid       yp_un.yp_st.yp_st_modid
+#define        yp_type         yp_un.yp_un_type
+#define        yp_value        yp_un.yp_un_value
+
+    char   *yp_intexp;         /* expressions to pass (use) as extra */
+    char   *yp_strexp;         /* parameters (primitive values) */
+    char    yp_prfexp;
+
+    char   *yp_declexp;
+    char   *yp_varexp;
+
+    char   *yp_structname;
+    char   *yp_ptrname;
+
+    char   *yp_param_type;
+
+    char   *yp_action0;
+    int     yp_act0_lineno;
+
+    char   *yp_action05;
+    int            yp_act05_lineno;
+
+    char   *yp_action1;
+    int            yp_act1_lineno;
+
+    char   *yp_action2;
+    int            yp_act2_lineno;
+
+    char   *yp_action3;
+    int            yp_act3_lineno;
+
+    int     yp_flags;
+#define        YP_NOFLAGS      0x0000  /* no flags */
+#define        YP_OPTIONAL     0x0001  /* OPTIONAL */
+#define        YP_COMPONENTS   0x0002  /* COMPONENTS OF */
+#define        YP_IMPLICIT     0x0004  /* IMPLICIT */
+#define        YP_DEFAULT      0x0008  /* DEFAULT */
+#define        YP_ID           0x0010  /* ID */
+#define        YP_TAG          0x0020  /* Tag */
+#define        YP_BOUND        0x0040  /* ID LANGLE */
+#define        YP_PULLEDUP     0x0080  /* member is a choice */
+#define YP_PARMVAL     0x0100  /* value to be passed to parm is present */
+#define YP_CONTROLLED  0x0200  /* encoding item has a controller */
+#define        YP_OPTCONTROL   0x0400  /*   .. */
+#define        YP_ACTION1      0x0800  /* action1 acted upon */
+#define        YP_PARMISOID    0x1000  /* value to be passed to parm is OID */
+#define YP_ENCRYPTED   0x2000  /* encypted - which is a bit hazy */
+#define YP_IMPORTED    0x4000  /* value imported from another module */
+#define YP_EXPORTED    0x8000  /* value exported to another module */
+#define YP_WANTIMPLICIT 0x10000 /* Keep the implicit tag */
+#define        YPBITS  "\020\01OPTIONAL\02COMPONENTS\03IMPLICIT\04DEFAULT\05ID\06TAG\
+\07BOUND\010PULLEDUP\011PARMVAL\012CONTROLLED\013OPTCONTROL\
+\014ACTION1\015PARMISOID\016ENCRYPTED\017IMPORTED\020EXPORTED"
+
+    YV     yp_default;                         /* flags & YP_DEFAULT */
+
+    char   *yp_id;                             /* flags & YP_ID */
+
+    YT     yp_tag;                             /* flags & YP_TAG */
+
+    char   *yp_bound;                          /* flags & YP_BOUND */
+
+    char   *yp_parm;                           /* flags & YP_PARMVAL */
+
+    char   *yp_control;                                /* flags & YP_CONTROLLED */
+
+    char   *yp_optcontrol;                     /* flags & YP_OPTCONTROL */
+
+    char   *yp_offset;
+
+    struct ype *yp_next;
+
+%BEGIN(PEPSY)%
+    YFN           yp_yfn;      /* encoding/decoding functions */
+
+    YAL    yp_bef_alist;       /* list of before this */
+    YAL    yp_aft_alist;       /* list of after this */
+
+    YAL           yp_control_act;      /* controlled actions */
+    YAL           yp_optional_act;     /* optional actions */
+%END(PEPSY)%
+    
+    int           yp_lineno;           /* line number for diagnostics */
+
+}                      ype, *YP;
+#define        NULLYP  ((YP) 0)
+
+YP     new_type (), add_type (), copy_type (), lkup();
+
+char   *new_string ();
+
+#define        TBL_EXPORT      0
+#define TBL_IMPORT     1
+#define MAX_TBLS       2
+
+extern int tagcontrol;
+#define TAG_UNKNOWN    0
+#define TAG_IMPLICIT   1
+#define TAG_EXPLICIT   2
+
+#define CH_FULLY       0
+#define CH_PARTIAL     1
+
+typedef struct yop {
+    char   *yo_name;
+
+    YP     yo_arg;
+    YP     yo_result;
+    YV     yo_errors;
+    YV     yo_linked;
+
+    int            yo_opcode;
+}              yop, *YO;
+#define        NULLYO  ((YO) 0)
+
+
+typedef struct yerr {
+    char   *ye_name;
+
+    YP     ye_param;
+
+    int            ye_errcode;
+
+    int            ye_offset;
+}          yerr, *YE;
+#define        NULLYE  ((YE) 0)
+
+/* \f */
+
+%BEGIN(PEPSY)%
+extern char *pepsyversion;
+%END(PEPSY)%
+%BEGIN(PEPY)%
+extern char *pepyversion;
+%END(PEPY)%
+
+extern int yysection;
+extern char *yyencpref;
+extern char *yydecpref;
+extern char *yyprfpref;
+extern char *yyencdflt;
+extern char *yydecdflt;
+extern char *yyprfdflt;
+
+extern int yydebug;
+extern int yylineno;
+
+#ifndef        HPUX
+extern char yytext[];
+#else
+extern unsigned char yytext[];
+#endif
+
+extern char *mymodule;
+
+extern OID   mymoduleid;
+
+extern char *bflag;
+extern int   Cflag;
+extern int   dflag;
+extern int   Pflag;
+extern char *sysin;
+
+extern char *module_actions;
+
+OID    addoid ();
+OID    int2oid ();
+OID    oidlookup ();
+char   *oidname ();
+char   *oidprint ();
+
+extern int errno;
diff --git a/usr/src/contrib/isode/pepsy/prnt.c b/usr/src/contrib/isode/pepsy/prnt.c
new file mode 100644 (file)
index 0000000..39d1763
--- /dev/null
@@ -0,0 +1,1748 @@
+/* prnt.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/prnt.c,v 7.9 91/02/22 09:49:54 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/prnt.c,v 7.9 91/02/22 09:49:54 mrose Interim $
+ *
+ *
+ * $Log:       prnt.c,v $
+ * Revision 7.9  91/02/22  09:49:54  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.8  90/12/23  17:25:20  mrose
+ * patches
+ * 
+ * Revision 7.7  90/11/11  09:58:56  mrose
+ * touch-up
+ * 
+ * Revision 7.6  90/11/04  19:21:00  mrose
+ * update
+ * 
+ * Revision 7.5  90/10/23  20:43:16  mrose
+ * update
+ * 
+ * Revision 7.4  90/08/08  14:14:38  mrose
+ * update
+ * 
+ * Revision 7.3  90/07/27  08:48:34  mrose
+ * update
+ * 
+ * Revision 7.2  90/07/09  14:53:08  mrose
+ * sync
+ * 
+ * Revision 7.1  90/07/01  20:02:00  mrose
+ * update
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/* LINTLIBRARY */
+
+#include       <stdio.h>
+#include       <ctype.h>
+#include       <varargs.h>
+#include       "pepsy-driver.h"
+#include       "psap.h"
+#include       "pepsy.h"
+#include       "tailor.h"
+
+#define PRINT_TYPES    0
+#define        CHOICE_PUSH
+
+
+extern PE p_setpresent();
+extern IFP vfnx;
+extern FILE *vfp;
+
+extern ptpe *next_ptpe();
+extern int pepsylose ();
+
+int     xlevel = 0;
+int     tabed = 0;
+int     xpushed = 0;
+
+#define NEXT_PTPE(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 */
+
+/*
+ * to guarentee the rules that vname and a vprint-type routine are called
+ * alternatively. Basically can't have two vname's in a row
+ */
+static vnamelock = 0;
+   /* if vnamelock > 0 don't call vname */
+#define VNAME(x)  if (vnamelock++ <= 0) vname(x); else
+#define VTAG(class, tag)       if (vnamelock++ <= 0)  \
+                                       vtag((int )class, (int )tag); else
+
+/* as vprint takes a variable number of arguements we have to put all of
+ * the arguements inside () and remove them when we expand to vprint
+ */
+#define VPRINT(x)      vnamelock = 0, vprint x
+#define VSTRING(x)     vnamelock = 0, vstring(x)
+#define VUNKNOWN(x)    vnamelock = 0, vunknown(x)
+#define VPUSH          vnamelock = 0, vpush
+#define VPOP           vnamelock = 0, vpop
+
+
+/*
+ * Print out ASN data given in pe using the information given in the tables
+ */
+prnt_f(typ, mod, pe, explicit, len, buf)
+/* ARGSUSED */
+int     typ;                   /* which type it is */
+modtyp *mod;                   /* ASN Module it is from */
+PE      pe;
+int     explicit;      /* nonzero means we are call top level 
+                        * print final \n
+                        */
+int    *len;
+char  **buf;
+{
+    ptpe   *p;
+
+    if (typ < 0 || typ >= mod->md_nentries) {
+       return (ppepsylose (mod, NULLPTPE, pe, "prnt_f:Illegal type %d\n",typ));
+    }
+
+    p = mod->md_ptab[typ];
+
+    if (p->pe_type != PE_START) {
+       return (ppepsylose (mod, p, pe, "prnt_f: missing PE_START\n"));
+    }
+
+#if EXTRA_BRACKETS
+    if (explicit) {
+       if (p->pe_typename)
+           VNAME(p->pe_typename);
+    }
+    VPUSH();
+#endif
+
+
+    if (p_pr_obj(explicit, pe, p, mod) == NOTOK) {
+#if EXTRA_BRACKETS
+       VPOP();
+#endif
+       return (NOTOK);
+    }
+#if EXTRA_BRACKETS
+    VPOP();
+#endif
+    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.
+ */
+static int
+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 PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+
+    p++;
+    while (p->pe_type != PE_END) {
+
+       if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
+           if (DEFAULT(p)) {
+               return (ppepsylose (mod, p, pe,
+                   "p_pr_obj:Default not implemented\n"));
+           }
+           else if (OPTIONAL(p))
+               return (NO_DATA_USED);
+           else {
+               return (ppepsylose (mod, p, pe,
+                   "p_pr_obj:missing mandatory parameter", p, mod));
+           }
+       }
+       if (p->pe_typename)
+           VNAME(p->pe_typename);
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           goto bad;
+
+       case UCODE:
+           if (mod->md_pucode == NULLIFP
+           || (*mod->md_pucode) (pe, p) == NOTOK)
+               goto bad;
+           break;
+
+
+       default:
+           if (p_pr_type(expl, pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+       if (ISDTYPE(p) && cnt > 0)
+           return (ppepsylose (mod, p, pe, "p_pr_obj:compound type found\n"));
+       if (ISDTYPE(p) && pe != NULLPE) {
+           return (OK);
+       }
+       if (NEXT_PTPE(p) == NULLPTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a single type. If a basic type parse it, if a compound type
+ * call the appropriate parsing routine
+ */
+static int
+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;
+    integer     i;
+    OID     oid;
+
+
+    while (p->pe_type != PE_END) {
+
+       if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
+           if (DEFAULT(p)) {
+#ifdef PRINT_DEFAULTS
+               setpval(p, p + 1, mod);
+#endif
+               return (OK);
+           } else if (OPTIONAL(p))
+               return (OK);
+           else {
+               dmp_ptpe("p_pr_type:missing mandatory parameter", p, mod);
+               goto bad;
+           }
+       }
+       switch (p->pe_type) {
+       case PE_END:
+       case PE_START:
+           goto bad;
+
+        case BOPTIONAL:
+            if (CHKTAG(mod, p + 1, pe) == 0) {
+                return (OK);
+            }
+            p++;
+            continue;
+
+       case UCODE:
+           if (mod->md_pucode == NULLIFP
+           || (*mod->md_pucode) (pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case ETAG:
+           switch (p->pe_ucode) {
+           default:
+               if (p_pr_etype(pe->pe_cons, p, mod) == NOTOK)
+                   goto bad;
+           }
+           break;
+
+       case SSEQ_START:
+       case SEQ_START:
+           if (p_pr_seq(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SSEQOF_START:
+       case SEQOF_START:
+           if (p_pr_seqof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SSET_START:
+       case SET_START:
+           if (p_pr_set(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SSETOF_START:
+       case SETOF_START:
+           if (p_pr_setof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                   (char **) 0) == NOTOK)
+                   goto bad;
+           } else {
+               if (p_pr_obj(0, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+           }
+           break;
+
+       case SOBJECT:
+       case OBJECT:
+           if (p_pr_obj(expl, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SCHOICE_START:
+       case CHOICE_START:
+           if (p_pr_choice(pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD) {
+               return (ppepsylose (mod, p, pe, "p_pr_type: missing EXTMOD"));
+           }
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                  (char **) 0) == NOTOK)
+                  goto bad;
+           break;
+
+       case INTEGER:
+           if (pe != NULLPE) {
+               if ((i = prim2num(pe)) == NOTOK && pe->pe_errno != PE_ERR_NONE)
+                   goto bad;
+               VPRINT(("%d", i));
+           }
+           break;
+
+#ifdef PEPSY_REALS
+       case REALTYPE:
+           if (pe != NULLPE) {
+               double r;
+
+               if ((r = prim2real(pe)) == NOTOK
+                   && pe->pe_errno != PE_ERR_NONE)
+                   goto bad;
+               VPRINT(("%g", r));
+           }
+           break;
+#endif
+
+       case BOOLEAN:
+           if (pe != NULLPE) {
+               if ((i = prim2flag(pe)) == NOTOK)
+                   goto bad;
+               VPRINT((i ? "TRUE" : "FALSE"));
+           }
+           break;
+
+       case T_NULL:
+           VPRINT(("NULL"));
+           break;
+
+       case SANY:
+           if (pe != NULLPE) {
+               if (pe->pe_errno != PE_ERR_NONE) {
+                   goto bad;
+               } else
+                   VUNKNOWN(pe);
+           }
+           break;
+
+
+       case ANY:
+           if (pe != NULLPE) {
+               if (pe->pe_errno != PE_ERR_NONE) {
+                   goto bad;
+               } else
+                   VUNKNOWN(pe);
+           }
+           break;
+
+       case SOCTETSTRING:
+           if (pe != NULLPE) {
+               VSTRING(pe);
+           }
+           break;
+
+       case OCTETSTRING:
+       case T_STRING:
+       case OCTET_PTR:
+           if (pe != NULLPE) {
+               VSTRING(pe);
+           }
+           break;
+
+       case SBITSTRING:
+           if (pe != NULLPE) {
+               PE      bstr;
+
+               if ((bstr = prim2bit(pe)) == NULLPE)
+                   goto bad;
+               if (p -> pe_ucode >= 0 && mod->md_ptrtab &&
+                   mod -> md_ptrtab[p -> pe_ucode] &&
+                   bstr -> pe_nbits < LOTSOFBITS)
+                   VPRINT (("%s", bit2str(bstr,
+                                          mod -> md_ptrtab[p -> pe_ucode])));
+               else if (bstr->pe_nbits < LOTSOFBITS)
+                   VPRINT(("%s", bit2str(bstr, "\020")));
+               else
+                   VUNKNOWN(pe);
+           }
+           break;
+
+       case BITSTR_PTR:
+       case BITSTRING:
+           if (pe != NULLPE) {
+               PE      bstr;
+
+               if ((bstr = prim2bit(pe)) == NULLPE)
+                   goto bad;
+               if (p -> pe_ucode >= 0 && mod->md_ptrtab &&
+                   mod -> md_ptrtab[p -> pe_ucode] &&
+                   bstr -> pe_nbits < LOTSOFBITS)
+                   VPRINT (("%s", bit2str(bstr,
+                                          mod -> md_ptrtab[p -> pe_ucode])));
+               else if (bstr->pe_nbits < LOTSOFBITS)
+                   VPRINT(("%s", bit2str(bstr, "\020")));
+               else
+                   VUNKNOWN(pe);
+           }
+           break;
+
+       case SOBJID:
+           if ((oid = (OID) prim2oid(pe)) == NULLOID) {
+               goto bad;
+           } else {
+               VPRINT(("%s", oid2ode(oid)));
+           }
+           break;
+
+       case OBJID:
+           if ((oid = (OID) prim2oid(pe)) == NULLOID) {
+               goto bad;
+           } else {
+               VPRINT(("%s", oid2ode(oid)));
+           }
+           break;
+
+       case FN_CALL:
+           if ((FN_PTR(mod, p))(pe) == NOTOK)
+               return ppepsylose (mod, &p[1], NULLPE,
+                                 "p_pr_type:FN_CALL:call failed");
+           break;
+
+       default:
+           return (ppepsylose (mod, p, pe, "p_pr_type: %d not implemented\n",
+               p->pe_type));
+       }
+       if (ISDTYPE(p) && cnt > 0)
+           return (ppepsylose (mod, p, pe, "p_pr_type:compound type found\n"));
+       if (ISDTYPE(p) && pe != NULLPE)
+           return (OK);
+       if (NEXT_PTPE(p) == NULLPTPE)
+           goto bad;
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * Parse a sequence, calling appropriate routines to parse each sub
+ * type
+ */
+static int
+p_pr_seq(head, p, mod)
+PE      head;
+ptpe   *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+
+    if (p->pe_type != SEQ_START && p->pe_type != SSEQ_START)
+       return (ppepsylose (mod, p, head, "p_pr_seq: missing SEQ_START\n"));
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+    VPUSH();
+
+    p++;
+    if (p->pe_type == DFLT_B)
+       p++;
+
+
+    pe = first_member(head);
+    while (p->pe_type != PE_END) {
+       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)) {
+#ifdef PRINT_DEFAULTS
+               setpval(p, p + 1, mod);
+#endif
+               goto next;
+           } else {
+               dmp_ptpe("p_pr_seq:missing mandatory parameter", p, mod);
+               goto bad;
+           }
+       }
+       if (p->pe_typename)
+           VNAME(p->pe_typename);
+       switch (p->pe_type) {
+       case OPTL:
+           break;
+
+       case UCODE:
+           if (mod->md_pucode == NULLIFP
+           || (*mod->md_pucode) (pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case BOPTIONAL:
+           if (CHKTAG(mod, p + 1, pe) == 0)
+               goto next;
+           p++;
+           continue;
+
+       case ETAG:
+           if (p_pr_type(1, pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQ_START:
+           if (p_pr_seq(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SEQOF_START:
+           if (p_pr_seqof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SET_START:
+           if (p_pr_set(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SETOF_START:
+           if (p_pr_setof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ) {
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                   (char **) 0) == NOTOK)
+                   goto bad;
+           } else {
+               if (p_pr_obj(0, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+           }
+           break;
+
+       case SOBJECT:
+           if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case OBJECT:
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+           if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SCHOICE_START:
+       case CHOICE_START:
+           if (p_pr_choice(pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD) {
+               return (ppepsylose (mod, p, pe, "p_pr_seq: missing EXTMOD"));
+           }
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0,NULLIP,
+               (char **)0) == NOTOK)
+               goto bad;
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD) {
+               return (ppepsylose (mod, p, pe, "p_pr_seq: missing EXTMOD"));
+           }
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                   (char **)0) == NOTOK)
+               goto bad;
+           break;
+
+       default:
+           if (p_pr_type(1, pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+
+       if (ISDTYPE(p) && pe != NULLPE)
+           pe = next_member(head, pe);
+next:
+       if (NEXT_PTPE(p) == NULLPTPE)
+           goto bad;
+    }
+
+    VPOP();
+    return (OK);
+
+bad:
+    VPOP();
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a set, calling appropriate routines to parse each sub type
+ */
+static int
+p_pr_set(head, p, mod)
+PE      head;
+ptpe   *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+
+    if (p->pe_type != SET_START && p->pe_type != SSET_START)
+       return (ppepsylose (mod, p, head, "p_pr_seq: missing SET_START\n"));
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+    VPUSH();
+
+    p++;
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    while (p->pe_type != PE_END) {
+
+       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)) {
+#ifdef PRINT_DEFAULTS
+               setpval(p, p + 1, mod);
+#endif
+               goto next;
+           } else {
+               dmp_ptpe("p_pr_set:missing mandatory parameter", p, mod);
+               goto bad;
+           }
+       }
+       if (p->pe_typename)
+           VNAME(p->pe_typename);
+       switch (p->pe_type) {
+       case OPTL:
+           break;
+
+       case UCODE:
+           if (mod->md_pucode == NULLIFP
+           || (*mod->md_pucode) (pe, p) == NOTOK)
+               goto bad;
+           break;
+
+       case BOPTIONAL:
+           if ((pe = (PE) p_setpresent(head, p + 1, mod)) == NULLPE)
+               goto next;
+           p++;
+           continue;
+
+       case ETAG:
+           if (p_pr_type(1, pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEQ_START:
+           if (p_pr_seq(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SEQOF_START:
+           if (p_pr_seqof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SET_START:
+           if (p_pr_set(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SETOF_START:
+           if (p_pr_setof(pe, p, mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case IMP_OBJ:
+           p++;
+           if (p->pe_type == EXTOBJ) {
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                      (char **) 0) == NOTOK)
+                      goto bad;
+           } else {
+               if (p_pr_obj(0, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+           }
+           break;
+
+       case SOBJECT:
+           if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case OBJECT:
+           if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+               goto bad;
+           }
+           break;
+
+       case SCHOICE_START:
+       case CHOICE_START:
+           if (p_pr_choice(pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+
+       case SEXTOBJ:
+           if (p[1].pe_type != EXTMOD) {
+               return (ppepsylose (mod, p, pe, "p_pr_set: missing EXTMOD"));
+           }
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP, (char **)0) == NOTOK)
+                   return (NOTOK);
+           break;
+
+       case EXTOBJ:
+           if (p[1].pe_type != EXTMOD) {
+               return (ppepsylose (mod, p, pe, "p_pr_set: missing EXTMOD"));
+           }
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+               (char **)0) == NOTOK)
+               goto bad;
+           break;
+
+       default:
+           if (p_pr_type(1, pe, p, mod) == NOTOK)
+               goto bad;
+           break;
+       }
+
+next:
+       if (NEXT_PTPE(p) == NULLPTPE)
+           goto bad;
+    }
+
+    VPOP();
+    return (OK);
+
+bad:
+    VPOP();
+    return (NOTOK);
+}
+
+
+/*
+ * Parse a sequence of calling appropriate routines to parse each sub
+ * type
+ */
+
+static int
+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 && p->pe_type != SSEQOF_START) {
+       return (ppepsylose (mod, p, head, "p_pr_seqof: missing SEQOF_START\n"));
+    }
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+    VPUSH();
+
+    p++;
+
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    start = p;
+
+
+    pe = first_member(head);
+    while (pe != NULLPE) {
+       while (p->pe_type != PE_END) {
+
+           if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) {
+               if (DEFAULT(p))
+                   return (ppepsylose (mod, p, pe,
+                       "p_pr_seqof:Default not implemented\n"));
+               else if (OPTIONAL(p))
+                   goto next;
+               else {
+                   return (ppepsylose (mod, p, pe,
+                       "p_pr_seqof:missing mandatory parameter"));
+               }
+           }
+           if (p->pe_typename)
+               VNAME(p->pe_typename);
+           switch (p->pe_type) {
+           case UCODE:
+               if (mod->md_pucode == NULLIFP
+               || (*mod->md_pucode) (pe, p) == NOTOK)
+                   goto bad;
+               break;
+
+           case BOPTIONAL:
+               if (CHKTAG(mod, p + 1, pe) == 0)
+                   goto next;
+               p++;
+               continue;
+
+           case ETAG:
+               if (p_pr_type(1, pe, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+               /*
+                * case SCTRL:  parm = (char *) ((char *) parm);
+                * break;
+                */
+
+           case SEQ_START:
+               if (p_pr_seq(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SEQOF_START:
+               if (p_pr_seqof(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SET_START:
+               if (p_pr_set(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SETOF_START:
+               if (p_pr_setof(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SOBJECT:
+               if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case OBJECT:
+               if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SCHOICE_START:
+           case CHOICE_START:
+               if (p_pr_choice(pe, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD) {
+                   return (ppepsylose (mod, p, pe,"p_pr_seqof:missing EXTMOD"));
+               }
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                    (char **)0) == NOTOK)
+                    goto bad;
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD) {
+                   return (ppepsylose (mod, p, pe,"p_pr_seqof:missing EXTMOD"));
+               }
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP, 
+                   (char **) 0) == NOTOK)
+                   goto bad;
+               break;
+
+           default:
+               if (p_pr_type(1, pe, p, mod) == NOTOK)
+                   goto bad;
+               break;
+           }
+
+           if (ISDTYPE(p) && dflt == 0)
+               pe = next_member(head, pe);
+    next:
+           if (NEXT_PTPE(p) == NULLPTPE)
+               goto bad;
+       }
+       /* parm = (char *) (parm); */
+       p = start;
+    }
+
+    VPOP();
+    return (OK);
+
+bad:
+    VPOP();
+    return (NOTOK);
+}
+
+/*
+ * Parse a setof, calling appropriate routines to parse each sub type
+ */
+static int
+p_pr_setof(head, p, mod)
+PE      head;
+ptpe   *p;
+modtyp *mod;                   /* Module it is from */
+{
+    PE      pe;
+    ptpe   *start;
+
+    if (p->pe_type != SETOF_START && p->pe_type != SSETOF_START)
+       return (ppepsylose (mod, p, head, "p_pr_setof: missing SETOF_START\n"));
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+    VPUSH();
+
+    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 (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
+               if (DEFAULT(p)) {
+#ifdef PRINT_DEFAULTS
+                   setpval(p, p + 1, mod);
+#endif
+                   goto next;
+               } else {
+                   dmp_ptpe("p_pr_setof:missing mandatory parameter", p, mod);
+                   goto bad;
+               }
+           }
+
+           if (p->pe_typename)
+               VNAME(p->pe_typename);
+           switch (p->pe_type) {
+           case UCODE:
+               if (mod->md_pucode == NULLIFP
+               || (*mod->md_pucode) (pe, p) == NOTOK)
+                   goto bad;
+               break;
+
+           case BOPTIONAL:
+               if ((pe = (PE) p_setpresent(head, p + 1, mod)) == NULLPE)
+                   goto next;
+               p++;
+               continue;
+
+           case ETAG:
+               if (p_pr_type(1, pe->pe_cons, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+               /*
+                * case SCTRL: parm = (char *) (parm); break;
+                */
+
+           case SEQ_START:
+               if (p_pr_seq(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SEQOF_START:
+               if (p_pr_seqof(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SET_START:
+               if (p_pr_set(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SETOF_START:
+               if (p_pr_setof(pe, p, mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SOBJECT:
+               if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case OBJECT:
+               if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK) {
+                   goto bad;
+               }
+               break;
+
+           case SCHOICE_START:
+           case CHOICE_START:
+               if (p_pr_choice(pe, p, mod) == NOTOK)
+                   goto bad;
+               break;
+
+           case SEXTOBJ:
+               if (p[1].pe_type != EXTMOD) {
+                   return (ppepsylose (mod, p, pe,"p_pr_setof:missing EXTMOD"));
+               }
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                   (char **) 0) == NOTOK)
+                   goto bad;
+               break;
+
+           case EXTOBJ:
+               if (p[1].pe_type != EXTMOD) {
+                   return (ppepsylose (mod, p, pe,"p_pr_setof:missing EXTMOD"));
+               }
+               if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                   (char **) 0) == NOTOK)
+                   goto bad;
+               break;
+
+           default:
+               if (p_pr_type(1, pe, p, mod) == NOTOK)
+                   goto bad;
+               break;
+           }
+
+    next:
+           if (NEXT_PTPE(p) == NULLPTPE)
+               goto bad;
+       }
+       /* parm = (char *)(parm); */
+       p = start;
+    }
+
+    VPOP();
+    return (OK);
+
+bad:
+    VPOP();
+    return (NOTOK);
+
+}
+
+/*
+ * parse a choice field. This means find which choice is taken
+ */
+static int
+p_pr_choice(head, p, mod)
+PE      head;
+ptpe   *p;
+modtyp *mod;                   /* Module it is from */
+{
+    if (p->pe_type != CHOICE_START && p->pe_type != SCHOICE_START) {
+       return (ppepsylose (mod, p, head, "p_pr_choice:missing CHOICE_START"));
+    }
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+#ifdef CHOICE_PUSH
+    VPUSH();
+#endif
+
+    p++;
+    if (p->pe_type == DFLT_B)
+       p++;
+
+    if (p->pe_type == SCTRL) {
+       p++;
+    }
+
+    for (; p->pe_type != PE_END; NEXT_PTPE(p)) {
+       if (ISDTYPE(p) && p_ismatch(p, mod, head->pe_class, head->pe_id)) {
+           if (p->pe_typename)
+               VNAME(p->pe_typename);
+           if (p_pr_type(0, head, p, mod) == NOTOK)
+               return (NOTOK);
+#ifdef CHOICE_PUSH
+           VPOP();
+#endif
+           NEXT_PTPE(p);
+           if (p->pe_type == UCODE) {
+               if (mod->md_pucode == NULLIFP
+               || (*mod->md_pucode) (head, p) == NOTOK)
+                   return (NOTOK);
+           }
+           return (OK);
+       }
+    }
+
+    dmp_ptpe("p_pr_choice: no choice taken", p, mod);
+#ifdef CHOICE_PUSH
+       VPOP();
+#endif
+    return (NOTOK);
+}
+
+/*
+ * 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) {
+       (void) ppepsylose (NULLMODTYP, p, NULLPE,
+           "next_ptpe: unexpected PE_END");
+       return (NULLPTPE);
+    }
+    do {
+again:
+       switch (p->pe_type) {
+       case SSEQ_START:
+       case SSEQOF_START:
+       case SSET_START:
+       case SSETOF_START:
+       case SCHOICE_START:
+       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 REALTYPE:
+       case BOOLEAN:
+       case SANY:
+       case ANY:
+       case T_NULL:
+       case OBJECT:
+       case SOBJECT:
+       case BITSTRING:
+       case SBITSTRING:
+       case BITSTR_LEN:
+       case OCTETSTRING:
+       case T_STRING:
+       case OCTET_LEN:
+       case SOCTETSTRING:
+       case OBJID:
+       case SOBJID:
+       case OPTL:
+       case EXTMOD:
+       case DFLT_B:
+       case FN_CALL:
+       case FFN_CALL:
+           break;
+
+       case OCTET_PTR:
+       case BITSTR_PTR:
+       case IMP_OBJ:
+       case ETAG:
+       case EXTOBJ:
+       case SEXTOBJ:
+       case DFLT_F:
+       case BOPTIONAL:
+           p++;
+           goto again;
+
+       case PE_END:
+           level--;
+           break;
+
+       default:
+           (void) ppepsylose (NULLMODTYP, p, NULLPE,
+               "next_ptpe: unknown type %d\n", p->pe_type);
+           return (NULLPTPE);
+       }
+       p++;
+    } while (level > 0 || p->pe_type == DFLT_B);
+
+    return (p);
+}
+
+/*
+ * Parse a single type for explicit tag If a basic type parse it, if
+ * a compound type call the appropriate parsing routine
+ */
+static int
+p_pr_etype(pe, p, mod)
+PE      pe;
+ptpe   *p;
+modtyp *mod;                   /* Module it is from */
+{
+    integer     i;
+    OID     oid;
+
+    if (p->pe_type != ETAG)
+       return (ppepsylose (mod, p, pe, "p_pr_etype: missing ETAG\n"));
+    
+
+    if (PRINT_TAG(p))
+       VTAG (CLASS (p), TAG (p));
+    p++;
+
+    switch (p->pe_type) {
+    case PE_END:
+    case PE_START:
+       goto bad;
+
+    case UCODE:
+       if (mod->md_pucode == NULLIFP
+       || (*mod->md_pucode) (pe, p) == NOTOK)
+           goto bad;
+       break;
+
+    case BOPTIONAL:
+       return (ppepsylose (mod, p, pe, "p_pr_etype:illegal BOPTIONAL\n"));
+
+    case ETAG:
+       switch (p->pe_ucode) {
+
+       default:
+           if (p_pr_etype(pe->pe_cons, p, mod) == NOTOK)
+               goto bad;
+       }
+       break;
+
+    case SSEQ_START:
+    case SEQ_START:
+       if (p_pr_seq(pe, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSEQOF_START:
+    case SEQOF_START:
+       if (p_pr_seqof(pe, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSET_START:
+    case SET_START:
+       if (p_pr_set(pe, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SSETOF_START:
+    case SETOF_START:
+       if (p_pr_setof(pe, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case IMP_OBJ:
+       p++;
+       if (p->pe_type == EXTOBJ) {
+           if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+                  (char **) 0) == NOTOK)
+                  goto bad;
+       } else {
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+           if (p_pr_obj(0, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK)
+               goto bad;
+       }
+       break;
+
+    case SOBJECT:
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+       if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK)
+           goto bad;
+       break;
+
+    case OBJECT:
+#if PRINT_TYPES
+    if (p->pe_typename)
+       VNAME(p->pe_typename);
+#endif
+       if (p_pr_obj(1, pe, mod->md_ptab[p->pe_tag], mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SCHOICE_START:
+    case CHOICE_START:
+       if (p_pr_choice(pe, p, mod) == NOTOK)
+           goto bad;
+       break;
+
+    case SEXTOBJ:
+       if (p[1].pe_type != EXTMOD) {
+           return (ppepsylose (mod, p, pe, "p_pr_etype: missing EXTMOD"));
+       }
+       if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+              (char **) 0) == NOTOK)
+              goto bad;
+       break;
+
+    case EXTOBJ:
+       if (p[1].pe_type != EXTMOD) {
+           return (ppepsylose (mod, p, pe, "p_pr_etype: missing EXTMOD"));
+       }
+       if (prnt_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0, NULLIP,
+              (char **) 0) == NOTOK)
+              goto bad;
+       break;
+
+    case INTEGER:
+       if (pe != NULLPE) {
+           if ((i = prim2num(pe)) == NOTOK && pe->pe_errno != PE_ERR_NONE)
+               goto bad;
+           VPRINT(("%d", i));
+       }
+       break;
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       if (pe != NULLPE) {
+           double r;
+
+           if ((r = prim2real(pe)) == NOTOK
+               && pe->pe_errno != PE_ERR_NONE)
+               goto bad;
+           VPRINT(("%g", r));
+       }
+       break;
+#endif
+
+
+    case BOOLEAN:
+       if (pe != NULLPE) {
+           if ((i= prim2flag(pe)) == NOTOK)
+               goto bad;
+           VPRINT((i ? "TRUE" : "FALSE"));
+       }
+       break;
+
+    case T_NULL:
+       VPRINT(("NULL"));
+       break;
+
+    case ANY:
+       if (pe != NULLPE) {
+           if (pe->pe_errno != PE_ERR_NONE) {
+               goto bad;
+           } else
+               VUNKNOWN(pe);
+       }
+       break;
+
+    case SANY:
+       if (pe != NULLPE) {
+           if (pe->pe_errno != PE_ERR_NONE) {
+               goto bad;
+           } else
+               VUNKNOWN(pe);
+       }
+       break;
+
+    case SOCTETSTRING:
+    case OCTETSTRING:
+    case T_STRING:
+    case OCTET_PTR:
+       if (pe != NULLPE) {
+           VSTRING(pe);
+       }
+       break;
+
+    case BITSTRING:
+    case BITSTR_PTR:
+    case SBITSTRING:
+       if (pe != NULLPE) {
+           PE  bstr;
+
+           if ((bstr = prim2bit(pe)) == NULLPE)
+               goto bad;
+           if (p -> pe_ucode >= 0 && mod->md_ptrtab &&
+               mod -> md_ptrtab[p -> pe_ucode] &&
+               bstr -> pe_nbits < LOTSOFBITS)
+               VPRINT (("%s", bit2str(bstr,
+                                      mod -> md_ptrtab[p -> pe_ucode])));
+           else if (bstr->pe_nbits < LOTSOFBITS)
+               VPRINT(("%s", bit2str(bstr, "\020")));
+           else
+               VUNKNOWN(pe);
+       }
+       break;
+
+    case SOBJID:
+       if (((OID) oid = prim2oid(pe)) == NULLOID) {
+           goto bad;
+       } else {
+           VPRINT(("%s", oid2ode(oid)));
+       }
+       break;
+
+    case OBJID:
+       if (((OID) oid = prim2oid(pe)) == NULLOID) {
+           goto bad;
+       } else {
+           VPRINT(("%s", oid2ode(oid)));
+       }
+       break;
+
+    default:
+       return (ppepsylose (mod, p, pe, "p_pr_etype: %d not implemented\n",
+           p->pe_type));
+    }
+
+    return (OK);
+
+bad:
+    return (NOTOK);
+}
+
+/*
+ * 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) {
+           (void) ppepsylose (mod, p, NULLPE, "p_ismatch: missing EXTMOD");
+           return (0); /* fixup ismatch return -1 */
+       }
+       return (p_ismatch(EXT2MOD(mod, (p + 1))->md_ptab[p->pe_tag] + 1,
+                         EXT2MOD(mod, (p + 1)), cl, tag));
+
+    case SCHOICE_START:
+    case CHOICE_START:
+       for (p++; p->pe_type != PE_END; p = NEXT_PTPE(p)) {
+           if (!ISDTYPE(p))
+               continue;
+           if (p_ismatch(p, mod, cl, tag))
+               return (1);
+       }
+       return (0);
+
+
+    case SANY:
+       return (1);
+
+    case ANY:
+       if (STAG(p) == -1)
+           return (1);
+       /* else fall through - not sure if this is needed */
+
+    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;
+    modtyp     *nmod;
+
+    while (!ISDTYPE(p) && p->pe_type != PE_END) {
+       p++;
+    }
+    if (!ISDTYPE(p) || p->pe_type == PE_END)
+       return (NULLPE);
+
+    switch (p->pe_type) {
+    case EXTOBJ:
+    case SEXTOBJ:
+       /* Needs to be changed for optional and default */
+       nmod = EXT2MOD(mod, (p + 1));
+       return (p_setpresent(head, p = nmod->md_ptab[p->pe_tag] + 1, nmod));
+
+    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 SCHOICE_START:
+    case CHOICE_START:
+       for (p++; p->pe_type != PE_END; p = NEXT_PTPE(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)));
+    }
+}
+
+#ifdef PRINT_DEFAULTS
+/*
+ * set the default value to that value in the structure
+ */
+setpval(typ, dflt, mod)
+ptpe   *typ, *dflt;
+modtyp *mod;
+{
+    int     len, i;
+    integer intval;
+    char   *ptr, *optr;
+    PE      pe_ptr;
+
+    switch (typ->pe_type) {
+
+    case INTEGER:
+       intval = IVAL(mod, dflt);
+       (*vfnx) (vfp, "%d (DEFAULT INTEGER)\n", intval);
+       break;
+
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       (*vfnx) (vfp, "%f (DEFAULT Real)\n", RVAL(mod, dflt));
+       break;
+#endif
+
+    case BOOLEAN:
+       intval = IVAL(mod, dflt);
+       /*
+        * (*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:
+    case BITSTRING:
+       (PE) pe_ptr = strb2bitstr(PVAL(mod, dflt), IVAL(mod, dflt), 0, 0);
+       (*vfnx) (vfp, " '");
+       optr = ptr = bitstr2strb((PE) pe_ptr, &len);
+       for (i = 0; i < len; i += 8)
+           (*vfnx) (vfp, "%.2x", *ptr++);
+       (*vfnx) (vfp, "'H (DEFAULT BITSTRING)\n");
+       pe_free (pe_ptr);
+       free (optr);
+       break;
+
+    case SOCTETSTRING:
+    case OCTETSTRING:
+        ptr = PVAL(mod, dflt); /* array of octets */
+        intval = IVAL(mod, dflt);              /* length of array */
+       if (printable(ptr, intval)) {
+           (*vfnx) (vfp, "\"");
+           for (; *ptr && intval-- > 0; ptr++)
+                (void) fputc(*ptr, vfp);
+           (*vfnx) (vfp, "\"\n");
+       } else {
+           (*vfnx) (vfp, "'");
+           if (ptr) {
+               for (; intval-- > 0; ptr++)
+                   (*vfnx) (vfp, "%.2x", *ptr & 0xff);
+           }
+           (*vfnx) (vfp, "'H \n");
+       }
+       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 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:
+       return (ppepsylose (mod, p, pe, "setpval: type %d not implemented\n",
+           typ->pe_type));
+       break;
+    }
+
+}
+#endif
+/*
+ * return non zero if we can print out the string
+ */
+printable(strptr, len)
+char   *strptr;
+int    len;
+{
+    if (strptr == NULL || *strptr == '\0') {
+       return (0);
+    }
+
+     while (len-- > 0) {
+       if (!isprint(*strptr++))
+           return (0);
+    }
+
+    return (1);
+}
+
+/*
+ * (Dump) Print out a printable entry in a human recognisable form
+ */
+dmp_ptpe(s, p, mod)
+char   *s;
+modtyp *mod;                   /* Module it is from */
+ptpe   *p;
+{
+    int     i, j;
+    ptpe  **par, **prev;
+    char   *name;
+
+    (void) fprintf(vfp, "%s:(%s)", s, mod->md_name);
+    /*
+     * Calculate what table it is in - we assume they are in order of
+     * increasing address
+     */
+
+    par = NULL;
+    if (mod->md_ptab != NULL && mod->md_ptab[0] < p) {
+       par = mod->md_ptab;
+       name = "Printing:";
+    }
+    if (par == NULL) {
+       (void) fprintf(vfp, "can't find entry 0x%x\n", p);
+       return;
+    }
+    prev = par;
+    for (i = mod->md_nentries; i > 0; i--) {
+       if (*par > p)
+           break;
+       par++;
+    }
+    if (par == prev) {
+       (void) ppepsylose (mod, p, NULLPE,
+           "dmp_ptpe:par == prev == 0x%x internal error\n", (int) par);
+       return;
+    }
+    par--;
+    j = p - *par;
+
+    (void) fprintf(vfp, "%s type %d + %d ", name, par - prev, j);
+    p_pr_entry(p);
+}
diff --git a/usr/src/contrib/isode/pepsy/ptabs.c b/usr/src/contrib/isode/pepsy/ptabs.c
new file mode 100644 (file)
index 0000000..2abe31f
--- /dev/null
@@ -0,0 +1,1127 @@
+/* ptabs.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/ptabs.c,v 7.8 91/02/22 09:49:58 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/ptabs.c,v 7.8 91/02/22 09:49:58 mrose Interim $
+ *
+ *
+ * $Log:       ptabs.c,v $
+ * Revision 7.8  91/02/22  09:49:58  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.7  91/01/08  12:50:56  mrose
+ * update
+ * 
+ * Revision 7.6  90/12/23  17:25:26  mrose
+ * patches
+ * 
+ * Revision 7.5  90/12/11  10:41:09  mrose
+ * sync
+ * 
+ * Revision 7.4  90/11/11  10:54:20  mrose
+ * update
+ * 
+ * Revision 7.3  90/11/04  19:21:09  mrose
+ * update
+ * 
+ * Revision 7.2  90/07/27  08:49:29  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:53:16  mrose
+ * sync
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <stdio.h>
+#include "pepsydefs.h"
+#include "pass2.h"
+#include "mine.h"
+
+extern FILE *fp;
+extern char *c_tag(), *c_class();
+extern char *ec_tag(), *ec_class(), *pec_class();
+extern char *strip_last();
+extern char *str_yp_code[];
+extern char *get_val(), *get_comp(), *strp2name();
+extern s_table *lookup_list(), *get_offset();
+extern YP tprnt_loop();
+extern int     gen_pentry();
+
+extern char *concat();
+extern char *my_strcat();
+extern char    *rm_indirect();
+extern char    *getfield();
+extern char    *setfield();
+
+/*
+extern int explicit;
+*/
+
+static int cons_type = 0;
+
+s_table *ptr;
+s_table *save_ptr;
+
+#define WORDSIZE       20
+
+/*
+ * Marshall's three extra conditions for changing the printing output
+ */
+static int     mrose1; /* if NamedType */
+static int     mrose2; /* !mrose1 && -h && DefinedType */
+static int     mrose3; /* (mrose1 || !mrose2) && TAG && (OPTIONAL|DEFAULT) */
+
+/*
+ * table printe a type. generate tables for the printing of a type
+ */
+tprnt_typ(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+    char   *t, *f;
+    char   *p1;
+    char   *s1, *s2, *s3;
+    char   *s;
+    s_table *ptr1, *ptr2;
+    YP      y;
+    int                flag;
+    int                ptr_tblidx = -1;
+
+    if (yp->yp_code < 0 || yp->yp_code > YP_REAL)
+       ferrd(1, "tdec_typ: unimplemented type %d\n", yp->yp_code);
+
+    if (yp == NULL) {
+       ferr(0, "tprnt_typ:NULL arguement\n");
+       return;
+    }
+
+    if (yp->yp_bef_alist && yp->yp_bef_alist->yal_prn)
+       gen_act(fp, yp->yp_bef_alist->yal_prn);
+
+    if (yp->yp_flags & YP_ID)
+       mrose1 = 1;
+    else
+       mrose1 = 0;
+
+    if (!mrose1 && hflag && yp->yp_code == YP_IDEFINED)
+       mrose2 = 1;
+    else
+       mrose2 = 0;
+
+    if ((mrose1 || !mrose2) && yp->yp_flags & YP_TAG
+       && yp->yp_flags & (YP_OPTIONAL|YP_DEFAULT))
+        mrose3 = 1;
+    else
+       mrose3 = 0;
+
+    if (type)
+       t = type;
+    else if (yp->yp_param_type) {
+       char *t1;
+       /* we have a [[ P type ]] specification */
+       if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+           fprintf(stderr,
+           "\ntenc_typ:SETLIST can't extract direct type from %s\n",
+               yp->yp_param_type);
+           exit(1);
+       }
+       t = strdup(t1);
+    } else
+       t = my_strcat("struct ", modsym(mymodule, id, "type"));
+
+    if ((yp->yp_flags & YP_PARMVAL) && yp->yp_parm) {
+       if ((f = getfield(yp->yp_parm)) == NULLCP) {
+           fprintf(stderr, "\ntprnt_typ:can't extract field from %s\n",
+               yp->yp_parm);
+           exit(1);
+       }
+       f = strdup(f);
+    } else
+       f = yp->yp_varexp;
+
+    if ((yp->yp_flags & (YP_OPTIONAL|YP_OPTCONTROL|YP_DEFAULT))
+       == (YP_OPTIONAL|YP_OPTCONTROL)) {
+       yp->yp_flags &= ~YP_OPTCONTROL;
+       flag = 1;
+    } else
+       flag = 0;
+
+    if (yp->yp_flags & YP_TAG && !(yp->yp_flags & YP_IMPLICIT)) {
+       prte_enoff(fp, "ETAG", yp, ptr_tblidx);
+    }
+
+    if (yp->yp_yfn && yp->yp_yfn->yfn_prt) {
+       gen_fn(fp, yp, yp->yp_yfn->yfn_prt);
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (yp->yp_aft_alist && yp->yp_aft_alist->yal_prn)
+           gen_act(fp, yp->yp_aft_alist->yal_prn);
+
+       return;
+    }
+
+    switch (yp->yp_code) {
+
+    case YP_UNDF:
+       ferr(1, "tprnt_typ:Undefined type\n");
+
+    case YP_BOOL:
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:BOOL: must specify a field [[ b .. ]]\n");
+       p1 = "BOOLEAN";
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f)))
+           break;
+       ferr(1, "tdec_typ:BOOL: can't find a type for boolean\n");
+
+       /* This needs to be fixed up in the action generating area */
+    case YP_INTLIST:
+
+    case YP_INT:
+
+    case YP_ENUMLIST:
+       if (yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:INT: must specify a field [[ i .. ]]\n");
+       p1 = "INTEGER";
+       if (yp->yp_varexp || (yp->yp_intexp && !noindirect(f)))
+           break;
+       ferr(1, "tdec_typ:INT: couldn't determine type\n");
+
+    case YP_REAL:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (noindirect(f))
+           ferr(1, "tdec_typ:REAL: must specify a field [[ r .. ]]\n");
+       p1 = "REALTYPE";
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f)))
+           break;
+       ferr(1, "tdec_typ:INT: couldn't determine type\n");
+
+
+    case YP_BITLIST:
+       ptr_tblidx = addptr (modsym(mymodule,
+                                   yp->yp_varexp ? yp -> yp_varexp : id,
+                                   "bits"));
+       /* fall */
+    case YP_BIT:
+       if (yp->yp_strexp && yp->yp_intexp) {
+           if (yp->yp_strexp)
+               f = setfield(yp->yp_strexp);
+           if (noindirect(f))
+               ferr(1, "tdec_typ:BIT: must specify a field [[ x .. ]]\n");
+           p1 = "BITSTR_PTR";
+           prte_off(fp, p1, yp, t, f, ptr_tblidx);
+           if (yp->yp_intexp)
+               f = setfield(yp->yp_intexp);
+           if (noindirect(f))
+               ferr(1, "tdec_typ:BIT: must specify a field [[ x .. ]]\n");
+           p1 = "BITSTR_LEN";
+           break;
+       }
+       if (yp->yp_strexp == NULLCP && yp->yp_intexp)
+           f = setfield(yp->yp_intexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "BITSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       (void) fprintf(fp, "\t{ SBITSTRING, %d, %s, %s, NULL },\n",
+                      ptr_tblidx, c_tag(yp), c_class(yp));
+       break;
+
+    case YP_OCT:
+       if (yp->yp_strexp) {
+           switch (yp->yp_prfexp) {
+           case 'q': /* [[ q parm->qbufptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   p1 = "SOCTETSTRING";
+               else
+                   p1 = "OCTETSTRING";
+               break;
+
+           case 's': /* [[ s ptr ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCT: must specify a field [[ s .. ]]\n");
+               p1 = "T_STRING";
+               break;
+               
+           case 'o': /* [[ o ptr $ length ]] */
+               if (yp->yp_strexp)
+                   f = setfield(yp->yp_strexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCT: must specify a field [[ o .. ]]\n");
+               p1 = "OCTET_PTR";
+               prte_off(fp, p1, yp, t, f, ptr_tblidx);
+               if (yp->yp_intexp)
+                   f = setfield(yp->yp_intexp);
+               if (noindirect(f))
+                   ferr(1, "tdec_typ:OCT: must specify a field [[ o .. ]]\n");
+               p1 = "OCTET_LEN";
+               break;
+
+           default:
+              fprintf(stderr,"\ntprnt_typ:Unknown Octet string specifier %c\n",
+                  yp->yp_prfexp);
+               exit(1);
+           }
+           break;
+       }
+
+       if (f && !noindirect(f)) {
+           p1 = "OCTETSTRING";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       prte_noff(fp, "SOCTETSTRING", yp, ptr_tblidx);
+       break;
+
+    case YP_OID:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "OBJID";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       prte_noff(fp, "SOBJID", yp, ptr_tblidx);
+       break;
+
+    case YP_SEQ:
+    case YP_SET:
+    case YP_ANY:
+       if (yp->yp_strexp)
+           f = setfield(yp->yp_strexp);
+       if (yp->yp_varexp || (yp->yp_strexp && !noindirect(f))) {
+           p1 = "ANY";
+           break;
+       }
+       t = NULL;
+       p1 = NULL;
+       prte_noff(fp, "SANY", yp, ptr_tblidx);
+       break;
+
+    case YP_NULL:
+       p1 = "T_NULL";
+       t = NULL;
+       break;
+
+    case YP_IDEFINED:
+       p1 = NULL;
+
+       if ((yp->yp_flags & YP_PARMVAL) && yp->yp_prfexp)
+               ferr(1,
+    "\n[[ ? reference ]] [[ p reference ]] is illegal\n\t only one allowed\n");
+
+       if (yp->yp_prfexp) { /* [[ ? parm->field ]] - complex to process */
+           gen_identry(fp, t, f, yp, gen_pentry);
+
+           if (yp->yp_flags & YP_DEFAULT)
+               gdflt(fp, yp, G_DEC);
+
+           break;
+       }
+
+       pr_deftyp(fp, yp, t, f);
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       break;
+
+    case YP_SEQLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       cons_type++;
+       save_ptr = ptr;
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tprnt_typ:YP_SEQLIST:NULL varexp pointer\n");
+       if (type == NULL)
+           prte_noff(fp, "SSEQ_START", yp, ptr_tblidx);
+       else if (noindirect(f))
+           prte_noff(fp, "SSEQ_START", yp, ptr_tblidx);
+       else
+           prte_off(fp, "SEQ_START", yp, t, f, ptr_tblidx);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntprnt_typ:SEQLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tprnt_typ:YP_SEQLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+#ifdef DO_OFFSETS
+           if (optfield(y)) {
+               (void) fprintf(fp,
+               "\t{ OPTL, OFFSET(%s, optionals), 0, 0, NULL },\n",
+                                   yp->yp_structname);
+           }
+#endif
+           tprnt_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL },\n");
+       ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SETLIST:
+       p1 = NULL;
+       /* support for -h flag */
+       cons_type++;
+       if (yp->yp_varexp == NULL && type != NULL)
+           ferr(1, "tprnt_typ:YP_SETLIST:NULL varexp pointer\n");
+       if (type == NULL)
+           prte_noff(fp, "SSET_START", yp, ptr_tblidx);
+       else if (noindirect(f))
+           prte_noff(fp, "SSET_START", yp, ptr_tblidx);
+       else
+           prte_off(fp, "SET_START", yp, t, f, ptr_tblidx);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           ddflt(fp, yp);
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntprnt_typ:SETLIST can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tprnt_typ:YP_SETLIST:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+#ifdef DO_OFFSETS
+           if (optfield(y)) {
+               (void) fprintf(fp,
+                   "\t{ OPTL, OFFSET(%s, optionals), 0, 0, NULL },\n",
+                                       yp->yp_structname);
+           }
+#endif
+           tprnt_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL },\n");
+       ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SEQTYPE:           /* What is the difference ?? */
+       p1 = NULL;
+       cons_type++;
+       save_ptr = ptr;
+       if (type == NULL)
+           prte_noff(fp, "SSEQOF_START", yp, ptr_tblidx);
+       else if (noindirect(f))
+           prte_noff(fp, "SSEQOF_START", yp, ptr_tblidx);
+       else
+           prte_off(fp, "SEQOF_START", yp, t, f, ptr_tblidx);
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntprnt_typ:SEQTYPE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tprnt_typ:YP_SEQTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tprnt_loop(fp, y, id, yp->yp_structname);
+       }
+#ifdef DO_OFFSETS
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntprnt_typ:SEQ OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp,
+               "\t{ PE_END, OFFSET(%s, next), 0, 0, NULL },\n",
+                   yp->yp_structname);
+       else
+#endif
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL },\n");
+       ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_SETTYPE:
+       p1 = NULL;
+       cons_type++;
+       save_ptr = ptr;
+       if (type == NULL)
+           prte_noff(fp, "SSETOF_START", yp, ptr_tblidx);
+       else if (noindirect(f))
+           prte_noff(fp, "SSETOF_START", yp, ptr_tblidx);
+       else
+           prte_off(fp, "SETOF_START", yp, t, f, ptr_tblidx);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+
+       if (y = yp->yp_type) {
+           char *t1;
+
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                   "\ntprnt_typ:SETTYPE can't extract direct type from %s\n",
+                       yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tprnt_typ:YP_SETTYPE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tprnt_loop(fp, y, id, yp->yp_structname);
+       }
+       if (yp->yp_flags & YP_CONTROLLED) {
+           char *f1;
+
+           if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+               fprintf(stderr, "\ntprnt_typ:SET OF: can't extract field from %s\n",
+                   yp->yp_control);
+               exit(1);
+           }
+           (void) fprintf(fp, "\t{ PE_END, OFFSET(%s, %s), 0, 0 },\n",
+                   yp->yp_structname, f1);
+       } else if (yp->yp_structname != NULL)
+           (void) fprintf(fp,
+               "\t{ PE_END, OFFSET(%s, next), 0, 0, NULL },\n",
+                   yp->yp_structname);
+       else
+           (void) fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL },\n");
+       ptr = save_ptr;
+       cons_type--;
+       break;
+
+    case YP_CHOICE:
+       p1 = NULL;
+       /* support for -h flag */
+       if (hflag && (y = yp->yp_type) && !y->yp_next) {
+           tprnt_typ(fp, y, id, yp->yp_structname);
+           break;
+       }
+       cons_type++;
+       save_ptr = ptr;
+       /* Generates an unused tags field - so beware */
+       if (type == NULL)
+           prte_noff(fp, "SCHOICE_START", yp, ptr_tblidx);
+       else if (noindirect(f))
+           prte_noff(fp, "SCHOICE_START", yp, ptr_tblidx);
+       else
+           prte_off(fp, "CHOICE_START", yp, t, f, ptr_tblidx);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+       if (y = yp->yp_type) {
+           char *t1;
+           char *f1;
+
+#ifdef DO_OFFSETS
+           if (yp->yp_flags & YP_CONTROLLED) {
+
+               if ((f1 = getfield(yp->yp_control)) == NULLCP) {
+                   fprintf(stderr,
+                           "\ntprnt_typ:CHOICE: can't extract field from %s\n",
+                           yp->yp_control);
+                   exit(1);
+               }
+
+           } else
+               f1 = "offset";
+
+           if ((yp->yp_flags & YP_ID) && yp->yp_id)
+               (void) fprintf(fp,
+                              "\t{ SCTRL, OFFSET(%s, %s), 0, 0, \"%s\" },\n",
+                              yp->yp_structname, f1, yp->yp_id);
+           else
+               (void) fprintf(fp,
+                              "\t{ SCTRL, OFFSET(%s, %s), 0, 0, NULL },\n",
+                              yp->yp_structname, f1);
+#else
+           if ((yp->yp_flags & YP_ID) && yp->yp_id)
+               (void) fprintf(fp,"\t{ SCTRL, 0, 0, 0, \"%s\" },\n",
+                              yp->yp_id);
+           else
+               (void) fprintf(fp, "\t{ SCTRL, 0, 0, 0, NULL },\n");
+
+#endif
+           if (yp->yp_param_type) {
+               /* we have a [[ P type ]] specification */
+               if ((t1 = rm_indirect(yp->yp_param_type)) == NULLCP) {
+                   fprintf(stderr,
+                           "\ntprnt_typ:CHOICE can't extract direct type from %s\n",
+                           yp->yp_param_type);
+                   exit(1);
+               }
+               yp->yp_structname = strdup(t1);
+           } else if (type) {
+               if (yp->yp_declexp == NULL)
+                   ferr(1, "tprnt_typ:YP_CHOICE:no declexp\n");
+               yp->yp_structname = my_strcat("struct ", yp->yp_declexp);
+           } else
+               yp->yp_structname = t;
+           tprnt_loop(fp, y, id, yp->yp_structname);
+       }
+       (void) fprintf(fp, "\t{ PE_END, 0, 0, 0, NULL },\n");
+       ptr = save_ptr;
+       cons_type--;
+       break;
+
+    default:
+       ferrd(1, "tprnt_typ: yp_code = %d  not implemented\n", yp->yp_code);
+    }
+
+    if (p1 != NULL) {
+       if (t != NULL)
+           prte_off(fp, p1, yp, t, f, ptr_tblidx);
+       else
+           prte_noff(fp, p1, yp, ptr_tblidx);
+
+       if (yp->yp_flags & YP_DEFAULT)
+           gdflt(fp, yp, G_DEC);
+    }
+
+    if (flag)
+       yp->yp_flags |= YP_OPTCONTROL;
+
+    if (yp->yp_aft_alist && yp->yp_aft_alist->yal_prn)
+       gen_act(fp, yp->yp_aft_alist->yal_prn);
+
+}
+
+static int fflags[] = {
+    0, 1, 2, 2, 3, 3, 4, 5, 16, 16, 16, 17, 17, 17,
+0, -1, 7,};
+
+/*
+ * generate tables for printing a contructed type
+ */
+YP 
+tprnt_loop(fp, yp, id, type)
+FILE   *fp;
+YP      yp;
+char   *id;
+char   *type;
+{
+    for (; yp != NULL; yp = yp->yp_next) {
+       tprnt_typ(fp, yp, id, type);
+    }
+}
+
+
+ddflt(fp, yp)
+FILE   *fp;
+YP      yp;
+{
+    switch (yp->yp_code) {
+    case YP_BOOL:
+    case YP_INT:
+    case YP_INTLIST:
+       (void) fprintf(fp, "\t{DFLT_B,      %d,     0,      0 },\n",
+               yp->yp_default->yv_number);
+       break;
+    case YP_BIT:
+    case YP_BITLIST:
+    case YP_OCT:
+    case YP_NULL:
+    case YP_SEQ:
+    case YP_SEQTYPE:
+    case YP_SEQLIST:
+    case YP_SET:
+    case YP_SETTYPE:
+    case YP_SETLIST:
+    case YP_CHOICE:
+    case YP_ANY:
+    case YP_OID:
+    case YP_IDEFINED:
+    case YP_ENUMLIST:
+    case YP_REAL:
+       (void) fprintf(fp, "\t{DFLT_B,      0,      0,      0 },\n");
+       break;
+
+    default:
+       ferr(1, "ddflt:unknown type %d\n", yp->yp_code);
+    }
+
+}
+
+/*
+ * print a Non offset table entry
+ */
+prte_noff(fp, type, yp, idx)
+FILE   *fp;
+char   *type;
+YP     yp;
+int    idx;
+{
+    char       *tag;
+    char       *flags;
+    char       *typename;
+    char       buf1[BUFSIZ];
+
+    tag = c_tag(yp);
+    flags = c_class(yp);
+    if (mrose3) {              /* need to append FL_PRTAG flag */
+       strncpy(buf1, flags, BUFSIZ);
+       strncat(buf1, "|FL_PRTAG", BUFSIZ);
+       flags = buf1;
+    }
+    if (mrose1)
+       typename = yp->yp_id;
+    else if (mrose2)
+       typename = yp->yp_identifier;
+    else
+       typename = (char *)0;
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, \"%s\" },\n",
+                      type, idx, tag, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, NULL},\n",
+                      type,idx, tag, flags);
+}
+
+/*
+ * print a Non offset table entry for an ETAG - special case
+ */
+prte_enoff(fp, type, yp, idx)
+FILE   *fp;
+char   *type;
+YP     yp;
+int    idx;
+{
+    char       *tag;
+    char       *flags;
+    char       *typename;
+    char       buf1[BUFSIZ];
+
+    tag = ec_tag(yp);
+    flags = ec_class(yp);
+    if (mrose3) {              /* need to append FL_PRTAG flag */
+       strncpy(buf1, flags, BUFSIZ);
+       strncat(buf1, "|FL_PRTAG", BUFSIZ);
+       flags = buf1;
+       mrose3 = 0;     /* don't want the next tag */
+    }
+    if (mrose1) {
+       typename = yp->yp_id;
+       mrose1 = 0;
+    } else if (mrose2) {
+       typename = yp->yp_identifier;
+       mrose2 = 0;
+    } else
+       typename = NULL;
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, \"%s\" },\n",
+                                   type, idx, tag, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, NULL },\n",
+                                   type, idx, tag, flags);
+}
+
+/*
+ * print an offset table entry
+ */
+prte_off(fp, type, yp, t, f, idx)
+FILE   *fp;
+char   *type;
+YP     yp;
+char   *t, *f;
+int    idx;
+{
+    char       *tag;
+    char       *flags;
+    char       *typename;
+    char       buf1[BUFSIZ];
+
+    tag = c_tag(yp);
+    flags = c_class(yp);
+    if (mrose3) {              /* need to append FL_PRTAG flag */
+       strncpy(buf1, flags, BUFSIZ);
+       strncat(buf1, "|FL_PRTAG", BUFSIZ);
+       flags = buf1;
+    }
+    if (mrose1)
+       typename = yp->yp_id;
+    else if (mrose2)
+       typename = yp->yp_identifier;
+    else
+       typename = (char *)0;
+#ifdef DO_OFFSETS
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, OFFSET(%s, %s), %s, %s, \"%s\" },\n",
+                                   type,       t, f,   tag, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, OFFSET(%s, %s), %s, %s, NULL},\n",
+                                   type,       t, f,    tag, flags);
+#else
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, \"%s\" },\n",
+                      type, idx, tag, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, %d, %s, %s, NULL},\n",
+                      type, idx, tag, flags);
+#endif
+}
+
+/*
+ * handle the very complex task of defined types.
+ * Basically generating object calls
+ */
+pr_deftyp(fp, yp, t, f)
+FILE   *fp;
+YP     yp;
+char   *t;
+char   *f;
+{
+    /* Predefined Universal Type */
+    struct univ_typ *p, *univtyp();
+
+    if ((p = univtyp(yp->yp_identifier))) {
+       if (p->univ_flags & UNF_EXTMOD) {
+           yp->yp_module = p->univ_mod;
+           goto do_obj;
+       }
+       prte_univt(fp, p, yp, t, f);
+       return;
+    }
+
+do_obj:
+    if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT)
+       prte_noff(fp, "IMP_OBJ", yp, -1);
+       prte_obj(fp, yp, t, f);
+}
+
+/*
+ * print an offset table entry for an OBJECT type entry
+ */
+prte_obj(fp, yp, t, f)
+FILE   *fp;
+YP     yp;
+char   *t, *f;
+{
+    char       *type;
+    char       *obj;
+    char       *flags;
+    char       *typename;
+    char       *off;
+    char       buf1[BUFSIZ];
+    char       buf2[BUFSIZ];
+    int                extflag;
+
+    if (yp->yp_module == NULL || strcmp(yp->yp_module, mymodule) == 0) {
+       if (f && !noindirect(f))
+           type = "OBJECT";
+       else
+           type = "SOBJECT";
+       obj = proc_name(yp->yp_identifier, 0);
+       extflag = 0;
+    } else {
+       if (f && !noindirect(f))
+           type = "EXTOBJ";
+       else
+           type = "SEXTOBJ";
+       obj = strp2name(yp->yp_identifier, yp->yp_module);
+       extflag = 1;
+    }
+    flags = c_class(yp);
+    if (mrose3) {              /* need to append FL_PRTAG flag */
+       strncpy(buf1, flags, BUFSIZ);
+       strncat(buf1, "|FL_PRTAG", BUFSIZ);
+       flags = buf1;
+    }
+    if (mrose1)
+       typename = yp->yp_id;
+    else if (mrose2)
+       typename = yp->yp_identifier;
+    else
+       typename = (char *)0;
+#ifdef DO_OFFSETS
+    if (f && !noindirect(f)) {
+       sprintf(buf2, "OFFSET(%s, %s)", t, f);
+       off = buf2;
+    } else if (f && *f == '&') {
+       sprintf(buf2, "OFFSET(%s, %s)", t, f + 1);
+       off = buf2;
+    } else
+#endif
+        off = "0";
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, %s, _Z%s, %s, \"%s\" },\n",
+                                   type, off, obj, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, %s, _Z%s, %s, NULL},\n",
+                                   type, off, obj, flags);
+    if (extflag)
+       (void) fprintf(fp, "\t{ EXTMOD, %d, 0, 0, NULL },\n",
+               gen_modref(yp->yp_module));
+}
+
+/*
+ * print an table entry for Universal type with the given entry
+ */
+prte_univt(fp, p, yp, t, f)
+FILE   *fp;
+struct univ_typ *p;
+YP     yp;
+char   *t, *f;
+{
+    char       *type;
+    int                tag;
+    int                class;
+    char       *flags;
+    char       *typename;
+    char       *off;
+    char       buf1[BUFSIZ];
+    char       buf2[BUFSIZ];
+    char       buf3[BUFSIZ];
+
+    if (f == NULL || noindirect(f))  {
+       sprintf(buf3, "S%s", p->univ_tab);
+       type = buf3;
+    } else
+       type = p->univ_tab;
+
+    if (yp->yp_flags & YP_TAG && yp->yp_flags & YP_IMPLICIT) {
+       tag = yp->yp_tag->yt_value->yv_number;
+       class = yp->yp_tag->yt_class;
+    } else {
+       tag = p->univ_id;
+       class = p->univ_class;
+    }
+    
+    strncpy(buf1, c_flags(yp, class), BUFSIZ);
+    flags = buf1;
+    if (mrose3) {              /* need to append FL_PRTAG flag */
+       strncat(buf1, "|FL_PRTAG", BUFSIZ);
+    }
+    if (mrose1)
+       typename = yp->yp_id;
+    else if (mrose2)
+       typename = yp->yp_identifier;
+    else
+       typename = (char *)0;
+#ifdef DO_OFFSETS
+    if (f && !noindirect(f)) {
+       sprintf(buf2, "OFFSET(%s, %s)", t, f);
+       off = buf2;
+    } else if (f && *f == '&') {
+       sprintf(buf2, "OFFSET(%s, %s)", t, f + 1);
+       off = buf2;
+    } else
+#endif
+        off = "0";
+    if (typename)
+       (void) fprintf(fp, "\t{ %s, %s, %d, %s, \"%s\" },\n",
+                                   type, off, tag, flags, typename);
+    else
+       (void) fprintf(fp, "\t{ %s, %s, %d, %s, NULL},\n",
+                                   type, off, tag, flags);
+}
+
+/*
+ * generate the table entry for a value passing defined type which
+ * is equivalent to the given primative type
+ */
+gen_pentry(fp, oyp, yp, t, f)
+FILE   *fp;
+YP     oyp, yp;
+char   *t, *f;
+{
+    char       *p1;
+    register char      s = oyp->yp_prfexp;     /* type of value passing */
+    int                idx;
+
+
+    if (noindirect(f) && s != 'q' && s != 'a')
+       ferrs(1,
+        "gen_ventry: must specify a field for primative value- not %s\n", f);
+
+#if 0
+/* can't get id from in here - yet */
+    if (yp->yp_code == YP_BITLIST) {
+       idx = addptr (modsym(mymodule, yp->yp_varexp ? yp -> yp_varexp : id,
+                                    "bits"));
+    } else
+#endif
+        idx = -1;
+
+    switch (s) {
+    case 'q': /* [[ q parm->qbufptr ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("qbuf pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+                
+       f = setfield(oyp->yp_strexp);
+       if (noindirect(f))
+           p1 = "SOCTETSTRING";
+       else
+           p1 = "OCTETSTRING";
+       break;
+
+    case 's': /* [[ s ptr ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("string pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "T_STRING";
+       break;
+
+    case 'o': /* [[ o ptr $ length ]] */
+       if (yp->yp_code != YP_OCT)
+           warning("octet/length pair passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       p1 = "OCTET_PTR";
+       prte_off(fp, p1, yp, t, f, idx);
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "gen_ventry:OCT: must specify a field [[ s .. ]]\n");
+       p1 = "OCTET_LEN";
+       break;
+
+    case 'x': /* [[ x ptr $ length ]] */
+       if (yp->yp_code != YP_BIT && yp->yp_code != YP_BITLIST)
+           warning("bit string/length pair passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "BITSTR_PTR";
+       prte_off(fp, p1, yp, t, f, idx);
+       f = setfield(oyp->yp_intexp);
+       if (noindirect(f))
+           ferr(1, "tenc_typ:BIT: must specify a field [[ x .. ]]\n");
+       p1 = "BITSTR_LEN";
+       break;
+
+    case 'r': /* [[ r REAL ]] */
+       if (yp->yp_code != YP_REAL)
+           warning("Real passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_strexp);
+       p1 = "REALTYPE";
+       break;
+
+    case 'i': /* [[ i INTEGER ]] */
+       if (yp->yp_code != YP_INT && yp->yp_code != YP_INTLIST
+        && yp->yp_code != YP_ENUMLIST)
+           warning("integer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       p1 = "INTEGER";
+       break;
+
+    case 't': /* [[ t Bitvector ]] */
+       if (yp->yp_code != YP_BIT && yp->yp_code != YP_BITLIST)
+           warning("Bitvector (PE) passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       f = setfield(oyp->yp_intexp);
+       if (oyp->yp_varexp && !noindirect(f))
+           p1 = "BITSTRING";
+       else
+           p1 = "SBITSTRING";
+       break;
+
+    case 'b': /* [[ b BOOLEAN ]] */
+       if (yp->yp_code != YP_BOOL)
+           warning("Boolean passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+
+       if (oyp->yp_intexp)
+           f = setfield(oyp->yp_intexp);
+       p1 = "BOOLEAN";
+       break;
+
+    case 'O': /* [[ O Object Identifier ]] */
+       if (yp->yp_code != YP_OID)
+           warning("Object Identifier pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       p1 = "OBJID";
+       break;
+
+    case 'a': /* [[ a ANY ]] */
+       if (yp->yp_code != YP_ANY)
+           warning("PE pointer passed for a %s by type %s",
+           code2name(yp->yp_code), yp2name(oyp));
+       f = setfield(oyp->yp_strexp);
+       if (noindirect(f))
+           p1 = "SANY";
+       else
+           p1 = "ANY";
+       break;
+     default:
+       ferrd("gen_vident:unknown Value passed %d\n", (int )s);
+   }
+
+    prte_off(fp, p1, yp, t, f, idx);
+}
diff --git a/usr/src/contrib/isode/pepsy/t1.py b/usr/src/contrib/isode/pepsy/t1.py
new file mode 100644 (file)
index 0000000..d9d76d1
--- /dev/null
@@ -0,0 +1,365 @@
+T1 { joint-iso-ccitt rubbish(999) modid(1) } DEFINITIONS ::=
+
+
+BEGIN
+
+IMPORTS
+       + Info,
+       + Sset,
+       + Sseq,
+       - Sany,
+       + Soid
+               FROM T2
+       Pepy-refs,
+       Single-type,
+       Repeated,
+       Defined,
+       CodeTest,
+       AllSimples,
+       UAction
+               FROM T3;
+
+-- Embedded Sequences test
+
+
+    -- Test of Embedded Strings
+Emb-Strings ::= SEQUENCE {
+       atest INTEGER,
+       btest OCTET STRING,
+       ctest BIT STRING,
+       big-test Strings,
+       emb-test SEQUENCE {
+           em-int INTEGER,
+           em-oct OCTET STRING,
+           em-bit BIT STRING
+       }
+    }
+
+
+Strings ::= SEQUENCE { -- Test Octet strings, bit strings and character
+                      -- Strings in general
+       ostring OCTET STRING,
+       bstring BIT STRING,
+       nstring NumericString,
+       pstring PrintableString,
+       tstring TeletexString,
+       t61string T61String,
+       vstring VideotexString,
+       vis-string VisibleString,
+       i646string ISO646String,
+       ia5string IA5String,
+       graphstring GraphicString,
+       genstring GeneralString
+       }
+
+Embedded ::= SEQUENCE {
+       anMPDU MPDU,
+       ei INTEGER
+       }
+
+MPDU ::=
+       SEQUENCE {
+           a-seq SEQUENCE {
+               fred [0] IMPLICIT INTEGER,
+
+                   george BOOLEAN
+           }
+       }
+
+ServiceMPDU ::=
+       SET {
+           a-set SET {
+                   a-data [1] IMPLICIT BIT STRING,
+
+               a-more-data [2] IMPLICIT INTEGER
+           },
+           b-set SET {
+                   b-data [1] IMPLICIT BIT STRING,
+
+               b-more-data [2] IMPLICIT INTEGER
+           }
+       }
+-- Implicit tags
+
+Impl-Tags ::= SEQUENCE {
+       i-impl [1] IMPLICIT INTEGER,
+       o-impl [2] IMPLICIT OCTET STRING,
+       b-impl [3] IMPLICIT BIT STRING,
+       f-impl [4] IMPLICIT BOOLEAN,
+       obj-impl [5] IMPLICIT Emb-Strings,
+
+    -- Test of Embedded Strings
+       i-emb-test [APPLICATION 88] IMPLICIT SEQUENCE {
+           i-em-int INTEGER,
+           i-em-oct OCTET STRING,
+           i-em-bit BIT STRING
+       }
+    }
+
+-- Explicit tags
+
+Expl-Tags ::= SEQUENCE {
+       i-expl [1] INTEGER,
+       o-expl [2] OCTET STRING,
+       b-expl [3] BIT STRING,
+       f-expl [4] BOOLEAN,
+       obj-expl [5] Emb-Strings,
+
+    -- Test of Embedded Strings
+       i-exp-test [APPLICATION 88] SEQUENCE {
+           i-ex-int INTEGER,
+           i-ex-oct OCTET STRING,
+           i-ex-bit BIT STRING
+       }
+    }
+
+  -- Test of Sequence of
+Seqof-Test ::= SEQUENCE {
+       sqof-test1 SEQUENCE OF Expl-Tags,
+       stof-test1 SET OF Expl-Tags,
+       i-test1 INTEGER,
+       sqof-test2 SEQUENCE OF SEQUENCE {
+           sqof-in Expl-Tags,
+           sqof-i INTEGER,
+           sqof-o OCTET STRING
+       },
+       stof-test2 SET OF SEQUENCE {
+           stof-in Expl-Tags,
+           stof-i INTEGER,
+           stof-o OCTET STRING
+       },
+       i-test2 INTEGER
+    }
+
+
+   -- Test data for the Choice type
+Choice-Test ::= SET {
+       c1 CHOICE {
+       i-c1 [1] IMPLICIT INTEGER,
+       o-c1 [2] IMPLICIT OCTET STRING,
+       b-c1 [3] IMPLICIT BIT STRING,
+       f-c1 [4] IMPLICIT BOOLEAN,
+       obj-c1 [5] IMPLICIT Emb-Strings
+       },
+       c2 CHOICE {
+       i-c2 [6] INTEGER,
+       o-c2 [7] OCTET STRING,
+       b-c2 [8] BIT STRING,
+       f-c2 [9] BOOLEAN,
+       obj-c2 [10] Emb-Strings
+       },
+       c3 CHOICE {
+           seq-c3 SEQUENCE {
+               seq-c3-in Expl-Tags,
+               seq-c3-i INTEGER,
+               seq-c3-o OCTET STRING
+           },
+           set-c3 SET {
+               set-c3-in Expl-Tags,
+               set-c3-i INTEGER,
+               set-c3-o OCTET STRING
+           },
+           i-c3 INTEGER
+       },
+       c4 [12] IMPLICIT SEQUENCE {
+           c4-choice CHOICE {
+               c4-i INTEGER,
+               c4-obj [2] IMPLICIT Expl-Tags,
+               c4-subch CHOICE {
+                   sc-a-i [0] IMPLICIT INTEGER,
+                   sc-b-i [1] IMPLICIT INTEGER
+               }
+           }
+       }
+
+
+    }
+
+  -- Test of Optional fields
+
+Opt-Strings ::= SEQUENCE {
+       a-opt INTEGER OPTIONAL,
+       b-opt OCTET STRING,
+       c-opt BIT STRING OPTIONAL,
+       d-opt BOOLEAN OPTIONAL,
+       e-opt NULL OPTIONAL,
+       big-opt Strings OPTIONAL,
+       emb-opt SEQUENCE {
+           oem-int INTEGER OPTIONAL,
+           oem-oct OCTET STRING OPTIONAL,
+           oem-bit BIT STRING OPTIONAL
+       }       OPTIONAL,
+       st-opt SET {
+           st-int0 [0] IMPLICIT INTEGER OPTIONAL,
+           st-int1 [1] IMPLICIT INTEGER OPTIONAL,
+           st-int2 [2] IMPLICIT INTEGER OPTIONAL
+       }       OPTIONAL,
+       obj-opt [APPLICATION 1] IMPLICIT  MPDU OPTIONAL,
+       etag-opt [APPLICATION 2] INTEGER OPTIONAL,
+       ch-opt CHOICE {
+           ch-1 [10] IMPLICIT INTEGER,
+           ch-2 [20] IMPLICIT INTEGER
+       } OPTIONAL
+    }
+
+  -- Test of Default fields
+
+Def-Strings ::= SEQUENCE {
+       a-def INTEGER  { a-def-0 (0), a-def-1(1) } DEFAULT a-def-0,
+       -- posy bug does not allow handling of 'xxx'b or 'xx'h notation
+       -- so we don't use proper posy notation
+       -- b-def OCTET STRING DEFAULT 'ff01ab20'h,
+       b-def PrintableString   DEFAULT "hello, world",
+       c-def BIT STRING  { c-def-one(3), c-def-two (1)}
+               DEFAULT { c-def-one },
+       okay BOOLEAN DEFAULT TRUE,
+       e-def NULL DEFAULT NULL,
+       big-def Strings,
+       emb-def SEQUENCE {
+           colour INTEGER { red(1), green(2), yellow(3) } DEFAULT green,
+           oem-oct OCTET STRING OPTIONAL,
+           version BIT STRING { basic(0), patch1(1), patch2(2) }
+               DEFAULT { basic }
+       }    DEFAULT { red, { basic } },
+       st-def SET {
+           wine [0] IMPLICIT INTEGER { claret(1), burgundy(2), moselle(3) }
+               DEFAULT claret,
+           beer [1] IMPLICIT INTEGER { vb(0), fosters(1), hieneken(2) }
+               DEFAULT vb,
+           spirit [2] IMPLICIT INTEGER { brandy(0), vodka(1), wisky(2) }
+               DEFAULT vodka
+       }       DEFAULT { vb, vodka }
+    }
+
+-- External References
+--
+E-ref  ::= SEQUENCE {
+    a-ref T2.Info,
+    b-ref [APPLICATION 33] IMPLICIT T2.Info,
+    c-ref [1] T1.Choice-Test,
+    d-ref [2] T2.Info OPTIONAL,
+    e-ref [APPLICATION 33] IMPLICIT T2.Info OPTIONAL
+    }
+
+
+-- Simple type optimisations of POSY/PEPY
+
+ Bstring ::= [APPLICATION 8] BIT STRING
+
+ Ostring ::= [31] IMPLICIT OCTET STRING
+
+ Obj ::= [101] IMPLICIT MPDU
+
+ Sset ::= SET
+
+ Sseq ::= SEQUENCE
+
+ Sany ::= ANY
+
+ Soid ::= OBJECT IDENTIFIER
+
+
+Optimised ::= SEQUENCE {
+    o1 Bstring,
+    o2 Ostring,
+    o3 Obj,
+    o4 [APPLICATION 3] IMPLICIT Sset OPTIONAL,
+    [APPLICATION 21] SET {
+       o5 [PRIVATE 9] IMPLICIT Sseq,
+       o6 [PRIVATE 33] IMPLICIT Sany,
+       o7 [PRIVATE 8] IMPLICIT Soid
+    }
+}
+
+-- Use of External Simple types
+Ext-Opt ::= SEQUENCE {
+    o1 T2.Bstring,
+    o2 T2.Ostring,
+    o3 T2.Obj,
+    o4 [PRIVATE 38] IMPLICIT T2.Sset OPTIONAL,
+    [APPLICATION 21] SET {
+       o5 [PRIVATE 1] IMPLICIT T2.Sseq,
+       o6 [PRIVATE 2] IMPLICIT T2.Sany,
+       o7 [PRIVATE 3] IMPLICIT T2.Soid
+    }
+}
+
+-- External type and ANY usage
+
+Ext-typ ::= SEQUENCE {
+     ext EXTERNAL,
+     a-ny      [APPLICATION 32] ANY,
+     ext-impl  [PRIVATE 6] IMPLICIT EXTERNAL,
+     any-impl  [APPLICATION 7] ANY,
+     ext-expl  [PRIVATE 9] EXTERNAL,
+     any-expl  [APPLICATION 10] ANY
+   }
+
+SExt ::= [PRIVATE 99] IMPLICIT EXTERNAL
+
+-- check of posy's %[ name $ head %] stuff
+Names ::=
+       SEQUENCE {
+           SEQUENCE %[ seq_str $ ptr %] {
+               fred [0] IMPLICIT INTEGER
+           }
+       }
+
+-- Test explicit tags as the first field of an object
+Etags ::=
+       [APPLICATION 3]
+          CHOICE {
+               aE [0] IMPLICIT INTEGER,
+               bE [1] IMPLICIT INTEGER
+           }
+
+Stest ::=
+    [APPLICATION 4] SET {
+           st1 Sint DEFAULT 33,
+           st2 Soctet DEFAULT "goodbye, world"
+       }
+
+Sint ::= INTEGER
+
+Soctet ::= OCTET STRING
+
+Simpl-test ::= SEQUENCE { si-t [23] IMPLICIT Sbstring }
+
+Sbstring ::= BIT STRING { bit0(0), bit1(1), bit2(2) }
+
+SStest ::= [101] IMPLICIT Simpl-test
+
+Enum-type ::= ENUMERATED { pork(0), beef(1), chicken(3), lamb(-1) }
+
+T-enum ::= SEQUENCE {
+               ae1 Enum-type,
+               ae2 [12] Enum-type,
+               ae3 [13] IMPLICIT Enum-type,
+               ae4 [15] IMPLICIT Enum-type DEFAULT chicken,
+               ae5 Enum-type OPTIONAL
+           }
+Real ::= REAL
+
+T-real ::= SEQUENCE {
+               r1 Real,
+               r2 [99] Real,
+               r3 [101] IMPLICIT Real,
+               r4 [501] IMPLICIT Real DEFAULT { 31415962, 10, -7 },
+               r5 Real OPTIONAL
+           }
+
+T-pepy ::= T3.Pepy-refs
+
+T3-Single ::= T3.Single-type
+
+T3-Repeat ::= T3.Repeated
+
+T3-Defined ::= T3.Defined
+
+T3-CodeTest ::= T3.CodeTest
+
+T3-AllSimples ::= T3.AllSimples
+
+T3-UAction ::= T3.UAction
+
+END
diff --git a/usr/src/contrib/isode/pepsy/t3.py b/usr/src/contrib/isode/pepsy/t3.py
new file mode 100644 (file)
index 0000000..01855d7
--- /dev/null
@@ -0,0 +1,487 @@
+
+T3 DEFINITIONS ::=
+
+%{
+/*
+ * this stuff is to test the verbatim actions at the start of the 
+ * type definitions
+ */
+%}
+
+BEGIN
+
+
+
+Pepy-refs [[ P struct pepy_refs * ]] ::= SEQUENCE {
+    [1] IMPLICIT INTEGER [[ i parm->t_int ]],
+    [2] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
+       orange(1), apple(2), pear(3), bannana(4) },
+
+    [3] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]],
+    [4] IMPLICIT OCTET STRING [[ s parm->t_string ]],
+    [5] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]],
+    [6] IMPLICIT BIT STRING [[ t parm->t_pe ]],
+    [7] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]],
+    [8] IMPLICIT BOOLEAN [[ b parm->t_bool ]],
+    [9] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]],
+    [10] IMPLICIT REAL [[ r parm->t_real ]],
+    [11] ANY [[ a parm->t_any ]],
+    [12] Def-types [[ p parm->t_def ]],
+    [13] Opt-types [[ p parm->t_opt ]] OPTIONAL
+
+    }
+
+-- Optional and Default test cases
+
+Def-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
+    [1] INTEGER [[ i parm->t_int ]] DEFAULT 2,
+    [2] IMPLICIT INTEGER [[ i parm->t_int1 ]] DEFAULT 2,
+    [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]]
+       { orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,
+
+    [4] ENUMERATED [[ i parm->t_enum1 ]] {
+       orange(1), apple(2), pear(3), bannana(4) } DEFAULT pear,
+    [5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]]
+                       DEFAULT '536f6d65206973206f757420746865726521'H,
+    [6] OCTET STRING [[ q parm->t_qbuf1 ]]
+                       DEFAULT '536f6d65206973206f757420746865726521'H,
+    [7] IMPLICIT OCTET STRING [[ s parm->t_string ]] DEFAULT '003132'h,
+    [8] OCTET STRING [[ s parm->t_string1 ]] DEFAULT '003132'h,
+    [9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
+                       DEFAULT 'ff01ab20'h,
+    [10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
+                       DEFAULT 'ff01ab20'h,
+    [11] IMPLICIT BIT STRING [[ t parm->t_pe ]]
+       DEFAULT '00010010001100010001101000110111001010101'B,
+    [12] BIT STRING [[ t parm->t_pe1 ]]
+       DEFAULT '00010010001100010001101000110111001010101'B,
+    [13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]]
+       DEFAULT '00000000001100010011001000110011'B,
+    [14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]]
+       DEFAULT '00000000001100010011001000110011'B,
+    [15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
+    [16] BOOLEAN [[ b parm->t_bool ]] DEFAULT TRUE,
+    [17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day  DEFAULT 1.17.42,
+    [18] OBJECT IDENTIFIER [[ O parm->t_oid1 ]] OPTIONAL, -- one day  DEFAULT 1.17.42,
+    [19] IMPLICIT REAL [[ r parm->t_real ]] DEFAULT { 306998, 10, -5 },
+    [20] REAL [[ r parm->t_real1 ]] DEFAULT { 306998, 10, -5 },
+    [21] ANY [[ a parm->t_any ]] OPTIONAL
+
+    }
+
+Opt-types [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
+    [1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>,
+    [2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>,
+    [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
+       orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>,
+    [4] ENUMERATED [[ i parm->t_enum1 ]] {
+       orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>,
+
+    [5] IMPLICIT OCTET STRING [[ q parm->t_qbuf ]] OPTIONAL,
+    [6] OCTET STRING [[ q parm->t_qbuf1 ]] OPTIONAL,
+    [7] IMPLICIT OCTET STRING [[ s parm->t_string ]] OPTIONAL,
+    [8] OCTET STRING [[ s parm->t_string1 ]] OPTIONAL,
+    [9] IMPLICIT OCTET STRING [[ o parm->t_ostring $ parm->t_olen ]]
+                       OPTIONAL,
+    [10] OCTET STRING [[ o parm->t_ostring1 $ parm->t_olen1 ]]
+                       OPTIONAL,
+    [11] IMPLICIT BIT STRING [[ t parm->t_pe ]] OPTIONAL,
+    [12] BIT STRING [[ t parm->t_pe1 ]] OPTIONAL,
+    [13] IMPLICIT BIT STRING [[ x parm->t_bstring $ t_blen ]] OPTIONAL,
+    [14] BIT STRING [[ x parm->t_bstring1 $ t_blen1 ]] OPTIONAL,
+    [15] IMPLICIT BOOLEAN [[ b parm->t_bool ]] OPTIONAL << opt_set $ OPT_BOOL1>>,
+    [16] BOOLEAN [[ b parm->t_bool1 ]] OPTIONAL << opt_set $ OPT_BOOL2>>,
+    [17] IMPLICIT OBJECT IDENTIFIER [[ O parm->t_oid ]], -- one day  OPTIONAL,
+    [18] IMPLICIT REAL [[ r parm->t_real ]] OPTIONAL << opt_set $ OPT_REAL1 >>,
+    [19] REAL [[ r parm->t_real1 ]] OPTIONAL << opt_set $ OPT_REAL2 >>,
+    [20] ANY [[ a parm->t_any ]]
+
+    }
+
+    Single-type [[ P struct pepy_refs1 * ]] ::= SEQUENCE {
+       a SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
+               [1] IMPLICIT INTEGER [[ i parm->t_int ]] OPTIONAL << opt_set $ OPT_INT1 >>
+           },
+       b SEQUENCE [[ T struct pepy_refs1 * $ * ]] {
+               [2] INTEGER [[ i parm->t_int1 ]] OPTIONAL << opt_set $ OPT_INT2 >>
+           },
+
+       c SET [[ T struct pepy_refs1 * $ *parm ]] {
+           [3] IMPLICIT ENUMERATED [[ i parm->t_enum ]] {
+orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM1 >>
+       },
+       d SET [[ T struct pepy_refs1 *  $ *parm ]] {
+           [4] ENUMERATED [[ i parm->t_enum1 ]] {
+orange(1), apple(2), pear(3), bannana(4) } OPTIONAL << opt_set $ OPT_ENUM2 >>
+       }
+    }
+
+    Repeated [[ P struct repeats * ]]::= SEQUENCE {
+       a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
+           <<r>> [1] INTEGER [[ i i ]],
+
+       b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
+               Rep-elem [[ p * ]],
+
+       c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],
+
+       d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
+               [3] IMPLICIT Rep-elem [[ p * ]],
+
+       e CHOICE [[ T struct repeats  * $ * ]] <<rp_choice>> {
+               [1] INTEGER [[ i rp_int ]],
+               [2] BOOLEAN [[ b rp_bool ]],
+               [3] OCTET STRING [[ o rp_ostring $ rp_int ]]
+           }
+       }
+
+    Rep-elem [[ P struct rep_elem * ]]
+       ::= SEQUENCE {
+           a INTEGER [[ i r_int ]],
+           b OCTET STRING [[ s r_ostring ]],
+           c BIT STRING [[ x r_bstring $ r_int ]]
+       }
+
+    Defined [[ P struct pepy_refs * ]] ::= 
+       SEQUENCE {
+       a PrintableString [[ s t_string ]],
+       b [ APPLICATION 3 ] AString [[ q t_qbuf ]],
+       c [ APPLICATION 3 ] IMPLICIT AnOctetString [[ o t_ostring $ t_olen ]],
+       d BitsAndPieces [[ x t_bstring $ t_blen ]],
+       e AnAny [[ a t_any ]],
+       ABitString [[ t t_pe ]],
+       AnotherType [[ i t_int ]],
+       [12] AReal [[ r t_real ]],
+       [99] IMPLICIT AnOID [[ O t_oid ]],
+       [13] IMPLICIT Boodles [[ b t_bool ]],
+       AnEnumerated [[ i t_enum ]]
+       }
+
+    AString ::= GraphicString
+
+    AnOctetString ::= OCTET STRING
+
+    BitsAndPieces ::= [31] SomeBits
+
+    SomeBits ::= [APPLICATION 10] IMPLICIT ABitString
+
+    ABitString ::= BIT STRING
+
+    AnAny ::= ANY
+
+    AnotherType ::= [21] AnInteger
+
+    AnInteger ::= INTEGER
+
+    AReal ::= REAL
+
+    AnOID ::= OBJECT IDENTIFIER
+
+    Boodles ::= [PRIVATE 9] ABoolean
+
+    ABoolean ::= [APPLICATION 12] BOOLEAN
+
+    AnEnumerated ::= [4] ENUMERATED { orange(1), apple(2), pear(3), bannana(4) } 
+    -- Coding functions tests
+
+    CodeTest [[ P struct codedata * ]] ::= SEQUENCE {
+       a BasicANY [[ p cd_a ]],
+       b [42] E-ANY [[ p cd_b ]],
+       c [36] D-ANY [[ p cd_c ]],
+       d DE-ANY [[ p cd_d ]],
+       e [APPLICATION 44] IMPLICIT INTEGER [[ i cd_int ]]
+           [[ E get_int ]] [[ D put_int ]] DEFAULT 1,
+       f [17] GraphicString [[ s cd_string ]]
+           [[ E get_string ]][[ D put_string ]] [[ F fr_string ]] OPTIONAL,
+       left CodeOpt [[ p cd_left ]] OPTIONAL,
+       right CodeDflt [[ p cd_right ]] OPTIONAL
+    }
+
+   BasicANY ::= ANY [[ a * ]] 
+
+   E-ANY ::= ANY [[ a * ]] [[ E get_pe ]]
+
+   D-ANY ::= ANY [[ a * ]]  [[ D put_pe ]] [[ F fr_pe ]]
+
+   DE-ANY ::= ANY [[ a * ]]  [[ D put_pe ]] [[ E get_pe ]]
+
+    CodeOpt [[ P struct codedata * ]] ::= SEQUENCE {
+       a [PRIVATE 5] BasicANY [[ p cd_a ]] OPTIONAL,
+       b [35] E-ANY [[ p cd_b ]] OPTIONAL,
+       c [45] EXPLICIT D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
+       d [1] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
+       e [15] IMPLICIT INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
+               OPTIONAL << cd_opt_set $ CD_INT >>,
+       f GraphicString [[ s cd_string ]] [[ E get_string ]][[ D put_string ]]
+               OPTIONAL
+    }
+
+    -- It would be nice to do DEFAULTs for ANY but how do we specify
+    -- DEFAULT ANY in the ASN.1 ?? Let alone parse it
+
+    CodeDflt [[ P struct codedata * ]] ::= SEQUENCE {
+       a [1] BasicANY [[ p cd_a ]] OPTIONAL,
+       b [2] E-ANY [[ p cd_b ]] OPTIONAL,
+       c [3] D-ANY [[ p cd_c ]] OPTIONAL <<cd_opt_set $ CD_C>>,
+       d [4] DE-ANY [[ p cd_d ]] OPTIONAL <<cd_opt_set $ CD_D>>,
+       e [APPLICATION 4] INTEGER [[ i cd_int ]] [[ E get_int ]] [[ D put_int ]]
+               DEFAULT 3,
+       f [90] IMPLICIT GraphicString [[ s cd_string ]] [[ E get_string2 ]]
+           [[ D put_string2 ]] DEFAULT '536f6d65206973206f7574'H
+    }
+
+    Simple1 [[ P struct codedata * ]] ::= CodeDflt [[ p cd_right ]]
+
+    Simple2 [[ P struct codedata * ]] ::= INTEGER [[ i cd_int ]]
+
+    Simple3 [[ P struct codedata * ]] ::= [1] INTEGER [[ i cd_int1 ]]
+
+    Simple4 [[ P struct codedata * ]] ::= [1] IMPLICIT INTEGER [[ i cd_int2 ]]
+
+    Simple5 [[ P struct codedata * ]] ::= OCTET STRING [[ s cd_string ]]
+
+    Simple6 [[ P struct codedata * ]] ::= [1] OCTET STRING [[ s cd_string1 ]]
+
+    Simple7 [[ P struct codedata * ]] ::= [1] IMPLICIT OCTET STRING
+                                               [[ s cd_string2 ]]
+
+    Simple8 [[ P struct codedata * ]] ::= OBJECT IDENTIFIER [[ O cd_oid ]]
+
+    Simple9 [[ P struct codedata * ]] ::= [1] OBJECT IDENTIFIER [[ O cd_oid1 ]]
+
+    Simple10 [[ P struct codedata * ]] ::= [1] IMPLICIT OBJECT IDENTIFIER
+                                               [[ O cd_oid2 ]]
+
+    Simple11 [[ P struct codedata * ]] ::= ANY [[ a cd_a ]]
+
+    Simple12 [[ P struct codedata * ]] ::= BIT STRING [[ t cd_bit ]]
+
+    Simple13 [[ P struct codedata * ]] ::= REAL [[ r cd_real ]]
+
+    Simple14 [[ P struct codedata * ]] ::= BOOLEAN [[ b cd_bool ]]
+
+    AllSimples [[ P struct codedata * ]] ::= SEQUENCE {
+
+       a Simple1 [[ p * ]],
+       b Simple2 [[ p * ]],
+       c Simple3 [[ p * ]],
+       d Simple4 [[ p * ]],
+       e Simple5 [[ p * ]],
+       f Simple6 [[ p * ]],
+       g Simple7 [[ p * ]],
+       h Simple8 [[ p * ]],
+       i Simple9 [[ p * ]],
+       j Simple10 [[ p * ]],
+       k Simple11 [[ p * ]],
+       l Simple12 [[ p * ]],
+       m Simple13 [[ p * ]],
+       n Simple14 [[ p * ]]
+
+    }
+
+    UAction [[ P struct repeats * ]]::= SEQUENCE {
+       a SEQUENCE OF [[ T struct rep_int * $ rp_sq1 ]]
+           <<r>> [1] INTEGER [[ i i ]],
+
+       b SEQUENCE OF [[ T struct rep_elem * $ rp_sq2 ]] <<r_next>>
+               Rep-action [[ p * ]],
+
+       c SET OF [[ T struct rep_int * $ rp_st1 ]] <<r>> INTEGER [[ i i ]],
+
+       d SET OF [[ T struct rep_elem * $ rp_st2 ]] <<r_next>>
+               %E{ (void) printf("encoding SET OF Rep-action\n");%}
+               [3] IMPLICIT Rep-action [[ p * ]],
+
+       e CHOICE [[ T struct repeats  * $ * ]] <<rp_choice>> {
+           %D{ (void) printf("Before Encoding CHOICE\n"); %}
+               [1] INTEGER [[ i rp_int ]],
+               [2]
+               %E{ (void) printf("encoding Boolean %d\n", parm->rp_bool);%}
+               BOOLEAN [[ b rp_bool ]]
+               %D{ (void) printf("Decoding Boolean\n"); %},
+               [3] OCTET STRING [[ o rp_ostring $ rp_int ]]
+           }
+       %D{ (void) printf("After Decoding CHOICE: chosen %d\n", (*parm)->rp_choice); %}
+       }  %D{ (void) printf("After Decoding UAction\n"); %}
+
+    Rep-action [[ P struct rep_elem * ]]
+       ::=
+               %D{ (void) printf("Before Decoding Rep-action\n"); %}
+       SEQUENCE {
+               %E{ (void) printf("before encoding INTEGER %d\n", parm->r_int);%}
+           a INTEGER [[ i r_int ]],
+               %E{ (void) printf("before encoding OCTET STRING \"%s\"\n",
+                           parm->r_ostring);
+           %}
+           b OCTET STRING [[ s r_ostring ]],
+               %E{
+                   int i;
+
+                   (void) printf("before encoding BIT STRING: ");
+                   for (i = 0; i < parm->r_int; i++) {
+                       if (BITTEST(parm->r_bstring, i))
+                           (void) putchar('1');
+                       else
+                           (void) putchar('0');
+                   }
+                   (void) putchar('\n');
+
+               %}
+           c BIT STRING [[ x r_bstring $ r_int ]]
+               %E{
+                   (void) printf("After Bitstring encoding:");
+                   vunknown(*ppe);
+               %}
+       }
+               %E{
+                   (void) printf("After Sequence encoding:\n");
+                   vunknown(*ppe);
+               %}
+               %D{
+                   int i;
+
+                   (void) printf("After Decoding Rep-action:\n");
+                   (void) printf("rp_int %d\n", (*parm)->r_int);
+                   (void) printf("r_ostring \"%s\"\n", (*parm)->r_ostring);
+                   (void) printf("r_bstring: ");
+
+                   for (i = 0; i < (*parm)->r_int; i++) {
+                       if (BITTEST((*parm)->r_bstring, i))
+                           (void) putchar('1');
+                       else
+                           (void) putchar('0');
+                   }
+                   (void) putchar('\n');
+
+               %}
+
+END
+%{
+
+/*
+ * Encoding function for test examples of the Coding functions in t3.py
+ */
+
+get_pe(parm, ppe)
+PE     parm;
+PE     *ppe;
+{
+    if (ppe == (PE *)0) {
+       if (parm == NULLPE)     /* Optional */
+           return (OK + 1);
+       return (OK);
+    }
+
+    *ppe = pe_cpy(parm);
+    return (OK);
+}
+
+put_pe(parm, pe)
+PE     *parm;
+PE     pe;
+{
+    *parm = pe_cpy(pe);
+    return (OK);
+}
+
+get_int(parm, ppe)
+struct codedata        *parm;
+PE     *ppe;
+{
+    if (ppe == (PE *)0) {
+       if (parm->cd_int == 1)  /* Default case */
+           return (OK + 1);
+       return (OK);
+    }
+
+    *ppe = int2prim(parm->cd_int);
+    return (OK);
+}
+
+put_int(parm, pe)
+struct codedata        **parm;
+PE     pe;
+{
+    if (pe)
+       (*parm)->cd_int = prim2num(pe);
+    else
+       (*parm)->cd_int = 1;    /* Default */
+    return (OK);
+}
+
+get_string(parm, ppe)
+struct codedata        *parm;
+PE     *ppe;
+{
+    if (ppe == (PE *)0) {
+       if (parm->cd_string == NULLCP) /* Not present */
+           return (OK + 1);
+       return (OK);
+    }
+
+    *ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
+    return (OK);
+}
+
+put_string(parm, pe)
+struct codedata        **parm;
+PE     pe;
+{
+    int        len;
+
+    if (pe)
+       (*parm)->cd_string = prim2str(pe, &len);
+    else
+       (*parm)->cd_string = NULLCP;    /* Default */
+
+    return (OK);
+}
+get_string2(parm, ppe)
+struct codedata        *parm;
+PE     *ppe;
+{
+    if (ppe == (PE *)0) {
+       if (parm->cd_string == NULLCP
+        || strcmp(parm->cd_string, "Some is out") == 0)/* Not present */
+           return (OK + 1);
+       return (OK);
+    }
+
+    *ppe = str2prim(parm->cd_string, strlen(parm->cd_string), 0, 0);
+    return (OK);
+}
+
+put_string2(parm, pe)
+struct codedata        **parm;
+PE     pe;
+{
+    int        len;
+
+    if (pe)
+       (*parm)->cd_string = prim2str(pe, &len);
+    else
+       (*parm)->cd_string = strdup("Some is out");     /* Default */
+
+    return (OK);
+}
+
+fr_string(parm)
+struct codedata        *parm;
+{
+     if (parm->cd_string)
+       free(parm->cd_string);
+
+     return (OK);
+}
+
+fr_pe(parm)
+PE     parm;
+{
+    if (parm)
+       pe_free(parm);
+
+    return (OK);
+}
+
+%}
+
diff --git a/usr/src/contrib/isode/pepsy/test_table.h b/usr/src/contrib/isode/pepsy/test_table.h
new file mode 100644 (file)
index 0000000..6e541c2
--- /dev/null
@@ -0,0 +1,208 @@
+/* test_table.h */
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/test_table.h,v 7.2 91/02/22 09:50:10 mrose Interim $
+ *
+ *
+ * $Log:       test_table.h,v $
+ * Revision 7.2  91/02/22  09:50:10  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.1  90/11/04  19:21:15  mrose
+ * update
+ * 
+ * Revision 7.0  90/07/01  19:54:46  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/*
+ * This contains the information about each test case necessary to test it
+ * e.g. size, name
+ */
+
+ struct tst_typ {
+       char    *tst_name;      /* Name for error messages */
+       unsigned int    tst_size; /* Size of its data structure in bytes */
+       int     tst_entry;      /* entry for decoding/encoding */
+       int     tst_tests;      /* How many values of the t_test variable
+                                * to try it with
+                                */
+#define NOENTRY                -1
+       }  t_case[] = {
+       /* MPDU */
+       { "MPDU", sizeof (struct type_T1_MPDU), _ZMPDUT1, 1, },
+#define TY_MPDU        0       
+       { "Embedded", sizeof (struct type_T1_Embedded), _ZEmbeddedT1, 1, },
+#define TY_EMBEDDED    1       
+       { "Strings", sizeof (struct type_T1_Strings), _ZStringsT1, 1, },
+#define TY_STRINGS     2       
+       { "Embedded Strings", sizeof (struct type_T1_Emb__Strings),
+           _ZEmb_StringsT1, 1, },
+#define TY_EMB_STRINGS 3       
+       { "Implicit tags", sizeof (struct type_T1_Impl__Tags),
+           _ZImpl_TagsT1, 1, },
+#define TY_IMPLICIT    4       
+       { "Explicit tags", sizeof (struct type_T1_Expl__Tags),
+           _ZExpl_TagsT1, 1, },
+#define TY_EXPLICIT    5       
+       { "SEQ OF and SET OF", sizeof (struct type_T1_Seqof__Test),
+           _ZSeqof_TestT1, 10, },
+#define TY_SEQOF       6       
+       { "Seqof Test 1", sizeof (struct element_T1_4), NOENTRY, 0, },
+#define TY_ELEMENT4    7       
+       { "Set of Test 1", sizeof (struct member_T1_2), NOENTRY, 0, },
+#define TY_MEMBER2     8       
+       { "Seq of Test 2", sizeof (struct element_T1_6), NOENTRY, 0, },
+#define TY_ELEMENT6    9       
+       { "Seq of Sequence test", sizeof (struct element_T1_8), NOENTRY, 0, },
+#define TY_ELEMENT8    10      
+       { "Set of Test 2", sizeof (struct member_T1_4), NOENTRY, 0, },
+#define TY_MEMBER4     11      
+       { "Set of Sequence", sizeof (struct element_T1_9), NOENTRY, 0, },
+#define TY_ELEMENT9    12      
+       { "Choice", sizeof (struct type_T1_Choice__Test), _ZChoice_TestT1, 7, },
+#define TY_CHOICE      13      
+       { "Choice test 0", sizeof (struct choice_T1_0), NOENTRY, 0, },
+#define TY_CHOICE0     14      
+       { "Choice test 1", sizeof (struct choice_T1_1), NOENTRY, 0, },
+#define TY_CHOICE1     15
+       { "Choice test 2", sizeof (struct choice_T1_2), NOENTRY, 0, },
+#define TY_CHOICE2     16
+       { "Element 10", sizeof (struct element_T1_10), NOENTRY, 0, },
+#define TY_ELEMENT10   17
+       { "Member 6", sizeof (struct member_T1_6), NOENTRY, 0, },
+#define TY_MEMBER6     18
+       { "Element 11", sizeof (struct element_T1_11), NOENTRY, 0, },
+#define TY_ELEMENT11   19
+       { "Choice test 3", sizeof (struct choice_T1_3), NOENTRY, 0, },
+#define TY_CHOICE3     20
+       { "Optional test", sizeof (struct type_T1_Opt__Strings), _ZOpt_StringsT1,
+       8, },
+#define TY_OPTIONAL    21
+       { "Element 12", sizeof (struct element_T1_12), NOENTRY, 0, },
+#define TY_ELEMENT12   22
+       { "Member 7", sizeof (struct member_T1_7), NOENTRY, 0, },
+#define TY_MEMBER7     23
+       { "Choice test 4", sizeof (struct choice_T1_4), NOENTRY, 0, },
+#define TY_CHOICE4     24
+       { "Default test", sizeof (struct type_T1_Def__Strings), _ZDef_StringsT1,
+       12, },
+#define TY_DEFAULT     25
+       { "Element 13", sizeof (struct element_T1_13), NOENTRY, 0, },
+#define TY_ELEMENT13   26
+       { "Member 8", sizeof (struct member_T1_8), NOENTRY, 0, },
+#define TY_MEMBER8     27
+       { "External References", sizeof (struct type_T1_E__ref), _ZE_refT1, 6,},
+#define TY_EXTREF      28
+       { "T2 Info", sizeof (struct type_T2_Info), NOENTRY, 0, },
+#define TY_T2_INFO     29
+       { "T2 MPDU", sizeof (struct type_T2_MPDU), NOENTRY, 0, },
+#define TY_T2_MPDU     30
+       { "T2 ELEMENT 0", sizeof (struct element_T2_0), NOENTRY, 0, },
+#define TY_T2_ELEM0    31
+       { "Optimised", sizeof (struct type_T1_Optimised), _ZOptimisedT1, 8, },
+#define TY_OPTIMISED   32
+       { "MEMBER 9", sizeof (struct member_T1_9), NOENTRY, 0, },
+#define TY_MEMBER9     33
+       { "EXTERNAL", sizeof (struct type_T1_Ext__typ), _ZExt_typT1, 6, },
+#define TY_EXTERNAL    34
+       { "Single EXTERNAL", sizeof (struct type_T1_SExt), _ZSExtT1, 1, },
+#define TY_SEXTERNAL   35
+       { "Explicit Tagged Objects", sizeof (struct type_T1_Etags), _ZEtagsT1, 3, },
+#define TY_ETAGOBJ     36
+       { "Single Objects", sizeof (struct type_T1_Stest), _ZStestT1, 4, },
+#define TY_STEST       37
+       { "Single Integer", sizeof (struct type_T1_Sint), NOENTRY, 0, },
+#define TY_SINT                38
+       { "Enumerated Type", sizeof (struct type_T1_Enum__type), _ZEnum_typeT1,
+       4, },
+#define TY_ETYPE       39
+       { "Tests of Enumerated type", sizeof (struct type_T1_T__enum),
+       _ZT_enumT1, 4, },
+#define TY_ENUM_TEST   40
+#define TY_REAL                41
+#ifdef PEPSY_REALS
+       { "Real", sizeof (struct type_T1_Real), _ZRealT1, 3, },
+
+       { "Tests of Real type", sizeof (struct type_T1_T__real),
+       _ZT_realT1, 4, },
+
+       { "Pepy Stuff", sizeof (struct pepy_refs), _ZT_pepyT1, 3, },
+
+       { "Default Pepy", sizeof (struct pepy_refs1), NOENTRY, 0, },
+
+       { "Optional Pepy", sizeof (struct pepy_refs1), NOENTRY, 0, },
+
+       { "Compound S-types", sizeof (struct pepy_refs1), _ZT3_SingleT1, 3, },
+
+#else
+       { NULLCP, 0, NOENTRY, 3, },
+
+       { NULLCP, 0, NOENTRY, 4, },
+
+       { NULLCP, 0, NOENTRY, 3, },
+
+       { NULLCP, 0, NOENTRY, 3, },
+
+       { NULLCP, 0, NOENTRY, 0, },
+
+       { NULLCP, 0, NOENTRY, 3, },
+#endif
+#define TY_REAL_TEST   42
+#define TY_PEPY                43
+#define TY_DEFPEPY     44
+#define TY_OPTPEPY     45
+#define TY_S_COMPD     46
+
+       {"Repeating pepy elements",sizeof (struct repeats), _ZT3_RepeatT1, 3, },
+#define TY_REPEAT      47
+
+#ifdef PEPSY_REALS
+
+       {"Value Passing Defined types",sizeof (struct pepy_refs),
+           _ZT3_DefinedT1, 3, },
+
+#else
+       { NULLCP, 0, NOENTRY, 3, },
+
+#endif
+
+#define TY_VPDEFINED   48
+
+       {"function calling code",sizeof (struct codedata), _ZT3_CodeTestT1, 3,},
+#define TY_FUNC        49
+
+       {"optional function calling",sizeof (struct codedata), NOENTRY, 3,},
+#define TY_OPTFUNC     50
+
+       {"default function calling",sizeof (struct codedata), NOENTRY, 3,},
+#define TY_DFTFUNC     51
+
+#ifdef PEPSY_REALS
+
+       {"All Simple Types",sizeof (struct codedata), _ZT3_AllSimplesT1, 3,},
+
+#else
+       { NULLCP, 0, NOENTRY, 3, },
+
+#endif
+
+#define TY_ASIMPLE     52
+
+       {"Action Statements",sizeof (struct repeats), _ZT3_UActionT1, 3, },
+#define TY_ACTION      53
+       };
+
+#define MAXTCASE       (sizeof (t_case)/sizeof (t_case[0]))
diff --git a/usr/src/contrib/isode/pepsy/util.c b/usr/src/contrib/isode/pepsy/util.c
new file mode 100644 (file)
index 0000000..d5382a4
--- /dev/null
@@ -0,0 +1,794 @@
+/* util.c */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/util.c,v 7.7 91/02/22 09:50:13 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/util.c,v 7.7 91/02/22 09:50:13 mrose Interim $
+ *
+ *
+ * $Log:       util.c,v $
+ * Revision 7.7  91/02/22  09:50:13  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.6  90/12/11  10:41:13  mrose
+ * sync
+ * 
+ * Revision 7.5  90/11/04  19:21:19  mrose
+ * update
+ * 
+ * Revision 7.4  90/10/23  20:43:20  mrose
+ * update
+ * 
+ * Revision 7.3  90/08/18  00:44:30  mrose
+ * touch-up
+ * 
+ * Revision 7.2  90/08/08  14:14:45  mrose
+ * update
+ * 
+ * Revision 7.1  90/07/09  14:53:23  mrose
+ * sync
+ * 
+ * Revision 7.0  90/07/01  19:54:33  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/* LINTLIBRARY */
+
+#include       <stdio.h>
+#include       "pepsy-driver.h"
+#include       "psap.h"
+#include       "pepsy.h"
+#include        <varargs.h>
+#include       "tailor.h"
+
+#ifndef        PEPYPARM
+#define PEPYPARM       char *
+#endif
+
+static char *pr_petype ();
+
+extern void exit();
+
+#ifdef lint
+/* VARARGS4 */
+
+int    pepsylose (module, p, pe, str)
+modtyp *module;
+tpe    *p;
+char   *str;
+PE     pe;
+{
+       return pepsylose (module, p, pe, str);
+}
+
+#else
+int    pepsylose (va_alist)
+va_dcl
+{
+       va_list ap;
+       int     type;
+       modtyp  *module;
+       tpe     *p;
+       char    *cp;
+       PE      pe;
+       char    buffer[BUFSIZ];
+
+       va_start (ap);
+
+       module = va_arg (ap, modtyp *);
+       p = va_arg (ap, tpe *);
+       pe = va_arg (ap, PE);
+
+       _asprintf (buffer, NULLCP, ap);
+       (void) sprintf (PY_pepy, "%s: module %s",
+                       buffer, module ? module -> md_name : "<none>");
+       if (p) {
+           cp = PY_pepy + strlen (PY_pepy);
+           (void) sprintf (cp, " %s/class=%s/id=%d",
+                           pr_petype (p -> pe_type),
+                           pe_classlist[p -> pe_flags & FL_CLASS],
+                           p -> pe_tag);
+       }
+       if (pe && pe -> pe_class >= 0 && pe -> pe_class < pe_maxclass) {
+           cp = PY_pepy + strlen (PY_pepy);
+           (void) sprintf (cp, " got %s/%d", pe_classlist[pe -> pe_class],
+                           pe -> pe_id);
+       }
+
+       SLOG (psap_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
+
+       va_end (ap);
+       return NOTOK;
+}
+#endif
+
+#ifdef lint
+/* VARARGS4 */
+
+int    ppepsylose (module, p, pe, str)
+modtyp *module;
+ptpe   *p;
+char   *str;
+PE     pe;
+{
+       return ppepsylose (module, p, pe, str);
+}
+
+#else
+int    ppepsylose (va_alist)
+va_dcl
+{
+       va_list ap;
+       int     type;
+       modtyp  *module;
+       ptpe    *p;
+       char    *cp;
+       PE      pe;
+       char    buffer[BUFSIZ];
+
+       va_start (ap);
+
+       module = va_arg (ap, modtyp *);
+       p = va_arg (ap, ptpe *);
+       pe = va_arg (ap, PE);
+
+       _asprintf (buffer, NULLCP, ap);
+       (void) sprintf (PY_pepy, "%s: module %s",
+                       buffer, module ? module -> md_name : "<none>");
+       if (p) {
+           cp = PY_pepy + strlen (PY_pepy);
+           (void) sprintf (cp, " %s/class=%s/id=%d",
+                           pr_petype (p -> pe_type),
+                           pe_classlist[p -> pe_flags & FL_CLASS],
+                           p -> pe_tag);
+           if (p->pe_typename)
+               (void) sprintf (cp, "(%s)", p -> pe_typename);
+       }
+       if (pe && pe -> pe_class >= 0 && pe -> pe_class < pe_maxclass) {
+           cp = PY_pepy + strlen (PY_pepy);
+           (void) sprintf (cp, " got %s/%d", pe_classlist[pe -> pe_class],
+                           pe -> pe_id);
+       }
+
+       SLOG (psap_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
+
+       va_end (ap);
+       return NOTOK;
+}
+#endif
+
+/*
+ * Useful little routines
+ */
+/*
+ * print out the message and if the arguement is greater than 0
+ * terminate
+ */
+ferr(n, mesg)
+char   *mesg;
+{
+    (void) printf(mesg);
+    if (n > 0)
+       exit(n);
+}
+/*
+ * print out the message and number and if the arguement is greater
+ * than 0 terminate
+ */
+ferrd(n, mesg, d)
+char   *mesg;
+int     d;
+{
+    (void) printf(mesg, d);
+    if (n > 0)
+       exit(n);
+}
+
+/*
+ * 0 = Encoding table, 1 = Decoding table, 2 = Printing table
+ */
+#define TYP_ENC                0
+#define TYP_DEC                1
+#define TYP_PRINT      2
+#define TYP_LAST       2
+
+dmp_tpe(s, p, mod)
+char   *s;
+modtyp *mod;                   /* Module it is from */
+tpe    *p;
+{
+    int     typ, i, j;
+    tpe   **par, **prev;
+    char   *name;
+
+    (void) printf("%s: (%s)", s, mod->md_name);
+    /*
+     * Calculate what table it is in - we assume they are in order of
+     * increasing address
+     */
+
+    par = NULL;
+    for (typ = 0; typ <= TYP_LAST; typ++) {
+       switch (typ) {
+       case TYP_ENC:
+           if (mod->md_etab != NULL && mod->md_etab[0] < p) {
+               par = mod->md_etab;
+               name = "Encoding:";
+           }
+           break;
+
+       case TYP_DEC:
+           if (mod->md_dtab != NULL && mod->md_dtab[0] < p) {
+               par = mod->md_dtab;
+               name = "Decoding:";
+           }
+           break;
+
+       case TYP_PRINT:
+           if (mod->md_ptab != NULL && mod->md_ptab[0] < (ptpe *) p) {
+               (ptpe **) par = mod->md_ptab;
+               name = "Printing:";
+           }
+           break;
+
+       default:
+           (void) pepsylose (mod, p, NULLPE, "dmp_tpe:typ = %d internal error\n",
+               typ);
+           return;
+       }
+    }
+    if (par == NULL) {
+       (void) printf("can't find entry 0x%x\n", p);
+       return;
+    }
+    prev = par;
+    for (i = mod->md_nentries; i > 0; i--) {
+       if (*par > p)
+           break;
+       par++;
+    }
+    if (par == prev)
+       (void) pepsylose (mod, p, NULLPE,
+           "dmp_tpe:par == prev == 0x%x internal error\n", (int) par);
+    par--;
+    j = p - *par;
+
+    (void) printf("%s type %d + %d ", name, par - prev, j);
+    pr_entry(p);
+}
+#define NENTRY(x)      ((sizeof (x)/sizeof (x[0])))
+/*
+ * Print out a tpe entry
+ */
+static char    *ntypes[] = { "PE_START", "PE_END", "illegal 1", "illegal 2",
+    "XOBJECT", "illegal 4", "illegal 5", "UCODE", "MALLOC", "SCTRL", "CH_ACT",
+    "OPTL", "BOPTIONAL", "FFN_CALL",},
+
+       *otypes[] = { "ANY", "INTEGER", "BOOLEAN", "OBJECT",
+    "BITSTRING", "OCTETSTRING", "SET_START", "SEQ_START", "SEQOF_START",
+    "SETOF_START", "CHOICE_START", "UNKNOWN", "T_NULL", "T_OID",
+    "ETAG", "IMP_OBJ", "EXTOBJ", "EXTMOD", "OBJID", "DFLT_F", "DFLT_B",
+    "T_STRING", "OCTET_PTR", "OCTET_LEN", "BITSTR_PTR", "BITSTR_LEN",
+    "FN_CALL" };
+
+static char *
+pr_petype (type)
+int    type;
+{
+    static char nbuf[30];
+
+    if (type >= PE_START && type < NENTRY(ntypes) - 1)
+       return ntypes[type + 1];
+    else if (type >= TYPE_DATA && type < NENTRY(otypes) + TYPE_DATA)
+       return otypes[type - TYPE_DATA];
+    (void) sprintf (nbuf, "%d", type);
+    return nbuf;
+}
+
+pr_entry(p)
+tpe    *p;
+{
+    (void) printf ("%s, ", pr_petype (p -> pe_type));
+    (void) printf("%d, %d, %d}\n", p->pe_ucode, p->pe_tag, p->pe_flags);
+}
+
+p_pr_entry(p)
+ptpe    *p;
+{
+    if (p->pe_type >= PE_START && p->pe_type < NENTRY(ntypes) - 1)
+        (void) printf("{%s, ", ntypes[p->pe_type + 1]);
+    else if (p->pe_type >= TYPE_DATA && p->pe_type < NENTRY(otypes) + TYPE_DATA)
+        (void) printf("{%s, ", otypes[p->pe_type - TYPE_DATA]);
+    else
+        (void) printf("{%d, ", p->pe_type);
+
+    (void) printf("%d, %d, %d}\n", p->pe_ucode, p->pe_tag, p->pe_flags);
+}
+
+
+/*
+ * null function for what evr purposes
+ */
+f_null()
+{
+}
+
+/*
+ * compare a given number of bits pointed to by the two character
+ * pointers return 0 if they are the same non zero otherwise
+ */
+bitscmp(p1, p2, len)
+register char *p1, *p2;
+int     len;
+{
+    register int i;
+    register unsigned int mask;
+
+    if (len >= 8 && bcmp(p1, p2, len / 8))
+       return (1);
+
+    if (len % 8 == 0)
+       return (0);
+    /* Check those last few bits */
+    i = len / 8;
+    mask = (0xff00 >> len % 8) & 0xff;
+    if ((p1[i] & mask) != (p2[i] & mask))
+       return (1);
+
+    return (0);
+}
+
+#define MIN(a, b)      (a < b ? a : b)
+/*
+ * compare an octet string and a qb and return 0 if they are the same
+ * and non zero otherwise
+ */
+ostrcmp(p, len, qb)
+register char *p;
+register int len;
+register struct qbuf *qb;
+{
+    register struct qbuf *qp;
+
+    if (len < 0 || qb == NULL || p == NULL)
+       return (1);
+    qp = qb;
+    do {
+       if (qp->qb_data != NULL) {
+           if (qp->qb_len < 0)
+               ferrd(1, "ostrcmp:qb_len %d < 0", qp->qb_len);
+           if (qp->qb_len > len)
+               return (1);
+           if (bcmp(qp->qb_data, p, qp->qb_len))
+               return (1);
+           if ((len -= qp->qb_len) == 0)
+               return (0);
+           p += qp->qb_len;
+       }
+       qp = qp->qb_forw;
+    } while (qp != qb);
+
+    return (len);
+}
+
+/*
+ * Is data present for the optional item? 1 for yes 0 for no
+ */
+hasdata(parm, p, mod, popt, optcnt)
+PEPYPARM parm;
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+int    *popt, optcnt;
+{
+    int        val;
+
+    switch (p->pe_type) {
+    case INTEGER:
+    case REALTYPE:
+    case BOOLEAN:
+    case T_NULL:
+       if (DEFAULT(p)) {
+           /* Default's don't have bit map */
+           if (p[1].pe_type == DFLT_B && same(p, p + 1, parm, mod)
+           || p[-1].pe_type == DFLT_F && same(p, p - 1, parm, mod))
+               goto next;
+           break;
+       }
+       if (!TESTBIT(*popt, optcnt++))
+           goto next;          /* Missing so skip */
+       break;
+
+    case ETAG:
+       if (!hasdata(parm, p + 1, mod, popt, optcnt))
+           goto next;
+       break;
+
+    case IMP_OBJ:
+       if (p[1].pe_type == SOBJECT && parm == NULL
+           || *((char **) (parm + p[1].pe_ucode)) == NULL)
+           goto next;
+       break;
+
+    case FN_CALL:      /* function call */
+       if ((val = (FN_PTR(mod, p))(parm, (PE *)0)) == NOTOK)
+           return pepsylose (mod, p, NULLPE,
+                             "hasdata:FN_CALL:call failed");
+       if (val != OK)
+           goto next;
+       break;
+
+    default:
+       if (*((char **) (parm + p->pe_ucode)) == NULL)
+           goto next;
+       break;
+    }
+    return (1);
+
+next:
+    return (0);
+}
+
+/*
+ * determine if the default value is the same as the value in the
+ * structure and if so return greater than zero (meaning don't encode this
+ * item). On error return NOTOK
+ */
+same(typ, dflt, parm, mod)
+tpe    *typ, *dflt;
+char   *parm;
+modtyp *mod;                   /* Module it is from */
+{
+    int     val;
+    int        len;
+    char   *p1;
+    PE      pe;
+    struct qbuf *qb;
+
+    switch (typ->pe_type) {
+    case INTEGER:
+       val = IVAL(mod, dflt) == *(integer *) (parm + typ->pe_ucode);
+       break;
+
+#ifdef PEPSY_REALS
+    case REALTYPE:
+       val = RVAL(mod, dflt) == *(double *) (parm + typ->pe_ucode);
+       break;
+#endif
+
+    case BOOLEAN:
+       val = IVAL(mod, dflt) == *(char *) (parm + typ->pe_ucode);
+       break;
+
+    case T_NULL:
+       val = 1;                /* Only one value */
+       break;
+
+    case SBITSTRING:
+       if ((pe = (PE) parm) == NULL) {
+           val = 1;
+           break;
+       }
+       goto bstring;
+
+    case BITSTRING:
+       if ((pe = *(PE *) (parm + typ->pe_ucode)) == NULL) {
+           val = 1;
+           break;
+       }
+bstring:
+       if ((p1 = bitstr2strb(pe, &val)) == NULL) {
+           (void) pepsylose (mod, typ, pe, "same:bad bitstring\n");
+           return (NOTOK);
+           /* Should really abort encoding here but how can we comunicate this
+            * to the routine that calls us?
+            */
+       }
+bstring2:
+       if (val != IVAL(mod, dflt) || bitscmp(PVAL(mod, dflt), p1, val))
+           val = 0;
+       else
+           val = 1;
+       if (typ->pe_type != BITSTR_PTR)
+           free(p1);
+       break;
+
+    case BITSTR_PTR:
+       if (typ[1].pe_type != BITSTR_LEN)
+           return pepsylose (mod, typ, pe, "same:missing BITSTR_LEN\n");
+       if ((p1 = *(char **) (parm + typ->pe_ucode)) == NULL) {
+           val = 1;
+           break;
+       }
+       val = *(int *) (parm + (typ + 1)->pe_ucode);
+       goto bstring2;
+
+    case SOCTETSTRING:
+       if ((qb = (struct qbuf *) parm) == NULL) {
+           val = 1;
+           break;
+       }
+       goto ostring;
+
+    case OCTETSTRING:
+       if ((qb = *(struct qbuf **) (parm + typ->pe_ucode)) == NULL) {
+           val = 1;
+           break;
+       }
+ostring:
+       if (ostrcmp(PVAL(mod, dflt), (int ) IVAL(mod, dflt), qb))
+           val = 0;
+       else
+           val = 1;
+       break;
+
+    case OCTET_PTR:
+       if (typ[1].pe_type != OCTET_LEN)
+           return pepsylose (mod, typ, pe, "same:missing OCTET_LEN\n");
+       if ((p1 = *(char **) (parm + typ->pe_ucode)) == NULL) {
+           val = 1;
+           break;
+       }
+       len = *(int *) (parm + (typ + 1)->pe_ucode);
+       goto o1string;
+
+    case T_STRING:
+       if ((p1 = *(char **) (parm + typ->pe_ucode)) == NULL) {
+           val = 1;
+           break;
+       }
+       len = strlen(p1);
+o1string:
+       if (len != IVAL(mod, dflt)) {
+           val = 0;
+           break;
+       }
+       if (bcmp(PVAL(mod, dflt), p1, len))
+           val = 0;
+       else
+           val = 1;
+       break;
+
+    case OBJECT:
+       if (*(char **) (parm + typ->pe_ucode) == NULL) {
+           val = 1;            /* to conform with pepy's way of
+                                * doing default */
+           break;
+       }
+       val = same(mod->md_etab[typ->pe_tag] + 1, dflt,
+                  *(char **) (parm + typ->pe_ucode), mod);
+       break;
+
+    case SOBJECT:
+       if ((char *) parm == NULL) {
+           val = 1;            /* to conform with pepy's way of
+                                * doing default */
+           break;
+       }
+       val = same(mod->md_etab[typ->pe_tag] + 1, dflt, parm, mod);
+       break;
+
+    case IMP_OBJ:
+       typ++;                  /* fall through */
+
+    case 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
+        */
+       val = *(char **) (parm + typ->pe_ucode) == NULL;
+       break;
+
+    case FN_CALL:      /* function call */
+       if ((val = (FN_PTR(mod, typ))(parm, (PE *)0)) == NOTOK)
+           return pepsylose (mod, typ, NULLPE,
+                             "same:FN_CALL:call failed");
+       if (val != OK)
+           val = 1;
+       else
+           val = 0;
+       break;
+
+
+    default:
+       (void) pepsylose (mod, typ, NULLPE, "same: %d not implemented\n",
+           typ->pe_type);
+       return (NOTOK);
+    }
+
+    return (val);
+}
+
+/*
+ * Calculate the next tpe entry in the sequence. Count a sequence as
+ * one element
+ */
+tpe    *
+next_tpe(p)
+tpe    *p;
+{
+    int     level;
+
+
+
+    level = 0;
+    if (p->pe_type == PE_END) {
+       (void) pepsylose (NULLMODTYP, p, NULLPE,
+           "next_tpe:internal error: unexpected PE_END found");
+       return (p);
+    }
+    do {
+again:
+       switch (p->pe_type) {
+       case SSEQ_START:
+       case SSEQOF_START:
+       case SSET_START:
+       case SSETOF_START:
+       case SCHOICE_START:
+       case SEQ_START:
+       case SEQOF_START:
+       case SET_START:
+       case SETOF_START:
+       case CHOICE_START:
+           level++;
+           break;
+
+       case UCODE:
+       case MEMALLOC:
+       case SCTRL:
+       case CH_ACT:
+       case INTEGER:
+       case REALTYPE:
+       case BOOLEAN:
+       case SANY:
+       case ANY:
+       case T_NULL:
+       case OBJECT:
+       case SOBJECT:
+       case BITSTRING:
+       case BITSTR_LEN:
+       case SBITSTRING:
+       case OCTETSTRING:
+       case T_STRING:
+       case OCTET_LEN:
+       case SOCTETSTRING:
+       case OBJID:
+       case SOBJID:
+       case OPTL:
+       case EXTMOD:
+       case DFLT_B:
+       case FN_CALL:
+       case FFN_CALL:
+           break;
+
+       case IMP_OBJ:
+       case ETAG:
+       case EXTOBJ:
+       case SEXTOBJ:
+       case DFLT_F:
+       case OCTET_PTR:
+       case BITSTR_PTR:
+       case BOPTIONAL:
+       case FREE_ONLY:
+           p++;
+           goto again;
+
+       case PE_END:
+           level--;
+           break;
+
+       default:
+           ferrd(1, "next_tpe: unknown type %d\n", p->pe_type);
+       }
+       p++;
+    } while (level > 0 || p->pe_type == DFLT_B);
+
+    return (p);
+}
+
+/*
+ * 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
+ */
+ismatch(p, mod, cl, tag)
+tpe    *p;
+modtyp *mod;                   /* Module it is from */
+unsigned int cl, tag;
+{
+    while (!ISDTYPE(p))
+       p++;
+
+    switch (p->pe_type) {
+    case SOBJECT:
+    case OBJECT:
+       /* Needs to be changed for optional and default */
+       return (ismatch(p = mod->md_dtab[p->pe_tag] + 1, mod, cl, tag));
+
+    case SEXTOBJ:
+    case EXTOBJ:
+       if (p[1].pe_type != EXTMOD) {
+           dmp_tpe("ismatch: missing EXTMOD", p, mod);
+           ferr(1, "ismatch:internal error\n");
+       }
+       return (ismatch(EXT2MOD(mod, (p + 1))->md_dtab[p->pe_tag] + 1,
+                       EXT2MOD(mod, (p + 1)), cl, tag));
+
+    case CHOICE_START:
+    case SCHOICE_START:
+       for (p++; p->pe_type != PE_END; p = next_tpe (p)) {
+           if (!ISDTYPE(p))
+               continue;
+           if (ismatch(p, mod, cl, tag))
+               return (1);
+       }
+       return (0);
+
+    case SANY:
+       return (1);
+
+    case FN_CALL:
+    case ANY:
+       if (STAG(p) == -1)
+           return (1);
+       /* else fall through - not sure if this is needed */
+
+    default:
+       return (tag == TAG(p) && cl == CLASS(p));
+    }
+}
+
+/*
+ * find the data entry that goes with this DFLT_F entry
+ * bascially skip over any ETAGS that (an arbitary number but almost always 1)
+ */
+tpe    *
+fdflt_f(p)
+register tpe   *p;
+{
+    if (p->pe_type != DFLT_F)
+       ferr(1, "fdlt_f:Internal Error missing DFLT_F\n");
+    
+    for (p++; p->pe_type != PE_END; p++) {
+       if (p->pe_type != ETAG)
+               return (p);
+    }
+    ferr(1, "fdlt_f:Internal Error PE_END found\n");
+    /*NOTREACHED*/
+}
+
+/*
+ * find the DFLT_B entry
+ */
+tpe    *
+fdflt_b(p)
+register tpe   *p;
+{
+    for (p++; p->pe_type != PE_END; p++) {
+       if (p->pe_type == DFLT_B)
+               return (p);
+    }
+    ferr(1, "fdflt_b:Internal Error PE_END found\n");
+    /*NOTREACHED*/
+}
diff --git a/usr/src/contrib/isode/pepsy/vprint.c b/usr/src/contrib/isode/pepsy/vprint.c
new file mode 100644 (file)
index 0000000..54550b2
--- /dev/null
@@ -0,0 +1,757 @@
+/* vprint.c - pepy printer support */
+
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/vprint.c,v 7.4 91/02/22 09:50:15 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/vprint.c,v 7.4 91/02/22 09:50:15 mrose Interim $
+ *
+ *
+ * $Log:       vprint.c,v $
+ * Revision 7.4  91/02/22  09:50:15  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.3  90/12/23  18:42:12  mrose
+ * update
+ * 
+ * Revision 7.2  90/11/11  09:59:04  mrose
+ * touch-up
+ * 
+ * Revision 7.1  90/07/27  08:49:12  mrose
+ * update
+ * 
+ * Revision 7.0  90/07/01  19:54:34  mrose
+ * *** empty log message ***
+ * 
+ * Revision 7.0  89/11/23  22:12:08  mrose
+ * Release 6.0
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+/* LINTLIBRARY */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <varargs.h>
+#include "UNIV-types.h"
+#include "psap.h"
+#include "pepsy.h"
+#include "logger.h"
+
+
+int    fprintf ();
+
+/* \f   DATA */
+
+#define        VPRINT(s)       vprint1 (), vwrite ((s)), vprint2 ()
+
+static int vlevel = 0;
+
+static int didname = 0;
+static int didvpop = 0;
+static int didvpush = 0;
+static int docomma = 0;
+
+static char  *py_classlist[] = {
+    "UNIVERSAL", "APPLICATION", "", "PRIVATE"
+};
+
+static char *vbp = NULL;
+static char *vsp;
+
+IFP   vfnx = fprintf;
+FILE *vfp = stdout;
+static PS    vps = NULLPS;
+
+char   *oct2str (), *newbuf ();
+
+/* \f   VPUSH/VPOP */
+
+vpush () {
+    if (didvpush)
+       vwrite ("\n"), didvpush = 0;
+    else
+       if (!didname && docomma)
+           vwrite (",\n");
+
+    if (didname)
+       vwrite (" ");
+    else
+       if (vfp && vlevel > 0)
+           (*vfnx) (vfp, "%*s", vlevel * 3, "");
+    vwrite ("{");
+    vlevel++;
+
+    didname = didvpop = docomma = 0, didvpush = 1;
+}
+
+
+vpop () {
+    if (didname || docomma)
+       vwrite ("\n");
+
+    vlevel--;
+    if (!didvpush && vfp && vlevel > 0)
+       (*vfnx) (vfp, "%*s", vlevel * 3, "");
+    vwrite ("}");
+    if (vlevel == 0)
+       vwrite ("\n");
+
+    didname = didvpush = 0, didvpop = docomma = vlevel ? 1 : 0;
+}
+
+/* \f   VNAME/VTAG */
+
+vname (name)
+char   *name;
+{
+    if (didvpush)
+       vwrite ("\n"), didvpush = 0;
+    else
+       if (docomma)
+           vwrite (",\n");
+
+    if (vfp && vlevel > 0)
+       (*vfnx) (vfp, "%*s", vlevel * 3, "");
+    vwrite (name);
+
+    didname = 1;
+}
+
+
+vtag (class, id)
+int    class,
+       id;
+{
+    register char *bp;
+    static char buffer[BUFSIZ];
+
+    if (didname)
+       return;
+
+    bp = buffer;
+    *bp++ = '[';
+    switch (class) {
+       case PE_CLASS_UNIV: 
+       case PE_CLASS_APPL: 
+       case PE_CLASS_PRIV: 
+           (void) sprintf (bp, "%s ", py_classlist[class]);
+           bp += strlen (bp);
+           break;
+
+       case PE_CLASS_CONT: 
+       default:
+           break;
+    }
+    (void) sprintf (bp, "%d]", id);
+
+    vname (buffer);
+}
+
+/* \f   VPRINT */
+
+#ifndef        lint
+vprint (va_alist)
+va_dcl
+{
+    char    buffer[BUFSIZ];
+    va_list ap;
+    
+    vprint1 ();
+
+    va_start (ap);
+
+    _asprintf (buffer, NULLCP, ap);
+    
+    va_end (ap);
+
+    vwrite (buffer);
+
+    vprint2 ();
+}
+#else
+/* VARARGS */
+
+vprint (fmt)
+char   *fmt;
+{
+    vprint (fmt);
+}
+#endif
+
+
+static vprint1 ()
+{
+    if (didvpush) {
+       vwrite ("\n"), didvpush = 0;
+       goto indent;
+    }
+    else
+       if (didname)
+           vwrite (" ");
+       else {
+           if (docomma)
+               vwrite (",\n");
+indent: ;
+           if (vfp && vlevel > 0)
+               (*vfnx) (vfp, "%*s", vlevel * 3, "");
+       }
+}
+
+
+static vprint2 ()
+{
+    if (vlevel == 0)
+       vwrite ("\n");
+
+    didname = didvpop = 0, docomma = vlevel ? 1 : 0;
+}
+
+/* \f */
+
+static vwrite (s)
+char   *s;
+{
+    if (vfp)
+       (*vfnx) (vfp, "%s", s);
+    else {
+       register char   c,
+                      *cp;
+
+       if (vps)
+               for (cp = s; *cp; cp++) {
+                   if (*cp == '\n' )
+                           (void) ps_write (vps, (PElementData) " ", 1);
+                   else
+                           (void) ps_write (vps, (PElementData) cp, 1);
+               }
+       else
+               for (cp = s; *cp; )
+                   *vbp++ = (c = *cp++) != '\n' ? c : ' ';
+    }
+}
+
+/* \f   VSTRING */
+
+vstring (pe)
+register PE    pe;
+{
+    register PE            p;
+
+    switch (pe -> pe_form) {
+       case PE_FORM_PRIM: 
+       case PE_FORM_ICONS:
+           VPRINT (oct2str ((char *) pe -> pe_prim, (int) pe -> pe_len));
+           break;
+
+       case PE_FORM_CONS: 
+           vpush ();
+           for (p = pe -> pe_cons; p; p = p -> pe_next)
+               vstring (p);
+           vpop ();
+           break;
+    }
+}
+
+/* \f */
+
+static char   *oct2str (s, len)
+register char  *s;
+register int   len;
+{
+    int     ia5ok;
+    register int    k;
+    register char  *bp,
+                   *cp,
+                   *dp,
+                  *zp;
+
+    ia5ok = 1, k = 0;
+    for (dp = (cp = s) + len; cp < dp; cp++) {
+       switch (*cp) {
+           case ' ': 
+               continue;
+
+           case '"': 
+               break;
+
+           case '\b':
+           case '\f':
+           case '\n':
+           case '\r':
+           case '\t':
+           case '\\':
+               ia5ok = -1, k++;
+               continue;
+
+           case '-': 
+               if (cp > s && *(cp + 1) == '-')
+                   break;
+               continue;
+
+           default: 
+               if (iscntrl (*cp) || isspace (*cp) || (*cp & 0x80))
+                   break;
+               continue;
+       }
+       ia5ok = 0;
+       break;
+    }
+
+    switch (ia5ok) {
+       case 1: 
+           zp = newbuf (len + 2);
+           (void) sprintf (zp, "\"%*.*s\"", len, len, s);
+           break;
+
+       case -1: 
+           bp = zp = newbuf (len + k + 2);
+           *bp++ = '"';
+           for (cp = s; cp < dp; cp++)
+               if (*cp >= ' ' && *cp != '\\')
+                   *bp++ = *cp;
+               else {
+                   *bp++ = '\\';
+                   switch (*cp) {
+                       case '\b':
+                           *bp++ = 'b';
+                           break;
+                       case '\f':
+                           *bp++ = 'f';
+                           break;
+                       case '\n':
+                           *bp++ = 'n';
+                           break;
+                       case '\r':
+                           *bp++ = 'r';
+                           break;
+                       case '\t':
+                           *bp++ = 't';
+                           break;
+
+                       case '\\':
+                           *bp++ =  '\\';
+                           break;
+                   }
+               }
+           (void) sprintf (bp, "\"");
+           break;
+
+       case 0: 
+       default: 
+           bp = zp = newbuf (len * 2 + 3);
+           *bp++ = '\'';
+           for (cp = s; cp < dp; cp++) {
+               (void) sprintf (bp, "%02x", *cp & 0xff);
+               bp += strlen (bp);
+           }
+           (void) sprintf (bp, "'H");
+           break;
+    }
+
+    return zp;
+}
+
+/* \f */
+
+char   *bit2str (pe, s)
+PE     pe;
+char   *s;
+{
+    int     ia5ok;
+    register int    hit,
+                   i,
+                    j,
+                    k;
+    register char  *bp,
+                   *cp,
+                  *zp;
+
+    j = pe -> pe_nbits;
+    if ((cp = s) && *++cp) {
+       ia5ok = 1, hit = 0;
+       for (i = 0; i < j;)
+           if (bit_test (pe, i++) == 1) {
+               do {
+                   if (!(k = *cp++ & 0xff))
+                       break;
+                   if (k == i) {
+                       hit += hit ? 2 : 1;
+                       for (; *cp > ' '; cp++)
+                           hit++;
+                   }
+                   else
+                       for (; *cp > ' '; cp++)
+                           continue;
+               } while (k != 0 && k < i);
+               if (k == 0 || k > i) {
+                   ia5ok = 0;
+                   break;
+               }
+           }
+    }
+    else
+       ia5ok = 0;
+
+    if (ia5ok) {
+       bp = zp = newbuf (hit + 3);
+       *bp++ = '{';
+
+       cp = s, cp++;
+       for (i = hit = 0; i < j;)
+           if (bit_test (pe, i++) == 1) {
+               do {
+                   if (!(k = *cp++ & 0xff))
+                       break;
+                   if (k == i) {
+                       if (hit)
+                           *bp++ = ',';
+                       *bp++ = ' ';
+                       for (; *cp > ' '; cp++)
+                           *bp++ = *cp;
+                   }
+                   else
+                       for (; *cp > ' '; cp++)
+                           continue;
+               } while (k != 0 && k < i);
+               if (k == 0 || k > i)
+                   break;
+               hit++;
+           }
+
+       (void) sprintf (bp, "%s}", hit ? " " : "");
+    }
+    else {
+       bp = zp = newbuf (j + 3);
+       *bp++ = '\'';
+       for (i = 0; i < j; i++)
+           *bp++ = bit_test (pe, i) ? '1' : '0';
+       (void) sprintf (bp, "'B");
+    }
+
+    return zp;
+}
+
+/* \f */
+
+#ifdef vunknown
+#undef vunknown
+#endif
+
+vunknown (pe)
+register PE    pe;
+{
+    int     i;
+#ifdef notyet      /* could comment this in, but then all programs need -lm */
+    double  j;
+#endif
+    OID            oid;
+    register PE            p;
+
+    switch (pe -> pe_form) {
+       case PE_FORM_PRIM: 
+           switch (PE_ID (pe -> pe_class, pe -> pe_id)) {
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_BOOL): 
+                   if ((i = prim2flag (pe)) == NOTOK)
+                       goto bad_pe;
+                   VPRINT (i ? "TRUE" : "FALSE");
+                   break;
+
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_INT): 
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_ENUM): 
+                   if ((i = prim2num (pe)) == NOTOK
+                           && pe -> pe_errno != PE_ERR_NONE)
+                       goto bad_pe;
+                   vprint ("%d", i);
+                   break;
+
+#ifdef notyet
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_REAL): 
+                   if ((j = prim2real (pe)) == NOTOK
+                           && pe -> pe_errno != PE_ERR_NONE)
+                       goto bad_pe;
+                   vprint ("%g", j);
+                   break;
+#endif
+
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_BITS): 
+                   if ((p = prim2bit (pe)) == NULLPE)
+                       goto bad_pe;
+                   if (p -> pe_nbits < LOTSOFBITS) {
+                       VPRINT (bit2str (p, "\020"));
+                       break;
+                   }
+                   /* else fall... */
+
+               default: 
+           bad_pe: ;
+                   vtag ((int) pe -> pe_class, (int) pe -> pe_id);
+               /* fall */
+
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_OCTS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_IA5S): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_NUMS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_PRTS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_T61S): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_VTXS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_GENT): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_UTCT): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_GFXS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_VISS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_GENS): 
+               case PE_ID (PE_CLASS_UNIV, PE_DEFN_CHRS): 
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_ODE): 
+                   vstring (pe);
+                   break;
+
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_NULL):
+                   VPRINT ("NULL");
+                   break;
+
+               case PE_ID (PE_CLASS_UNIV, PE_PRIM_OID): 
+                   if ((oid = prim2oid (pe)) == NULLOID)
+                       goto bad_pe;
+                   VPRINT (oid2ode (oid));
+                   break;
+           }
+           break;
+
+       case PE_FORM_CONS: 
+           switch (PE_ID (pe -> pe_class, pe -> pe_id)) {
+               case PE_ID (PE_CLASS_UNIV, PE_CONS_SEQ):
+               case PE_ID (PE_CLASS_UNIV, PE_CONS_SET):
+                   break;
+
+               case PE_ID (PE_CLASS_UNIV, PE_CONS_EXTN):
+                   (void) print_UNIV_EXTERNAL (pe, 1, NULLIP, NULLVP,
+                                               NULLCP);
+                   return;
+
+               default:
+                   vtag ((int) pe -> pe_class, (int) pe -> pe_id);
+                   break;
+           }
+           vpush ();
+           for (p = pe -> pe_cons; p; p = p -> pe_next)
+               vunknown (p);
+           vpop ();
+           break;
+
+       case PE_FORM_ICONS:
+           vtag ((int) pe -> pe_class, (int) pe -> pe_id);
+           vstring (pe);
+           break;
+    }
+}
+
+/* \f   VPUSHFP/VPOPFP */
+
+vpushfp (fp, pe, s, rw)
+FILE   *fp;
+PE     pe;
+char   *s;
+int    rw;
+{
+    vpushpp ((caddr_t) fp, fprintf, pe, s, rw);
+}
+
+vsetfp (fp, s)
+FILE   * fp;
+char   * s;
+{
+    vfp = fp;
+    vfnx = fprintf;
+
+    if(s != NULLCP)
+       (*vfnx) (vfp, "%s\n", s);
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+}
+
+vpopfp ()
+{
+    (*vfnx) (vfp, "-------\n");
+    (void) fflush (vfp);
+
+    vpopp ();
+}
+
+/* \f   VPUSHSTR/VPOPSTR */
+
+vpushstr (cp)
+char   *cp;
+{
+    vfp = NULL;
+    vbp = vsp = cp;
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+}
+
+
+vpopstr ()
+{
+    while (--vbp >= vsp)
+       if (*vbp != ' ')
+           break;
+    *++vbp = NULL;
+
+    vfp = stdout;
+}
+
+/* \f   VPUSHPP */
+
+vpushpp (pv, pfnx, pe, text, rw)
+caddr_t pv;
+IFP    pfnx;
+register PE    pe;
+char   *text;
+int    rw;
+{
+    vfp = (FILE *) pv, vfnx = pfnx;
+
+    (*vfnx) (vfp, "%s %s", rw ? "read" : "wrote", text ? text : "pdu");
+    if (pe -> pe_context != PE_DFLT_CTX)
+       (*vfnx) (vfp, ", context %d", pe -> pe_context);
+    (*vfnx) (vfp, "\n");
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+}
+
+vpopp ()
+{
+    vfp = stdout, vfnx = fprintf;
+}
+
+
+vpushquipu (ps)
+PS     ps;
+{
+    vps = ps;
+    vfp = NULL;
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+}
+
+
+vpopquipu ()
+{
+       vpopp();
+       vps = NULLPS;
+}
+
+/* \f   PVPDU - for pepsy */
+
+#undef pvpdu
+
+pvpdu (lp, ind, mod, pe, text, rw)
+register LLog *lp;
+int    ind;            /* index into tables */
+modtyp *mod;           /* pointer to tables */
+register PE pe;
+char   *text;
+int    rw;
+{
+    register char   *bp;
+    char   buffer[BUFSIZ];
+
+    vfp = (FILE *) lp, vfnx = ll_printf;
+
+    bp = buffer;
+    (void) sprintf (bp, "%s %s", rw ? "read" : "wrote",
+                   text ? text : "pdu");
+    bp += strlen (bp);
+    if (pe -> pe_context != PE_DFLT_CTX) {
+       (void) sprintf (bp, ", context %d", pe -> pe_context);
+       bp += strlen (bp);
+    }
+    LLOG (lp, LLOG_ALL, ("%s", buffer));
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+
+    if (mod == NULL)
+        (void) vunknown (pe);
+    else
+        (void) prnt_f (ind, mod, pe, 1, NULLIP, NULLVP);
+
+    (void) ll_printf (lp, "-------\n");
+
+    (void) ll_sync (lp);
+
+    vfp = stdout, vfnx = fprintf;
+}
+
+/* \f   MISC */
+
+static char *bp = NULL;
+
+static char *newbuf (i)
+int    i;
+{
+    static unsigned int len = 0;
+
+    if (i++ < len)
+       return bp;
+
+    if (bp)
+       free (bp);
+    if ((bp = malloc ((unsigned int) i)))
+       len = i;
+    else
+       len = 0;
+
+    return bp;
+}
+/*  VPDU - support for backwards compatibility */
+
+_vpdu (lp, fnx, pe, text, rw)
+register LLog *lp;
+IFP    fnx;
+register PE pe;
+char   *text;
+int    rw;
+{
+    register char   *bp;
+    char   buffer[BUFSIZ];
+
+    vfp = (FILE *) lp, vfnx = ll_printf;
+
+    bp = buffer;
+    (void) sprintf (bp, "%s %s", rw ? "read" : "wrote",
+                   text ? text : "pdu");
+    bp += strlen (bp);
+    if (pe -> pe_context != PE_DFLT_CTX) {
+       (void) sprintf (bp, ", context %d", pe -> pe_context);
+       bp += strlen (bp);
+    }
+    LLOG (lp, LLOG_ALL, ("%s", buffer));
+
+    vlevel = didname = didvpush = didvpop = docomma = 0;
+
+    (void) (*fnx) (pe, 1, NULLIP, NULLVP, NULLCP);
+
+    (void) ll_printf (lp, "-------\n");
+
+    (void) ll_sync (lp);
+
+    vfp = stdout, vfnx = fprintf;
+}
+
+#ifdef PEP_TEST
+free_bp()
+{
+    if (bp)
+       free(bp);
+}
+#endif
diff --git a/usr/src/contrib/isode/pepsy/yacc.y.gnrc b/usr/src/contrib/isode/pepsy/yacc.y.gnrc
new file mode 100644 (file)
index 0000000..313a912
--- /dev/null
@@ -0,0 +1,1631 @@
+/* yacc.y - yacc ASN.1 parser */
+/* %WARNING% */
+
+%{
+#ifndef        lint
+static char *rcsid = "$Header: /f/osi/pepsy/RCS/yacc.y.gnrc,v 7.7 91/02/22 09:50:19 mrose Interim $";
+#endif
+
+/* 
+ * $Header: /f/osi/pepsy/RCS/yacc.y.gnrc,v 7.7 91/02/22 09:50:19 mrose Interim $
+ *
+ *
+ * $Log:       yacc.y.gnrc,v $
+ * Revision 7.7  91/02/22  09:50:19  mrose
+ * Interim 6.8
+ * 
+ * Revision 7.6  91/01/09  11:17:59  mrose
+ * pow
+ * 
+ * Revision 7.5  91/01/08  12:51:06  mrose
+ * update
+ * 
+ * Revision 7.4  90/12/23  18:42:15  mrose
+ * update
+ * 
+ * Revision 7.3  90/12/11  10:41:16  mrose
+ * sync
+ * 
+ * Revision 7.2  90/11/11  10:54:24  mrose
+ * update
+ * 
+ * Revision 7.1  90/11/04  19:17:31  mrose
+ * update
+ * 
+ * Revision 7.0  90/11/03  21:18:17  mrose
+ * *** empty log message ***
+ * 
+ */
+
+/*
+ *                               NOTICE
+ *
+ *    Acquisition, use, and distribution of this module and related
+ *    materials are subject to the restrictions of a license agreement.
+ *    Consult the Preface in the User's Manual for the full terms of
+ *    this agreement.
+ *
+ */
+
+
+#include <stdio.h>
+#include <ctype.h>
+%BEGIN(PEPSY)%
+#include "pepsydefs.h"
+%END(PEPSY)%
+%BEGIN(PEPY)%
+#include "pepy.h"
+%END(PEPY)%
+%BEGIN(ROSY)%
+#include "rosy-defs.h"
+%END(ROSY)%
+%BEGIN(MOSY)%
+#include "mosy-defs.h"
+%END(MOSY)%
+
+#define        YYSTYPE YYSTKTYPE
+
+
+#define        YYDEBUG 1
+
+extern int pepydebug;
+extern int doexternals;
+
+int    tagcontrol = TAG_UNKNOWN;
+static int     tagdefault;
+static int     listtype;
+static OID     modid;
+
+static int     yyporting = 0;
+
+typedef struct ypa {
+    char   *ya_text;
+    int            ya_lineno;
+}              ypa, *YA;
+#define        NULLYA  ((YA) 0)
+extern double pow ();
+
+%BEGIN(PEPSY)%
+/* encoding/decoding/printing/freeing functions */
+static char    *efn, *dfn, *pfn, *ffn;
+
+/*
+ * clear the ?fn variables for the next coding functions
+ */
+clrfn()
+{
+    if (efn) {
+       efn = NULLCP;
+    }
+    if (dfn) {
+       dfn = NULLCP;
+    }
+    if (pfn) {
+       pfn = NULLCP;
+    }
+    if (ffn) {
+       ffn = NULLCP;
+    }
+}
+
+%END(PEPSY)%
+
+static YA  new_action (text, lineno)
+char   *text;
+int    lineno;
+{
+    register YA            ya;
+
+    if ((ya = (YA) calloc (1, sizeof *ya)) == NULLYA)
+       yyerror ("out of memory");
+
+    ya -> ya_text = text;
+    ya -> ya_lineno = lineno;
+
+    return ya;
+}
+#define        free_action(ya) (void) free ((char *) (ya))
+
+typedef struct {
+    char *ys_structname;
+    char *ys_ptrname;
+} ysa, *YS;
+#define NULLYS ((YS) 0)
+
+static YS new_ys (str)
+char   *str;
+{
+    register YS        ys;
+    register char *p, *q;
+    char c;
+
+    if((ys = (YS) malloc (sizeof *ys)) == NULLYS)
+       yyerror ("out of memory");
+    q = str;
+    while (isspace (*q)) q++;
+    for (p = q; isalnum(*p) || *p == '_'; p++)
+       continue;
+    if (*p != '\0') {
+       c = *p;
+       *p = '\0';
+       ys -> ys_structname = new_string (q);
+       *p = c;
+    }
+    else {
+       ys -> ys_structname = new_string (q);
+       ys -> ys_ptrname = NULLCP;
+       free (str);
+       return ys;
+    }
+    for (q = p; *q != '$'; q++)
+       if (! *q) {
+           free (str);
+           ys -> ys_ptrname = NULLCP;
+           return ys;
+       }
+    q++;
+    while (isspace (*q)) q++;
+    for (p = q; isalnum(*p) || *p == '_'; p++)
+       continue;
+    *p = '\0';
+    ys -> ys_ptrname = new_string (q);
+    free (str);
+    return ys;
+}
+#define        free_ys(ys) (void) free ((char *) (ys))
+
+static int  final_actions = 0;
+static int  start_actions = 0;
+
+extern char    *malloc();
+
+char   *
+hex2bin (s, pi)
+register char   *s;
+int    *pi;
+{
+    register char *d;
+    char       *start;
+    register int    c,
+                   i;
+
+
+    if ((d = malloc(strlen(s)/2 + 2)) == NULLCP)
+       yyerror ("out of memory");
+    start = d;
+    for (i = 0; *s; i++) {
+       if ((c = *s++) >= 'a' && c <= 'f')
+           c -= 'a' - 0x0a;
+       else
+           if (c >= 'A' && c <= 'F')
+               c -= 'A' - 0x0a;
+           else
+               if (c >= '0' && c <= '9')
+                   c -= '0';
+               else
+                   c = 0;
+
+       if (i & 1)
+           *d++ |= c & 0xf;
+       else
+           *d = (c & 0xf) << 4;
+    }
+
+    *pi = i;   /* We use number semi-octets ! */
+    return start;
+}
+
+char   *
+bit2bin (s, pi)
+register char   *s;
+int    *pi;
+{
+    register char *d;
+    char       *start;
+    register int    c,
+                   shft,
+                   i;
+
+
+    if ((d = malloc(strlen(s)/8 + 2)) == NULLCP)
+       yyerror ("out of memory");
+    start = d;
+    *d = 0;
+    for (i = 0; *s; i++) {
+       if ((c = *s++) == '1')
+           c = 1;
+       else if (c == '0')
+           c = 0;
+       else
+           break;      /* ?? */
+
+       shft = 7 - i % 8;       /* shift to get to its bit */
+       *d |= c << shft;
+       if (shft == 0)  /* last bit in this octet so goto next octet */
+           *++d = 0;   /* initialise it to zero */
+    }
+
+    *pi = i;
+    return start;
+}
+
+bin2hex (s, d, len)
+register    u_char *s;
+register char  *d;
+int     len;
+{
+    register int    i,
+                   g;
+
+    for (i = 0; i < len; i++) {
+       g = s[i >> 1];
+       if ((i & 1) == 0)
+           g >>= 4;
+       g &= 0xf;
+
+       if (g < 0x0a)
+           *d++ = g + '0';
+       else
+           *d++ = g + 'a' - 0x0a;
+    }
+
+    *d = NULL;
+
+    return len;
+}
+
+int
+hex2int(s)
+register char  *s;
+{
+    register int       sum = 0;
+    register int               i;
+
+    while (*s) {
+       if (!isxdigit(*s))
+           break;
+       if (isdigit(*s))
+           i = *s - '0';
+       else
+           i = tolower(*s) - 'a' + 10;
+       sum = sum << 4 + i;
+       s++;
+    }
+
+    return (sum);
+}
+
+int
+bit2int(s)
+register char  *s;
+{
+    register int       sum = 0;
+    register int               i;
+
+    while (*s) {
+       if (*s != '0' && *s != '1')
+           break;
+       if (*s == '1')
+           sum <<= 1;
+       else
+           sum = sum << 1 + 1;
+       s++;
+    }
+    return (sum);
+}
+
+%}
+
+%start ModuleDefinition
+
+
+%union {
+    int            yy_number;
+    char   *yy_string;
+    YP     yy_type;
+    YV     yy_value;
+    YT     yy_tag;
+    YA     yy_action;
+    OID            yy_oid;
+    YS     yy_sctrl;
+    double  yy_real;
+%BEGIN(PEPSY)%
+    YFN     yy_yfn;
+    YAL     yy_yal;
+%END(PEPSY)%
+}
+
+
+%token  ABSENT ACTION ANY APPLICATION BAR BGIN BIT BITSTRING BOOLEAN
+       BSTRING BY CCE CHOICE COMMA COMPONENT COMPONENTS COMPONENTSOF
+       CONTROL DEC_FN DECODER DEFAULT DEFINED DEFINITIONS DOT DOTDOT
+       DOTDOTDOT ENC_FN ENCODER ENCRYPTED END ENUMERATED EXPORTS
+       EXPLICIT FALSE FRE_FN FROM HSTRING ID IDENTIFIER IMPLICIT
+       IMPORTS INCLUDES INTEGER LANGLE LBRACE LBRACKET LITNUMBER
+       LITSTRING LPAREN MIN MINUS MAX NAME NIL OBJECT OCTET
+       OCTETSTRING OF OPTIONAL PARAMETERTYPE PLUS PREFIXES PRESENT
+       PRINTER PRIVATE PRT_FN RBRACE RBRACKET REAL RPAREN STAR
+       SECTIONS SEMICOLON SEQUENCE SEQUENCEOF SET SETOF SIZE STRING
+       TAGS TRUE UNIVERSAL VALA VALB VALI VALS VALP VALO VALOID VALR
+       VALT VALTYPE VALQ VALX VLENGTH WITH SCTRL PLUSINFINITY
+       MINUSINFINITY
+%BEGIN(ROSY)%
+        OPERATION ARGUMENT RESULT ERRORS LINKED ERROR PARAMETER
+/* new stuff */
+       ABSTRACT OPERATIONS CONSUMER SUPPLIER INVOKES PORT PORTS
+       OBJECTCONSUMER OBJECTSUPPLIER REFINE AS RECURRING VISIBLE
+       PAIRED BIND UNBIND
+/* end new stuff */
+%END(ROSY)%
+%BEGIN(MOSY)%
+       OBJECTYPE SYNTAX ACCESS STATUS
+%END(MOSY)%
+%BEGIN(PEPSY)%
+       EACTION DACTION PACTION ECHOICE DCHOICE PCHOICE
+%END(PEPSY)%
+
+%type  <yy_number>     LITNUMBER 
+%type  <yy_number>     ABSENT ANY BGIN APPLICATION BIT BITSTRING
+                       BOOLEAN CHOICE COMPONENT COMPONENTS COMPONENTSOF
+                       DECODER DEFAULT DEFINED DEFINITIONS ENCODER 
+                       ENCRYPTED END ENUMERATED EXPLICIT EXPORTS
+                       FALSE FROM IDENTIFIER IMPLICIT IMPORTS INCLUDES
+                       INTEGER MIN MAX NIL OBJECT OCTET OCTETSTRING
+                       OF OPTIONAL PREFIXES PRESENT PRINTER PRIVATE REAL
+                       SECTIONS SEQUENCE SEQUENCEOF SET STRING TAGS
+                       TRUE UNIVERSAL WITH PLUSINFINITY MINUSINFINITY
+                       AnyType
+%type  <yy_real>       RealValue NumericRealValue SpecialRealValue
+%type   <yy_string>     DEC_FN ENC_FN PRT_FN FRE_FN ID NAME LITSTRING
+                       BSTRING HSTRING VALA VALB VALI VALS VALP VALQ
+                       VALR VALT VALTYPE VALO VALX VLENGTH VALOID
+                       CONTROL PARAMETERTYPE ParameterType Control
+                       ValParameter String PassInt PassBool PassOid
+                       PassAny PassReal ModuleIdentifier Symbol
+                       SymbolList SCTRL
+%type   <yy_type>       Type BuiltinType DefinedType PassValue PassBit
+                       PassString NullPass ElementTypes
+                       OptionalTypeList OptionalType NamedType
+                       ComponentsOf AlternativeTypeList MemberTypes
+                       SubType Valtype
+%BEGIN(ROSY)%
+                       Argument Result Parameter
+%END(ROSY)%
+%type   <yy_value>      NamedNumberList NamedNumber
+NumericValue
+                       Value BuiltinValue DefinedValue IdentifierList
+                       Values NamedValueList NamedValue NNlist
+%BEGIN(ROSY)%
+                       Errors ErrorNames LinkedOperations
+                       LinkedOperationNames
+%END(ROSY)%
+%BEGIN(MOSY)%
+                       ObjectID ObjectIDComponentList ObjectSubID
+%END(MOSY)%
+%BEGIN(PEPSY)%
+%type   <yy_yfn>        CodingFn
+%type   <yy_yal>        UAction CAction
+%type   <yy_action>    EACTION DACTION PACTION ECHOICE DCHOICE PCHOICE
+%END(PEPSY)%
+%type   <yy_tag>        Tag Class
+%type   <yy_action>     ACTION
+%type   <yy_oid>        ObjIdComponentList ObjectIdentifierValue
+                       ObjIdComponent NumberForm NameAndNumberForm
+%type   <yy_sctrl>      Sctrl
+%%
+
+ModuleDefinition:      ModuleIdentifier DEFINITIONS TagDefault CCE
+                               {
+                                   mymodule = $1;
+                                   mymoduleid = modid;
+                                   pass1 ();
+                               }
+                       ModuleActions ModulePrefixes { start_actions++; }
+                       BGIN ModuleBody END
+                       ModuleActions { pass2 (); final_actions++; }
+       ;
+
+TagDefault:            EXPLICIT TAGS { 
+                           tagdefault = 0;
+                           tagcontrol = TAG_EXPLICIT;
+                       }
+       |               IMPLICIT TAGS {
+                           tagdefault = YP_IMPLICIT;
+                           tagcontrol = TAG_IMPLICIT;
+                       }
+       |               empty {
+                           tagdefault = 0;
+                           tagcontrol = TAG_UNKNOWN;
+                       }
+       ;
+
+ModuleIdentifier:      ID AssignedIdentifier { $$ = $1; }
+       ;
+
+AssignedIdentifier:    ObjectIdentifierValue { modid = $1; }
+       |               empty
+       ;
+
+ModuleActions:         ACTION {
+%BEGIN(PEPSY)%
+                               { Action a;
+
+                                   if (start_actions) {
+                                       a = final_action = new_action_t();
+                                   } else {
+                                       a = start_action = new_action_t();
+                                   }
+                                   a->a_data = $1->ya_text;
+                                   a->a_line = $1->ya_lineno;
+                                   free_action ($1);
+                                   break;
+                                   /*NOTREACHED*/
+                               }
+%END(PEPSY)%
+                       /*
+%BEGIN(PEPY)%
+                           if (bflag) {
+                               if (final_actions) 
+                                   init_new_file ();
+                               else {
+                                   module_actions = $1 -> ya_text;
+                                   free_action ($1);
+                                   break;
+                               }
+                           }
+%END(PEPY)%
+                           if (!dflag) {
+                               if (Cflag > 0) {
+                                   if (!Pflag && *sysin)
+                                       (void) printf ("# line %d \"%s\"\n",
+                                               $1 -> ya_lineno, sysin);
+                                   fputs ($1 -> ya_text, stdout);
+                               }
+                               else {
+                                   (void) printf ("%%{\n#include \"%s-types.h\"\n",
+                                           mymodule);
+                                   (void) printf ("%s%%}\n", $1 -> ya_text);
+                                   Cflag = -1;
+                               }
+                           }
+                           free_action ($1);
+%BEGIN(PEPY)%
+                           if (bflag)
+                               end_file ();
+%END(PEPY)%
+                   */
+                       }
+       |               empty
+       ;
+ModulePrefixes:
+                       PREFIXES String String String
+                       {
+                           yyencdflt = $2;
+                           yydecdflt = $3;
+                           yyprfdflt = $4;
+                       }
+       |               empty
+       ;
+ModuleBody:            Exports Imports AssignmentList
+       ;
+
+Exports:               EXPORTS  { listtype = TBL_EXPORT; doexternals = 0;
+                                  yyporting = 1; }
+                                SymbolsExported SEMICOLON {
+                           yyporting = 0;
+                           if (mymoduleid == NULLOID)
+                               warning ("EXPORTS but no ModuleIdentifier");
+                               
+                       }
+       |               empty
+       ;
+
+SymbolsExported:       SymbolList
+       |               empty
+       ;
+
+Imports:               IMPORTS  { listtype = TBL_IMPORT; yyporting = 1; }
+                                SymbolsImported SEMICOLON {
+                           yyporting = 0;
+                           if (mymoduleid == NULLOID)
+                               warning ("IMPORTS but no ModuleIdentifier");
+                       }
+
+       |               empty
+       ;
+
+SymbolsImported:       SymbolsFromModuleList
+       |               empty
+       ;
+
+SymbolsFromModuleList: SymbolsFromModuleList SymbolsFromModule
+       |               SymbolsFromModule
+       ;
+
+SymbolsFromModule:     SymbolList FROM ModuleIdentifier
+                               {
+                                   addtableref ($3, modid, listtype);
+                               }
+       ;
+
+SymbolList:            SymbolList COMMA Symbol {
+                           addtable($3, listtype, ER_UNKNOWN);
+                       }
+       |               Symbol { addtable ($1, listtype, ER_UNKNOWN); }
+
+       |               SymbolList COMMA MINUS Symbol {
+                           addtable($4, listtype, ER_NORMAL);
+                       }
+       |               MINUS Symbol { addtable ($2, listtype, ER_NORMAL); }
+
+       |               SymbolList COMMA PLUS Symbol {
+                           addtable($4, listtype, ER_EXPLICIT);
+                       }
+       |               PLUS Symbol { addtable ($2, listtype, ER_EXPLICIT); }
+       ;
+
+Symbol:                        ID
+       |               NAME
+       ;
+
+AssignmentList:                AssignmentList Section Assignment
+       |               empty
+       ;
+
+Section:               ENCODER String
+                       { yysection = YP_ENCODER; yyencpref = $2;
+                         yyprint (NULLCP, 0, 1); }
+       |               DECODER String
+                       { yysection = YP_DECODER; yydecpref = $2;
+                         yyprint (NULLCP, 0, 1); }
+       |               PRINTER String
+                       { yysection = YP_PRINTER; yyprfpref = $2;
+                         yyprint (NULLCP, 0, 1); }
+       |               SECTIONS String String String
+                       {
+                           yysection = NULL;
+                           if (strcmp (yyencpref = $2, "none"))
+                               yysection |= YP_ENCODER;
+                           if (strcmp (yydecpref = $3, "none"))
+                               yysection |= YP_DECODER;
+                           if (strcmp (yyprfpref = $4, "none"))
+                               yysection |= YP_PRINTER;
+                           yyprint (NULLCP, 0, 1); 
+                       }
+       |               empty
+       ;
+
+String:                        ID { $$ = $1; }
+       |               NAME { $$ = $1; }
+       ;
+
+Assignment:            Typeassignment
+%BEGIN(ROSY)%
+       |               OperationDefinition
+       |               ErrorDefinition
+/* new stuff */
+       |               PortDefinition
+       |               ObjectDefinition
+/*     |               RefineDefinition        -- impossible!!!! (JPO) */
+/*     |               BindDefinition          -- lacking defs... */
+/*     |               UnBindDefinition        -- ditto */
+/* end new stuff */
+%END(ROSY)%
+%BEGIN(MOSY)%
+       |               ObjectTypeDefinition
+       |               ObjectIDefinition
+%END(MOSY)%
+       |               Valueassignment
+       ;
+
+%BEGIN(ROSY)%
+OperationDefinition:   NAME OPERATION Argument Result Errors LinkedOperations
+                       CCE LITNUMBER {
+                           pass1_op (mymodule, $1, $3, $4, $5, $6, $8);
+                       }
+       ;
+
+Argument:              ARGUMENT NamedType { $$ = $2; }
+       |               empty { $$ = NULLYP; }
+       ;
+
+Result:                        RESULT NamedType { $$ = $2; }
+       |               empty { $$ = NULLYP; }
+       ;
+
+Errors:                        ERRORS LBRACE ErrorNames RBRACE { $$ = $3; }
+       |               empty { $$ = NULLYV; }
+
+LinkedOperations:      LINKED LBRACE LinkedOperationNames RBRACE { $$ = $3; }
+       |               empty { $$ = NULLYV; }
+    
+
+ErrorNames:            NamedValueList {
+                           $$ = new_value (YV_VALIST);
+                           $$ -> yv_idlist = $1;
+                       }
+       |               empty { $$ = NULLYV; }
+
+
+LinkedOperationNames:  NamedValueList {
+                           $$ = new_value (YV_VALIST);
+                           $$ -> yv_idlist = $1;
+                       }
+       |               empty { $$ = NULLYV; }
+
+
+ErrorDefinition:       NAME ERROR Parameter CCE LITNUMBER {
+                           pass1_err (mymodule, $1, $3, $5);
+                       }
+       ;
+
+Parameter:             PARAMETER NamedType { $$ = $2; }
+       |               empty { $$ = NULLYP; }
+       ;
+
+/* new stuff start */
+PortDefinition:                NAME PORT PortOperations CCE PortValue
+       ;
+
+PortValue:             ObjectIdentifierValue
+       |               NAME
+       ;
+
+PortOperations:                PortSymmetrical
+       |               PortAsymetrical
+       |               empty
+
+PortSymmetrical:       ABSTRACT OPERATIONS LBRACE PortOperationList RBRACE
+       ;
+
+PortAsymetrical:       PortOneSided
+       |               PortTwoSided
+       ;
+
+PortOneSided:          PortConsumer
+       |               PortSupplier
+       ;
+
+PortTwoSided:          PortConsumer PortSupplier
+       |               PortSupplier PortConsumer
+       ;
+
+PortConsumer:          CONSUMER INVOKES LBRACE PortOperationList RBRACE
+       ;
+
+PortSupplier:          SUPPLIER INVOKES LBRACE PortOperationList RBRACE
+       ;
+
+PortOperationList:     OperationValue
+       |               OperationValue COMMA PortOperationList
+       ;
+
+OperationValue:                NAME
+       |               ID
+       |               LITNUMBER
+       |               ObjectIdentifierValue
+       ;
+
+ObjectDefinition:      NAME OBJECT ObjectType CCE PortValue
+       ;
+
+ObjectType:            PORTS LBRACE ObjectPortList RBRACE
+       |               empty
+       ;
+
+ObjectPortList:                ObjectPort COMMA ObjectPortList
+       |               ObjectPort
+       ;
+
+ObjectPort:            PortValue ObjectPortType
+       ;
+
+ObjectPortType:                ObjectSymetric
+       |               ObjectAsymetric
+       ;
+
+ObjectSymetric:                empty
+       ;
+
+ObjectAsymetric:       OBJECTCONSUMER
+       |               OBJECTSUPPLIER
+       ;
+
+/* New stuff end */
+%END(ROSY)%
+
+%BEGIN(MOSY)%
+ObjectTypeDefinition:  NAME OBJECTYPE SYNTAX NamedType ACCESS NAME
+                       STATUS NAME CCE ObjectID {
+                           pass1_obj (mymodule, $1, $4, $10, $6, $8);
+                       }
+       ;
+
+ObjectIDefinition:     NAME OBJECT IDENTIFIER CCE ObjectID {
+                           pass1_oid (mymodule, $1, $5);
+                       }
+       ;
+
+ObjectID:              NAME {
+                           $$ = new_value (YV_OIDLIST);
+                           $$ -> yv_idlist = new_value (YV_IDEFINED);
+                           $$ -> yv_idlist -> yv_identifier = $1;
+                           $$ -> yv_idlist -> yv_flags |= YV_BOUND;
+                       }
+       |               LBRACE ObjectIDComponentList RBRACE {
+                           $$ = new_value (YV_OIDLIST);
+                           $$ -> yv_idlist = $2;
+                       }
+       ;
+ObjectIDComponentList: ObjectSubID { $$ = $1; }
+       |               ObjectIDComponentList ObjectSubID {
+                           $$ = add_value ($1, $2);
+                       }
+       ;
+ObjectSubID:           LITNUMBER {
+                           $$ = new_value (YV_NUMBER);
+                           $$ -> yv_number = $1;
+                       }
+       |               NAME {
+                           $$ = new_value (YV_IDEFINED);
+                           $$ -> yv_identifier = $1;
+                           $$ -> yv_flags |= YV_BOUND;
+                       }
+       |               NAME LPAREN LITNUMBER RPAREN {
+                           $$ = new_value (YV_NUMBER);
+                           $$ -> yv_number = $3;
+                           $$ -> yv_named = $1;
+                           $$ -> yv_flags |= YV_NAMED;
+                       }
+       ;
+%END(MOSY)%
+%BEGIN(PEPSY)%
+UAction:               UAction EACTION {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_enc)
+                               yyerror("multiple encoding actions at the one place\n");
+                           $$->yal_enc = new_action_t($2->ya_text,
+                               $2->ya_lineno, e_actions++);
+                       }
+       |               UAction DACTION {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_dec)
+                               yyerror("multiple decoding actions at the one place\n");
+                           $$->yal_dec = new_action_t($2->ya_text, $2->ya_lineno, d_actions++);
+                       }
+       |               UAction PACTION {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_prn)
+                               yyerror("multiple printing actions at the one place\n");
+                           $$->yal_prn = new_action_t($2->ya_text, $2->ya_lineno, p_actions++);
+                       }
+       |               empty
+                       { $$ = NULLYAL; }
+       ;
+
+CAction:               CAction ECHOICE {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_enc)
+                               yyerror("multiple choice encoding actions at the one place\n");
+                           $$->yal_enc = new_action_t($2->ya_text,
+                               $2->ya_lineno, e_actions++);
+                       }
+       |               CAction DCHOICE {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_dec)
+                               yyerror("multiple choice decoding actions at the one place\n");
+                           $$->yal_dec = new_action_t($2->ya_text, $2->ya_lineno, d_actions ++);
+                       }
+       |               CAction PCHOICE {
+                           if ($1 == NULLYAL)
+                               $$ = new_yal();
+                           else
+                               $$ = $1;
+                           if ($$->yal_prn)
+                               yyerror("multiple choice printing actions at the one place\n");
+                           $$->yal_prn = new_action_t($2->ya_text, $2->ya_lineno, 0);
+                       }
+       |               empty
+                       { $$ = NULLYAL; }
+       ;
+
+%END(PEPSY)%
+
+Typeassignment:                ID ParameterType CCE UAction Type {
+                           if ($2)
+                               $5 -> yp_param_type = $2;
+                           if ($4)
+                               $5->yp_bef_alist=yal_join($4, $5->yp_bef_alist);
+                           pass1_type (yyencpref, yydecpref, yyprfpref,
+                                   mymodule, $1, $5);
+                       } ;
+
+Type:                  BuiltinType CodingFn UAction {
+                           $$ = $1;
+                           $$ -> yp_direction = yysection;
+                           if ($2)
+                               $$->yp_yfn = join_yfn($$->yp_yfn, $2);
+                           if ($3)
+                               $$->yp_aft_alist=yal_join($3, $$->yp_aft_alist);
+                       }
+       |               DefinedType CodingFn UAction {
+                           $$ = $1;
+                           $$ -> yp_direction = yysection;
+                           if ($2)
+                               $$->yp_yfn = join_yfn($$->yp_yfn, $2);
+                           if ($3)
+                               $$->yp_aft_alist=yal_join($3, $$->yp_aft_alist);
+                       }
+       |               SubType CodingFn UAction {
+                           $$ = $1;
+                           $$ -> yp_direction = yysection;
+                           if ($2)
+                               $$->yp_yfn = join_yfn($$->yp_yfn, $2);
+                           if ($3)
+                               $$->yp_aft_alist=yal_join($3, $$->yp_aft_alist);
+                       }
+       ;
+
+
+Control:               CONTROL
+       |               empty { $$ = NULLCP; }
+       ;
+
+ParameterType:         PARAMETERTYPE
+       |               empty { $$ = NULLCP; }
+       ;
+
+Valtype:               VALTYPE {
+                           $$ = new_type(YP_UNDF, -1);
+                           if (setvaltype($$, $1) == 0)
+                               yyerror("syntax error in [[ T ... ]]");
+                           free($1);
+                       }
+       |               empty { $$ = new_type(YP_UNDF, -1); }
+       ;
+
+BuiltinType:           BOOLEAN PassBool {
+                           $$ = new_type (YP_BOOL, $1);
+                           $$ -> yp_intexp = $2;
+                       }
+       |               INTEGER PassInt NNlist {
+                           $$ = new_type ($3 ? YP_INTLIST : YP_INT, $1);
+                           $$ -> yp_intexp = $2;
+                           if ($3)
+                                   $$ -> yp_value = $3;
+                       }
+       |               ENUMERATED PassInt LBRACE NamedNumberList
+                           RBRACE {
+                           $$ = new_type (YP_ENUMLIST, $1);
+                           $$ -> yp_intexp = $2;
+                           $$ -> yp_value = $4;
+                       }
+
+       |               Bitstring PassBit NNlist {
+                           $$ = $2;
+                           $$ -> yp_code = $3 ? YP_BITLIST: YP_BIT;
+                           if ($3)
+                               $$ -> yp_value = $3;
+                       }
+       |               Octetstring PassString {
+                           $$ = $2;
+                           $$ -> yp_code = YP_OCT;
+                       }
+       |               NIL {
+                           $$ = new_type (YP_NULL, $1);
+                       }
+       |               SEQUENCE Sctrl PassAny {
+                           $$ = new_type (YP_SEQ, $1);
+                           $$ -> yp_strexp = $3;
+                       }
+       |               SequenceOf Sctrl Valtype Control UAction Type {
+                           $$ = $3;
+                           $$->yp_code = YP_SEQTYPE;
+                           $$ -> yp_type = $6;
+                           if ($2) {
+                               $$ -> yp_structname = $2 -> ys_structname;
+                               $$ -> yp_ptrname = $2 -> ys_ptrname;
+                               free_ys ($2);
+                           }
+                           if ($4) {
+                               $$ -> yp_control = $4;
+                               $$ -> yp_flags |= YP_CONTROLLED;
+                           }
+                           if ($5)
+                               $6->yp_bef_alist=yal_join($5, $6->yp_bef_alist);
+                       }
+       |       SEQUENCE Sctrl Valtype LBRACE UAction ElementTypes RBRACE {
+                           $$ = $3;
+                           $$->yp_code = YP_SEQLIST;
+                           $$ -> yp_type = $6;
+                           if ($2) {
+                                $$ -> yp_structname = $2 -> ys_structname;
+                                $$ -> yp_ptrname = $2 -> ys_ptrname;
+                                free_ys ($2);
+                            }
+                           if ($6 && $5)
+                               $6->yp_bef_alist=yal_join($5, $6->yp_bef_alist);
+                       }
+       |               SET Sctrl PassAny {
+                           $$ = new_type (YP_SET, $1);
+                           $$ -> yp_strexp = $3;
+                       }
+       |               SetOf Sctrl Valtype Control UAction Type {
+                           $$ = $3;
+                           $$->yp_code = YP_SETTYPE;
+                           $$ -> yp_type = $6;
+                           if ($2) {
+                               $$ -> yp_structname = $2 -> ys_structname;
+                               $$ -> yp_ptrname = $2 -> ys_ptrname;
+                               free_ys ($2);
+                           }
+                           if ($4) {
+                               $$ -> yp_control = $4;
+                               $$ -> yp_flags |= YP_CONTROLLED;
+                           }
+                           if ($5)
+                               $6->yp_bef_alist=yal_join($5, $6->yp_bef_alist);
+                       }
+
+       |               SET Sctrl Valtype LBRACE UAction MemberTypes RBRACE {
+                           $$ = $3;
+                           $$->yp_code = YP_SETLIST;
+                           $$ -> yp_type = $6;
+                           if ($2) {
+                               $$ -> yp_structname = $2 -> ys_structname;
+                               $$ -> yp_ptrname = $2 -> ys_ptrname;
+                               free_ys ($2);
+                           }
+                           if ($6 && $5)
+                               $6->yp_bef_alist=yal_join($5, $6->yp_bef_alist);
+                       }
+       |               Tag UAction IMPLICIT Type {
+                           $$ = $4;
+                           $$ -> yp_tag = $1;
+                           $$ -> yp_flags |= (YP_IMPLICIT | YP_TAG);
+                           if ($2)
+                               $$->yp_bef_alist=yal_join($2, $$->yp_bef_alist);
+                       }
+       |               Tag UAction EXPLICIT Type {
+                           $$ = $4;
+                           $$ -> yp_tag = $1;
+                           $$ -> yp_flags |= YP_TAG;
+                           if ($2)
+                               $$->yp_bef_alist=yal_join($2, $$->yp_bef_alist);
+                       }
+       |               Tag UAction Type {
+                           $$ = $3;
+                           $$ -> yp_tag = $1;
+                           $$ -> yp_flags |= (YP_TAG| tagdefault);
+                           if ($2)
+                               $$->yp_bef_alist=yal_join($2, $$->yp_bef_alist);
+                       }
+       |               CHOICE Sctrl Valtype Control CAction LBRACE UAction
+                                       AlternativeTypeList RBRACE {
+                           $$ = $3;
+                           $$->yp_code = YP_CHOICE;
+                           $$ -> yp_type = $8;
+                           if ($2) {
+                               $$ -> yp_structname = $2 -> ys_structname;
+                               $$ -> yp_ptrname = $2 -> ys_ptrname;
+                               free_ys ($2);
+                           }
+                           if ($4) {
+                               $$ -> yp_control = $4;
+                               $$ -> yp_flags |= YP_CONTROLLED;
+                           }
+                           if ($5)
+                               $$ -> yp_control_act = $5;
+                           if ($8 && $7)
+                               $8->yp_bef_alist=yal_join($7, $8->yp_bef_alist);
+                       }
+       |               NAME LANGLE Type {
+                           $$ = $3;
+                           $$ -> yp_bound = $1;
+                           $$ -> yp_flags |= YP_BOUND;
+                       }
+       |               AnyType PassAny {
+                           $$ = new_type (YP_ANY, $1);
+                           $$ -> yp_strexp = $2;
+                       }
+       |               STAR AnyType PassAny {
+                           $$ = new_type (YP_ANY, $2);
+                           $$ -> yp_strexp = $3;
+                           $$ -> yp_flags |= YP_WANTIMPLICIT;
+                       }
+       |               OBJECT IDENTIFIER PassOid {
+                           $$ = new_type (YP_OID, $1);
+                           $$ -> yp_strexp = $3;
+                       }
+       |               ENCRYPTED Type {
+                           $$ = $2;
+                           $$ -> yp_tag = new_tag (PE_CLASS_UNIV);
+                           $$ -> yp_tag -> yt_value = new_value(YV_NUMBER);
+                           $$ -> yp_tag -> yt_value -> yv_number = PE_PRIM_ENCR;
+                           $$ -> yp_flags |=
+                               (YP_ENCRYPTED | YP_TAG | YP_IMPLICIT);
+                       }
+       |               REAL PassReal {
+                           $$ = new_type(YP_REAL, $1);
+                           $$ -> yp_strexp = $2;
+                       }
+       ;
+
+NNlist:                        LBRACE NamedNumberList RBRACE { $$ = $2; }
+       |               empty { $$ = NULL; }
+       ;
+DefinedType:           ID PassValue ValParameter {
+                           $$ = $2;
+                           $$ -> yp_code = YP_IDEFINED;
+                           $$ -> yp_identifier = $1;
+                           if ($3) {
+                               $$ -> yp_parm = $3;
+                               $$ -> yp_flags |= YP_PARMVAL;
+                           }
+%BEGIN(ROSY)%
+#ifndef        lint
+%END(ROSY)%
+                           check_impexp ($$);
+%BEGIN(ROSY)%
+#endif
+%END(ROSY)%
+                       }
+       |               ID DOT ID PassValue ValParameter {
+                           $$ = $4;
+                           $$ -> yp_code = YP_IDEFINED;
+                           $$ -> yp_identifier = $3;
+                           $$ -> yp_module = $1;
+                           if ($5) {
+                               $$ -> yp_parm = $5;
+                               $$ -> yp_flags |= YP_PARMVAL;
+                           }
+                       }
+       ;
+
+PassValue:             VALA {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'a';
+                       }
+       |               VALB {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $1;
+                           $$ -> yp_strexp = NULLCP;
+                           $$ -> yp_prfexp = 'b';
+                       }
+       |               VALI {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $1;
+                           $$ -> yp_strexp = NULLCP;
+                           $$ -> yp_prfexp = 'i';
+                       }
+       |               VALX VLENGTH {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $2;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'x';
+                       }
+       |               VALOID {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'O';
+                       }
+       |               VALR  {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'r';
+                       }
+       |               VALT  {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $1;
+                           $$ -> yp_prfexp = 't';
+                       }
+       |               PassString
+       ;
+
+AnyType:               ANY
+       |               ANY DEFINED BY NAME
+       ;
+                       
+PassOid:               VALOID
+       |               empty { $$ = NULLCP; }
+       ;
+
+PassAny:               VALA
+       |               empty { $$ = NULLCP; }
+       ;
+
+PassBool:              VALB
+       |               empty { $$ = NULLCP; }
+       ;
+
+PassInt:               VALI
+       |               empty { $$ = NULLCP; }
+       ;
+
+PassBit:               VALX VLENGTH {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $2;
+                           $$ -> yp_strexp = $1;
+                       }
+       |               VALT {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $1;
+                           $$ -> yp_strexp = NULLCP;
+                       }
+       |               NullPass
+       ;
+
+PassString:            VALS {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 's';
+                       }
+       |               VALO VLENGTH {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = $2;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'o';
+                       }
+       |               VALQ {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = $1;
+                           $$ -> yp_prfexp = 'q';
+                       }
+       |               NullPass
+       ;
+
+PassReal:              VALR 
+       |               empty { $$ = NULLCP; }
+       ;
+
+NullPass:              empty {
+                           $$ = new_type (YP_UNDF, -1);
+                           $$ -> yp_intexp = NULLCP;
+                           $$ -> yp_strexp = NULLCP;
+                       }
+       ;
+
+CodingFn:              fnlist {
+                           $$ = new_yfn(efn, dfn, pfn, ffn);
+                           clrfn();
+                       }
+       |               { $$ = NULLYFN; }
+       ;
+
+fn:            ENC_FN  {
+                   if (efn)
+                       myyerror("extra encoding function %s ignored\n", $1);
+                   else
+                       efn = $1;
+               }
+       |       DEC_FN {
+                   if (dfn)
+                       myyerror("extra decoding function %s ignored\n", $1);
+                   else
+                       dfn = $1;
+               }
+       |       PRT_FN {
+                   if (pfn)
+                       myyerror("extra printing function %s ignored\n", $1);
+                   else
+                       pfn = $1;
+               }
+       |       FRE_FN {
+                   if (ffn)
+                       myyerror("extra freeing function %s ignored\n", $1);
+                   else
+                       ffn = $1;
+               }
+       ;
+
+fnlist:                fn
+       |       fnlist fn
+
+ValParameter:          VALP
+       |               empty { $$ = NULLCP; }
+       ;
+
+NamedNumberList:       NamedNumber { $$ = $1; }
+       |               NamedNumberList COMMA NamedNumber {
+                           $$ = add_value ($1, $3);
+                       }
+       ;
+NamedNumber:           NAME LPAREN NumericValue RPAREN {
+                           $$ = $3;
+                           $$ -> yv_named = $1;
+                           $$ -> yv_flags |= YV_NAMED;
+                       }
+       ;
+NumericValue:          LITNUMBER {
+                           $$ = new_value (YV_NUMBER);
+                           $$ -> yv_number = $1;
+                       }
+       |               DefinedValue
+       ;
+
+ElementTypes:          OptionalTypeList { $$ = $1; }
+       |               empty { $$ = NULLYP; }
+       ;
+MemberTypes:           OptionalTypeList { $$ = $1; }
+
+       |               empty { $$ = NULLYP; }
+       ;
+OptionalTypeList:      OptionalType { $$ = $1; }
+       |               OptionalTypeList COMMA UAction OptionalType {
+                           if ($3)
+                               $4->yp_bef_alist=yal_join($3, $4->yp_bef_alist);
+                           $$ = add_type ($1, $4);
+                       }
+       ;
+OptionalType:          NamedType { $$ = $1; }
+       |               NamedType OPTIONAL Control {
+                           $$ = $1;
+                           $$ -> yp_flags |= YP_OPTIONAL;
+                           if ($3) {
+                               $$ -> yp_optcontrol = $3;
+                               $$ -> yp_flags |= YP_OPTCONTROL;
+                           }
+                       }
+       |               NamedType OPTIONAL CAction {
+                           $$ = $1;
+                           $$ -> yp_flags |= YP_OPTIONAL;
+                           if ($3) {
+                               $$ -> yp_flags |= YP_OPTCONTROL;
+                               $$ -> yp_optional_act = $3;
+                           }
+                       }
+       |               NamedType DEFAULT Value Control {
+                           $$ = $1;
+                           $$ -> yp_default = $3;
+                           $$ -> yp_flags |= YP_DEFAULT;
+                           if ($4) {
+                               $$ -> yp_optcontrol = $4;
+                               $$ -> yp_flags |= YP_OPTCONTROL;
+                           }
+                       }
+       |               ComponentsOf { $$ = $1; }
+       |               NAME ComponentsOf { $$ = $2; $$->yp_id = $1; }
+       ;
+NamedType:             NAME Type {
+                           $$ = $2;
+                           $$ -> yp_id = $1;
+                           $$ -> yp_flags |= YP_ID;
+                       }
+       |               Type { $$ = $1; }
+       ;
+ComponentsOf:          Components Type {
+                           $$ = $2;
+                           $$ -> yp_flags |= YP_COMPONENTS;
+                       }
+       ;
+AlternativeTypeList:   NamedType { $$ = $1; }
+       |               AlternativeTypeList COMMA UAction NamedType {
+                           if ($3)
+                               $4->yp_bef_alist=yal_join($3, $4->yp_bef_alist);
+                           $$ = add_type ($1, $4);
+                       }
+       ;
+
+Tag:                   LBRACKET Class NumericValue RBRACKET {
+                           $$ = $2;
+                           $$ -> yt_value = $3;
+                       }
+       ;
+Class:                 UNIVERSAL { $$ = new_tag (PE_CLASS_UNIV); }
+       |               APPLICATION { $$ = new_tag (PE_CLASS_APPL); }
+       |               PRIVATE { $$ = new_tag (PE_CLASS_PRIV); }
+       |               empty { $$ = new_tag (PE_CLASS_CONT); }
+       ;
+
+
+Valueassignment:       NAME Type CCE Value
+       ;
+
+Value:                 BuiltinValue
+       |               DefinedValue
+       ;
+BuiltinValue:          TRUE {
+                           $$ = new_value (YV_BOOL);
+                           $$ -> yv_number = 1;
+                       }
+       |               FALSE {
+                           $$ = new_value (YV_BOOL);
+                           $$ -> yv_number = 0;
+                       }
+       |               LITNUMBER {
+                           $$ = new_value (YV_NUMBER);
+                           $$ -> yv_number = $1;
+                       }
+       |               BSTRING {
+                           $$ = new_value (YV_BSTRING);
+                           $$ -> yv_xstring = bit2bin($1, &$$->yv_xlength);
+                           free($1);
+                       }
+       |               HSTRING {
+                           $$ = new_value (YV_HSTRING);
+                           $$ -> yv_xstring = hex2bin($1, &$$->yv_xlength);
+                           free($1);
+                       }
+       |               LBRACE ID IdentifierList RBRACE {
+                           $$ = new_value (YV_IDLIST);
+                           $$ -> yv_idlist = new_value (YV_IDEFINED);
+                           $$ -> yv_idlist -> yv_identifier = $2;
+                           if ($3)
+                               $$ = add_value ($$, $3);
+                       }
+       |               LITSTRING {
+                           $$ = new_value (YV_STRING);
+                           $$ -> yv_string = $1;
+                       }
+       |               NIL { $$ = new_value (YV_NULL); }
+       |               LBRACE Values RBRACE {
+                           $$ = new_value (YV_VALIST);
+                           $$ -> yv_idlist = $2;
+                       }
+       |               NAME Value {
+                           $$ = $2;
+                           $$ -> yv_id = $1;
+                           $$ -> yv_flags |= YV_ID;
+                       }
+       |               Type Value {
+                           $$ = $2;
+                           $$ -> yv_type = $1;
+                           $$ -> yv_flags |= YV_TYPE;
+                       }
+       |               RealValue {
+                           $$ = new_value (YV_REAL);
+                           $$ -> yv_real = $1;
+                       }
+       ;
+
+RealValue:             NumericRealValue
+       |               SpecialRealValue
+       ;
+
+SpecialRealValue:      PLUSINFINITY { $$ = PE_REAL_INFINITY;} 
+       |               MINUSINFINITY { $$ = - PE_REAL_INFINITY; }
+       ;
+
+NumericRealValue:      LBRACE LITNUMBER COMMA LITNUMBER COMMA
+                                LITNUMBER RBRACE {
+                               if ($4 != 2 && $4 != 10)
+                                       myyerror ("Illegal base value %d", $4);
+                               $$ = $2 * pow ((double)$4, (double)$6);
+                       }
+       ;
+
+DefinedValue:          ID {
+                           $$ = new_value (YV_IDEFINED);
+                           $$ -> yv_identifier = $1;
+                       }
+       |               NAME {  /* XXX */
+                           $$ = new_value (YV_IDEFINED);
+                           $$ -> yv_identifier = $1;
+                           $$ -> yv_flags |= YV_BOUND;
+                       }
+       |               ID DOT ID {
+                           $$ = new_value (YV_IDEFINED);
+                           $$ -> yv_identifier = $3;
+                           $$ -> yv_module = $1;
+                       }
+       ;
+
+IdentifierList:                IdentifierList COMMA ID {
+                           $$ = new_value (YV_IDEFINED);
+                           $$ -> yv_identifier = $3;
+                           if ($1)
+                               $$ = add_value ($1, $$);
+                       }
+       |               empty { $$ = NULLYV; }
+       ;
+
+Values:                        NamedValueList { $$ = $1; }
+       |               empty { $$ = NULLYV; }
+       ;
+NamedValueList:                NamedValue { $$ = $1; }
+       |               NamedValueList COMMA NamedValue {
+                           $$ = add_value ($1, $3);
+                       }
+       ;
+NamedValue:            Value { $$ = $1; }
+       ;
+
+empty: ;
+
+Octetstring:           OCTET STRING
+       |               OCTETSTRING
+       ;
+
+Bitstring:             BITSTRING
+       |               BIT STRING
+       ;
+
+SequenceOf:            SEQUENCEOF
+       |               SEQUENCE OF
+       ;
+SetOf:                 SETOF
+       |               SET OF
+       ;
+Components:            COMPONENTSOF
+       |               COMPONENTS OF
+       ;
+
+ObjectIdentifierValue: LBRACE ObjIdComponentList RBRACE
+                       { $$ = $2; }
+       ;
+
+ObjIdComponentList:    ObjIdComponent
+       |               ObjIdComponentList ObjIdComponent
+                       {
+                               $$ = addoid($1, $2);
+                               oid_free ($1);
+                               oid_free ($2);
+                       }
+       ;
+
+ObjIdComponent:                NumberForm
+       |               NameAndNumberForm
+       ;
+
+NumberForm:            LITNUMBER { $$ = int2oid ($1); }
+       |               DefinedValue {
+                               $$ = oidlookup($1->yv_identifier);
+                               free((char *)$1);
+                       }
+       ;
+
+NameAndNumberForm:     NAME LPAREN NumberForm RPAREN {
+                               free ($1);
+                               $$ = $3;
+                       }
+       ;
+
+SubType:               Type SubtypeSpec
+       |               SET SizeConstraint OF Sctrl UAction Control Type {
+                           $$ = new_type (YP_SETTYPE, $1);
+                           $$ -> yp_type = $7;
+                           if ($4) {
+                               $$ -> yp_structname = $4 -> ys_structname;
+                               $$ -> yp_ptrname = $4 -> ys_ptrname;
+                               free_ys ($4);
+                           }
+                           if ($6) {
+                               $$ -> yp_control = $6;
+                               $$ -> yp_flags |= YP_CONTROLLED;
+                           }
+                           if ($5)
+                               $7->yp_bef_alist=yal_join($5, $7->yp_bef_alist);
+                       }
+
+       |               SEQUENCE SizeConstraint OF Sctrl UAction Control Type {
+                           $$ = new_type (YP_SEQTYPE, $1);
+                           $$ -> yp_type = $7;
+                           if ($4) {
+                               $$ -> yp_structname = $4 -> ys_structname;
+                               $$ -> yp_ptrname = $4 -> ys_ptrname;
+                               free_ys ($4);
+                           }
+                           if ($6) {
+                               $$ -> yp_control = $6;
+                               $$ -> yp_flags |= YP_CONTROLLED;
+                           }
+                           if ($5)
+                               $7->yp_bef_alist=yal_join($5, $7->yp_bef_alist);
+                       }
+       ;
+
+SubtypeSpec:           LPAREN SubtypeAlternative SubtypeAlternativeList RPAREN
+       ;
+
+SubtypeAlternative:    SubtypeValueSet
+       |               SubtypeConstraint
+       ;
+
+SubtypeAlternativeList:        BAR SubtypeAlternative SubtypeAlternativeList
+       |               empty
+       ;
+
+SubtypeValueSet:       Value
+       |               ContainedSubType
+       |               ValueRange
+       |               PermittedAlphabet
+       ;
+
+SubtypeConstraint:     SizeConstraint
+       |               InnerTypeConstraint
+       ;
+
+ContainedSubType:      INCLUDES Type   ;
+
+ValueRange:            LowerEndPoint DOTDOT UpperEndpoint
+       ;
+
+LowerEndPoint:         LowerEndValue
+       |               LowerEndValue LANGLE
+       ;
+
+UpperEndpoint:         UpperEndValue
+       |               LANGLE UpperEndValue
+       ;
+
+LowerEndValue:         Value
+       |               MIN
+       ;
+
+UpperEndValue:         Value
+       |               MAX
+       ;
+
+SizeConstraint:                SIZE SubtypeSpec
+       ;
+
+PermittedAlphabet:     FROM SubtypeSpec
+       ;
+
+InnerTypeConstraint:   WITH COMPONENT SingleTypeConstraint
+       |               WITH COMPONENTS MultipleTypeConstraints
+       ;
+
+SingleTypeConstraint:  SubtypeSpec
+       ;
+
+MultipleTypeConstraints:FullSpecification
+       |               PartialSpecification
+       ;
+
+FullSpecification:     LBRACE TypeConstraints RBRACE
+       ;
+
+PartialSpecification:  LBRACE DOTDOTDOT COMMA TypeConstraints RBRACE
+       ;
+
+TypeConstraints:       NamedConstraint
+       |               NamedConstraint COMMA TypeConstraints
+       ;
+
+NamedConstraint:       NAME Constraint
+       |               Constraint
+       ;
+
+Constraint:            ValueConstraint
+       |               PresenceConstraint
+       |               empty
+       ;
+
+ValueConstraint:       SubtypeSpec
+       ;
+
+PresenceConstraint:    PRESENT
+       |               ABSENT
+       ;
+
+Sctrl:                 SCTRL { $$ = new_ys ($1); }
+       |               empty { $$ = NULLYS; }
+       ;
+%%
+
+#ifdef HPUX
+#define        uchar   Uchar
+#endif
+#include "lex.c"