summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lang/snobol/Makefile11
-rw-r--r--lang/snobol/files/patch-ad11
-rw-r--r--lang/snobol/files/patch-ae2285
3 files changed, 2307 insertions, 0 deletions
diff --git a/lang/snobol/Makefile b/lang/snobol/Makefile
index 1e4878a..e70eced 100644
--- a/lang/snobol/Makefile
+++ b/lang/snobol/Makefile
@@ -6,6 +6,7 @@
PORTNAME= snobol
PORTVERSION= 0.99.4
+PORTREVISION= 1
CATEGORIES= lang
MASTER_SITES= ftp://ftp.snobol4.com/
@@ -14,4 +15,14 @@ COMMENT= 0.99.4 release of ``The Macro Implementation of SNOBOL4 in C''
MAN1= snobol4.1
+# Fix GCC 3.x from freaking out over some of our pointers.
+#
+# I had to patch gendata.sno, so I patched the changes it produces
+# in res.h as well. To keep the port from trying to run gendata.sno
+# (with your potentially nonexistant snobol compiler), touch it
+# back to it's original mod time.
+
+post-patch:
+ touch -t 199705212205.21 ${WRKSRC}/gendata.sno
+
.include <bsd.port.mk>
diff --git a/lang/snobol/files/patch-ad b/lang/snobol/files/patch-ad
new file mode 100644
index 0000000..37c993a
--- /dev/null
+++ b/lang/snobol/files/patch-ad
@@ -0,0 +1,11 @@
+--- gendata.sno.orig Wed May 21 22:05:21 1997
++++ gendata.sno Tue Jun 3 09:29:43 2003
+@@ -105,7 +105,7 @@
+ MK_LBL0 IDENT(PREV) :S(MK_LBL1)
+ RES.H = IND 'struct ' PREVTYPE ' ' LCPREV '[' SIZE '];'
+ * output char address of res element (since CPA is 1)!
+- RES.H = '#define ' PREV TAB '((char *)' RES '.' LCPREV ')'
++ RES.H = '#define ' PREV TAB '((void *)' RES '.' LCPREV ')'
+ PREV =
+
+ MK_LBL1 RES.H = DIFFER(HERE) '#define ' HERE TAB NAME
diff --git a/lang/snobol/files/patch-ae b/lang/snobol/files/patch-ae
new file mode 100644
index 0000000..87e214a
--- /dev/null
+++ b/lang/snobol/files/patch-ae
@@ -0,0 +1,2285 @@
+--- res.h.orig Tue Jun 3 20:18:12 2003
++++ res.h Tue Jun 3 20:16:09 2003
+@@ -2,1526 +2,1526 @@
+
+ struct res {
+ struct descr dtlist[21];
+-#define DTLIST ((char *)res.dtlist)
++#define DTLIST ((void *)res.dtlist)
+ #define DTLEND KNLIST
+ struct descr knlist[1];
+-#define KNLIST ((char *)res.knlist)
++#define KNLIST ((void *)res.knlist)
+ struct descr trimcl[2];
+-#define TRIMCL ((char *)res.trimcl)
++#define TRIMCL ((void *)res.trimcl)
+ struct descr trapcl[2];
+-#define TRAPCL ((char *)res.trapcl)
++#define TRAPCL ((void *)res.trapcl)
+ struct descr exlmcl[2];
+-#define EXLMCL ((char *)res.exlmcl)
++#define EXLMCL ((void *)res.exlmcl)
+ struct descr outsw[2];
+-#define OUTSW ((char *)res.outsw)
++#define OUTSW ((void *)res.outsw)
+ struct descr mlencl[2];
+-#define MLENCL ((char *)res.mlencl)
++#define MLENCL ((void *)res.mlencl)
+ struct descr insw[2];
+-#define INSW ((char *)res.insw)
++#define INSW ((void *)res.insw)
+ struct descr fullcl[2];
+-#define FULLCL ((char *)res.fullcl)
++#define FULLCL ((void *)res.fullcl)
+ struct descr tracl[2];
+-#define TRACL ((char *)res.tracl)
++#define TRACL ((void *)res.tracl)
+ struct descr errlcl[2];
+-#define ERRLCL ((char *)res.errlcl)
++#define ERRLCL ((void *)res.errlcl)
+ struct descr dmpcl[2];
+-#define DMPCL ((char *)res.dmpcl)
++#define DMPCL ((void *)res.dmpcl)
+ struct descr retcod[2];
+-#define RETCOD ((char *)res.retcod)
++#define RETCOD ((void *)res.retcod)
+ struct descr anccl[2];
+-#define ANCCL ((char *)res.anccl)
++#define ANCCL ((void *)res.anccl)
+ struct descr abndcl[2];
+-#define ABNDCL ((char *)res.abndcl)
++#define ABNDCL ((void *)res.abndcl)
+ struct descr casecl[2];
+-#define CASECL ((char *)res.casecl)
++#define CASECL ((void *)res.casecl)
+ #define KNEND KVLIST
+ struct descr kvlist[1];
+-#define KVLIST ((char *)res.kvlist)
++#define KVLIST ((void *)res.kvlist)
+ struct descr errtyp[1];
+-#define ERRTYP ((char *)res.errtyp)
++#define ERRTYP ((void *)res.errtyp)
+ struct descr errtky[1];
+-#define ERRTKY ((char *)res.errtky)
++#define ERRTKY ((void *)res.errtky)
+ struct descr errtxt[1];
+-#define ERRTXT ((char *)res.errtxt)
++#define ERRTXT ((void *)res.errtxt)
+ struct descr etxtky[1];
+-#define ETXTKY ((char *)res.etxtky)
++#define ETXTKY ((void *)res.etxtky)
+ struct descr arbpat[1];
+-#define ARBPAT ((char *)res.arbpat)
++#define ARBPAT ((void *)res.arbpat)
+ struct descr arbky[1];
+-#define ARBKY ((char *)res.arbky)
++#define ARBKY ((void *)res.arbky)
+ struct descr balpat[1];
+-#define BALPAT ((char *)res.balpat)
++#define BALPAT ((void *)res.balpat)
+ struct descr balky[1];
+-#define BALKY ((char *)res.balky)
++#define BALKY ((void *)res.balky)
+ struct descr fncpat[1];
+-#define FNCPAT ((char *)res.fncpat)
++#define FNCPAT ((void *)res.fncpat)
+ struct descr fnceky[1];
+-#define FNCEKY ((char *)res.fnceky)
++#define FNCEKY ((void *)res.fnceky)
+ struct descr abopat[1];
+-#define ABOPAT ((char *)res.abopat)
++#define ABOPAT ((void *)res.abopat)
+ struct descr abrtky[1];
+-#define ABRTKY ((char *)res.abrtky)
++#define ABRTKY ((void *)res.abrtky)
+ struct descr falpat[1];
+-#define FALPAT ((char *)res.falpat)
++#define FALPAT ((void *)res.falpat)
+ struct descr failky[1];
+-#define FAILKY ((char *)res.failky)
++#define FAILKY ((void *)res.failky)
+ struct descr filenm[2];
+-#define FILENM ((char *)res.filenm)
++#define FILENM ((void *)res.filenm)
+ struct descr lnnocl[2];
+-#define LNNOCL ((char *)res.lnnocl)
++#define LNNOCL ((void *)res.lnnocl)
+ struct descr lsflnm[2];
+-#define LSFLNM ((char *)res.lsflnm)
++#define LSFLNM ((void *)res.lsflnm)
+ struct descr lslncl[2];
+-#define LSLNCL ((char *)res.lslncl)
++#define LSLNCL ((void *)res.lslncl)
+ struct descr rempat[1];
+-#define REMPAT ((char *)res.rempat)
++#define REMPAT ((void *)res.rempat)
+ struct descr remky[1];
+-#define REMKY ((char *)res.remky)
++#define REMKY ((void *)res.remky)
+ struct descr sucpat[1];
+-#define SUCPAT ((char *)res.sucpat)
++#define SUCPAT ((void *)res.sucpat)
+ struct descr succky[1];
+-#define SUCCKY ((char *)res.succky)
++#define SUCCKY ((void *)res.succky)
+ struct descr falcl[1];
+-#define FALCL ((char *)res.falcl)
++#define FALCL ((void *)res.falcl)
+ struct descr falky[1];
+-#define FALKY ((char *)res.falky)
++#define FALKY ((void *)res.falky)
+ struct descr lstncl[2];
+-#define LSTNCL ((char *)res.lstncl)
++#define LSTNCL ((void *)res.lstncl)
+ struct descr retpcl[2];
+-#define RETPCL ((char *)res.retpcl)
++#define RETPCL ((void *)res.retpcl)
+ struct descr stnocl[2];
+-#define STNOCL ((char *)res.stnocl)
++#define STNOCL ((void *)res.stnocl)
+ struct descr alphvl[2];
+-#define ALPHVL ((char *)res.alphvl)
++#define ALPHVL ((void *)res.alphvl)
+ struct descr exnocl[1];
+-#define EXNOCL ((char *)res.exnocl)
++#define EXNOCL ((void *)res.exnocl)
+ struct descr stctky[1];
+-#define STCTKY ((char *)res.stctky)
++#define STCTKY ((void *)res.stctky)
+ struct descr lvlcl[1];
+-#define LVLCL ((char *)res.lvlcl)
++#define LVLCL ((void *)res.lvlcl)
+ struct descr fnclky[1];
+-#define FNCLKY ((char *)res.fnclky)
++#define FNCLKY ((void *)res.fnclky)
+ struct descr lcasvl[2];
+-#define LCASVL ((char *)res.lcasvl)
++#define LCASVL ((void *)res.lcasvl)
+ struct descr ucasvl[2];
+-#define UCASVL ((char *)res.ucasvl)
++#define UCASVL ((void *)res.ucasvl)
+ struct descr parmvl[2];
+-#define PARMVL ((char *)res.parmvl)
++#define PARMVL ((void *)res.parmvl)
+ #define KVEND INLIST
+ struct descr inlist[5];
+-#define INLIST ((char *)res.inlist)
++#define INLIST ((void *)res.inlist)
+ struct descr otlist[5];
+-#define OTLIST ((char *)res.otlist)
++#define OTLIST ((void *)res.otlist)
+ struct descr otsatl[1];
+-#define OTSATL ((char *)res.otsatl)
++#define OTSATL ((void *)res.otsatl)
+ struct descr output[2];
+-#define OUTPUT ((char *)res.output)
++#define OUTPUT ((void *)res.output)
+ struct descr punch[1];
+-#define PUNCH ((char *)res.punch)
++#define PUNCH ((void *)res.punch)
+ struct descr pchfst[1];
+-#define PCHFST ((char *)res.pchfst)
++#define PCHFST ((void *)res.pchfst)
+ struct descr insatl[1];
+-#define INSATL ((char *)res.insatl)
++#define INSATL ((void *)res.insatl)
+ struct descr input[1];
+-#define INPUT ((char *)res.input)
++#define INPUT ((void *)res.input)
+ struct descr dflsiz[1];
+-#define DFLSIZ ((char *)res.dflsiz)
++#define DFLSIZ ((void *)res.dflsiz)
+ struct descr termin[2];
+-#define TERMIN ((char *)res.termin)
++#define TERMIN ((void *)res.termin)
+ struct descr trlist[2];
+-#define TRLIST ((char *)res.trlist)
++#define TRLIST ((void *)res.trlist)
+ struct descr valtrs[3];
+-#define VALTRS ((char *)res.valtrs)
++#define VALTRS ((void *)res.valtrs)
+ struct descr tfnclp[2];
+-#define TFNCLP ((char *)res.tfnclp)
++#define TFNCLP ((void *)res.tfnclp)
+ struct descr tfnrlp[4];
+-#define TFNRLP ((char *)res.tfnrlp)
++#define TFNRLP ((void *)res.tfnrlp)
+ struct descr trcblk[2];
+-#define TRCBLK ((char *)res.trcblk)
++#define TRCBLK ((void *)res.trcblk)
+ struct descr lit1cl[4];
+-#define LIT1CL ((char *)res.lit1cl)
++#define LIT1CL ((void *)res.lit1cl)
+ struct descr atrhd[1];
+-#define ATRHD ((char *)res.atrhd)
++#define ATRHD ((void *)res.atrhd)
+ struct descr atprcl[3];
+-#define ATPRCL ((char *)res.atprcl)
++#define ATPRCL ((void *)res.atprcl)
+ struct descr atexcl[1];
+-#define ATEXCL ((char *)res.atexcl)
++#define ATEXCL ((void *)res.atexcl)
+ struct descr atdtp[1];
+-#define ATDTP ((char *)res.atdtp)
++#define ATDTP ((void *)res.atdtp)
+ struct descr iidtp[1];
+-#define IIDTP ((char *)res.iidtp)
++#define IIDTP ((void *)res.iidtp)
+ struct descr ipdtp[1];
+-#define IPDTP ((char *)res.ipdtp)
++#define IPDTP ((void *)res.ipdtp)
+ struct descr irdtp[1];
+-#define IRDTP ((char *)res.irdtp)
++#define IRDTP ((void *)res.irdtp)
+ struct descr ivdtp[1];
+-#define IVDTP ((char *)res.ivdtp)
++#define IVDTP ((void *)res.ivdtp)
+ struct descr pidtp[1];
+-#define PIDTP ((char *)res.pidtp)
++#define PIDTP ((void *)res.pidtp)
+ struct descr ppdtp[1];
+-#define PPDTP ((char *)res.ppdtp)
++#define PPDTP ((void *)res.ppdtp)
+ struct descr pvdtp[1];
+-#define PVDTP ((char *)res.pvdtp)
++#define PVDTP ((void *)res.pvdtp)
+ struct descr ridtp[1];
+-#define RIDTP ((char *)res.ridtp)
++#define RIDTP ((void *)res.ridtp)
+ struct descr rpdtp[1];
+-#define RPDTP ((char *)res.rpdtp)
++#define RPDTP ((void *)res.rpdtp)
+ struct descr rrdtp[1];
+-#define RRDTP ((char *)res.rrdtp)
++#define RRDTP ((void *)res.rrdtp)
+ struct descr rvdtp[1];
+-#define RVDTP ((char *)res.rvdtp)
++#define RVDTP ((void *)res.rvdtp)
+ struct descr tadtp[1];
+-#define TADTP ((char *)res.tadtp)
++#define TADTP ((void *)res.tadtp)
+ struct descr vcdtp[1];
+-#define VCDTP ((char *)res.vcdtp)
++#define VCDTP ((void *)res.vcdtp)
+ struct descr vedtp[1];
+-#define VEDTP ((char *)res.vedtp)
++#define VEDTP ((void *)res.vedtp)
+ struct descr vidtp[1];
+-#define VIDTP ((char *)res.vidtp)
++#define VIDTP ((void *)res.vidtp)
+ struct descr vpdtp[1];
+-#define VPDTP ((char *)res.vpdtp)
++#define VPDTP ((void *)res.vpdtp)
+ struct descr vrdtp[1];
+-#define VRDTP ((char *)res.vrdtp)
++#define VRDTP ((void *)res.vrdtp)
+ struct descr vvdtp[1];
+-#define VVDTP ((char *)res.vvdtp)
++#define VVDTP ((void *)res.vvdtp)
+ struct descr arthcl[1];
+-#define ARTHCL ((char *)res.arthcl)
++#define ARTHCL ((void *)res.arthcl)
+ struct descr cstncl[1];
+-#define CSTNCL ((char *)res.cstncl)
++#define CSTNCL ((void *)res.cstncl)
+ struct descr rstat[1];
+-#define RSTAT ((char *)res.rstat)
++#define RSTAT ((void *)res.rstat)
+ struct descr scncl[1];
+-#define SCNCL ((char *)res.scncl)
++#define SCNCL ((void *)res.scncl)
+ struct descr wstat[1];
+-#define WSTAT ((char *)res.wstat)
++#define WSTAT ((void *)res.wstat)
+ struct descr timecl[1];
+-#define TIMECL ((char *)res.timecl)
++#define TIMECL ((void *)res.timecl)
+ struct descr alcl[1];
+-#define ALCL ((char *)res.alcl)
++#define ALCL ((void *)res.alcl)
+ struct descr arrmrk[1];
+-#define ARRMRK ((char *)res.arrmrk)
++#define ARRMRK ((void *)res.arrmrk)
+ struct descr banrcl[1];
+-#define BANRCL ((char *)res.banrcl)
++#define BANRCL ((void *)res.banrcl)
+ struct descr compcl[1];
+-#define COMPCL ((char *)res.compcl)
++#define COMPCL ((void *)res.compcl)
+ struct descr cutno[1];
+-#define CUTNO ((char *)res.cutno)
++#define CUTNO ((void *)res.cutno)
+ struct descr cnslcl[1];
+-#define CNSLCL ((char *)res.cnslcl)
++#define CNSLCL ((void *)res.cnslcl)
+ struct descr datacl[1];
+-#define DATACL ((char *)res.datacl)
++#define DATACL ((void *)res.datacl)
+ struct descr execcl[1];
+-#define EXECCL ((char *)res.execcl)
++#define EXECCL ((void *)res.execcl)
+ struct descr fnvlcl[1];
+-#define FNVLCL ((char *)res.fnvlcl)
++#define FNVLCL ((void *)res.fnvlcl)
+ struct descr inicom[1];
+-#define INICOM ((char *)res.inicom)
++#define INICOM ((void *)res.inicom)
+ struct descr lenfcl[1];
+-#define LENFCL ((char *)res.lenfcl)
++#define LENFCL ((void *)res.lenfcl)
+ struct descr listcl[1];
+-#define LISTCL ((char *)res.listcl)
++#define LISTCL ((void *)res.listcl)
+ struct descr llist[1];
+-#define LLIST ((char *)res.llist)
++#define LLIST ((void *)res.llist)
+ struct descr namgcl[1];
+-#define NAMGCL ((char *)res.namgcl)
++#define NAMGCL ((void *)res.namgcl)
+ struct descr nerrcl[1];
+-#define NERRCL ((char *)res.nerrcl)
++#define NERRCL ((void *)res.nerrcl)
+ struct descr scercl[1];
+-#define SCERCL ((char *)res.scercl)
++#define SCERCL ((void *)res.scercl)
+ struct descr spitcl[1];
+-#define SPITCL ((char *)res.spitcl)
++#define SPITCL ((void *)res.spitcl)
+ struct descr statcl[1];
+-#define STATCL ((char *)res.statcl)
++#define STATCL ((void *)res.statcl)
+ struct descr arbsiz[1];
+-#define ARBSIZ ((char *)res.arbsiz)
++#define ARBSIZ ((void *)res.arbsiz)
+ struct descr charcl[1];
+-#define CHARCL ((char *)res.charcl)
++#define CHARCL ((void *)res.charcl)
+ struct descr cndsiz[1];
+-#define CNDSIZ ((char *)res.cndsiz)
++#define CNDSIZ ((void *)res.cndsiz)
+ struct descr codelt[1];
+-#define CODELT ((char *)res.codelt)
++#define CODELT ((void *)res.codelt)
+ struct descr dscrtw[1];
+-#define DSCRTW ((char *)res.dscrtw)
++#define DSCRTW ((void *)res.dscrtw)
+ struct descr eoscl[1];
+-#define EOSCL ((char *)res.eoscl)
++#define EOSCL ((void *)res.eoscl)
+ struct descr esalim[1];
+-#define ESALIM ((char *)res.esalim)
++#define ESALIM ((void *)res.esalim)
+ struct descr extval[1];
+-#define EXTVAL ((char *)res.extval)
++#define EXTVAL ((void *)res.extval)
+ struct descr fblkrq[1];
+-#define FBLKRQ ((char *)res.fblkrq)
++#define FBLKRQ ((void *)res.fblkrq)
+ struct descr gobrcl[1];
+-#define GOBRCL ((char *)res.gobrcl)
++#define GOBRCL ((void *)res.gobrcl)
+ struct descr gtocl[1];
+-#define GTOCL ((char *)res.gtocl)
++#define GTOCL ((void *)res.gtocl)
+ struct descr inclsz[1];
+-#define INCLSZ ((char *)res.inclsz)
++#define INCLSZ ((void *)res.inclsz)
+ struct descr ioblsz[1];
+-#define IOBLSZ ((char *)res.ioblsz)
++#define IOBLSZ ((void *)res.ioblsz)
+ struct descr lnodsz[1];
+-#define LNODSZ ((char *)res.lnodsz)
++#define LNODSZ ((void *)res.lnodsz)
+ struct descr nodsiz[1];
+-#define NODSIZ ((char *)res.nodsiz)
++#define NODSIZ ((void *)res.nodsiz)
+ struct descr obend[1];
+-#define OBEND ((char *)res.obend)
++#define OBEND ((void *)res.obend)
+ struct descr ocalim[1];
+-#define OCALIM ((char *)res.ocalim)
++#define OCALIM ((void *)res.ocalim)
+ struct descr onecl[1];
+-#define ONECL ((char *)res.onecl)
++#define ONECL ((void *)res.onecl)
+ struct descr outblk[1];
+-#define OUTBLK ((char *)res.outblk)
++#define OUTBLK ((void *)res.outblk)
+ struct descr errblk[1];
+-#define ERRBLK ((char *)res.errblk)
++#define ERRBLK ((void *)res.errblk)
+ struct descr sizlmt[1];
+-#define SIZLMT ((char *)res.sizlmt)
++#define SIZLMT ((void *)res.sizlmt)
+ struct descr snodsz[1];
+-#define SNODSZ ((char *)res.snodsz)
++#define SNODSZ ((void *)res.snodsz)
+ struct descr starsz[1];
+-#define STARSZ ((char *)res.starsz)
++#define STARSZ ((void *)res.starsz)
+ struct descr zerocl[1];
+-#define ZEROCL ((char *)res.zerocl)
++#define ZEROCL ((void *)res.zerocl)
+ struct descr trskel[1];
+-#define TRSKEL ((char *)res.trskel)
++#define TRSKEL ((void *)res.trskel)
+ struct descr comdct[1];
+-#define COMDCT ((char *)res.comdct)
++#define COMDCT ((void *)res.comdct)
+ struct descr comreg[1];
+-#define COMREG ((char *)res.comreg)
++#define COMREG ((void *)res.comreg)
+ struct descr arback[1];
+-#define ARBACK ((char *)res.arback)
++#define ARBACK ((void *)res.arback)
+ struct descr arhead[1];
+-#define ARHEAD ((char *)res.arhead)
++#define ARHEAD ((void *)res.arhead)
+ struct descr artail[1];
+-#define ARTAIL ((char *)res.artail)
++#define ARTAIL ((void *)res.artail)
+ struct descr strpat[1];
+-#define STRPAT ((char *)res.strpat)
++#define STRPAT ((void *)res.strpat)
+ struct descr anyccl[1];
+-#define ANYCCL ((char *)res.anyccl)
++#define ANYCCL ((void *)res.anyccl)
+ struct descr asgncl[1];
+-#define ASGNCL ((char *)res.asgncl)
++#define ASGNCL ((void *)res.asgncl)
+ struct descr atopcl[1];
+-#define ATOPCL ((char *)res.atopcl)
++#define ATOPCL ((void *)res.atopcl)
+ struct descr basecl[1];
+-#define BASECL ((char *)res.basecl)
++#define BASECL ((void *)res.basecl)
+ struct descr brkccl[1];
+-#define BRKCCL ((char *)res.brkccl)
++#define BRKCCL ((void *)res.brkccl)
+ struct descr brxccl[1];
+-#define BRXCCL ((char *)res.brxccl)
++#define BRXCCL ((void *)res.brxccl)
+ struct descr brxfcl[1];
+-#define BRXFCL ((char *)res.brxfcl)
++#define BRXFCL ((void *)res.brxfcl)
+ struct descr chrcl[1];
+-#define CHRCL ((char *)res.chrcl)
++#define CHRCL ((void *)res.chrcl)
+ struct descr cmacl[1];
+-#define CMACL ((char *)res.cmacl)
++#define CMACL ((void *)res.cmacl)
+ struct descr concl[1];
+-#define CONCL ((char *)res.concl)
++#define CONCL ((void *)res.concl)
+ struct descr dnmecl[1];
+-#define DNMECL ((char *)res.dnmecl)
++#define DNMECL ((void *)res.dnmecl)
+ struct descr dnmicl[1];
+-#define DNMICL ((char *)res.dnmicl)
++#define DNMICL ((void *)res.dnmicl)
+ struct descr endcl[1];
+-#define ENDCL ((char *)res.endcl)
++#define ENDCL ((void *)res.endcl)
+ struct descr enmecl[1];
+-#define ENMECL ((char *)res.enmecl)
++#define ENMECL ((void *)res.enmecl)
+ struct descr enmicl[1];
+-#define ENMICL ((char *)res.enmicl)
++#define ENMICL ((void *)res.enmicl)
+ struct descr erorcl[1];
+-#define ERORCL ((char *)res.erorcl)
++#define ERORCL ((void *)res.erorcl)
+ struct descr fncfcl[1];
+-#define FNCFCL ((char *)res.fncfcl)
++#define FNCFCL ((void *)res.fncfcl)
+ struct descr fnmecl[1];
+-#define FNMECL ((char *)res.fnmecl)
++#define FNMECL ((void *)res.fnmecl)
+ struct descr gotgcl[1];
+-#define GOTGCL ((char *)res.gotgcl)
++#define GOTGCL ((void *)res.gotgcl)
+ struct descr gotlcl[1];
+-#define GOTLCL ((char *)res.gotlcl)
++#define GOTLCL ((void *)res.gotlcl)
+ struct descr gotocl[1];
+-#define GOTOCL ((char *)res.gotocl)
++#define GOTOCL ((void *)res.gotocl)
+ struct descr initcl[1];
+-#define INITCL ((char *)res.initcl)
++#define INITCL ((void *)res.initcl)
+ struct descr itemcl[1];
+-#define ITEMCL ((char *)res.itemcl)
++#define ITEMCL ((void *)res.itemcl)
+ struct descr litcl[1];
+-#define LITCL ((char *)res.litcl)
++#define LITCL ((void *)res.litcl)
+ struct descr lnthcl[1];
+-#define LNTHCL ((char *)res.lnthcl)
++#define LNTHCL ((void *)res.lnthcl)
+ struct descr nmecl[1];
+-#define NMECL ((char *)res.nmecl)
++#define NMECL ((void *)res.nmecl)
+ struct descr nnyccl[1];
+-#define NNYCCL ((char *)res.nnyccl)
++#define NNYCCL ((void *)res.nnyccl)
+ struct descr posicl[1];
+-#define POSICL ((char *)res.posicl)
++#define POSICL ((void *)res.posicl)
+ struct descr rpsicl[1];
+-#define RPSICL ((char *)res.rpsicl)
++#define RPSICL ((void *)res.rpsicl)
+ struct descr rtbcl[1];
+-#define RTBCL ((char *)res.rtbcl)
++#define RTBCL ((void *)res.rtbcl)
+ struct descr scancl[1];
+-#define SCANCL ((char *)res.scancl)
++#define SCANCL ((void *)res.scancl)
+ struct descr scflcl[1];
+-#define SCFLCL ((char *)res.scflcl)
++#define SCFLCL ((void *)res.scflcl)
+ struct descr scokcl[1];
+-#define SCOKCL ((char *)res.scokcl)
++#define SCOKCL ((void *)res.scokcl)
+ struct descr sconcl[1];
+-#define SCONCL ((char *)res.sconcl)
++#define SCONCL ((void *)res.sconcl)
+ struct descr sjsrcl[1];
+-#define SJSRCL ((char *)res.sjsrcl)
++#define SJSRCL ((void *)res.sjsrcl)
+ struct descr spnccl[1];
+-#define SPNCCL ((char *)res.spnccl)
++#define SPNCCL ((void *)res.spnccl)
+ struct descr sucfcl[1];
+-#define SUCFCL ((char *)res.sucfcl)
++#define SUCFCL ((void *)res.sucfcl)
+ struct descr tbcl[1];
+-#define TBCL ((char *)res.tbcl)
++#define TBCL ((void *)res.tbcl)
+ struct descr initb[1];
+-#define INITB ((char *)res.initb)
++#define INITB ((void *)res.initb)
+ struct descr inite[1];
+-#define INITE ((char *)res.inite)
++#define INITE ((void *)res.inite)
+ struct descr a4ptr[1];
+-#define A4PTR ((char *)res.a4ptr)
++#define A4PTR ((void *)res.a4ptr)
+ struct descr a5ptr[1];
+-#define A5PTR ((char *)res.a5ptr)
++#define A5PTR ((void *)res.a5ptr)
+ struct descr a6ptr[1];
+-#define A6PTR ((char *)res.a6ptr)
++#define A6PTR ((void *)res.a6ptr)
+ struct descr a7ptr[1];
+-#define A7PTR ((char *)res.a7ptr)
++#define A7PTR ((void *)res.a7ptr)
+ struct descr brtype[1];
+-#define BRTYPE ((char *)res.brtype)
++#define BRTYPE ((void *)res.brtype)
+ struct descr cmofcl[1];
+-#define CMOFCL ((char *)res.cmofcl)
++#define CMOFCL ((void *)res.cmofcl)
+ struct descr datseg[1];
+-#define DATSEG ((char *)res.datseg)
++#define DATSEG ((void *)res.datseg)
+ struct descr dmpptr[1];
+-#define DMPPTR ((char *)res.dmpptr)
++#define DMPPTR ((void *)res.dmpptr)
+ struct descr dtcl[1];
+-#define DTCL ((char *)res.dtcl)
++#define DTCL ((void *)res.dtcl)
+ struct descr dt1cl[1];
+-#define DT1CL ((char *)res.dt1cl)
++#define DT1CL ((void *)res.dt1cl)
+ struct descr emsgcl[1];
+-#define EMSGCL ((char *)res.emsgcl)
++#define EMSGCL ((void *)res.emsgcl)
+ struct descr errbas[1];
+-#define ERRBAS ((char *)res.errbas)
++#define ERRBAS ((void *)res.errbas)
+ struct descr esaicl[1];
+-#define ESAICL ((char *)res.esaicl)
++#define ESAICL ((void *)res.esaicl)
+ struct descr etmcl[1];
+-#define ETMCL ((char *)res.etmcl)
++#define ETMCL ((void *)res.etmcl)
+ struct descr exn2cl[1];
+-#define EXN2CL ((char *)res.exn2cl)
++#define EXN2CL ((void *)res.exn2cl)
+ struct descr fcl[1];
+-#define FCL ((char *)res.fcl)
++#define FCL ((void *)res.fcl)
+ struct descr nexfcl[1];
+-#define NEXFCL ((char *)res.nexfcl)
++#define NEXFCL ((void *)res.nexfcl)
+ struct descr frtncl[1];
+-#define FRTNCL ((char *)res.frtncl)
++#define FRTNCL ((void *)res.frtncl)
+ struct descr gogocl[1];
+-#define GOGOCL ((char *)res.gogocl)
++#define GOGOCL ((void *)res.gogocl)
+ struct descr incl[1];
+-#define INCL ((char *)res.incl)
++#define INCL ((void *)res.incl)
+ struct descr iokey[1];
+-#define IOKEY ((char *)res.iokey)
++#define IOKEY ((void *)res.iokey)
+ struct descr maxlen[1];
+-#define MAXLEN ((char *)res.maxlen)
++#define MAXLEN ((void *)res.maxlen)
+ struct descr msgno[1];
+-#define MSGNO ((char *)res.msgno)
++#define MSGNO ((void *)res.msgno)
+ struct descr namicl[1];
+-#define NAMICL ((char *)res.namicl)
++#define NAMICL ((void *)res.namicl)
+ struct descr nhedcl[1];
+-#define NHEDCL ((char *)res.nhedcl)
++#define NHEDCL ((void *)res.nhedcl)
+ struct descr nmover[1];
+-#define NMOVER ((char *)res.nmover)
++#define NMOVER ((void *)res.nmover)
+ struct descr nulvcl[1];
+-#define NULVCL ((char *)res.nulvcl)
++#define NULVCL ((void *)res.nulvcl)
+ struct descr ocicl[1];
+-#define OCICL ((char *)res.ocicl)
++#define OCICL ((void *)res.ocicl)
+ struct descr paticl[1];
+-#define PATICL ((char *)res.paticl)
++#define PATICL ((void *)res.paticl)
+ struct descr pdlend[1];
+-#define PDLEND ((char *)res.pdlend)
++#define PDLEND ((void *)res.pdlend)
+ struct descr pdlptr[1];
+-#define PDLPTR ((char *)res.pdlptr)
++#define PDLPTR ((void *)res.pdlptr)
+ struct descr scl[1];
+-#define SCL ((char *)res.scl)
++#define SCL ((void *)res.scl)
+ struct descr signcl[1];
+-#define SIGNCL ((char *)res.signcl)
++#define SIGNCL ((void *)res.signcl)
+ struct descr stkptr[1];
+-#define STKPTR ((char *)res.stkptr)
++#define STKPTR ((void *)res.stkptr)
+ struct descr stype[1];
+-#define STYPE ((char *)res.stype)
++#define STYPE ((void *)res.stype)
+ struct descr tblfnc[1];
+-#define TBLFNC ((char *)res.tblfnc)
++#define TBLFNC ((void *)res.tblfnc)
+ struct descr unit[1];
+-#define UNIT ((char *)res.unit)
++#define UNIT ((void *)res.unit)
+ struct descr varsym[1];
+-#define VARSYM ((char *)res.varsym)
++#define VARSYM ((void *)res.varsym)
+ struct descr datcl[1];
+-#define DATCL ((char *)res.datcl)
++#define DATCL ((void *)res.datcl)
+ struct descr defcl[1];
+-#define DEFCL ((char *)res.defcl)
++#define DEFCL ((void *)res.defcl)
+ struct descr fldcl[1];
+-#define FLDCL ((char *)res.fldcl)
++#define FLDCL ((void *)res.fldcl)
+ struct descr lodcl[1];
+-#define LODCL ((char *)res.lodcl)
++#define LODCL ((void *)res.lodcl)
+ struct descr pdlhed[1];
+-#define PDLHED ((char *)res.pdlhed)
++#define PDLHED ((void *)res.pdlhed)
+ struct descr undfcl[1];
+-#define UNDFCL ((char *)res.undfcl)
++#define UNDFCL ((void *)res.undfcl)
+ struct descr dpsptr[1];
+-#define DPSPTR ((char *)res.dpsptr)
++#define DPSPTR ((void *)res.dpsptr)
+ struct descr xspptr[1];
+-#define XSPPTR ((char *)res.xspptr)
++#define XSPPTR ((void *)res.xspptr)
+ struct descr yspptr[1];
+-#define YSPPTR ((char *)res.yspptr)
++#define YSPPTR ((void *)res.yspptr)
+ struct descr zspptr[1];
+-#define ZSPPTR ((char *)res.zspptr)
++#define ZSPPTR ((void *)res.zspptr)
+ struct descr tspptr[1];
+-#define TSPPTR ((char *)res.tspptr)
++#define TSPPTR ((void *)res.tspptr)
+ struct descr knatl[1];
+-#define KNATL ((char *)res.knatl)
++#define KNATL ((void *)res.knatl)
+ struct descr kvatl[1];
+-#define KVATL ((char *)res.kvatl)
++#define KVATL ((void *)res.kvatl)
+ struct descr tratl[1];
+-#define TRATL ((char *)res.tratl)
++#define TRATL ((void *)res.tratl)
+ struct spec blnsp[1];
+-#define BLNSP ((char *)res.blnsp)
++#define BLNSP ((void *)res.blnsp)
+ struct spec errsp[1];
+-#define ERRSP ((char *)res.errsp)
++#define ERRSP ((void *)res.errsp)
+ struct spec inbfsp[1];
+-#define INBFSP ((char *)res.inbfsp)
++#define INBFSP ((void *)res.inbfsp)
+ struct spec lnbfsp[1];
+-#define LNBFSP ((char *)res.lnbfsp)
++#define LNBFSP ((void *)res.lnbfsp)
+ struct spec nextsp[1];
+-#define NEXTSP ((char *)res.nextsp)
++#define NEXTSP ((void *)res.nextsp)
+ struct spec lnosp[1];
+-#define LNOSP ((char *)res.lnosp)
++#define LNOSP ((void *)res.lnosp)
+ struct spec rnosp[1];
+-#define RNOSP ((char *)res.rnosp)
++#define RNOSP ((void *)res.rnosp)
+ struct spec alphsp[1];
+-#define ALPHSP ((char *)res.alphsp)
++#define ALPHSP ((void *)res.alphsp)
+ struct spec ampsp[1];
+-#define AMPSP ((char *)res.ampsp)
++#define AMPSP ((void *)res.ampsp)
+ struct spec cerrsp[1];
+-#define CERRSP ((char *)res.cerrsp)
++#define CERRSP ((void *)res.cerrsp)
+ struct spec colsp[1];
+-#define COLSP ((char *)res.colsp)
++#define COLSP ((void *)res.colsp)
+ struct spec dmpsp[1];
+-#define DMPSP ((char *)res.dmpsp)
++#define DMPSP ((void *)res.dmpsp)
+ struct spec dtarsp[1];
+-#define DTARSP ((char *)res.dtarsp)
++#define DTARSP ((void *)res.dtarsp)
+ struct spec lcassp[1];
+-#define LCASSP ((char *)res.lcassp)
++#define LCASSP ((void *)res.lcassp)
+ struct spec protsp[1];
+-#define PROTSP ((char *)res.protsp)
++#define PROTSP ((void *)res.protsp)
+ struct spec qtsp[1];
+-#define QTSP ((char *)res.qtsp)
++#define QTSP ((void *)res.qtsp)
+ struct spec realsp[1];
+-#define REALSP ((char *)res.realsp)
++#define REALSP ((void *)res.realsp)
+ struct spec tracsp[1];
+-#define TRACSP ((char *)res.tracsp)
++#define TRACSP ((void *)res.tracsp)
+ struct spec ucassp[1];
+-#define UCASSP ((char *)res.ucassp)
++#define UCASSP ((void *)res.ucassp)
+ struct spec arrsp[1];
+-#define ARRSP ((char *)res.arrsp)
++#define ARRSP ((void *)res.arrsp)
+ struct spec asscsp[1];
+-#define ASSCSP ((char *)res.asscsp)
++#define ASSCSP ((void *)res.asscsp)
+ struct spec blsp[1];
+-#define BLSP ((char *)res.blsp)
++#define BLSP ((void *)res.blsp)
+ struct spec bleqsp[1];
+-#define BLEQSP ((char *)res.bleqsp)
++#define BLEQSP ((void *)res.bleqsp)
+ struct spec cmasp[1];
+-#define CMASP ((char *)res.cmasp)
++#define CMASP ((void *)res.cmasp)
+ struct spec col1sp[1];
+-#define COL1SP ((char *)res.col1sp)
++#define COL1SP ((void *)res.col1sp)
+ struct spec ejctsp[1];
+-#define EJCTSP ((char *)res.ejctsp)
++#define EJCTSP ((void *)res.ejctsp)
+ struct spec eqlsp[1];
+-#define EQLSP ((char *)res.eqlsp)
++#define EQLSP ((void *)res.eqlsp)
+ struct spec erorsp[1];
+-#define ERORSP ((char *)res.erorsp)
++#define ERORSP ((void *)res.erorsp)
+ struct spec etimsp[1];
+-#define ETIMSP ((char *)res.etimsp)
++#define ETIMSP ((void *)res.etimsp)
+ struct spec execsp[1];
+-#define EXECSP ((char *)res.execsp)
++#define EXECSP ((void *)res.execsp)
+ struct spec exdtsp[1];
+-#define EXDTSP ((char *)res.exdtsp)
++#define EXDTSP ((void *)res.exdtsp)
+ struct spec filesp[1];
+-#define FILESP ((char *)res.filesp)
++#define FILESP ((void *)res.filesp)
+ struct spec frznsp[1];
+-#define FRZNSP ((char *)res.frznsp)
++#define FRZNSP ((void *)res.frznsp)
+ struct spec inclsp[1];
+-#define INCLSP ((char *)res.inclsp)
++#define INCLSP ((void *)res.inclsp)
+ struct spec leftsp[1];
+-#define LEFTSP ((char *)res.leftsp)
++#define LEFTSP ((void *)res.leftsp)
+ struct spec linesp[1];
+-#define LINESP ((char *)res.linesp)
++#define LINESP ((void *)res.linesp)
+ struct spec listsp[1];
+-#define LISTSP ((char *)res.listsp)
++#define LISTSP ((void *)res.listsp)
+ struct spec lprnsp[1];
+-#define LPRNSP ((char *)res.lprnsp)
++#define LPRNSP ((void *)res.lprnsp)
+ struct spec lsfnsp[1];
+-#define LSFNSP ((char *)res.lsfnsp)
++#define LSFNSP ((void *)res.lsfnsp)
+ struct spec lslnsp[1];
+-#define LSLNSP ((char *)res.lslnsp)
++#define LSLNSP ((void *)res.lslnsp)
+ struct spec nerrsp[1];
+-#define NERRSP ((char *)res.nerrsp)
++#define NERRSP ((void *)res.nerrsp)
+ struct spec nexesp[1];
+-#define NEXESP ((char *)res.nexesp)
++#define NEXESP ((void *)res.nexesp)
+ struct spec ofsp[1];
+-#define OFSP ((char *)res.ofsp)
++#define OFSP ((void *)res.ofsp)
+ struct spec rprnsp[1];
+-#define RPRNSP ((char *)res.rprnsp)
++#define RPRNSP ((void *)res.rprnsp)
+ struct spec starsp[1];
+-#define STARSP ((char *)res.starsp)
++#define STARSP ((void *)res.starsp)
+ struct spec trclsp[1];
+-#define TRCLSP ((char *)res.trclsp)
++#define TRCLSP ((void *)res.trclsp)
+ struct spec trlvsp[1];
+-#define TRLVSP ((char *)res.trlvsp)
++#define TRLVSP ((void *)res.trlvsp)
+ struct spec trstsp[1];
+-#define TRSTSP ((char *)res.trstsp)
++#define TRSTSP ((void *)res.trstsp)
+ struct spec spitsp[1];
+-#define SPITSP ((char *)res.spitsp)
++#define SPITSP ((void *)res.spitsp)
+ struct spec unlsp[1];
+-#define UNLSP ((char *)res.unlsp)
++#define UNLSP ((void *)res.unlsp)
+ struct spec xfersp[1];
+-#define XFERSP ((char *)res.xfersp)
++#define XFERSP ((void *)res.xfersp)
+ struct descr iclblk[1];
+-#define ICLBLK ((char *)res.iclblk)
++#define ICLBLK ((void *)res.iclblk)
+ struct descr dtatl[1];
+-#define DTATL ((char *)res.dtatl)
++#define DTATL ((void *)res.dtatl)
+ struct descr fncpl[1];
+-#define FNCPL ((char *)res.fncpl)
++#define FNCPL ((void *)res.fncpl)
+ struct descr inatl[1];
+-#define INATL ((char *)res.inatl)
++#define INATL ((void *)res.inatl)
+ struct descr outatl[1];
+-#define OUTATL ((char *)res.outatl)
++#define OUTATL ((void *)res.outatl)
+ struct descr tvall[2];
+-#define TVALL ((char *)res.tvall)
++#define TVALL ((void *)res.tvall)
+ struct descr tlabl[2];
+-#define TLABL ((char *)res.tlabl)
++#define TLABL ((void *)res.tlabl)
+ struct descr tfentl[2];
+-#define TFENTL ((char *)res.tfentl)
++#define TFENTL ((void *)res.tfentl)
+ struct descr tfextl[2];
+-#define TFEXTL ((char *)res.tfextl)
++#define TFEXTL ((void *)res.tfextl)
+ struct descr tkeyl[2];
+-#define TKEYL ((char *)res.tkeyl)
++#define TKEYL ((void *)res.tkeyl)
+ struct descr a1ptr[1];
+-#define A1PTR ((char *)res.a1ptr)
++#define A1PTR ((void *)res.a1ptr)
+ struct descr a2ptr[1];
+-#define A2PTR ((char *)res.a2ptr)
++#define A2PTR ((void *)res.a2ptr)
+ struct descr a3ptr[1];
+-#define A3PTR ((char *)res.a3ptr)
++#define A3PTR ((void *)res.a3ptr)
+ struct descr atptr[1];
+-#define ATPTR ((char *)res.atptr)
++#define ATPTR ((void *)res.atptr)
+ struct descr f1ptr[1];
+-#define F1PTR ((char *)res.f1ptr)
++#define F1PTR ((void *)res.f1ptr)
+ struct descr f2ptr[1];
+-#define F2PTR ((char *)res.f2ptr)
++#define F2PTR ((void *)res.f2ptr)
+ struct descr io2ptr[1];
+-#define IO2PTR ((char *)res.io2ptr)
++#define IO2PTR ((void *)res.io2ptr)
+ struct descr io1ptr[1];
+-#define IO1PTR ((char *)res.io1ptr)
++#define IO1PTR ((void *)res.io1ptr)
+ struct descr lptr[1];
+-#define LPTR ((char *)res.lptr)
++#define LPTR ((void *)res.lptr)
+ struct descr nval[1];
+-#define NVAL ((char *)res.nval)
++#define NVAL ((void *)res.nval)
+ struct descr io3ptr[1];
+-#define IO3PTR ((char *)res.io3ptr)
++#define IO3PTR ((void *)res.io3ptr)
+ struct descr io4ptr[1];
+-#define IO4PTR ((char *)res.io4ptr)
++#define IO4PTR ((void *)res.io4ptr)
+ struct descr tblbcs[1];
+-#define TBLBCS ((char *)res.tblbcs)
++#define TBLBCS ((void *)res.tblbcs)
+ struct descr tblscs[1];
+-#define TBLSCS ((char *)res.tblscs)
++#define TBLSCS ((void *)res.tblscs)
+ struct descr tmval[1];
+-#define TMVAL ((char *)res.tmval)
++#define TMVAL ((void *)res.tmval)
+ struct descr tptr[1];
+-#define TPTR ((char *)res.tptr)
++#define TPTR ((void *)res.tptr)
+ struct descr tcl[1];
+-#define TCL ((char *)res.tcl)
++#define TCL ((void *)res.tcl)
+ struct descr tsiz[1];
+-#define TSIZ ((char *)res.tsiz)
++#define TSIZ ((void *)res.tsiz)
+ struct descr tval[1];
+-#define TVAL ((char *)res.tval)
++#define TVAL ((void *)res.tval)
+ struct descr vval[1];
+-#define VVAL ((char *)res.vval)
++#define VVAL ((void *)res.vval)
+ struct descr wcl[1];
+-#define WCL ((char *)res.wcl)
++#define WCL ((void *)res.wcl)
+ struct descr wptr[1];
+-#define WPTR ((char *)res.wptr)
++#define WPTR ((void *)res.wptr)
+ struct descr xcl[1];
+-#define XCL ((char *)res.xcl)
++#define XCL ((void *)res.xcl)
+ struct descr xptr[1];
+-#define XPTR ((char *)res.xptr)
++#define XPTR ((void *)res.xptr)
+ struct descr xsiz[1];
+-#define XSIZ ((char *)res.xsiz)
++#define XSIZ ((void *)res.xsiz)
+ struct descr ycl[1];
+-#define YCL ((char *)res.ycl)
++#define YCL ((void *)res.ycl)
+ struct descr yptr[1];
+-#define YPTR ((char *)res.yptr)
++#define YPTR ((void *)res.yptr)
+ struct descr ysiz[1];
+-#define YSIZ ((char *)res.ysiz)
++#define YSIZ ((void *)res.ysiz)
+ struct descr zcl[1];
+-#define ZCL ((char *)res.zcl)
++#define ZCL ((void *)res.zcl)
+ struct descr zptr[1];
+-#define ZPTR ((char *)res.zptr)
++#define ZPTR ((void *)res.zptr)
+ struct descr zsiz[1];
+-#define ZSIZ ((char *)res.zsiz)
++#define ZSIZ ((void *)res.zsiz)
+ struct descr boscl[1];
+-#define BOSCL ((char *)res.boscl)
++#define BOSCL ((void *)res.boscl)
+ struct descr cmbscl[1];
+-#define CMBSCL ((char *)res.cmbscl)
++#define CMBSCL ((void *)res.cmbscl)
+ struct descr nbsptr[1];
+-#define NBSPTR ((char *)res.nbsptr)
++#define NBSPTR ((void *)res.nbsptr)
+ struct descr fblock[1];
+-#define FBLOCK ((char *)res.fblock)
++#define FBLOCK ((void *)res.fblock)
+ struct descr ocbscl[1];
+-#define OCBSCL ((char *)res.ocbscl)
++#define OCBSCL ((void *)res.ocbscl)
+ struct descr oclim[1];
+-#define OCLIM ((char *)res.oclim)
++#define OCLIM ((void *)res.oclim)
+ struct descr ocsvcl[1];
+-#define OCSVCL ((char *)res.ocsvcl)
++#define OCSVCL ((void *)res.ocsvcl)
+ struct descr patbcl[1];
+-#define PATBCL ((char *)res.patbcl)
++#define PATBCL ((void *)res.patbcl)
+ struct descr scbscl[1];
+-#define SCBSCL ((char *)res.scbscl)
++#define SCBSCL ((void *)res.scbscl)
+ struct descr srncl[1];
+-#define SRNCL ((char *)res.srncl)
++#define SRNCL ((void *)res.srncl)
+ struct descr elemnd[1];
+-#define ELEMND ((char *)res.elemnd)
++#define ELEMND ((void *)res.elemnd)
+ struct descr elexnd[1];
+-#define ELEXND ((char *)res.elexnd)
++#define ELEXND ((void *)res.elexnd)
+ struct descr eleynd[1];
+-#define ELEYND ((char *)res.eleynd)
++#define ELEYND ((void *)res.eleynd)
+ struct descr exelnd[1];
+-#define EXELND ((char *)res.exelnd)
++#define EXELND ((void *)res.exelnd)
+ struct descr exexnd[1];
+-#define EXEXND ((char *)res.exexnd)
++#define EXEXND ((void *)res.exexnd)
+ struct descr exopcl[1];
+-#define EXOPCL ((char *)res.exopcl)
++#define EXOPCL ((void *)res.exopcl)
+ struct descr exopnd[1];
+-#define EXOPND ((char *)res.exopnd)
++#define EXOPND ((void *)res.exopnd)
+ struct descr exprnd[1];
+-#define EXPRND ((char *)res.exprnd)
++#define EXPRND ((void *)res.exprnd)
+ struct descr fgond[1];
+-#define FGOND ((char *)res.fgond)
++#define FGOND ((void *)res.fgond)
+ struct descr formnd[1];
+-#define FORMND ((char *)res.formnd)
++#define FORMND ((void *)res.formnd)
+ struct descr frncl[1];
+-#define FRNCL ((char *)res.frncl)
++#define FRNCL ((void *)res.frncl)
+ struct descr gotond[1];
+-#define GOTOND ((char *)res.gotond)
++#define GOTOND ((void *)res.gotond)
+ struct descr incstk[1];
+-#define INCSTK ((char *)res.incstk)
++#define INCSTK ((void *)res.incstk)
+ struct descr patnd[1];
+-#define PATND ((char *)res.patnd)
++#define PATND ((void *)res.patnd)
+ struct descr sgond[1];
+-#define SGOND ((char *)res.sgond)
++#define SGOND ((void *)res.sgond)
+ struct descr subjnd[1];
+-#define SUBJND ((char *)res.subjnd)
++#define SUBJND ((void *)res.subjnd)
+ struct descr dflfst[1];
+-#define DFLFST ((char *)res.dflfst)
++#define DFLFST ((void *)res.dflfst)
+ struct descr endptr[1];
+-#define ENDPTR ((char *)res.endptr)
++#define ENDPTR ((void *)res.endptr)
+ struct descr extptr[1];
+-#define EXTPTR ((char *)res.extptr)
++#define EXTPTR ((void *)res.extptr)
+ struct descr fretcl[1];
+-#define FRETCL ((char *)res.fretcl)
++#define FRETCL ((void *)res.fretcl)
+ struct descr nretcl[1];
+-#define NRETCL ((char *)res.nretcl)
++#define NRETCL ((void *)res.nretcl)
+ struct descr retcl[1];
+-#define RETCL ((char *)res.retcl)
++#define RETCL ((void *)res.retcl)
+ struct descr funtcl[1];
+-#define FUNTCL ((char *)res.funtcl)
++#define FUNTCL ((void *)res.funtcl)
+ struct spec dpsp[1];
+-#define DPSP ((char *)res.dpsp)
++#define DPSP ((void *)res.dpsp)
+ struct spec headsp[1];
+-#define HEADSP ((char *)res.headsp)
++#define HEADSP ((void *)res.headsp)
+ struct spec iosp[1];
+-#define IOSP ((char *)res.iosp)
++#define IOSP ((void *)res.iosp)
+ struct spec tailsp[1];
+-#define TAILSP ((char *)res.tailsp)
++#define TAILSP ((void *)res.tailsp)
+ struct spec textsp[1];
+-#define TEXTSP ((char *)res.textsp)
++#define TEXTSP ((void *)res.textsp)
+ struct spec tsp[1];
+-#define TSP ((char *)res.tsp)
++#define TSP ((void *)res.tsp)
+ struct spec txsp[1];
+-#define TXSP ((char *)res.txsp)
++#define TXSP ((void *)res.txsp)
+ struct spec vsp[1];
+-#define VSP ((char *)res.vsp)
++#define VSP ((void *)res.vsp)
+ struct spec xsp[1];
+-#define XSP ((char *)res.xsp)
++#define XSP ((void *)res.xsp)
+ struct spec ysp[1];
+-#define YSP ((char *)res.ysp)
++#define YSP ((void *)res.ysp)
+ struct spec zsp[1];
+-#define ZSP ((char *)res.zsp)
++#define ZSP ((void *)res.zsp)
+ struct descr arg1cl[1];
+-#define ARG1CL ((char *)res.arg1cl)
++#define ARG1CL ((void *)res.arg1cl)
+ struct descr bukptr[1];
+-#define BUKPTR ((char *)res.bukptr)
++#define BUKPTR ((void *)res.bukptr)
+ struct descr lstptr[1];
+-#define LSTPTR ((char *)res.lstptr)
++#define LSTPTR ((void *)res.lstptr)
+ struct descr axptr[1];
+-#define AXPTR ((char *)res.axptr)
++#define AXPTR ((void *)res.axptr)
+ struct spec specr1[1];
+-#define SPECR1 ((char *)res.specr1)
++#define SPECR1 ((void *)res.specr1)
+ struct spec specr2[1];
+-#define SPECR2 ((char *)res.specr2)
++#define SPECR2 ((void *)res.specr2)
+ #define ICLEND BK1CL
+ struct descr bk1cl[1];
+-#define BK1CL ((char *)res.bk1cl)
++#define BK1CL ((void *)res.bk1cl)
+ struct descr bkdx[1];
+-#define BKDX ((char *)res.bkdx)
++#define BKDX ((void *)res.bkdx)
+ struct descr bkdxu[1];
+-#define BKDXU ((char *)res.bkdxu)
++#define BKDXU ((void *)res.bkdxu)
+ struct descr bkltcl[1];
+-#define BKLTCL ((char *)res.bkltcl)
++#define BKLTCL ((void *)res.bkltcl)
+ struct descr bkptr[1];
+-#define BKPTR ((char *)res.bkptr)
++#define BKPTR ((void *)res.bkptr)
+ struct descr blocl[1];
+-#define BLOCL ((char *)res.blocl)
++#define BLOCL ((void *)res.blocl)
+ struct descr convsw[1];
+-#define CONVSW ((char *)res.convsw)
++#define CONVSW ((void *)res.convsw)
+ struct descr cpycl[1];
+-#define CPYCL ((char *)res.cpycl)
++#define CPYCL ((void *)res.cpycl)
+ struct descr descl[1];
+-#define DESCL ((char *)res.descl)
++#define DESCL ((void *)res.descl)
+ struct descr equvcl[1];
+-#define EQUVCL ((char *)res.equvcl)
++#define EQUVCL ((void *)res.equvcl)
+ struct descr frdscl[1];
+-#define FRDSCL ((char *)res.frdscl)
++#define FRDSCL ((void *)res.frdscl)
+ struct descr gcblk[1];
+-#define GCBLK ((char *)res.gcblk)
++#define GCBLK ((void *)res.gcblk)
+ struct descr gcno[1];
+-#define GCNO ((char *)res.gcno)
++#define GCNO ((void *)res.gcno)
+ struct descr gcmptr[1];
+-#define GCMPTR ((char *)res.gcmptr)
++#define GCMPTR ((void *)res.gcmptr)
+ struct descr gcreq[1];
+-#define GCREQ ((char *)res.gcreq)
++#define GCREQ ((void *)res.gcreq)
+ struct descr gcgot[1];
+-#define GCGOT ((char *)res.gcgot)
++#define GCGOT ((void *)res.gcgot)
+ struct descr lcptr[1];
+-#define LCPTR ((char *)res.lcptr)
++#define LCPTR ((void *)res.lcptr)
+ struct descr mvsgpt[1];
+-#define MVSGPT ((char *)res.mvsgpt)
++#define MVSGPT ((void *)res.mvsgpt)
+ struct descr nodpcl[1];
+-#define NODPCL ((char *)res.nodpcl)
++#define NODPCL ((void *)res.nodpcl)
+ struct descr obptr[1];
+-#define OBPTR ((char *)res.obptr)
++#define OBPTR ((void *)res.obptr)
+ struct descr ofset[1];
+-#define OFSET ((char *)res.ofset)
++#define OFSET ((void *)res.ofset)
+ struct descr prmdx[1];
+-#define PRMDX ((char *)res.prmdx)
++#define PRMDX ((void *)res.prmdx)
+ struct descr prmptr[1];
+-#define PRMPTR ((char *)res.prmptr)
++#define PRMPTR ((void *)res.prmptr)
+ struct descr st1ptr[1];
+-#define ST1PTR ((char *)res.st1ptr)
++#define ST1PTR ((void *)res.st1ptr)
+ struct descr st2ptr[1];
+-#define ST2PTR ((char *)res.st2ptr)
++#define ST2PTR ((void *)res.st2ptr)
+ struct descr tempcl[1];
+-#define TEMPCL ((char *)res.tempcl)
++#define TEMPCL ((void *)res.tempcl)
+ struct descr topcl[1];
+-#define TOPCL ((char *)res.topcl)
++#define TOPCL ((void *)res.topcl)
+ struct descr ttlcl[1];
+-#define TTLCL ((char *)res.ttlcl)
++#define TTLCL ((void *)res.ttlcl)
+ struct descr twocl[1];
+-#define TWOCL ((char *)res.twocl)
++#define TWOCL ((void *)res.twocl)
+ struct descr frsgpt[1];
+-#define FRSGPT ((char *)res.frsgpt)
++#define FRSGPT ((void *)res.frsgpt)
+ struct descr hdsgpt[1];
+-#define HDSGPT ((char *)res.hdsgpt)
++#define HDSGPT ((void *)res.hdsgpt)
+ struct descr tlsgp1[1];
+-#define TLSGP1 ((char *)res.tlsgp1)
++#define TLSGP1 ((void *)res.tlsgp1)
+ struct descr gcxttl[2];
+-#define GCXTTL ((char *)res.gcxttl)
++#define GCXTTL ((void *)res.gcxttl)
+ struct descr ftable[1];
+-#define FTABLE ((char *)res.ftable)
++#define FTABLE ((void *)res.ftable)
+ struct descr anyfn[2];
+-#define ANYFN ((char *)res.anyfn)
++#define ANYFN ((void *)res.anyfn)
+ struct descr aplyfn[2];
+-#define APLYFN ((char *)res.aplyfn)
++#define APLYFN ((void *)res.aplyfn)
+ struct descr arbofn[2];
+-#define ARBOFN ((char *)res.arbofn)
++#define ARBOFN ((void *)res.arbofn)
+ struct descr argfn[2];
+-#define ARGFN ((char *)res.argfn)
++#define ARGFN ((void *)res.argfn)
+ struct descr arrafn[2];
+-#define ARRAFN ((char *)res.arrafn)
++#define ARRAFN ((void *)res.arrafn)
+ struct descr asscfn[2];
+-#define ASSCFN ((char *)res.asscfn)
++#define ASSCFN ((void *)res.asscfn)
+ struct descr backfn[2];
+-#define BACKFN ((char *)res.backfn)
++#define BACKFN ((void *)res.backfn)
+ struct descr breafn[2];
+-#define BREAFN ((char *)res.breafn)
++#define BREAFN ((void *)res.breafn)
+ struct descr brexfn[2];
+-#define BREXFN ((char *)res.brexfn)
++#define BREXFN ((void *)res.brexfn)
+ struct descr charfn[2];
+-#define CHARFN ((char *)res.charfn)
++#define CHARFN ((void *)res.charfn)
+ struct descr cleafn[2];
+-#define CLEAFN ((char *)res.cleafn)
++#define CLEAFN ((void *)res.cleafn)
+ struct descr codefn[2];
+-#define CODEFN ((char *)res.codefn)
++#define CODEFN ((void *)res.codefn)
+ struct descr colefn[2];
+-#define COLEFN ((char *)res.colefn)
++#define COLEFN ((void *)res.colefn)
+ struct descr cnvrfn[2];
+-#define CNVRFN ((char *)res.cnvrfn)
++#define CNVRFN ((void *)res.cnvrfn)
+ struct descr copyfn[2];
+-#define COPYFN ((char *)res.copyfn)
++#define COPYFN ((void *)res.copyfn)
+ struct descr datfn[2];
+-#define DATFN ((char *)res.datfn)
++#define DATFN ((void *)res.datfn)
+ struct descr datdfn[2];
+-#define DATDFN ((char *)res.datdfn)
++#define DATDFN ((void *)res.datdfn)
+ struct descr defifn[2];
+-#define DEFIFN ((char *)res.defifn)
++#define DEFIFN ((void *)res.defifn)
+ struct descr difffn[2];
+-#define DIFFFN ((char *)res.difffn)
++#define DIFFFN ((void *)res.difffn)
+ struct descr dtchfn[2];
+-#define DTCHFN ((char *)res.dtchfn)
++#define DTCHFN ((void *)res.dtchfn)
+ struct descr dtfn[2];
+-#define DTFN ((char *)res.dtfn)
++#define DTFN ((void *)res.dtfn)
+ struct descr dumpfn[2];
+-#define DUMPFN ((char *)res.dumpfn)
++#define DUMPFN ((void *)res.dumpfn)
+ struct descr duplfn[2];
+-#define DUPLFN ((char *)res.duplfn)
++#define DUPLFN ((void *)res.duplfn)
+ struct descr endffn[2];
+-#define ENDFFN ((char *)res.endffn)
++#define ENDFFN ((void *)res.endffn)
+ struct descr eqfn[2];
+-#define EQFN ((char *)res.eqfn)
++#define EQFN ((void *)res.eqfn)
+ struct descr evalfn[2];
+-#define EVALFN ((char *)res.evalfn)
++#define EVALFN ((void *)res.evalfn)
+ struct descr fldsfn[2];
+-#define FLDSFN ((char *)res.fldsfn)
++#define FLDSFN ((void *)res.fldsfn)
+ struct descr frezfn[2];
+-#define FREZFN ((char *)res.frezfn)
++#define FREZFN ((void *)res.frezfn)
+ struct descr gefn[2];
+-#define GEFN ((char *)res.gefn)
++#define GEFN ((void *)res.gefn)
+ struct descr gtfn[2];
+-#define GTFN ((char *)res.gtfn)
++#define GTFN ((void *)res.gtfn)
+ struct descr idenfn[2];
+-#define IDENFN ((char *)res.idenfn)
++#define IDENFN ((void *)res.idenfn)
+ struct descr intgfn[2];
+-#define INTGFN ((char *)res.intgfn)
++#define INTGFN ((void *)res.intgfn)
+ struct descr itemfn[2];
+-#define ITEMFN ((char *)res.itemfn)
++#define ITEMFN ((void *)res.itemfn)
+ struct descr lefn[2];
+-#define LEFN ((char *)res.lefn)
++#define LEFN ((void *)res.lefn)
+ struct descr lenfn[2];
+-#define LENFN ((char *)res.lenfn)
++#define LENFN ((void *)res.lenfn)
+ struct descr leqfn[2];
+-#define LEQFN ((char *)res.leqfn)
++#define LEQFN ((void *)res.leqfn)
+ struct descr lgefn[2];
+-#define LGEFN ((char *)res.lgefn)
++#define LGEFN ((void *)res.lgefn)
+ struct descr lgtfn[2];
+-#define LGTFN ((char *)res.lgtfn)
++#define LGTFN ((void *)res.lgtfn)
+ struct descr llefn[2];
+-#define LLEFN ((char *)res.llefn)
++#define LLEFN ((void *)res.llefn)
+ struct descr lltfn[2];
+-#define LLTFN ((char *)res.lltfn)
++#define LLTFN ((void *)res.lltfn)
+ struct descr lnefn[2];
+-#define LNEFN ((char *)res.lnefn)
++#define LNEFN ((void *)res.lnefn)
+ struct descr loadfn[2];
+-#define LOADFN ((char *)res.loadfn)
++#define LOADFN ((void *)res.loadfn)
+ struct descr locfn[2];
+-#define LOCFN ((char *)res.locfn)
++#define LOCFN ((void *)res.locfn)
+ struct descr lpadfn[2];
+-#define LPADFN ((char *)res.lpadfn)
++#define LPADFN ((void *)res.lpadfn)
+ struct descr ltfn[2];
+-#define LTFN ((char *)res.ltfn)
++#define LTFN ((void *)res.ltfn)
+ struct descr nefn[2];
+-#define NEFN ((char *)res.nefn)
++#define NEFN ((void *)res.nefn)
+ struct descr notafn[2];
+-#define NOTAFN ((char *)res.notafn)
++#define NOTAFN ((void *)res.notafn)
+ struct descr opsyfn[2];
+-#define OPSYFN ((char *)res.opsyfn)
++#define OPSYFN ((void *)res.opsyfn)
+ struct descr posfn[2];
+-#define POSFN ((char *)res.posfn)
++#define POSFN ((void *)res.posfn)
+ struct descr prinfn[2];
+-#define PRINFN ((char *)res.prinfn)
++#define PRINFN ((void *)res.prinfn)
+ struct descr protfn[2];
+-#define PROTFN ((char *)res.protfn)
++#define PROTFN ((void *)res.protfn)
+ struct descr remdfn[2];
+-#define REMDFN ((char *)res.remdfn)
++#define REMDFN ((void *)res.remdfn)
+ struct descr rplafn[2];
+-#define RPLAFN ((char *)res.rplafn)
++#define RPLAFN ((void *)res.rplafn)
+ struct descr readfn[2];
+-#define READFN ((char *)res.readfn)
++#define READFN ((void *)res.readfn)
+ struct descr revrfn[2];
+-#define REVRFN ((char *)res.revrfn)
++#define REVRFN ((void *)res.revrfn)
+ struct descr rewnfn[2];
+-#define REWNFN ((char *)res.rewnfn)
++#define REWNFN ((void *)res.rewnfn)
+ struct descr rposfn[2];
+-#define RPOSFN ((char *)res.rposfn)
++#define RPOSFN ((void *)res.rposfn)
+ struct descr rpadfn[2];
+-#define RPADFN ((char *)res.rpadfn)
++#define RPADFN ((void *)res.rpadfn)
+ struct descr rsrtfn[2];
+-#define RSRTFN ((char *)res.rsrtfn)
++#define RSRTFN ((void *)res.rsrtfn)
+ struct descr rtabfn[2];
+-#define RTABFN ((char *)res.rtabfn)
++#define RTABFN ((void *)res.rtabfn)
+ struct descr setfn[2];
+-#define SETFN ((char *)res.setfn)
++#define SETFN ((void *)res.setfn)
+ struct descr sizefn[2];
+-#define SIZEFN ((char *)res.sizefn)
++#define SIZEFN ((void *)res.sizefn)
+ struct descr sortfn[2];
+-#define SORTFN ((char *)res.sortfn)
++#define SORTFN ((void *)res.sortfn)
+ struct descr sstrfn[2];
+-#define SSTRFN ((char *)res.sstrfn)
++#define SSTRFN ((void *)res.sstrfn)
+ struct descr spanfn[2];
+-#define SPANFN ((char *)res.spanfn)
++#define SPANFN ((void *)res.spanfn)
+ struct descr stptfn[2];
+-#define STPTFN ((char *)res.stptfn)
++#define STPTFN ((void *)res.stptfn)
+ struct descr tabfn[2];
+-#define TABFN ((char *)res.tabfn)
++#define TABFN ((void *)res.tabfn)
+ struct descr thawfn[2];
+-#define THAWFN ((char *)res.thawfn)
++#define THAWFN ((void *)res.thawfn)
+ struct descr timfn[2];
+-#define TIMFN ((char *)res.timfn)
++#define TIMFN ((void *)res.timfn)
+ struct descr trcefn[2];
+-#define TRCEFN ((char *)res.trcefn)
++#define TRCEFN ((void *)res.trcefn)
+ struct descr trimfn[2];
+-#define TRIMFN ((char *)res.trimfn)
++#define TRIMFN ((void *)res.trimfn)
+ struct descr unldfn[2];
+-#define UNLDFN ((char *)res.unldfn)
++#define UNLDFN ((void *)res.unldfn)
+ struct descr valfn[2];
+-#define VALFN ((char *)res.valfn)
++#define VALFN ((void *)res.valfn)
+ #define FTBLND INITLS
+ struct descr initls[9];
+-#define INITLS ((char *)res.initls)
++#define INITLS ((void *)res.initls)
+ struct descr fnlist[147+20*2];
+-#define FNLIST ((char *)res.fnlist)
++#define FNLIST ((void *)res.fnlist)
+ #define FNCPLE OPTBL
+ struct descr optbl[1];
+-#define OPTBL ((char *)res.optbl)
++#define OPTBL ((void *)res.optbl)
+ struct descr addfn[3];
+-#define ADDFN ((char *)res.addfn)
++#define ADDFN ((void *)res.addfn)
+ struct descr biamfn[3];
+-#define BIAMFN ((char *)res.biamfn)
++#define BIAMFN ((void *)res.biamfn)
+ struct descr biatfn[3];
+-#define BIATFN ((char *)res.biatfn)
++#define BIATFN ((void *)res.biatfn)
+ struct descr bingfn[3];
+-#define BINGFN ((char *)res.bingfn)
++#define BINGFN ((void *)res.bingfn)
+ struct descr bipdfn[3];
+-#define BIPDFN ((char *)res.bipdfn)
++#define BIPDFN ((void *)res.bipdfn)
+ struct descr biprfn[3];
+-#define BIPRFN ((char *)res.biprfn)
++#define BIPRFN ((void *)res.biprfn)
+ #define BISNFN SCANFN
+ struct descr scanfn[3];
+-#define SCANFN ((char *)res.scanfn)
++#define SCANFN ((void *)res.scanfn)
+ struct descr biqsfn[3];
+-#define BIQSFN ((char *)res.biqsfn)
++#define BIQSFN ((void *)res.biqsfn)
+ #define BISRFN SJSRFN
+ struct descr sjsrfn[3];
+-#define SJSRFN ((char *)res.sjsrfn)
++#define SJSRFN ((void *)res.sjsrfn)
+ #define BIEQFN ASGNFN
+ struct descr asgnfn[3];
+-#define ASGNFN ((char *)res.asgnfn)
++#define ASGNFN ((void *)res.asgnfn)
+ struct descr confn[3];
+-#define CONFN ((char *)res.confn)
++#define CONFN ((void *)res.confn)
+ struct descr divfn[3];
+-#define DIVFN ((char *)res.divfn)
++#define DIVFN ((void *)res.divfn)
+ struct descr dolfn[3];
+-#define DOLFN ((char *)res.dolfn)
++#define DOLFN ((void *)res.dolfn)
+ struct descr expfn[3];
+-#define EXPFN ((char *)res.expfn)
++#define EXPFN ((void *)res.expfn)
+ struct descr mpyfn[3];
+-#define MPYFN ((char *)res.mpyfn)
++#define MPYFN ((void *)res.mpyfn)
+ struct descr namfn[3];
+-#define NAMFN ((char *)res.namfn)
++#define NAMFN ((void *)res.namfn)
+ struct descr orfn[3];
+-#define ORFN ((char *)res.orfn)
++#define ORFN ((void *)res.orfn)
+ struct descr subfn[3];
+-#define SUBFN ((char *)res.subfn)
++#define SUBFN ((void *)res.subfn)
+ struct descr arowfn[2];
+-#define AROWFN ((char *)res.arowfn)
++#define AROWFN ((void *)res.arowfn)
+ struct descr atfn[2];
+-#define ATFN ((char *)res.atfn)
++#define ATFN ((void *)res.atfn)
+ struct descr barfn[2];
+-#define BARFN ((char *)res.barfn)
++#define BARFN ((void *)res.barfn)
+ struct descr dotfn[2];
+-#define DOTFN ((char *)res.dotfn)
++#define DOTFN ((void *)res.dotfn)
+ struct descr indfn[2];
+-#define INDFN ((char *)res.indfn)
++#define INDFN ((void *)res.indfn)
+ struct descr keyfn[2];
+-#define KEYFN ((char *)res.keyfn)
++#define KEYFN ((void *)res.keyfn)
+ struct descr mnsfn[2];
+-#define MNSFN ((char *)res.mnsfn)
++#define MNSFN ((void *)res.mnsfn)
+ struct descr negfn[2];
+-#define NEGFN ((char *)res.negfn)
++#define NEGFN ((void *)res.negfn)
+ struct descr pdfn[2];
+-#define PDFN ((char *)res.pdfn)
++#define PDFN ((void *)res.pdfn)
+ struct descr plsfn[2];
+-#define PLSFN ((char *)res.plsfn)
++#define PLSFN ((void *)res.plsfn)
+ struct descr prfn[2];
+-#define PRFN ((char *)res.prfn)
++#define PRFN ((void *)res.prfn)
+ struct descr quesfn[2];
+-#define QUESFN ((char *)res.quesfn)
++#define QUESFN ((void *)res.quesfn)
+ struct descr slhfn[2];
+-#define SLHFN ((char *)res.slhfn)
++#define SLHFN ((void *)res.slhfn)
+ struct descr strfn[2];
+-#define STRFN ((char *)res.strfn)
++#define STRFN ((void *)res.strfn)
+ #define OPTBND AREFN
+ struct descr arefn[1];
+-#define AREFN ((char *)res.arefn)
++#define AREFN ((void *)res.arefn)
+ struct descr basefn[1];
+-#define BASEFN ((char *)res.basefn)
++#define BASEFN ((void *)res.basefn)
+ struct descr cmafn[1];
+-#define CMAFN ((char *)res.cmafn)
++#define CMAFN ((void *)res.cmafn)
+ struct descr endafn[1];
+-#define ENDAFN ((char *)res.endafn)
++#define ENDAFN ((void *)res.endafn)
+ struct descr endfn[1];
+-#define ENDFN ((char *)res.endfn)
++#define ENDFN ((void *)res.endfn)
+ struct descr erorfn[1];
+-#define ERORFN ((char *)res.erorfn)
++#define ERORFN ((void *)res.erorfn)
+ struct descr fntrfn[1];
+-#define FNTRFN ((char *)res.fntrfn)
++#define FNTRFN ((void *)res.fntrfn)
+ struct descr fxtrfn[1];
+-#define FXTRFN ((char *)res.fxtrfn)
++#define FXTRFN ((void *)res.fxtrfn)
+ struct descr gotgfn[1];
+-#define GOTGFN ((char *)res.gotgfn)
++#define GOTGFN ((void *)res.gotgfn)
+ struct descr gotlfn[1];
+-#define GOTLFN ((char *)res.gotlfn)
++#define GOTLFN ((void *)res.gotlfn)
+ struct descr gotofn[1];
+-#define GOTOFN ((char *)res.gotofn)
++#define GOTOFN ((void *)res.gotofn)
+ struct descr initfn[1];
+-#define INITFN ((char *)res.initfn)
++#define INITFN ((void *)res.initfn)
+ struct descr keytfn[1];
+-#define KEYTFN ((char *)res.keytfn)
++#define KEYTFN ((void *)res.keytfn)
+ struct descr labtfn[1];
+-#define LABTFN ((char *)res.labtfn)
++#define LABTFN ((void *)res.labtfn)
+ struct descr litfn[1];
+-#define LITFN ((char *)res.litfn)
++#define LITFN ((void *)res.litfn)
+ struct descr vltrfn[1];
+-#define VLTRFN ((char *)res.vltrfn)
++#define VLTRFN ((void *)res.vltrfn)
+ struct descr anycfn[1];
+-#define ANYCFN ((char *)res.anycfn)
++#define ANYCFN ((void *)res.anycfn)
+ struct descr arbffn[1];
+-#define ARBFFN ((char *)res.arbffn)
++#define ARBFFN ((void *)res.arbffn)
+ struct descr arbnfn[1];
+-#define ARBNFN ((char *)res.arbnfn)
++#define ARBNFN ((void *)res.arbnfn)
+ struct descr atopfn[1];
+-#define ATOPFN ((char *)res.atopfn)
++#define ATOPFN ((void *)res.atopfn)
+ struct descr chrfn[1];
+-#define CHRFN ((char *)res.chrfn)
++#define CHRFN ((void *)res.chrfn)
+ struct descr balfn[1];
+-#define BALFN ((char *)res.balfn)
++#define BALFN ((void *)res.balfn)
+ struct descr balffn[1];
+-#define BALFFN ((char *)res.balffn)
++#define BALFFN ((void *)res.balffn)
+ struct descr brkcfn[1];
+-#define BRKCFN ((char *)res.brkcfn)
++#define BRKCFN ((void *)res.brkcfn)
+ struct descr brxcfn[1];
+-#define BRXCFN ((char *)res.brxcfn)
++#define BRXCFN ((void *)res.brxcfn)
+ struct descr brfcfn[1];
+-#define BRFCFN ((char *)res.brfcfn)
++#define BRFCFN ((void *)res.brfcfn)
+ struct descr dnmefn[1];
+-#define DNMEFN ((char *)res.dnmefn)
++#define DNMEFN ((void *)res.dnmefn)
+ struct descr dnmifn[1];
+-#define DNMIFN ((char *)res.dnmifn)
++#define DNMIFN ((void *)res.dnmifn)
+ struct descr earbfn[1];
+-#define EARBFN ((char *)res.earbfn)
++#define EARBFN ((void *)res.earbfn)
+ struct descr dsarfn[1];
+-#define DSARFN ((char *)res.dsarfn)
++#define DSARFN ((void *)res.dsarfn)
+ struct descr enmefn[1];
+-#define ENMEFN ((char *)res.enmefn)
++#define ENMEFN ((void *)res.enmefn)
+ struct descr enmifn[1];
+-#define ENMIFN ((char *)res.enmifn)
++#define ENMIFN ((void *)res.enmifn)
+ struct descr farbfn[1];
+-#define FARBFN ((char *)res.farbfn)
++#define FARBFN ((void *)res.farbfn)
+ struct descr fnmefn[1];
+-#define FNMEFN ((char *)res.fnmefn)
++#define FNMEFN ((void *)res.fnmefn)
+ struct descr lnthfn[1];
+-#define LNTHFN ((char *)res.lnthfn)
++#define LNTHFN ((void *)res.lnthfn)
+ struct descr nmefn[1];
+-#define NMEFN ((char *)res.nmefn)
++#define NMEFN ((void *)res.nmefn)
+ struct descr nnycfn[1];
+-#define NNYCFN ((char *)res.nnycfn)
++#define NNYCFN ((void *)res.nnycfn)
+ struct descr onarfn[1];
+-#define ONARFN ((char *)res.onarfn)
++#define ONARFN ((void *)res.onarfn)
+ struct descr onrffn[1];
+-#define ONRFFN ((char *)res.onrffn)
++#define ONRFFN ((void *)res.onrffn)
+ struct descr posifn[1];
+-#define POSIFN ((char *)res.posifn)
++#define POSIFN ((void *)res.posifn)
+ struct descr rpsifn[1];
+-#define RPSIFN ((char *)res.rpsifn)
++#define RPSIFN ((void *)res.rpsifn)
+ struct descr rtbfn[1];
+-#define RTBFN ((char *)res.rtbfn)
++#define RTBFN ((void *)res.rtbfn)
+ struct descr salffn[1];
+-#define SALFFN ((char *)res.salffn)
++#define SALFFN ((void *)res.salffn)
+ struct descr scflfn[1];
+-#define SCFLFN ((char *)res.scflfn)
++#define SCFLFN ((void *)res.scflfn)
+ struct descr scokfn[1];
+-#define SCOKFN ((char *)res.scokfn)
++#define SCOKFN ((void *)res.scokfn)
+ struct descr sconfn[1];
+-#define SCONFN ((char *)res.sconfn)
++#define SCONFN ((void *)res.sconfn)
+ struct descr spncfn[1];
+-#define SPNCFN ((char *)res.spncfn)
++#define SPNCFN ((void *)res.spncfn)
+ struct descr starfn[1];
+-#define STARFN ((char *)res.starfn)
++#define STARFN ((void *)res.starfn)
+ struct descr tbfn[1];
+-#define TBFN ((char *)res.tbfn)
++#define TBFN ((void *)res.tbfn)
+ struct descr aborfn[1];
+-#define ABORFN ((char *)res.aborfn)
++#define ABORFN ((void *)res.aborfn)
+ struct descr fncefn[1];
+-#define FNCEFN ((char *)res.fncefn)
++#define FNCEFN ((void *)res.fncefn)
+ struct descr fncffn[1];
+-#define FNCFFN ((char *)res.fncffn)
++#define FNCFFN ((void *)res.fncffn)
+ struct descr sucffn[1];
+-#define SUCFFN ((char *)res.sucffn)
++#define SUCFFN ((void *)res.sucffn)
+ struct spec abndsp[1];
+-#define ABNDSP ((char *)res.abndsp)
++#define ABNDSP ((void *)res.abndsp)
+ struct spec aborsp[1];
+-#define ABORSP ((char *)res.aborsp)
++#define ABORSP ((void *)res.aborsp)
+ struct spec alnmsp[1];
+-#define ALNMSP ((char *)res.alnmsp)
++#define ALNMSP ((void *)res.alnmsp)
+ struct spec anchsp[1];
+-#define ANCHSP ((char *)res.anchsp)
++#define ANCHSP ((void *)res.anchsp)
+ struct spec anysp[1];
+-#define ANYSP ((char *)res.anysp)
++#define ANYSP ((void *)res.anysp)
+ struct spec aplysp[1];
+-#define APLYSP ((char *)res.aplysp)
++#define APLYSP ((void *)res.aplysp)
+ struct spec arbsp[1];
+-#define ARBSP ((char *)res.arbsp)
++#define ARBSP ((void *)res.arbsp)
+ struct spec arbnsp[1];
+-#define ARBNSP ((char *)res.arbnsp)
++#define ARBNSP ((void *)res.arbnsp)
+ struct spec argsp[1];
+-#define ARGSP ((char *)res.argsp)
++#define ARGSP ((void *)res.argsp)
+ struct spec backsp[1];
+-#define BACKSP ((char *)res.backsp)
++#define BACKSP ((void *)res.backsp)
+ struct spec balsp[1];
+-#define BALSP ((char *)res.balsp)
++#define BALSP ((void *)res.balsp)
+ struct spec brksp[1];
+-#define BRKSP ((char *)res.brksp)
++#define BRKSP ((void *)res.brksp)
+ struct spec brkxsp[1];
+-#define BRKXSP ((char *)res.brkxsp)
++#define BRKXSP ((void *)res.brkxsp)
+ struct spec trfrsp[1];
+-#define TRFRSP ((char *)res.trfrsp)
++#define TRFRSP ((void *)res.trfrsp)
+ struct spec casesp[1];
+-#define CASESP ((char *)res.casesp)
++#define CASESP ((void *)res.casesp)
+ struct spec charsp[1];
+-#define CHARSP ((char *)res.charsp)
++#define CHARSP ((void *)res.charsp)
+ struct spec clersp[1];
+-#define CLERSP ((char *)res.clersp)
++#define CLERSP ((void *)res.clersp)
+ struct spec codesp[1];
+-#define CODESP ((char *)res.codesp)
++#define CODESP ((void *)res.codesp)
+ struct spec clsp[1];
+-#define CLSP ((char *)res.clsp)
++#define CLSP ((void *)res.clsp)
+ struct spec cnvtsp[1];
+-#define CNVTSP ((char *)res.cnvtsp)
++#define CNVTSP ((void *)res.cnvtsp)
+ struct spec copysp[1];
+-#define COPYSP ((char *)res.copysp)
++#define COPYSP ((void *)res.copysp)
+ struct spec datsp[1];
+-#define DATSP ((char *)res.datsp)
++#define DATSP ((void *)res.datsp)
+ struct spec datasp[1];
+-#define DATASP ((char *)res.datasp)
++#define DATASP ((void *)res.datasp)
+ struct spec defisp[1];
+-#define DEFISP ((char *)res.defisp)
++#define DEFISP ((void *)res.defisp)
+ struct spec diffsp[1];
+-#define DIFFSP ((char *)res.diffsp)
++#define DIFFSP ((void *)res.diffsp)
+ struct spec dtchsp[1];
+-#define DTCHSP ((char *)res.dtchsp)
++#define DTCHSP ((void *)res.dtchsp)
+ struct spec dtsp[1];
+-#define DTSP ((char *)res.dtsp)
++#define DTSP ((void *)res.dtsp)
+ struct spec dumpsp[1];
+-#define DUMPSP ((char *)res.dumpsp)
++#define DUMPSP ((void *)res.dumpsp)
+ struct spec duplsp[1];
+-#define DUPLSP ((char *)res.duplsp)
++#define DUPLSP ((void *)res.duplsp)
+ struct spec endsp[1];
+-#define ENDSP ((char *)res.endsp)
++#define ENDSP ((void *)res.endsp)
+ struct spec endfsp[1];
+-#define ENDFSP ((char *)res.endfsp)
++#define ENDFSP ((void *)res.endfsp)
+ struct spec eqsp[1];
+-#define EQSP ((char *)res.eqsp)
++#define EQSP ((void *)res.eqsp)
+ struct spec errlsp[1];
+-#define ERRLSP ((char *)res.errlsp)
++#define ERRLSP ((void *)res.errlsp)
+ struct spec errtsp[1];
+-#define ERRTSP ((char *)res.errtsp)
++#define ERRTSP ((void *)res.errtsp)
+ struct spec ertxsp[1];
+-#define ERTXSP ((char *)res.ertxsp)
++#define ERTXSP ((void *)res.ertxsp)
+ struct spec evalsp[1];
+-#define EVALSP ((char *)res.evalsp)
++#define EVALSP ((void *)res.evalsp)
+ struct spec expsp[1];
+-#define EXPSP ((char *)res.expsp)
++#define EXPSP ((void *)res.expsp)
+ struct spec failsp[1];
+-#define FAILSP ((char *)res.failsp)
++#define FAILSP ((void *)res.failsp)
+ struct spec fncesp[1];
+-#define FNCESP ((char *)res.fncesp)
++#define FNCESP ((void *)res.fncesp)
+ struct spec fldssp[1];
+-#define FLDSSP ((char *)res.fldssp)
++#define FLDSSP ((void *)res.fldssp)
+ struct spec fnclsp[1];
+-#define FNCLSP ((char *)res.fnclsp)
++#define FNCLSP ((void *)res.fnclsp)
+ struct spec frezsp[1];
+-#define FREZSP ((char *)res.frezsp)
++#define FREZSP ((void *)res.frezsp)
+ struct spec fretsp[1];
+-#define FRETSP ((char *)res.fretsp)
++#define FRETSP ((void *)res.fretsp)
+ struct spec ftrcsp[1];
+-#define FTRCSP ((char *)res.ftrcsp)
++#define FTRCSP ((void *)res.ftrcsp)
+ struct spec fullsp[1];
+-#define FULLSP ((char *)res.fullsp)
++#define FULLSP ((void *)res.fullsp)
+ struct spec funtsp[1];
+-#define FUNTSP ((char *)res.funtsp)
++#define FUNTSP ((void *)res.funtsp)
+ struct spec gesp[1];
+-#define GESP ((char *)res.gesp)
++#define GESP ((void *)res.gesp)
+ struct spec gtsp[1];
+-#define GTSP ((char *)res.gtsp)
++#define GTSP ((void *)res.gtsp)
+ struct spec idensp[1];
+-#define IDENSP ((char *)res.idensp)
++#define IDENSP ((void *)res.idensp)
+ struct spec insp[1];
+-#define INSP ((char *)res.insp)
++#define INSP ((void *)res.insp)
+ struct spec intgsp[1];
+-#define INTGSP ((char *)res.intgsp)
++#define INTGSP ((void *)res.intgsp)
+ struct spec itemsp[1];
+-#define ITEMSP ((char *)res.itemsp)
++#define ITEMSP ((void *)res.itemsp)
+ struct spec trkysp[1];
+-#define TRKYSP ((char *)res.trkysp)
++#define TRKYSP ((void *)res.trkysp)
+ struct spec trlasp[1];
+-#define TRLASP ((char *)res.trlasp)
++#define TRLASP ((void *)res.trlasp)
+ struct spec lstnsp[1];
+-#define LSTNSP ((char *)res.lstnsp)
++#define LSTNSP ((void *)res.lstnsp)
+ struct spec lcnmsp[1];
+-#define LCNMSP ((char *)res.lcnmsp)
++#define LCNMSP ((void *)res.lcnmsp)
+ struct spec lensp[1];
+-#define LENSP ((char *)res.lensp)
++#define LENSP ((void *)res.lensp)
+ struct spec lesp[1];
+-#define LESP ((char *)res.lesp)
++#define LESP ((void *)res.lesp)
+ struct spec leqsp[1];
+-#define LEQSP ((char *)res.leqsp)
++#define LEQSP ((void *)res.leqsp)
+ struct spec lgesp[1];
+-#define LGESP ((char *)res.lgesp)
++#define LGESP ((void *)res.lgesp)
+ struct spec lgtsp[1];
+-#define LGTSP ((char *)res.lgtsp)
++#define LGTSP ((void *)res.lgtsp)
+ struct spec llesp[1];
+-#define LLESP ((char *)res.llesp)
++#define LLESP ((void *)res.llesp)
+ struct spec lltsp[1];
+-#define LLTSP ((char *)res.lltsp)
++#define LLTSP ((void *)res.lltsp)
+ struct spec lnesp[1];
+-#define LNESP ((char *)res.lnesp)
++#define LNESP ((void *)res.lnesp)
+ struct spec loadsp[1];
+-#define LOADSP ((char *)res.loadsp)
++#define LOADSP ((void *)res.loadsp)
+ struct spec locsp[1];
+-#define LOCSP ((char *)res.locsp)
++#define LOCSP ((void *)res.locsp)
+ struct spec lpadsp[1];
+-#define LPADSP ((char *)res.lpadsp)
++#define LPADSP ((void *)res.lpadsp)
+ struct spec ltsp[1];
+-#define LTSP ((char *)res.ltsp)
++#define LTSP ((void *)res.ltsp)
+ struct spec maxlsp[1];
+-#define MAXLSP ((char *)res.maxlsp)
++#define MAXLSP ((void *)res.maxlsp)
+ struct spec namesp[1];
+-#define NAMESP ((char *)res.namesp)
++#define NAMESP ((void *)res.namesp)
+ struct spec nesp[1];
+-#define NESP ((char *)res.nesp)
++#define NESP ((void *)res.nesp)
+ struct spec nnysp[1];
+-#define NNYSP ((char *)res.nnysp)
++#define NNYSP ((void *)res.nnysp)
+ struct spec nretsp[1];
+-#define NRETSP ((char *)res.nretsp)
++#define NRETSP ((void *)res.nretsp)
+ struct spec numsp[1];
+-#define NUMSP ((char *)res.numsp)
++#define NUMSP ((void *)res.numsp)
+ struct spec opsnsp[1];
+-#define OPSNSP ((char *)res.opsnsp)
++#define OPSNSP ((void *)res.opsnsp)
+ struct spec outsp[1];
+-#define OUTSP ((char *)res.outsp)
++#define OUTSP ((void *)res.outsp)
+ struct spec parmsp[1];
+-#define PARMSP ((char *)res.parmsp)
++#define PARMSP ((void *)res.parmsp)
+ struct spec patsp[1];
+-#define PATSP ((char *)res.patsp)
++#define PATSP ((void *)res.patsp)
+ struct spec possp[1];
+-#define POSSP ((char *)res.possp)
++#define POSSP ((void *)res.possp)
+ struct spec prtsp[1];
+-#define PRTSP ((char *)res.prtsp)
++#define PRTSP ((void *)res.prtsp)
+ struct spec rlsp[1];
+-#define RLSP ((char *)res.rlsp)
++#define RLSP ((void *)res.rlsp)
+ struct spec remsp[1];
+-#define REMSP ((char *)res.remsp)
++#define REMSP ((void *)res.remsp)
+ struct spec remdsp[1];
+-#define REMDSP ((char *)res.remdsp)
++#define REMDSP ((void *)res.remdsp)
+ struct spec retsp[1];
+-#define RETSP ((char *)res.retsp)
++#define RETSP ((void *)res.retsp)
+ struct spec revrsp[1];
+-#define REVRSP ((char *)res.revrsp)
++#define REVRSP ((void *)res.revrsp)
+ struct spec rewnsp[1];
+-#define REWNSP ((char *)res.rewnsp)
++#define REWNSP ((void *)res.rewnsp)
+ struct spec rplcsp[1];
+-#define RPLCSP ((char *)res.rplcsp)
++#define RPLCSP ((void *)res.rplcsp)
+ struct spec rpossp[1];
+-#define RPOSSP ((char *)res.rpossp)
++#define RPOSSP ((void *)res.rpossp)
+ struct spec rpadsp[1];
+-#define RPADSP ((char *)res.rpadsp)
++#define RPADSP ((void *)res.rpadsp)
+ struct spec rsrtsp[1];
+-#define RSRTSP ((char *)res.rsrtsp)
++#define RSRTSP ((void *)res.rsrtsp)
+ struct spec rtabsp[1];
+-#define RTABSP ((char *)res.rtabsp)
++#define RTABSP ((void *)res.rtabsp)
+ struct spec rtypsp[1];
+-#define RTYPSP ((char *)res.rtypsp)
++#define RTYPSP ((void *)res.rtypsp)
+ struct spec setsp[1];
+-#define SETSP ((char *)res.setsp)
++#define SETSP ((void *)res.setsp)
+ struct spec sizesp[1];
+-#define SIZESP ((char *)res.sizesp)
++#define SIZESP ((void *)res.sizesp)
+ struct spec sstrsp[1];
+-#define SSTRSP ((char *)res.sstrsp)
++#define SSTRSP ((void *)res.sstrsp)
+ struct spec sortsp[1];
+-#define SORTSP ((char *)res.sortsp)
++#define SORTSP ((void *)res.sortsp)
+ struct spec spansp[1];
+-#define SPANSP ((char *)res.spansp)
++#define SPANSP ((void *)res.spansp)
+ struct spec stctsp[1];
+-#define STCTSP ((char *)res.stctsp)
++#define STCTSP ((void *)res.stctsp)
+ struct spec stfcsp[1];
+-#define STFCSP ((char *)res.stfcsp)
++#define STFCSP ((void *)res.stfcsp)
+ struct spec stlmsp[1];
+-#define STLMSP ((char *)res.stlmsp)
++#define STLMSP ((void *)res.stlmsp)
+ struct spec stptsp[1];
+-#define STPTSP ((char *)res.stptsp)
++#define STPTSP ((void *)res.stptsp)
+ struct spec stnosp[1];
+-#define STNOSP ((char *)res.stnosp)
++#define STNOSP ((void *)res.stnosp)
+ struct spec varsp[1];
+-#define VARSP ((char *)res.varsp)
++#define VARSP ((void *)res.varsp)
+ struct spec succsp[1];
+-#define SUCCSP ((char *)res.succsp)
++#define SUCCSP ((void *)res.succsp)
+ struct spec tabsp[1];
+-#define TABSP ((char *)res.tabsp)
++#define TABSP ((void *)res.tabsp)
+ struct spec termsp[1];
+-#define TERMSP ((char *)res.termsp)
++#define TERMSP ((void *)res.termsp)
+ struct spec thawsp[1];
+-#define THAWSP ((char *)res.thawsp)
++#define THAWSP ((void *)res.thawsp)
+ struct spec timsp[1];
+-#define TIMSP ((char *)res.timsp)
++#define TIMSP ((void *)res.timsp)
+ struct spec trcesp[1];
+-#define TRCESP ((char *)res.trcesp)
++#define TRCESP ((void *)res.trcesp)
+ struct spec trmsp[1];
+-#define TRMSP ((char *)res.trmsp)
++#define TRMSP ((void *)res.trmsp)
+ struct spec ucnmsp[1];
+-#define UCNMSP ((char *)res.ucnmsp)
++#define UCNMSP ((void *)res.ucnmsp)
+ struct spec unldsp[1];
+-#define UNLDSP ((char *)res.unldsp)
++#define UNLDSP ((void *)res.unldsp)
+ struct spec valsp[1];
+-#define VALSP ((char *)res.valsp)
++#define VALSP ((void *)res.valsp)
+ struct spec crdfsp[1];
+-#define CRDFSP ((char *)res.crdfsp)
++#define CRDFSP ((void *)res.crdfsp)
+ struct spec outpsp[1];
+-#define OUTPSP ((char *)res.outpsp)
++#define OUTPSP ((void *)res.outpsp)
+ struct descr abndb[19];
+-#define ABNDB ((char *)res.abndb)
++#define ABNDB ((void *)res.abndb)
+ struct descr dtend[1];
+-#define DTEND ((char *)res.dtend)
++#define DTEND ((void *)res.dtend)
+ struct descr prmtbl[19];
+-#define PRMTBL ((char *)res.prmtbl)
++#define PRMTBL ((void *)res.prmtbl)
+ #define PRMTRM OBLOCK
+ struct descr oblock[4];
+-#define OBLOCK ((char *)res.oblock)
++#define OBLOCK ((void *)res.oblock)
+ struct descr obstrt[OBSIZ];
+-#define OBSTRT ((char *)res.obstrt)
++#define OBSTRT ((void *)res.obstrt)
+ struct descr stack[1+STSIZE];
+-#define STACK ((char *)res.stack)
++#define STACK ((void *)res.stack)
+ struct descr aborpt[4];
+-#define ABORPT ((char *)res.aborpt)
++#define ABORPT ((void *)res.aborpt)
+ struct descr arbak[7];
+-#define ARBAK ((char *)res.arbak)
++#define ARBAK ((void *)res.arbak)
+ struct descr arbpt[10];
+-#define ARBPT ((char *)res.arbpt)
++#define ARBPT ((void *)res.arbpt)
+ struct descr arhed[13];
+-#define ARHED ((char *)res.arhed)
++#define ARHED ((void *)res.arhed)
+ struct descr artal[7];
+-#define ARTAL ((char *)res.artal)
++#define ARTAL ((void *)res.artal)
+ struct descr balpt[10];
+-#define BALPT ((char *)res.balpt)
++#define BALPT ((void *)res.balpt)
+ struct descr failpt[4];
+-#define FAILPT ((char *)res.failpt)
++#define FAILPT ((void *)res.failpt)
+ struct descr fncept[4];
+-#define FNCEPT ((char *)res.fncept)
++#define FNCEPT ((void *)res.fncept)
+ struct descr rempt[5];
+-#define REMPT ((char *)res.rempt)
++#define REMPT ((void *)res.rempt)
+ struct descr starpt[12];
+-#define STARPT ((char *)res.starpt)
++#define STARPT ((void *)res.starpt)
+ struct descr succpt[4];
+-#define SUCCPT ((char *)res.succpt)
++#define SUCCPT ((void *)res.succpt)
+ struct descr tvalpl[3];
+-#define TVALPL ((char *)res.tvalpl)
++#define TVALPL ((void *)res.tvalpl)
+ struct descr tlabpl[3];
+-#define TLABPL ((char *)res.tlabpl)
++#define TLABPL ((void *)res.tlabpl)
+ struct descr tfenpl[3];
+-#define TFENPL ((char *)res.tfenpl)
++#define TFENPL ((void *)res.tfenpl)
+ struct descr tfexpl[3];
+-#define TFEXPL ((char *)res.tfexpl)
++#define TFEXPL ((void *)res.tfexpl)
+ struct descr tkeypl[3];
+-#define TKEYPL ((char *)res.tkeypl)
++#define TKEYPL ((void *)res.tkeypl)
+ struct descr valblk[7];
+-#define VALBLK ((char *)res.valblk)
++#define VALBLK ((void *)res.valblk)
+ struct descr msglst[33];
+-#define MSGLST ((char *)res.msglst)
++#define MSGLST ((void *)res.msglst)
+ struct spec msg1[1];
+-#define MSG1 ((char *)res.msg1)
++#define MSG1 ((void *)res.msg1)
+ struct spec msg2[1];
+-#define MSG2 ((char *)res.msg2)
++#define MSG2 ((void *)res.msg2)
+ struct spec msg3[1];
+-#define MSG3 ((char *)res.msg3)
++#define MSG3 ((void *)res.msg3)
+ struct spec msg4[1];
+-#define MSG4 ((char *)res.msg4)
++#define MSG4 ((void *)res.msg4)
+ struct spec msg5[1];
+-#define MSG5 ((char *)res.msg5)
++#define MSG5 ((void *)res.msg5)
+ struct spec msg6[1];
+-#define MSG6 ((char *)res.msg6)
++#define MSG6 ((void *)res.msg6)
+ struct spec msg7[1];
+-#define MSG7 ((char *)res.msg7)
++#define MSG7 ((void *)res.msg7)
+ struct spec msg8[1];
+-#define MSG8 ((char *)res.msg8)
++#define MSG8 ((void *)res.msg8)
+ struct spec msg9[1];
+-#define MSG9 ((char *)res.msg9)
++#define MSG9 ((void *)res.msg9)
+ struct spec msg10[1];
+-#define MSG10 ((char *)res.msg10)
++#define MSG10 ((void *)res.msg10)
+ struct spec msg11[1];
+-#define MSG11 ((char *)res.msg11)
++#define MSG11 ((void *)res.msg11)
+ struct spec msg12[1];
+-#define MSG12 ((char *)res.msg12)
++#define MSG12 ((void *)res.msg12)
+ struct spec msg13[1];
+-#define MSG13 ((char *)res.msg13)
++#define MSG13 ((void *)res.msg13)
+ struct spec msg14[1];
+-#define MSG14 ((char *)res.msg14)
++#define MSG14 ((void *)res.msg14)
+ struct spec msg15[1];
+-#define MSG15 ((char *)res.msg15)
++#define MSG15 ((void *)res.msg15)
+ struct spec msg16[1];
+-#define MSG16 ((char *)res.msg16)
++#define MSG16 ((void *)res.msg16)
+ struct spec msg17[1];
+-#define MSG17 ((char *)res.msg17)
++#define MSG17 ((void *)res.msg17)
+ struct spec msg18[1];
+-#define MSG18 ((char *)res.msg18)
++#define MSG18 ((void *)res.msg18)
+ struct spec msg19[1];
+-#define MSG19 ((char *)res.msg19)
++#define MSG19 ((void *)res.msg19)
+ struct spec msg20[1];
+-#define MSG20 ((char *)res.msg20)
++#define MSG20 ((void *)res.msg20)
+ struct spec msg21[1];
+-#define MSG21 ((char *)res.msg21)
++#define MSG21 ((void *)res.msg21)
+ struct spec msg22[1];
+-#define MSG22 ((char *)res.msg22)
++#define MSG22 ((void *)res.msg22)
+ struct spec msg23[1];
+-#define MSG23 ((char *)res.msg23)
++#define MSG23 ((void *)res.msg23)
+ struct spec msg24[1];
+-#define MSG24 ((char *)res.msg24)
++#define MSG24 ((void *)res.msg24)
+ struct spec msg25[1];
+-#define MSG25 ((char *)res.msg25)
++#define MSG25 ((void *)res.msg25)
+ struct spec msg26[1];
+-#define MSG26 ((char *)res.msg26)
++#define MSG26 ((void *)res.msg26)
+ struct spec msg27[1];
+-#define MSG27 ((char *)res.msg27)
++#define MSG27 ((void *)res.msg27)
+ struct spec msg28[1];
+-#define MSG28 ((char *)res.msg28)
++#define MSG28 ((void *)res.msg28)
+ struct spec msg29[1];
+-#define MSG29 ((char *)res.msg29)
++#define MSG29 ((void *)res.msg29)
+ struct spec msg30[1];
+-#define MSG30 ((char *)res.msg30)
++#define MSG30 ((void *)res.msg30)
+ struct spec msg31[1];
+-#define MSG31 ((char *)res.msg31)
++#define MSG31 ((void *)res.msg31)
+ struct spec msg32[1];
+-#define MSG32 ((char *)res.msg32)
++#define MSG32 ((void *)res.msg32)
+ struct spec emsg1[1];
+-#define EMSG1 ((char *)res.emsg1)
++#define EMSG1 ((void *)res.emsg1)
+ struct spec emsg2[1];
+-#define EMSG2 ((char *)res.emsg2)
++#define EMSG2 ((void *)res.emsg2)
+ struct spec emsg3[1];
+-#define EMSG3 ((char *)res.emsg3)
++#define EMSG3 ((void *)res.emsg3)
+ struct spec emsg14[1];
+-#define EMSG14 ((char *)res.emsg14)
++#define EMSG14 ((void *)res.emsg14)
+ struct spec ilchar[1];
+-#define ILCHAR ((char *)res.ilchar)
++#define ILCHAR ((void *)res.ilchar)
+ struct spec illbin[1];
+-#define ILLBIN ((char *)res.illbin)
++#define ILLBIN ((void *)res.illbin)
+ struct spec illbrk[1];
+-#define ILLBRK ((char *)res.illbrk)
++#define ILLBRK ((void *)res.illbrk)
+ struct spec illdec[1];
+-#define ILLDEC ((char *)res.illdec)
++#define ILLDEC ((void *)res.illdec)
+ struct spec illeos[1];
+-#define ILLEOS ((char *)res.illeos)
++#define ILLEOS ((void *)res.illeos)
+ struct spec illint[1];
+-#define ILLINT ((char *)res.illint)
++#define ILLINT ((void *)res.illint)
+ struct spec opnlit[1];
+-#define OPNLIT ((char *)res.opnlit)
++#define OPNLIT ((void *)res.opnlit)
+ };
OpenPOWER on IntegriCloud