Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume21/ecu/part13

Text File | 1991-08-05 | 53.4 KB | 2,363 lines

Newsgroups: comp.sources.misc
From: Warren Tucker <[e-mail]>
Subject:  v21i065:  ecu - ECU async comm package rev 3.10, Part13/37
Message-ID: <[e-mail]>
X-Md4-Signature: cf7e0efdf5e487b3b9c63e4ca9af2145
Date: Sun, 4 Aug 1991 01:58:03 GMT
Approved: [e-mail]

Submitted-by: Warren Tucker <[e-mail]>
Posting-number: Volume 21, Issue 65
Archive-name: ecu/part13
Environment: SCO, XENIX, ISC
Supersedes: ecu3: Volume 16, Issue 25-59

---- Cut Here and feed the following to sh ----
#!/bin/sh
# this is ecu310.13 (part 13 of ecu310)
# do not concatenate these parts, unpack them in order with /bin/sh
# file expresp.c continued
#
if touch 2>&1 | fgrep 'amc' > /dev/null
 then TOUCH=touch
 else TOUCH=true
fi
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 13; then
    echo Please unpack part "$Scheck" next!
    exit 1
 else
    exit 0
 fi
) < _shar_seq_.tmp || exit 1
if test ! -f _shar_wnt_.tmp; then
    echo 'x - still skipping expresp.c'
