diff options
| author | wes <wes@FreeBSD.org> | 2003-06-04 04:45:54 +0000 |
|---|---|---|
| committer | wes <wes@FreeBSD.org> | 2003-06-04 04:45:54 +0000 |
| commit | 36925a2eeeea4b8257512b8745b4ba6bcd221785 (patch) | |
| tree | a9def759c311df94716731cbb3ea95f6cbc07654 /lang/snobol | |
| parent | fa19da4720b7d7103e2770e11485ca4434e726d9 (diff) | |
| download | FreeBSD-ports-36925a2eeeea4b8257512b8745b4ba6bcd221785.zip FreeBSD-ports-36925a2eeeea4b8257512b8745b4ba6bcd221785.tar.gz | |
Compile cleanly on GCC 3.x
Approved by: kris@
Diffstat (limited to 'lang/snobol')
| -rw-r--r-- | lang/snobol/Makefile | 11 | ||||
| -rw-r--r-- | lang/snobol/files/patch-ad | 11 | ||||
| -rw-r--r-- | lang/snobol/files/patch-ae | 2285 |
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) + }; |
