Compile cleanly on GCC 3.x

Approved by:	kris@

3 files changed, 2307 insertions, 0 deletions

diff --git a/lang/snobol/Makefile b/lang/snobol/Makefile
index 1e4878a4b877..e70ecedd6501 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 000000000000..37c993a7aace
--- /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 000000000000..87e214a1ca18
--- /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)
+ };