else
echo 'x - continuing file expresp.c'
sed 's/^X//' << 'SHAR_EOF' >> 'expresp.c' &&
X    expresp.c - HDB expect/respond per SCO Devices file
X    [e-mail]
X
X Meaning of some of the escape characters:
X \p - pause (approximately 1/4-1/2 second delay)
X \d - delay (2 seconds)
X \D - phone number/token
X \T - phone number with Dialcodes and character translation
X \N - null byte
X \K - insert a BREAK
X \E - turn on echo checking (for slow devices)
X \e - turn off echo checking
X \r - carriage return
X \c - no new-line
X \n - send new-line
X \nnn - send octal number
X \m### - sleep ### (decimal) milliseconds (non-standard)
X Speed - Hayes-specific speed-adaptive connect handler
X
X  Defined functions:
X    pcmd_expresp(param)
X    execute_expresp(expresp_script)
X    expect(str)
X    respond(str)
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-25-1991-12:57-wht@n4hgf-ECU release 3.10 */
X/*:07-17-1991-07:04-wht@n4hgf-avoid SCO UNIX nap bug */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecuerror.h"
X#include "esd.h"
X#include "var.h"
X#include "proc.h"
X
X
X#define MAX_FIELDS    50    /* max fields in a chat script */
X#define MAX_EXPRESP    511    /* max length of a chat script */
X#define MAX_EXPECT    63    /* max length of expect string */
X#define DEFAULT_TIMEOUT_MSECS (10*1000L)
X
X#define ERDEBUG(verb,str,arg) if(expresp_verbosity >= verb) \
X    pprintf(str,arg);
X
Xlong atol();
X
Xextern int proctrace;
Xextern int sigint;
X
Xint expresp_verbosity = 0;
Xulong expect_timeout_msecs = DEFAULT_TIMEOUT_MSECS;
Xint expresp_echo_check = 0;
X
Xchar last_Speed_result[32];
X
X/*+-------------------------------------------------------------------------
X    expect(str) - expect (read) string from remote
Xreturn code on failure, 0 on success
X--------------------------------------------------------------------------*/
Xint
Xexpect(str)
Xchar *str;
X{
X    register char *cptr;
X    char parsebuf[MAX_EXPECT + 1];
X    int remaining = MAX_EXPECT;
X    int erc;
X    int old_ttymode = get_ttymode();
X    register char *parsed = parsebuf;
X    char s4[4];
X    int itmp;
X    long atol();
X
X    if(old_ttymode != 2)
X        ttymode(2);
X
X    if(!strncmp(str,"~t[",3) || !strncmp(str,"~m[",3))
X    {
X        expect_timeout_msecs = atol(str + 3);
X        if(*(str + 1) == 't')
X            expect_timeout_msecs *= 1000L;
X        str += 3;
X        ERDEBUG(2,"expect timeout = %lu msec\n",expect_timeout_msecs);
X        if(cptr = strchr(str,']'))
X        {
X            str = cptr + 1;
X            ERDEBUG(3,"expect: %s\n",str);
X        }
X        else
X        {
X            erc = eExpectRespondFail;
X            goto RESTORE_TTYMODE_AND_RETURN_ERC;
X        }
X    }
X    ERDEBUG(2,"expect: <<%s>>\n",str);
X    if(!strlen(str) || !strcmp(str,"\"\""))
X        goto GOT_EXPECTED;
X
X    if(!strcmp(str,"Speed"))
X    {
X        LRWT lr;
X        long ms_start;
X        long ms_now;
X        struct timeb now_timeb;
X        ftime(&now_timeb);
X        ms_start = (now_timeb.time * 1000) + now_timeb.millitm;
X        do {
X            last_Speed_result[0] = 0;
X            lr.to1 = 90 * 100L;
X            lr.to2 = 120L;
X            /* allow interrupts + cooked read */
X            lr.raw_flag = 0x80;
X            lr.buffer = last_Speed_result;
X            lr.bufsize = sizeof(last_Speed_result);
X            lr.delim = "\n";
X            lr.echo = 0;
X            lgets_timeout(&lr);
X            ftime(&now_timeb);
X            ms_now = (now_timeb.time * 1000) + now_timeb.millitm;
X        } while(!sigint && !lr.count && ((ms_now - ms_start) < 90*1000L));
X
X        if(sigint || strncmp(lr.buffer,"CONNECT",7))
X            goto DID_NOT_GET_EXPECTED;
X        else
X            goto GOT_EXPECTED;
X    }
X
X    cptr = str;
X    while(remaining)
X    {
X        if(*cptr == '\\')
X        {
X            if(!*(++cptr))    /* if no character after escape, ... */
X            {
X                ERDEBUG(2," error: str ended with '\\'\n",0);
X                goto DID_NOT_GET_EXPECTED;
X            }
X
X            if(isdigit(*cptr))    /* handle \ooo */
X            {
X                strncpy(s4,cptr,3);
X                s4[3] = 0;
X                sscanf(s4,"%o",&itmp);
X                cptr += strspn(s4,"01234567");
X                *parsed++ = (char)itmp;
X                remaining--;
X                continue;
X            }
X
X            switch(*cptr)
X            {
X            case 'n':
X                *parsed++ = 0x0A;
X                remaining--;
X                break;
X            case 'r':
X                *parsed++ = 0x0D;
X                remaining--;
X                break;
X            default:
X                ERDEBUG(2," meaningless here: \\%c\n",*cptr);
X                break;
X            }
X            cptr++;
X        }
X        else
X        {
X            *parsed++ = *cptr++;
X            remaining--;
X        }
X    }
X    *parsed = 0;
X
X    if(remaining)
X        ERDEBUG(1," expect string too long\n",0);
X
X    if(expresp_verbosity >= 3)
X        hex_dump(parsebuf,strlen(parsebuf),"expecting",1);
X
X    if(llookfor(parsebuf,expect_timeout_msecs,
X        (expresp_verbosity < 3) ? expresp_verbosity : 0))
X    {
XGOT_EXPECTED:
X        ERDEBUG(2,"[EXPECT SUCCEEDED]\n",0);
X        erc = 0;
X        goto RESTORE_TTYMODE_AND_RETURN_ERC;
X
X    }
X
XDID_NOT_GET_EXPECTED:
X    ERDEBUG(2,"[EXPECT FAILED%s]\n",(sigint) ? " (interrupted)" : "");
X    if(sigint)
X    {
X        sigint = 0;
X        erc = eCONINT;
X    }
X    else
X        erc = eExpectRespondFail;
X    goto RESTORE_TTYMODE_AND_RETURN_ERC;
X
XRESTORE_TTYMODE_AND_RETURN_ERC:
X    if(old_ttymode != 2)
X        ttymode(old_ttymode);
X    return(erc);
X
X}    /* end of expect */
X
X/*+-------------------------------------------------------------------------
X    respond(str) - send to remote
X--------------------------------------------------------------------------*/
Xvoid
Xrespond(str)
Xregister char *str;
X{
Xint itmp;
Xlong ltmp;
Xchar s4[4];
Xint send_no_cr = 0;
X
X    ERDEBUG(2,"respond: <<%s>>\n",str);
X    while(*str)
X    {
X        if(*str == '\\')
X        {
X            /* handle \nnn - send octal number */
X            if(isdigit(*++str))    /* handle \ooo */
X            {
X                strncpy(s4,str,3);
X                s4[3] = 0;
X                sscanf(s4,"%o",&itmp);
X                str += strspn(s4,"01234567") - 1;    /* -1 cause str++ later */
X                lputc((char)itmp);
X            }
X            else switch(*str)
X            {
X                case 'p':  /* pause (approximately 1/4-1/2 second delay) */
X                    ldraino(0);    /* wait for output to drain */
X                    nap(400L);
X                    break;
X                case 'm':  /* nap a while (non-standard) */
X                    ltmp = atol(str + 1);
X                    str += strspn(str + 1,"0123456789");
X                    ldraino(0);    /* wait for output to drain */
X                    nap(ltmp);
X                    break;
X                case 'd':  /* delay (2 seconds) */
X                    ldraino(0);    /* wait for output to drain */
X                    nap(2000L);
X                    break;
X                case 'D':  /* phone number/token */
X                    if(expresp_echo_check)
X                        lputs_paced(40,shm->Ltelno);    /* fake it */
X                    else
X                        lputs(shm->Ltelno);
X                    break;
X                case 'T':  /* phnum with Dialcodes and char translation */
X                    if(expresp_echo_check)
X                        lputs_paced(40,shm->Ltelno);    /* fake it */
X                    else
X                        lputs(shm->Ltelno);
X                    break;
X                case 'N':  /* null byte */
X                    lputc(0);
X                    break;
X                case 'K':  /* insert a BREAK */
X                    lbreak();
X                    break;
X                case 'E':  /* turn on echo checking (for slow devices) */
X                    expresp_echo_check = 1;
X                    break;
X                case 'e':  /* turn off echo checking */
X                    expresp_echo_check = 0;
X                    break;
X                case 'r':  /* carriage return */
X                    lputc(0x0D);
X                    break;
X                case 'c':  /* no new-line */
X                    send_no_cr = 1;
X                    break;
X                case 'n':  /* send new-line */
X                    lputc(0x0D);
X                    break;
X            }
X
X        }
X        else
X            lputc(*str);
X
X
X        if(expresp_echo_check)
X        {
X            ldraino(1);        /* wait for output to drain, then flush input */
X            nap(40L);        /* fake it */
X        }
X        str++;
X    }
X
X    if(!send_no_cr)
X        lputc(0x0D);
X}    /* end of respond */
X
X/*+-------------------------------------------------------------------------
X    execute_expresp(expresp_script)
X
Xreturn 0 on success, else error code
X--------------------------------------------------------------------------*/
Xint
Xexecute_expresp(expresp_script)
Xchar *expresp_script;
X{
Xchar *fields[MAX_FIELDS + 1];
Xint ifields;
Xint nfields;
Xint erc;
Xchar expresp_copy[MAX_EXPRESP + 1];
Xchar *expect_this;
Xchar *send_on_fail;
X
X#define EXPECT_STATE (!(ifields & 1))    /* even numbered fields are expect */
X    expresp_echo_check = 0;
X    last_Speed_result[0] = 0;
X
X    strncpy(expresp_copy,expresp_script,sizeof(expresp_copy));
X    build_arg_array(expresp_copy,fields,MAX_FIELDS,&nfields);
X    if(!nfields)    /* if no script, assume success */
X    {
X        ERDEBUG(2,"[EMPTY SCRIPT - EXPECT/RESPOND SUCCEEDED]\n",0);
X        return(0);
X    }
X
X    for(ifields = 0; ifields < nfields; ifields++)
X    {
X        if(sigint)
X            break;
X        if(EXPECT_STATE)
X        {
X            expect_this = fields[ifields];
X            while(1)    /* until break or return(-1) */
X            {
X                if(send_on_fail = strchr(expect_this,'-'))
X                    *send_on_fail++ = 0;
X                if(!(erc = expect(expect_this)))
X                    break;
X                if((erc != eExpectRespondFail) || !send_on_fail)
X                {
X                    ERDEBUG(2,"[EXPECT/RESPOND FAILED]\n",0);
X                    return(eExpectRespondFail);
X                }
X                if(expect_this = strchr(send_on_fail,'-'))
X                    *expect_this++ = 0;
X                if(sigint)
X                    break;
X                respond(send_on_fail);
X            }
X        }
X        else
X            respond(fields[ifields]);
X    }
X    if(sigint)
X    {
X        sigint = 0;
X        ERDEBUG(2,"[CONSOLE INTERRUPT]\n",0);
X        return(eCONINT);
X    }
X    ERDEBUG(2,"[EXPECT/RESPOND SUCCEEDED]\n",0);
X    return(0);
X
X}    /* end of execute_expresp */
X
X/*+-------------------------------------------------------------------------
X    pcmd_expresp(param)
Xexpresp [-v[v...]] <exp-resp-str> [<timeout_msecs>]
X--------------------------------------------------------------------------*/
Xint
Xpcmd_expresp(param)
XESD *param;
X{
Xint erc;
Xint itmp;
Xchar *cptr;
XESD *tesd;
Xchar switches[8];
X
X    if((tesd = esdalloc(MAX_EXPRESP + 1)) == (ESD *)0)
X        return(eNoMemory);
X
X    get_switches(param,switches,sizeof(switches));
X
X    if(erc = gstr(param,tesd,0))
X    {
X        esdfree(tesd);
X        return(erc);
X    }
X
X    expect_timeout_msecs = DEFAULT_TIMEOUT_MSECS;
X    expresp_verbosity = (!!strchr(switches,'v')) || proctrace;
X    if(expresp_verbosity)
X    {
X        cptr = switches,itmp = 0;
X        while(*cptr)
X            itmp += (*cptr++ == 'v');
X        if(itmp > 1)
X            expresp_verbosity = itmp;
X    }
X
X    if(erc = gint(param,&expect_timeout_msecs))
X    {
X        /* if something there non-integer */
X        if(!end_of_cmd(param))
X        {
X            erc = eSyntaxError;
X            goto RETURN;
X        }
X    }
X
X    erc = execute_expresp(tesd->pb);
X
XRETURN:
X    esdfree(tesd);
X    iv[0] = !!erc;
X    if(erc == eExpectRespondFail)
X        erc = 0;
X    return(erc);
X
X}    /* end of pcmd_expresp */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of expresp.c */
SHAR_EOF
echo 'File expresp.c is complete' &&
$TOUCH -am 0725125791 'expresp.c' &&
chmod 0644 expresp.c ||
echo 'restore of expresp.c failed'
Wc_c="`wc -c < 'expresp.c'`"
test 9680 -eq "$Wc_c" ||
    echo 'expresp.c: original size 9680, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= fasiintf.c ==============
if test -f 'fasiintf.c' -a X"$1" != X"-c"; then
    echo 'x - skipping fasiintf.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting fasiintf.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'fasiintf.c' &&
X/*+-------------------------------------------------------------------------
X    fasiintf.c - FAS/i interface
X    [e-mail]
X
X  Defined functions:
X    display_fasi(fip)
X    fasi_breaks_detected()
X    fasi_line_errors()
X    fasi_msr()
X    fasi_rings_detected()
X    icmd_fasi(narg,arg)
X    ier_text(ier)
X    lcr_text(lcr)
X    mcr_text(mcr)
X    msr_text(msr)
X    pcmd_fasi(param)
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-25-1991-12:57-wht@n4hgf-ECU release 3.10 */
X/*:04-29-1991-18:52-wht@n4hgf-FAS/i 2.08.0 official release */
X/*:12-24-1990-00:51-wht-creation */
X
X#include "ecu.h"
X
X#if    defined(FASI)
X#include "ecuerror.h"
X#include "esd.h"
X#if defined(NULL)
X#undef NULL
X#endif
X# include <local/fas.h>
X
Xextern int proctrace;
X
X/*+-------------------------------------------------------------------------
X    msr_text(msr)
X--------------------------------------------------------------------------*/
Xchar *
Xmsr_text(msr)
Xuchar msr;
X{
Xstatic char txt[50];
X
X    txt[0] = '*';
X    txt[1] = 0;
X    if(!msr)
X    {
X        strcat(txt,"NULL*");
X        return(txt);
X    }
X    if(msr & MS_CTS_DELTA) strcat(txt,"dCTS*");
X    if(msr & MS_DSR_DELTA) strcat(txt,"dDSR*");
X    if(msr & MS_RING_TEDGE) strcat(txt,"dRI*");
X    if(msr & MS_DCD_DELTA) strcat(txt,"dDCD*");
X    if(msr & MS_CTS_PRESENT) strcat(txt,"CTS*");
X    if(msr & MS_DSR_PRESENT) strcat(txt,"DSR*");
X    if(msr & MS_RING_PRESENT) strcat(txt,"RING*");
X    if(msr & MS_DCD_PRESENT) strcat(txt,"DCD*");
X    return(txt);
X
X}    /* end of msr_text */
X
X/*+-------------------------------------------------------------------------
X    mcr_text(mcr)
X--------------------------------------------------------------------------*/
Xchar *
Xmcr_text(mcr)
Xuchar mcr;
X{
Xstatic char txt[32];
X
X    txt[0] = '*';
X    txt[1] = 0;
X    if(!mcr)
X    {
X        strcat(txt,"NULL*");
X        return(txt);
X    }
X    if(mcr & MC_SET_DTR) strcat(txt,"DTR*");
X    if(mcr & MC_SET_RTS) strcat(txt,"RTS*");
X    if(mcr & MC_SET_OUT1) strcat(txt,"OUT1*");
X    if(mcr & MC_SET_OUT2) strcat(txt,"OUT2*");
X    if(mcr & MC_SET_LOOPBACK) strcat(txt,"LOOPBACK*");
X    return(txt);
X
X}    /* end of mcr_text */
X
X/*+-------------------------------------------------------------------------
X    lcr_text(lcr)
X--------------------------------------------------------------------------*/
Xchar *
Xlcr_text(lcr)
Xuchar lcr;
X{
Xstatic char txt[64];
X
X    sprintf(txt,"*%ddb*",(lcr & LC_WORDLEN_MASK) + 5);
X    strcat(txt,(lcr & LC_STOPBITS_LONG) ? "2" : "1");
X    strcat(txt,"sb*");
X    if(lcr & LC_ENABLE_PARITY)
X    {
X        strcat(txt,"PARITY*");
X        if(lcr & LC_STICK_PARITY)
X            strcat(txt,(lcr & LC_EVEN_PARITY) ? "MARK*" : "SPACE*");
X        else
X            strcat(txt,(lcr & LC_EVEN_PARITY) ? "EVEN*" : "ODD*" );
X    }
X    else
X        strcat(txt,"NOPAR*");
X    if(lcr & LC_SET_BREAK_LEVEL)
X        strcat(txt,"SETBREAK*");
X    if(lcr & LC_ENABLE_DIVISOR)
X        strcat(txt,"ENABDIV*");
X    return(txt);
X
X}    /* end of lcr_text */
X
X/*+-------------------------------------------------------------------------
X    ier_text(ier)
X--------------------------------------------------------------------------*/
Xchar *
Xier_text(ier)
Xuchar ier;
X{
Xstatic char txt[32];
X
X    txt[0] = '*';
X    txt[1] = 0;
X    if(!ier)
X    {
X        strcat(txt,"NULL*");
X        return(txt);
X    }
X    if(ier & IE_RECV_DATA_AVAILABLE) strcat(txt,"RDAV*");
X    if(ier & IE_XMIT_HOLDING_BUFFER_EMPTY) strcat(txt,"TBMT*");
X    if(ier & IE_LINE_STATUS) strcat(txt,"LS*");
X    if(ier & IE_MODEM_STATUS) strcat(txt,"MS*");
X    return(txt);
X
X}    /* end of ier_text */
X
X/*+-------------------------------------------------------------------------
X    display_fasi(fip)
X--------------------------------------------------------------------------*/
Xvoid
Xdisplay_fasi(fip)
Xstruct fas_info *fip;
X{
X
X    pprintf("base address: %04x irq=%u ",fip->port_0.addr,fip->vec);
X    pputs("device is ");
X    if(fip->device_flags.s & DF_DEVICE_IS_NS16550A)
X        pputs("16550\n");
X    else if(fip->device_flags.s & DF_DEVICE_IS_I82510)
X        pputs("82510\n");
X    else
X        pputs("16450\n");
X    pprintf("MSR=%s   ",msr_text(fip->msr));
X    pprintf("MCR=%s\n",mcr_text(fip->mcr));
X    pprintf("LCR=%s   ",lcr_text(fip->lcr));
X    pprintf("IER=%s\n",ier_text(fip->ier));
X    pprintf("recv ring cnt=%u  ",fip->recv_ring_cnt);
X    pprintf("xmit ring cnt=%u  ",fip->xmit_ring_cnt);
X    pprintf("xmit fifo size=%u\n",fip->xmit_fifo_size);
X    pprintf("characters received    =%12lu\n",fip->characters_received);
X    pprintf("characters transmitted =%12lu\n",fip->characters_transmitted);
X    pprintf("modem status events    =%12lu\n",fip->modem_status_events);
X    pprintf("overrun errors=%lu  ",fip->overrun_errors);
X    pprintf("framing errors=%lu  ",fip->framing_errors);
X    pprintf("parity errors=%lu\n",fip->parity_errors);
X    pprintf("rings detected=%lu  ",fip->rings_detected);
X    pprintf("breaks detected=%lu\n",fip->breaks_detected);
X    pprintf("xmtr flow off XON/XOFF=%lu  RTS/CTS=%lu\n",
X        fip->xmtr_sw_flow_count,fip->xmtr_hw_flow_count);
X    pprintf("rcvr flow off XON/XOFF=%lu  RTS/CTS=%lu\n",
X        fip->rcvr_sw_flow_count,fip->rcvr_hw_flow_count);
X
X}    /* end of display_fasi */
X
X/*+-------------------------------------------------------------------------
X    fasi_msr() - return modem status register contents
X--------------------------------------------------------------------------*/
Xuchar
Xfasi_msr()
X{
Xulong ltmp;
X
X    return((uchar)ioctl(shm->Liofd,FASIC_MCR,(char *)<mp));
X    return(ltmp);
X}    /* end of fasi_msr */
X
X/*+-------------------------------------------------------------------------
X    fasi_line_errors() - return UART error count
X--------------------------------------------------------------------------*/
Xulong
Xfasi_line_errors()
X{
Xstruct fas_info finfo,*fip = &finfo;
X
X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
X        return(0);
X    return(fip->parity_errors + fip->framing_errors + fip->overrun_errors);
X
X}    /* end of fasi_line_errors */
X
X/*+-------------------------------------------------------------------------
X    fasi_rings_detected() - return number of RI trailing edges
X--------------------------------------------------------------------------*/
Xulong
Xfasi_rings_detected()
X{
Xstruct fas_info finfo,*fip = &finfo;
X
X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
X        return(0);
X    return(fip->rings_detected);
X
X}    /* end of fasi_rings_detected */
X
X/*+-------------------------------------------------------------------------
X    fasi_breaks_detected() - return number of BREAKs detected
X--------------------------------------------------------------------------*/
Xulong
Xfasi_breaks_detected()
X{
Xstruct fas_info finfo,*fip = &finfo;
X
X    if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
X        return(0);
X    return(fip->breaks_detected);
X
X}    /* end of fasi_breaks_detected */
X
X/*+-------------------------------------------------------------------------
X    pcmd_fasi(param)
Xfasi [-switches] <str-cmd>>
X
Xwhere <str-cmd> is 'd[isplay]'
X                or 'r[eset]'
X
Xfasi 'd'
Xfasi 'r'
X--------------------------------------------------------------------------*/
Xint
Xpcmd_fasi(param)
XESD *param;
X{
Xint erc;
Xchar switches[8];
XESD *tesd = (ESD *)0;
Xstruct fas_info finfo,*fip = &finfo;
Xchar ident_str[128];
X
X    get_switches(param,switches,sizeof(switches));
X    if(!(tesd = esdalloc(64)))
X        return(eNoMemory);
X    if(!(erc = gstr(param,tesd,1)))
X    {
X        skip_cmd_break(tesd);
X        switch(to_lower(*(tesd->pb + tesd->index)))
X        {
X            case 'd':    /* display */
X                if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
X                {
X                    pperror("ioctl FASIC_SIP");
X                    erc = eFATAL_ALREADY;
X                }
X                else
X                    display_fasi(fip);
X                if((ioctl(shm->Liofd,FASIC_DVR_IDENT,ident_str)) < 0)
X                {
X                    pperror("ioctl FASIC_DVR_IDENT");
X                    erc = eFATAL_ALREADY;
X                }
X                else
X                    pprintf("driver:  '%s'\n",ident_str);
X                if((ioctl(shm->Liofd,FASIC_SPACE_IDENT,ident_str)) < 0)
X                {
X                    pperror("ioctl FASIC_SPACE_IDENT");
X                    erc = eFATAL_ALREADY;
X                }
X                else
X                    pprintf("space.c: '%s'\n",ident_str);
X                break;
X
X            case 'r':    /* reset */
X                if((ioctl(shm->Liofd,FASIC_RESET_STAT,(char *)0)) < 0)
X                {
X                    pperror("ioctl FASIC_RESET_STAT");
X                    erc = eFATAL_ALREADY;
X                }
X                else if(proctrace)
X                    pputs("statistics reset\n");
X                break;
X
X            default:
X                pputs("invalid subcommand '");
X                pputs(tesd->pb);
X                pputs("'\n");
X                erc = eFATAL_ALREADY;
X                break;
X        }
X    }
X
X    if(tesd)
X        esdfree(tesd);
X    return(erc);
X
X}    /* end of pcmd_fasi */
X
X/*+-------------------------------------------------------------------------
X    icmd_fasi(narg,arg)
X--------------------------------------------------------------------------*/
Xvoid
Xicmd_fasi(narg,arg)
Xint narg;
Xchar **arg;
X{
Xstruct fas_info finfo,*fip = &finfo;
Xchar ident_str[128];
X
X    if((narg > 1) && (to_lower(*arg[1]) == 'r'))
X    {
X        if((ioctl(shm->Liofd,FASIC_RESET_STAT,(char *)0)) < 0)
X        {
X            pperror("   ioctl FASIC_RESET_STAT");
X            return;
X        }
X        ff(se,"  fasi statistics reset\r\n");
X    }
X    else
X    {
X        if((ioctl(shm->Liofd,FASIC_SIP,(char *)fip)) < 0)
X        {
X            pperror("   ioctl FASIC_SIP");
X            return;
X        }
X        ff(se,"\r\n");
X        display_fasi(fip);
X        if((ioctl(shm->Liofd,FASIC_DVR_IDENT,ident_str)) < 0)
X            pperror("ioctl FASIC_DVR_IDENT");
X        else
X            pprintf("driver:  '%s'\n",ident_str);
X        if((ioctl(shm->Liofd,FASIC_SPACE_IDENT,ident_str)) < 0)
X            pperror("ioctl FASIC_SPACE_IDENT");
X        else
X            pprintf("space.c: '%s'\n",ident_str);
X    }
X
X}    /* end of icmd_fasi */
X
X#endif /* FASI */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of fasiintf.c */
SHAR_EOF
$TOUCH -am 0725125791 'fasiintf.c' &&
chmod 0644 fasiintf.c ||
echo 'restore of fasiintf.c failed'
Wc_c="`wc -c < 'fasiintf.c'`"
test 9136 -eq "$Wc_c" ||
    echo 'fasiintf.c: original size 9136, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= feval.c ==============
if test -f 'feval.c' -a X"$1" != X"-c"; then
    echo 'x - skipping feval.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting feval.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'feval.c' &&
X/*+-------------------------------------------------------------------------
X    feval.c - integer and string function evaluation
X    [e-mail]
X
X    feval_int(param,&int_returned) where 'int' here means long ECU $i int
X    feval_str(param,&esd_to_be_plugged)
X
X  These routines are called with param.index as follows:
X
X         !nnnnn       nnn is name of function
X          ^
X          |
X
X  Defined functions:
X    feval_int(param,value)
X    feval_str(param,result_esd)
X    strfunc_left(param,scratch_esd,result_esd)
X    strfunc_right(param,scratch_esd,result_esd)
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
X/*:07-14-1991-18:18-wht@n4hgf-new ttygets functions */
X/*:06-29-1991-16:33-wht@n4hgf-use cuserid() instead of getlogin() */
X/*:03-16-1991-15:23-wht@n4hgf-add %nice */
X/*:01-31-1991-16:10-wht@n4hgf-was freeing tesd1 twice in feval_str */
X/*:12-24-1990-04:31-wht@n4hgf-experimental fasi driver functions */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecuerror.h"
X#include "esd.h"
X#include "proc.h"
X#include "var.h"
X#include "ecutty.h"
X
X#if defined(FASI)
Xchar *msr_text();
X#endif
X
X#define FIargc           1
X#define FIbaud           2
X#define FIcolors         3
X#define FIconn           4
X#define FIcsec           5
X#define FIctoi           6
X#define FIcurx           7
X#define FIcury           8
X#define FIfatime         9
X#define FIfmode         10
X#define FIfmtime        11
X#define FIfsize         12
X#define FIftell         13
X#define FIinstr         14
X#define FIisalnum       15
X#define FIisalpha       16
X#define FIisascii       17
X#define FIischr         18
X#define FIiscntrl       19
X#define FIisdigit       20
X#define FIisdir         21
X#define FIisgraph       22
X#define FIislower       23
X#define FIisprint       24
X#define FIispunct       25
X#define FIisreg         26
X#define FIisspace       27
X#define FIisupper       28
X#define FIisxdigit      29
X#define FIlen           30
X#define FIlgetc         31
X#define FImatch         32
X#define FImhack         33
X#define FIpid           34
X#define FIrchr          35
X#define FIrchrc         36
X#define FIshmid         37
X#define FIstoi          38
X#define FIxchr          39
X#define FIxchrc         40
X#define FIesecs         41
X#define FIlines         42
X#define FIcols          43
X#define FIrinstr        44
X#define FIfasi          45
X#if defined(FASI)
X#define FImsr           46
X#define FIlnerr         47
X#define FIridet         49
X#define FIbrdet         50
X#endif
X#define FInice          51
X#define FIuid           52
X#define FIgid           53
X
XKEYTAB feval_int_tbl[] =
X{
X    {"argc",FIargc},
X    {"baud",FIbaud},
X#if defined(FASI)
X    {"brdet",FIbrdet},
X#endif
X    {"colors",FIcolors},
X    {"cols",FIcols},
X    {"conn",FIconn},
X    {"csec",FIcsec},
X    {"ctoi",FIctoi},
X    {"curx",FIcurx},
X    {"cury",FIcury},
X    {"esecs",FIesecs},
X    {"fasi",FIfasi},
X    {"fatime",FIfatime},
X    {"fmode",FIfmode},
X    {"fmtime",FIfmtime},
X    {"fsize",FIfsize},
X    {"ftell",FIftell},
X    {"gid",FIgid},
X    {"instr",FIinstr},
X    {"isalnum",FIisalnum},
X    {"isalpha",FIisalpha},
X    {"isalpha",FIisalpha},
X    {"isascii",FIisascii},
X    {"ischr",FIischr},
X    {"iscntrl",FIiscntrl},
X    {"isdigit",FIisdigit},
X    {"isdir",FIisdir},
X    {"isgraph",FIisgraph},
X    {"islower",FIislower},
X    {"isprint",FIisprint},
X    {"ispunct",FIispunct},
X    {"isreg",FIisreg},
X    {"isspace",FIisspace},
X    {"isupper",FIisupper},
X    {"isxdigit",FIisxdigit},
X    {"len",FIlen},
X#if defined(FASI)
X    {"lnerr",FIlnerr},
X#endif
X    {"lgetc",FIlgetc},
X    {"lines",FIlines},
X    {"match",FImatch},
X    {"mhack",FImhack},
X#if defined(FASI)
X    {"msr",FImsr},
X#endif
X    {"nice",FInice},
X    {"pid",FIpid},
X    {"rchr",FIrchr},
X    {"rchrc",FIrchrc},
X#if defined(FASI)
X    {"ridet",FIridet},
X#endif
X    {"rinstr",FIrinstr},
X    {"shmid",FIshmid},
X    {"stoi",FIstoi},
X    {"uid",FIuid},
X    {"xchr",FIxchr},
X    {"xchrc",FIxchrc},
X    {(char *)0,0}
X};
X
X#define FSargv           1
X#define FScgetc          2
X#define FScgets          3
X#define FSchr            4
X#define FSdate           5
X#define FSdatez          6
X#define FSday            7
X#define FSdayz           8
X#define FSdir            9
X#define FSedate         10
X#define FSenvvar        11
X#define FSerrstr        12
X#define FSetime         13
X#define FSfmodestr      14
X#define FSitos          15
X#define FSleft          16
X#define FSline          17
X#define FSlogname       18
X#define FSmid           19
X#define FSmonth         20
X#define FSmonthz        21
X#define FSrdesc         22
X#define FSright         23
X#define FSrname         24
X#define FSrtel          25
X#define FSscreen        26
X#define FStime          27
X#define FStimes         28
X#define FStimez         29
X#define FStimezs        30
X#define FStty           31
X#define FSbasename      32
X#define FSdirpart       33
X#define FSfilepart      34
X#if defined(FASI)
X#define FSmsrtext       35
X#endif
X
XKEYTAB feval_str_tbl[] =
X{
X    {"argv",FSargv},
X    {"basename",FSbasename},
X    {"cgetc",FScgetc},
X    {"cgets",FScgets},
X    {"chr",FSchr},
X    {"date",FSdate},
X    {"datez",FSdatez},
X    {"day",FSday},
X    {"dir",FSdir},
X    {"dirpart",FSdirpart},
X    {"edate",FSedate},
X    {"envvar",FSenvvar},
X    {"errstr",FSerrstr},
X    {"etime",FSetime},
X    {"filepart",FSfilepart},
X    {"fmodestr",FSfmodestr},
X    {"itos",FSitos},
X    {"left",FSleft},
X    {"line",FSline},
X    {"logname",FSlogname},
X    {"mid",FSmid},
X    {"month",FSmonth},
X#if defined(FASI)
X    {"msrtext",FSmsrtext},
X#endif
X    {"rdesc",FSrdesc},
X    {"right",FSright},
X    {"rname",FSrname},
X    {"rtelno",FSrtel},
X    {"screen",FSscreen},
X    {"time",FStime},
X    {"times",FStimes},
X    {"timez",FStimez},
X    {"timezs",FStimezs},
X    {"tty",FStty},
X    {(char *)0,0}
X};
X
Xextern char curr_dir[];
Xextern int proctrace;
Xextern PCB *pcb_stack[];
Xextern int proc_level;
Xextern char *sys_errlist[];
Xextern int sys_nerr;
Xextern struct timeb starting_timeb;
Xextern uint tcap_LINES;
Xextern uint tcap_COLS;
X
Xextern int shm_shmid;
X
Xchar *day_of_week_list = "SunMonTueWedThuFriSat";
Xchar *month_name_list = "JanFebMarAprMayJunJulAugSepOctNovDec";
X
X/*+-------------------------------------------------------------------------
X    erc = feval_int(param,&int_returned);
XFunctions (parameter types are expressed by the usage of variables)
X--------------------------------------------------------------------------*/
Xfeval_int(param,value)
XESD *param;
Xlong *value;
X{
Xregister erc;
Xregister keyword_token;
Xint index_save;
XESD *tesd1 = (ESD *)0;
XESD *tesd2 = (ESD *)0;
Xulong int1;
Xchar s32[32];
Xstruct timeb now_timeb;
Xint nice();
X
X    index_save = param->index;
X
X    if(erc = get_alphanum_zstr(param,s32,sizeof(s32)))
X    {
X        erc = eInvalidFunction;
X        goto RETURN;
X    }
X
X    keyword_token = keyword_lookup(feval_int_tbl,s32);
X    switch(keyword_token)
X    {
X/* LEN($S0)         length of $S0 */
X    case FIlen:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X        *value = (long)tesd1->cb;
X        break;
X
X/* INSTR($I0,$I1)   index of first occurrence of $I1 in $I0, -1 if none */
X    case FIinstr:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(!(tesd2 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_comma(param))
X            goto RETURN;
X        if(erc = gstr(param,tesd2,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X
X        *value = (long)ulindex(tesd1->pb,tesd2->pb);
X        break;
X
X/* RINSTR($I0,$I1)   index of last occurrence of $I1 in $I0, -1 if none */
X    case FIrinstr:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(!(tesd2 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_comma(param))
X            goto RETURN;
X        if(erc = gstr(param,tesd2,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X
X        *value = (long)ulrindex(tesd1->pb,tesd2->pb);
X        break;
X
X    case FImatch:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(!(tesd2 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_comma(param))
X            goto RETURN;
X        if(erc = gstr(param,tesd2,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X
X        erc = regexp_operation(tesd1->pb,tesd2->pb,value);
X        break;
X
X    case FImhack:
X        ftime(&now_timeb);
X        *value = ((now_timeb.time - starting_timeb.time) * 1000) +
X                (now_timeb.millitm - starting_timeb.millitm);
X        erc = 0;
X        break;
X
X    case FIesecs:
X        ftime(&now_timeb);
X        *value = now_timeb.time;
X        erc = 0;
X        break;
X
X    case FIargc:
X        if(!proc_level)
X        {
X            pputs("not executing procedure\n");
X            erc = eFATAL_ALREADY;
X            break;
X        }
X        *value = (long)pcb_stack[proc_level - 1]->argc;
X        break;
X
X    case FIcolors:
X        if(erc = ifunc_colors(value))
X            goto RETURN;
X        break;
X
X    case FIftell:
X        if(erc = ifunc_ftell(param,value))
X            goto RETURN;
X        break;
X
X    case FIfmode:
X        if(erc = ifunc_fmode(param,value))
X            goto RETURN;
X        break;
X
X    case FIfsize:
X        if(erc = ifunc_fsize(param,value))
X            goto RETURN;
X        break;
X
X    case FIfmtime:
X        if(erc = ifunc_fmtime(param,value))
X            goto RETURN;
X        break;
X
X    case FIfatime:
X        if(erc = ifunc_fatime(param,value))
X            goto RETURN;
X        break;
X
X    case FIischr:
X        if(erc = ifunc_ischr(param,value))
X            goto RETURN;
X        break;
X
X    case FIisdir:
X        if(erc = ifunc_isdir(param,value))
X            goto RETURN;
X        break;
X
X    case FIisreg:
X        if(erc = ifunc_isreg(param,value))
X            goto RETURN;
X        break;
X
X    case FIbaud:
X        *value = (long)shm->Lbaud;
X        erc = 0;
X        break;
X
X    case FIpid:
X        *value = (long)getpid();
X        erc = 0;
X        break;
X
X    case FIcsec:
X        *value = (shm->Lmodem_off_hook) ? shm->Loff_hook_time : -1;
X        erc = 0;
X        break;
X
X    case FIconn:
X        *value = (long)(shm->Lmodem_off_hook) ? (long)shm->Liofd : 0;
X        erc = 0;
X        break;
X
X    case FIxchr:
X        *value = shm->xmit_chars;
X        erc = 0;
X        break;
X
X    case FIxchrc:
X        *value = shm->xmit_chars_this_connect;
X        erc = 0;
X        break;
X
X    case FIrchr:
X        shmx_rc_report(value,&int1);
X        break;
X
X    case FIrchrc:
X        shmx_rc_report(&int1,value);
X        erc = 0;
X        break;
X
X/* LGETC($I0) get char from line, waiting for $I0 msec
Xreturns  character read or -1 if none read in time */
X    case FIlgetc:
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gint(param,&int1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X        *value = (long)lgetc_timeout(int1);
X        break;
X
X    case FIctoi:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X        if(tesd1->cb == 0)
X            *value = -1;
X        else
X            *value = (long)((unsigned)0xFF & (unsigned)tesd1->pb[0]);
X        break;
X
X    case FIstoi:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X
X        tesd1->index = 0;
X        skip_cmd_break(tesd1);
X        *value = 0;
X        gint_constant(tesd1,value);
X        break;
X
X    case FIcurx:
X        *value = (long)shm->cursor_x;
X        break;
X
X    case FIcury:
X        *value = (long)shm->cursor_y;
X        break;
X
X    case FIshmid:
X        *value = (long)shm_shmid;
X        break;
X
X    case FIisalpha:
X    case FIisupper:
X    case FIislower:
X    case FIisdigit:
X    case FIisxdigit:
X    case FIisspace:
X    case FIispunct:
X    case FIisalnum:
X    case FIisprint:
X    case FIisgraph:
X    case FIiscntrl:
X    case FIisascii:
X        if(!(tesd1 = esdalloc(256)))
X        {
X            erc = eNoMemory;
X            goto RETURN;
X        }
X        if(erc = skip_paren(param,1))
X            goto RETURN;
X        if(erc = gstr(param,tesd1,1))
X            goto RETURN;
X        if(erc = skip_paren(param,0))
X            goto RETURN;
X        if(!tesd1->cb)
X        {
X            *value = 0;
X            goto RETURN;
X        }
X        switch(keyword_token)
X        {
X            case FIisalpha:
X                *value = !!isalpha(*tesd1->pb);
X                break;
X            case FIisupper:
X                *value = !!isupper(*tesd1->pb);
X                break;
X            case FIislower:
X                *value = !!islower(*tesd1->pb);
X                break;
X            case FIisdigit:
X                *value = !!isdigit(*tesd1->pb);
X                break;
X            case FIisxdigit:
X                *value = !!isxdigit(*tesd1->pb);
X                break;
X            case FIisspace:
X                *value = !!isspace(*tesd1->pb);
X                break;
X            case FIispunct:
X                *value = !!ispunct(*tesd1->pb);
X                break;
X            case FIisalnum:
X                *value = !!isalnum(*tesd1->pb);
X                break;
X            case FIisprint:
X                *value = !!isprint(*tesd1->pb);
X                break;
X            case FIisgraph:
X                *value = !!isgraph(*tesd1->pb);
X                break;
X            case FIiscntrl:
X                *value = !!iscntrl(*tesd1->pb);
X                break;
X            case FIisascii:
X                *value = !!isascii(*tesd1->pb);
X                break;
X        }
X        break;
X
X    case FIlines:
X        *value = (long)tcap_LINES;
X        break;
X
X    case FIcols:
X        *value = (long)tcap_COLS;
X        break;
X
X#if defined(FASI)
X    case FIfasi:
X        *value = 1;
X        break;
X    case FImsr:
X        *value = (long)fasi_msr();
X        break;
X    case FIlnerr:
X        *value = (long)fasi_line_errors();
X        break;
X    case FIridet:
X        *value = (long)fasi_rings_detected();
X        break;
X    case FIbrdet:
X        *value = (long)fasi_breaks_detected();
X        break;
X#else
X    case FIfasi:
X        *value = 0;
X        break;
X#endif
X
X    case FInice:
X        *value = (long)nice() + 20;
X        erc = 0;
X        break;
X
X    case FIuid:
X        *value = (long)getuid();
X        erc = 0;
X        break;
X
X    case FIgid:
X        *value = (long)getgid();
X        erc = 0;
X        break;
X
X    default:
X        erc = eInvalidFunction;
X    }   /* end of keyword lookup erc switch statement */
X
XRETURN:
X    if(tesd1)
X        esdfree(tesd1);
X    if(tesd2)
X        esdfree(tesd2);
X    return(erc);
X
X}   /* end of feval_int() */
X
X/*+------------------------------------------------------------------
X    strfunc_left(param,&scratch_esd,&result_esd)
X-------------------------------------------------------------------*/
Xint
Xstrfunc_left(param,scratch_esd,result_esd)
XESD *param;
XESD *scratch_esd;
XESD *result_esd;
X{
Xregister erc;
Xint itmp;
Xlong ltmp;
X
X    if(erc = skip_paren(param,1))
X        return(erc);
X    if(erc = gstr(param,scratch_esd,1))
X        return(erc);
X    if(erc = skip_comma(param))
X        return(erc);
X    if(erc = gint(param,<mp))
X        return(erc);
X    itmp = (int)ltmp;
X    if(itmp < 0)
X        return(eBadParameter);
X    if(erc = skip_paren(param,0))
X        return(erc);
X    /* take min of param and .cb */
X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
X    if(itmp > (result_esd->maxcb - result_esd->cb) )
X        return(eBufferTooSmall);
X    memcpy(&result_esd->pb[result_esd->cb],
X        scratch_esd->pb,itmp);
X    result_esd->cb += itmp;
X    return(erc);
X}   /* end of strfunc_left() */
X
X/*+-------------------------------------------------------------------------
X    erc = strfunc_right(param,&scratch_esd,&result_esd)
X--------------------------------------------------------------------------*/
Xint
Xstrfunc_right(param,scratch_esd,result_esd)
XESD *param;
XESD *scratch_esd;
XESD *result_esd;
X{
Xregister erc;
Xint itmp;
Xlong ltmp;
X
X    if(erc = skip_paren(param,1))
X        return(erc);
X    if(erc = gstr(param,scratch_esd,1))
X        return(erc);
X    if(erc = skip_comma(param))
X        return(erc);
X    if(erc = gint(param,<mp))
X        return(erc);
X    itmp = (int)ltmp;
X    if(itmp < 0)
X        return(eBadParameter);
X    if(erc = skip_paren(param,0))
X        return(erc);
X
X/* take min of param and .cb */
X    itmp = (itmp < scratch_esd->cb) ? itmp : scratch_esd->cb;
X    if(itmp > (result_esd->maxcb - result_esd->cb) )
X        return(eBufferTooSmall);
X    memcpy(&result_esd->pb[result_esd->cb],
X        &scratch_esd->pb[scratch_esd->cb - itmp],itmp);
X    result_esd->cb += itmp;
X    return(0);
X
X}   /* end of strfunc_right() */
X
X/*+-------------------------------------------------------------------------
X    erc = feval_str(param,&esd_to_be_plugged);
X    results are APPENDED to 'result_esd'
X--------------------------------------------------------------------------*/
Xfeval_str(param,result_esd)
XESD *param;
XESD *result_esd;
X{
Xregister erc;
Xregister itmp;
Xint int1,int2;
Xchar s32[32];
Xchar *cptr;
Xlong ltmp;
Xlong ltmp2;
Xlong ltmp3;
XESD *tesd1;
XESD *tesd2 = (ESD *)0;
Xchar *get_ttyname();
Xchar *getenv();
Xchar *cuserid();
Xchar *get_elapsed_time();
Xchar *mode_map();
X
X    if(!(tesd1 = esdalloc(128)))
X        return(eNoMemory);
X
X    if(erc = get_alphanum_zstr(param,s32,sizeof(s32)-1))
X    {
X        esdfree(tesd1);
X        return(eInvalidFunction);
X    }
X
X    erc = 0;
X    itmp=keyword_lookup(feval_str_tbl,s32);
X    switch(itmp)
X    {
X/* LEFT($S0,$I0)   return leftmost $I0 characters of $S0 */
X    case FSleft:
X        erc = strfunc_left(param,tesd1,result_esd);
X        break;
X
X/* RIGHT($S0,$I0)   return rightmost $I0 characters of $S0 */
X    case FSright:
X        erc = strfunc_right(param,tesd1,result_esd);
X        break;
X
X/* MID($S0,$I0,$I1)   return middle $I1 chars of $S0 starting at $I0 */
X    case FSmid:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gstr(param,tesd1,1))
X            break;
X        if(erc = skip_comma(param))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        int1 = (int)ltmp;
X        if(int1 < 0)
X        {
X            erc = eBadParameter;
X            break;
X        }
X        if(erc = skip_cmd_break(param))
X            break;
X        if(param->pb[param->index] == ')') /* if we find a ')' instead of ... */
X        {                                  /* 2nd int param, default to max */
X            ++param->index;
X            int2 = 256;
X        }
X        else
X        {
X            if(erc = skip_comma(param))
X                break;
X            if(erc = gint(param,<mp))
X                break;
X            int2 = (int)ltmp;
X            if(int2 < 0)
X            {
X                erc = eBadParameter;
X                break;
X            }
X            if(erc = skip_paren(param,0))
X                break;
X        }
X
X        if(int1 >= tesd1->cb) /* if initial index past end of string */
X            break;
X        itmp = tesd1->cb - int1;
X        itmp = (int2 < itmp) ? int2 : itmp;
X        cptr = tesd1->pb + int1;
X        goto CPTR_ITMP_COMMON;
X
X/* ARGV($I0) */
X    case FSargv:
X        if(!proc_level)
X        {
X            pputs("not executing procedure\n");
X            erc = eFATAL_ALREADY;
X            break;
X        }
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        itmp = (long)pcb_stack[proc_level - 1]->argc; /* arg count */
X        if((int)ltmp > itmp - 1)
X        {
X            if(proctrace)
X            {
X                pprintf("WARNING: %%argc=%d, %%argv(%ld) null\n",
X                    itmp,ltmp);
X            }
X            break;
X        }
X        cptr = (pcb_stack[proc_level - 1])->argv[(int)ltmp];
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSdir:
X        cptr = curr_dir;
X        itmp = strlen(curr_dir);
X        goto CPTR_ITMP_COMMON;
X
X    case FSetime:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        cptr = get_elapsed_time(ltmp);
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSerrstr:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        if((int)ltmp >= sys_nerr)
X        {
X            sprintf(s32,"error %d",(int)ltmp);
X            cptr = s32;
X        }
X        else
X            cptr = sys_errlist[(int)ltmp];
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSenvvar:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gstr(param,tesd1,1))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        if(!(cptr = getenv(tesd1->pb)))
X            break;
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSlogname:
X        if(!(cptr = cuserid((char *)0)))
X            break;
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSfmodestr:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        cptr = mode_map((ushort)ltmp,(char *)0);
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FStty:
X        cptr = get_ttyname();
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSrname:
X        if(!shm->Lmodem_off_hook)
X            break;
X        cptr = shm->Lrname;
X        itmp = strlen(shm->Lrname);
X        goto CPTR_ITMP_COMMON;
X
X    case FSrdesc:
X        if(!shm->Lmodem_off_hook)
X            break;
X        cptr = shm->Ldescr;
X        itmp = strlen(shm->Ldescr);
X        goto CPTR_ITMP_COMMON;
X
X    case FSrtel:
X        if(!shm->Lmodem_off_hook)
X            break;
X        cptr = shm->Ltelno;
X        itmp = strlen(shm->Ltelno);
X        goto CPTR_ITMP_COMMON;
X
X    case FSline:
X        if(shm->Liofd < 0)
X            break;
X        cptr = shm->Lline;
X        itmp = strlen(shm->Lline);
X        goto CPTR_ITMP_COMMON;
X
X    case FSmonth:
X    case FSmonthz:
X        cptr = &month_name_list[(get_month(itmp == FSmonthz) - 1) * 3];
X        itmp = 3;
X        goto CPTR_ITMP_COMMON;
X
X    case FSday:
X    case FSdayz:
X        cptr = &day_of_week_list[get_day(itmp == FSdayz) * 3];
X        itmp = 3;
X        goto CPTR_ITMP_COMMON;
X
X    case FSscreen:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))        /* y */
X            break;
X        if(ltmp > 42)
X        {
X            erc = eBadParameter;
X            break;
X        }
X        if(erc = skip_comma(param))
X            break;
X        if(erc = gint(param,<mp2))    /* x */
X            break;
X        if(ltmp2 > 79)
X        {
X            erc = eBadParameter;
X            break;
X        }
X        if(erc = skip_comma(param))
X            break;
X        if(erc = gint(param,<mp3))    /* len */
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X
X        int1 = ((int)ltmp * 80) + (int)ltmp2;    /* screen position */
X        itmp = (int)ltmp3;                        /* length */
X        int2 = sizeof(shm->screen) - int1;        /* size from y,x to end */
X        if(itmp > int2)
X            itmp = int2;
X        cptr = ((char *)shm->screen) + int1;
X        goto CPTR_ITMP_COMMON;
X
X    case FSbasename:
X        if(!(tesd2 = esdalloc(32)))
X            return(eNoMemory);
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gstr(param,tesd1,1))
X            break;
X        if(erc = skip_comma(param))
X            break;
X        if(erc = gstr(param,tesd2,1))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        cptr = tesd1->pb;
X        itmp = tesd1->cb;
X        if((tesd1->cb >= tesd2->cb) &&
X            !strcmp(cptr + tesd1->cb - tesd2->cb,tesd2->pb))
X        {
X            itmp -= tesd2->cb;
X        }
X        goto CPTR_ITMP_COMMON;
X
X    case FSdirpart:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gstr(param,tesd1,1))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        if(cptr = strrchr(tesd1->pb,'/'))
X            itmp = cptr - tesd1->pb;
X        else
X            itmp = tesd1->cb;
X        cptr = tesd1->pb;
X        goto CPTR_ITMP_COMMON;
X
X    case FSfilepart:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gstr(param,tesd1,1))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        if(cptr = strrchr(tesd1->pb,'/'))
X            itmp = strlen(++cptr);
X        else
X        {
X            cptr = tesd1->pb;
X            itmp = tesd1->cb;
X        }
X        goto CPTR_ITMP_COMMON;
X
X#if defined(FASI)
X    case FSmsrtext:
X        cptr = msr_text(fasi_msr());
X        itmp = strlen(cptr);
X        goto CPTR_ITMP_COMMON;
X#endif
X
XCPTR_ITMP_COMMON:
X        if( itmp > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        memcpy(&result_esd->pb[result_esd->cb],cptr,itmp);
X        result_esd->cb += itmp;
X        break;
X
X    case FSedate:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(erc = skip_paren(param,0))
X            break;
X        if(19 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        epoch_secs_to_str(ltmp,3,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 19;
X        break;
X
X    case FStime:
X        if(5 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(0,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 5;
X        break;
X
X    case FStimes:
X        if(8 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(1,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 8;
X        break;
X
X    case FStimez:
X        if(5 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(6,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 5;
X        break;
X
X    case FStimezs:
X        if(8 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(7,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 8;
X        break;
X
X    case FSdate:
X        if(10 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(5,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 10;
X        break;
X
X    case FSdatez:
X        if(10 > (result_esd->maxcb - result_esd->cb))
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        get_tod(8,&result_esd->pb[result_esd->cb]);
X        result_esd->cb += 10;
X        break;
X
X    case FScgets:
X        erc = ttygets_esd(result_esd,TG_CRLF,1);
X        break;
X
X    case FScgetc:
X        if(result_esd->cb == result_esd->maxcb)
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        result_esd->pb[result_esd->cb] = ttygetc(0);
X        result_esd->cb++;
X        break;
X
X    case FSchr:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        if(!ltmp)
X        {
X            pputs("cannot use %chr(0)\n");
X            return(eFATAL_ALREADY);
X        }
X        if(erc = skip_paren(param,0))
X            break;
X        if(result_esd->cb == result_esd->maxcb )
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        result_esd->pb[result_esd->cb] = (char)ltmp;
X        result_esd->cb++;
X        break;
X
X    case FSitos:
X        if(erc = skip_paren(param,1))
X            break;
X        if(erc = gint(param,<mp))
X            break;
X        s32[0] = 0;
X        if(!skip_comma(param))
X        {
X            if(erc = get_numeric_zstr(param,s32 + 1,sizeof(s32) - 4))
X                strcpy(s32 + 1,"1");
X            if(((itmp = atoi(s32 + 1)) < 0) ||
X                (itmp > (result_esd->maxcb - result_esd->cb)))
X            {
X                erc = eBufferTooSmall;
X                break;
X            }
X            s32[0] = '%';
X            if(ulindex(param->pb + param->index,"x") == 0)
X            {
X                param->index++;
X                strcat(s32,"lx");
X            }
X            else if(ulindex(param->pb + param->index,"o") == 0)
X            {
X                param->index++;
X                strcat(s32,"lo");
X            }
X            else if(ulindex(param->pb + param->index,"d") == 0)
X            {
X                param->index++;
X                strcat(s32,"ld");
X            }
X            else if(erc)
X                break;
X            else
X                strcat(s32,"ld");
X        }
X        if(erc = skip_paren(param,0))
X            break;
X        sprintf(tesd1->pb,s32[0] ? s32 : "%ld",ltmp);
X        tesd1->cb = strlen(tesd1->pb);
X        if(result_esd->maxcb - result_esd->cb < tesd1->cb)
X        {
X            erc = eBufferTooSmall;
X            break;
X        }
X        strcpy(&result_esd->pb[result_esd->cb],tesd1->pb);
X        result_esd->cb += tesd1->cb;
X        break;
X
X
X    default:
X        erc = eInvalidFunction;
X        break;
X    }   /* end of keyword lookup erc switch statement */
X
X    esd_null_terminate(result_esd);
X    esdfree(tesd1);
X    if(tesd2)
X        esdfree(tesd2);
X    return(erc);
X
X}   /* end of feval_str() */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of feval.c */
SHAR_EOF
$TOUCH -am 0725125891 'feval.c' &&
chmod 0644 feval.c ||
echo 'restore of feval.c failed'
Wc_c="`wc -c < 'feval.c'`"
test 25528 -eq "$Wc_c" ||
    echo 'feval.c: original size 25528, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= feval.h ==============
if test -f 'feval.h' -a X"$1" != X"-c"; then
    echo 'x - skipping feval.h (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting feval.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'feval.h' &&
X/*+-------------------------------------------------------------------------
X    feval.h
X    [e-mail]
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#define FIinstr        1
X#define FIlen        2
X#define FIstoi        3
X#define FIctoi        4
X#define FIbaud        5
X#define FIconn        6
X#define FIcsec        7
X#define FIpid        8
X#define FIrchr        9
X#define FIrchrc        10
X#define FIxchr        11
X#define FIxchrc        12
X#define FIlgetc        13
X#define FIargc        14
X#define FIftell        15
X#define FIfmode        16
X#define FIisdir        17
X#define FIisreg        18
X#define FIischr        19
X#define FIfatime    20
X#define FIfmtime    21
X#define FIfsize        22
X#define FIcolors    23
X
X
XKEYTAB feval_int_tbl[] =
X{
X    {"argc",FIargc},
X    {"baud",FIbaud},
X    {"colors",FIcolors},
X    {"conn",FIconn},
X    {"csec",FIcsec},
X    {"ctoi",FIctoi},
X    {"fatime",FIfatime},
X    {"fmode",FIfmode},
X    {"fmtime",FIfmtime},
X    {"fsize",FIfsize},
X    {"ftell",FIftell},
X    {"instr",FIinstr},
X    {"ischr",FIischr},
X    {"isdir",FIisdir},
X    {"isreg",FIisreg},
X    {"len",FIlen},
X    {"lgetc",FIlgetc},
X    {"pid",FIpid},
X    {"rchr",FIrchr},
X    {"rchrc",FIrchrc},
X    {"stoi",FIstoi},
X    {"xchr",FIxchr},
X    {"xchrc",FIxchrc},
X    {(char *)0,0}
X};
X
X#define FSleft        2
X#define FSright        3
X#define FSmid        4
X#define FSdate        5
X#define FSmonth        6
X#define FSday        7
X#define FScgets        9
X#define FScgetc        10
X#define FSitos        11
X#define FSchr        12
X#define FSdir        13
X#define FStty        14
X#define FSrdesc        15
X#define FSrname        16
X#define FSline        17
X#define FSrtel        18
X#define FSargv        19
X#define FStime        20
X#define FStimes        21
X#define FSedate        22
X#define FSetime        23
X#define FSgetenv    24
X#define FSgetlogin    25
X
X
XKEYTAB feval_str_tbl[] =
X{
X    {"argv",FSargv},
X    {"cgetc",FScgetc},
X    {"cgets",FScgets},
X    {"chr",FSchr},
X    {"date",FSdate},
X    {"day",FSday},
X    {"dir",FSdir},
X    {"edate",FSedate},
X    {"etime",FSetime},
X    {"getenv",FSgetenv},
X    {"getlogin",FSgetlogin},
X    {"itos",FSitos},
X    {"left",FSleft},
X    {"line",FSline},
X    {"mid",FSmid},
X    {"month",FSmonth},
X    {"rdesc",FSrdesc},
X    {"right",FSright},
X    {"rname",FSrname},
X    {"rtelno",FSrtel},
X    {"time",FStime},
X    {"times",FStimes},
X    {"tty",FStty},
X    {(char *)0,0}
X};
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of feval.h */
SHAR_EOF
$TOUCH -am 0725125891 'feval.h' &&
chmod 0644 feval.h ||
echo 'restore of feval.h failed'
Wc_c="`wc -c < 'feval.h'`"
test 2226 -eq "$Wc_c" ||
    echo 'feval.h: original size 2226, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= gint.c ==============
if test -f 'gint.c' -a X"$1" != X"-c"; then
    echo 'x - skipping gint.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting gint.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'gint.c' &&
X/*+-------------------------------------------------------------------------
X    gint.c - ecu get integer parameter functions
X    [e-mail]
X
X  Defined functions:
X    gcol_range(param,col1,col2)
X    gint(param,int_returned)
X    gint_base(param,value)
X    gint_constant(param,value)
X    gintop(param,intop)
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
X/*:01-31-1991-16:50-wht@n4hgf-reinstate octal with 0o prefix */
X/*:01-09-1991-22:31-wht@n4hgf-ISC port */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecuerror.h"
X#include "esd.h"
X#include "var.h"
X
X#define OP_ADD      1
X#define OP_SUB      2
X#define OP_MUL      3
X#define OP_DIV      4
X#define OP_XOR      5
X#define OP_MOD      6
X#define OP_OR       7
X#define OP_AND      8
X
X#define BASE_DEC    1
X#define BASE_OCT    2
X#define BASE_HEX      3
X
X
X/*+-------------------------------------------------------------------------
X    gint_constant(param,int_returned) - evaluate integer constant
X--------------------------------------------------------------------------*/
Xint
Xgint_constant(param,value)
XESD *param;
Xlong *value;
X{
Xregister itmp;
Xint base = BASE_DEC;
Xint erc;
Xlong new_value;
X
X    if(erc = skip_cmd_break(param))
X        return(erc);
X    esd_null_terminate(param);
X
X/* get integer from string */
X    if((!strncmp(param->pb + param->index,"0x",2)) ||
X        (!strncmp(param->pb + param->index,"0X",2)))
X    {
X        base = BASE_HEX;
X        param->index += 2;
X    }
X    else if((!strncmp(param->pb + param->index,"0o",2)) ||
X        (!strncmp(param->pb + param->index,"0O",2)))
X    {
X        base = BASE_OCT;
X        param->index += 2;
X    }
X
X    param->old_index = param->index;
X    switch(base)
X    {
X    case BASE_HEX:
X        sscanf(param->pb + param->index,"%lx",&new_value);
X        itmp = param->index + strspn(param->pb + param->index,
X            "0123456789ABCDEFabcdef");
X        erc = eInvalidHexNumber;
X        break;
X    case BASE_DEC:
X        sscanf(param->pb + param->index,"%ld",&new_value);
X        itmp = param->index + strspn(param->pb + param->index,"0123456789");
SHAR_EOF
true || echo 'restore of gint.c failed'
fi
echo 'End of ecu310 part 13'
echo 'File gint.c is continued in part 14'
echo 14 > _shar_seq_.tmp
exit 0
--------------------------------------------------------------------
Warren Tucker, TuckerWare emory!n4hgf!wht or [e-mail]
Hacker Extraordinaire  d' async PADs,  pods,  proteins and protocols

exit 0 # Just in case...
--
Kent Landfield                   INTERNET: [e-mail]
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    [phone]         FAX:      [phone]
Please send comp.sources.misc-related mail to [e-mail].