Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume42/ecu/part22

Internet Message Format | 1994-05-24 | 64.6 KB

From: [e-mail] (Warren Tucker)
Newsgroups: comp.sources.misc
Subject: v42i120:  ecu - ECU Asynchronous Communications v3.30, Part22/37
Date: 24 May 1994 09:07:08 -0500
Organization: Sterling Software
Sender: [e-mail]
Approved: [e-mail]
Message-ID: <2rt1mc$[e-mail]>
X-Md4-Signature: 658d76d361330e3dbef71950a3397a45

Submitted-by: [e-mail] (Warren Tucker)
Posting-number: Volume 42, Issue 120
Archive-name: ecu/part22
Environment: SCO,SCOXENIX,MOTOROLA,HP-UX,LINUX,NetBSD,SUNOS,SYSVR4,SOLARIS2
Supersedes: ecu: Volume 32, Issue 36-75

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# Contents:  ecu330/ecugrabbag.c ecu330/ecusetup.c ecu330/esdutil.c
#   ecu330/pc_scr.h
# Wrapped by kent@sparky on Mon May 23 13:40:57 1994
PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 22 (of 37)."'
if test -f 'ecu330/ecugrabbag.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/ecugrabbag.c'\"
else
  echo shar: Extracting \"'ecu330/ecugrabbag.c'\" \(19978 characters\)
  sed "s/^X//" >'ecu330/ecugrabbag.c' <<'END_OF_FILE'
X/*+-----------------------------------------------------------------
X    ecugrabbag.c -- very machine/OS dependent functions
X    [e-mail]
X
X  Defined functions:
X    bell_alarm(xbell_type)
X    bell_notify(xbell_type)
X    bell_notify_text(bn)
X    kbd_escape(xkey)
X    morse_bell(xbell_type,count)
X    parse_bell_notify_argument(strarg)
X    rename(from,to)
X    send_bell_fd(fd,count,nap_msec)
X    send_get_response(narg,arg)
X    set_bell_fd(fd,pitch,duration)
X    set_default_escape_prompt()
X    show_escape_prompt()
X    signal_name_text(sig)
X    xbell(type,count)
X    xbell_fd(fd,type,count)
X    xterm_title(text,code)
X
X  This module is a grab bag for historical reasons.  Needs reorg.
X
X  Like so many Americans, she was trying to construct a life that
X  made sense from things she found in gift shops.  -- Kurt
X  Vonnegut, Jr.
X
X------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:38-wht@n4hgf-ECU release 3.30 */
X/*:11-12-1993-11:00-wht@n4hgf-Linux changes by [e-mail] */
X/*:08-07-1993-21:16-wht@n4hgf-entering history mgr from col > 1 caused glitch */
X/*:01-01-1993-12:52-wht@n4hgf-add procedure binding for function keys */
X/*:12-20-1992-12:37-wht@n4hgf-WHT experiment with attributes */
X/*:09-10-1992-13:58-wht@n4hgf-ECU release 3.20 */
X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
X/*:04-09-1992-05:47-wht@n4hgf-cleanup new "bn" argument parsing */
X/*:02-16-1992-01:41-wht@n4hgf-turn off xterm_title */
X/*:12-13-1991-17:14-wht@n4hgf-add bell_notify_text */
X/*:12-13-1991-17:14-wht@n4hgf-add parse_bell_notify_argument */
X/*:09-03-1991-18:23-wht@n4hgf-sigint rearrangement in send_get_response */
X/*:08-28-1991-14:07-wht@n4hgf2-SVR4 cleanup by aega84!lh */
X/*:08-13-1991-15:28-wht@n4hgf-more problems with history manager */
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/*:07-14-1991-18:18-wht@n4hgf-new ttygets functions */
X/*:06-29-1991-15:42-wht@n4hgf-if WHT and xterm, play with title bar */
X/*:06-04-1991-13:19-wht@n4hgf-WHT version always gets morse for bells */
X/*:05-07-1991-06:10-wht@n4hgf-subtle changes in send_and_get_response */
X/*:03-18-1991-22:31-wht@n4hgf-ISC 2.2 has rename() */
X/*:01-16-1991-23:54-wht@n4hgf-if WHT, bell_notify always available */
X/*:01-09-1991-22:31-wht@n4hgf-ISC port */
X/*:12-04-1990-03:55-wht@n4hgf-bell_notify only if on multiscreen */
X/*:09-19-1990-19:36-wht@n4hgf-ecu_log_event now gets pid for log from caller */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecu.h"
X#include "ecukey.h"
X#include "ecufkey.h"
X#include "ecuxkey.h"
X#include "ecutty.h"
X#include "ecufork.h"
X#include "esd.h"
X
X#if defined(MORSE)
X/* the space between # and include prevents make depend from seeing this */
X#include <local/morse_dvr.h>
X#endif
X
Xchar *get_ttyname();
X
Xextern char curr_dir[];         /* current working key defns */
Xextern KDE keyset_table[];
Xextern char keyset_name[];
X
XESD *icmd_prompt;             /* interactive command prompt */
Xint icmd_prompt_len;
X
X/*+-------------------------------------------------------------------------
X    show_escape_prompt()
Xreturns number of character positions written to screen
X--------------------------------------------------------------------------*/
Xint
Xshow_escape_prompt()
X{
X    char prompt_last;
X
X    prompt_last = 'd';         /* dummy */
X    if (icmd_prompt->cb)
X        prompt_last = *(icmd_prompt->pb + icmd_prompt->cb - 1);
X
X    icmd_prompt_len = 0;
X    shmx_make_rcvr_sleep(1);
X    if (!(colors_current & 0xFFFF0000L) || !(colors_current & 0xFFFFL))
X        setcolor(colors_normal);
X    else
X        setcolor(colors_current);
X#ifdef WHT
X    tcap_bold_on();
X    tcap_underscore_on();
X#else
X    tcap_stand_out();
X#endif
X    if (icmd_prompt->cb)
X    {
X        ff(se, " %s", icmd_prompt->pb);
X        icmd_prompt_len += icmd_prompt->cb + 1;
X    }
X    if (isalnum(prompt_last))
X    {
X        fputs(" %", se);
X        icmd_prompt_len += 2;
X    }
X#ifdef WHT
X    tcap_bold_off();
X    tcap_underscore_off();
X#else
X    tcap_stand_end();
X#endif
X    fputc(' ', se);
X    icmd_prompt_len++;
X    return (icmd_prompt_len);
X
X}                             /* end of show_escape_prompt */
X
X/*+-------------------------------------------------------------------------
X    set_default_escape_prompt()
X--------------------------------------------------------------------------*/
Xvoid
Xset_default_escape_prompt()
X{
X    register char *cptr;
X    char *getenv();
X
X    if ((cptr = getenv("ECUPROMPT")) != (char *)0)
X    {
X        strncpy(icmd_prompt->pb, cptr, icmd_prompt->maxcb);
X        *(icmd_prompt->pb + icmd_prompt->maxcb - 1) = 0;
X        icmd_prompt->cb = strlen(icmd_prompt->pb);
X        esd_null_terminate(icmd_prompt);
X    }
X
X}                             /* end of set_default_escape_prompt */
X
X/*+-------------------------------------------------------------------------
X    kbd_escape() -- xmtr got extended key -- process it
Xreturns(1)
X--------------------------------------------------------------------------*/
Xkbd_escape(xkey)
Xuchar xkey;
X{
X    register itmp;
X    int ttygets_flags = TG_XDELIM;
X    uchar delim;
X    int strpos;
X    int old_ttymode = get_ttymode();
X    register backspace_count;
X    register KDE *tkde;
X    uchar icmd_buf[128];
X
X    if ((xkey >= XF_ALTA) && (xkey <= XF_ALTZ))
X    {
X        char alt_key_proc_name[8];
X        char *arg = alt_key_proc_name;
X        int narg = 1;
X        int restart_rcvr = need_rcvr_restart();
X
X        kill_rcvr_process(SIGUSR1);
X        sprintf(alt_key_proc_name, "alt_%c", xkey - XF_ALTA + 'a');
X        ttymode(2);
X        ttyflush(0);
X        if (do_proc(narg, &arg))
X            ring_bell();
X        sigint = 0;
X        proc_file_reset();
X        ttymode(old_ttymode);
X        if (restart_rcvr)
X            start_rcvr_process(0);
X        return (1);
X    }
X
X    switch (xkey)
X    {
X        case XFhome:         /* home key pressed ? */
X            icmd_buf[0] = 0;
X            backspace_count = show_escape_prompt();
X            strpos = 0;
X            icmd_buf[0] = 0;
X          GET_ICMD:
X            ttygets(icmd_buf, sizeof(icmd_buf), ttygets_flags, &delim, &strpos);
X            switch (delim)
X            {
X                case XFhome:
X                case XFpgup:
X                case XFcurup:
X                    itmp = strlen((char *)icmd_buf);
X                    while (itmp--)
X                        ff(se, "\b \b");
X                    if (icmd_history_manager(delim, icmd_buf, sizeof(icmd_buf)))
X                    {
X                        ring_bell();
X                        ttygets_flags |= 4;
X                        goto GET_ICMD;
X                    }
X                    break;
X                case ESC:
X                case NL:
X                    break;
X                default:
X                    ring_bell();
X                    itmp = strlen((char *)icmd_buf);
X                    while (itmp--)
X                        ff(se, "\b \b");
X                    ttygets_flags |= 4;
X                    goto GET_ICMD;
X            }
X            if ((delim == ESC) || !icmd_buf[0])
X            {
X                while (backspace_count--)
X                    ff(se, "\b \b");
X                break;
X            }
X            if (icmd(icmd_buf))
X                termecu(TERMECU_OK);
X            break;
X
X        default:
X            if ((itmp = xf_to_ikde(xkey)) < 0)
X            {
X                ring_bell();
X                break;
X            }
X            tkde = &keyset_table[itmp];
X            if ((itmp = tkde->count) > 0)
X            {
X                register char *cptr = tkde->str;
X
X                while (itmp--)
X                    lputc(*cptr++);
X            }
X            else if (tkde->count < 0)
X            {
X                switch (tkde->count)
X                {
X                    case KACT_LOCAL_SHELL:
X                        fputs("\r\n", se);
X                        tcap_stand_out();
X                        ff(se, " local shell in %s ", curr_dir);
X                        tcap_stand_end();
X                        ff(se, "\r\n");
X                        shell("!");
X                        break;
X                    case KACT_REDISPLAY:
X                        redisplay_rcvr_screen();
X                        break;
X                    case KACT_PROC:
X                        {
X#define ARG_MAX_QUAN 32
X                            char *arg[ARG_MAX_QUAN];
X                            int narg;
X
X                            build_arg_array(tkde->str, arg, ARG_MAX_QUAN, &narg);
X                            kill_rcvr_process(SIGUSR1);
X                            ttymode(2);
X                            do_proc(narg, arg);
X                            proc_file_reset();
X                            ttymode(1);
X                            sigint = 0;
X                        }
X                        break;
X                }
X            }
X            else
X                ring_bell();
X            break;
X    }
X    return (1);
X}                             /* end of kbd_escape */
X
X/*+-------------------------------------------------------------------------
X    set_bell_fd(fd,pitch,duration)
XExample: 1B 5B 3D 34 30 30 30 3B 31 42 | .[=4000;1B
X--------------------------------------------------------------------------*/
Xvoid
Xset_bell_fd(fd, pitch, duration)
Xint fd;
Xint pitch;
Xint duration;
X{
X#if defined(M_SYSV)
X    char bell_cmd[32];
X
X    if (!tty_is_multiscreen)
X        return;
X
X    sprintf(bell_cmd, "\033[=%d;%dB", pitch, duration);
X    write(fd, bell_cmd, strlen(bell_cmd));
X#endif
X}                             /* end of set_bell_fd */
X
X/*+-------------------------------------------------------------------------
X    send_bell_fd(fd,count,nap_msec)
X--------------------------------------------------------------------------*/
Xvoid
Xsend_bell_fd(fd, count, nap_msec)
Xregister fd;
Xregister count;
Xregister nap_msec;
X{
X    static char bellch = 0x07;
X
X    if (count)
X    {
X        while (count--)
X        {
X            write(fd, &bellch, 1);
X            Nap((long)nap_msec);
X        }
X    }
X}                             /* end of send_bell_fd */
X
X/*+-------------------------------------------------------------------------
X    xbell_fd(fd,type,count)
X--------------------------------------------------------------------------*/
Xvoid
Xxbell_fd(fd, type, count)
Xregister fd;
Xregister type;
Xregister count;
X{
X#if defined(M_SYSV)
X    register itmp;
X
X    if (!tty_is_multiscreen)
X    {
X        ring_bell();
X        return;
X    }
X
X    if (count)
X    {
X        while (count--)
X        {
X            switch (type)
X            {
X                case XBELL_DONE:    /* octaves */
X                    set_bell_fd(fd, 1000, 1);
X                    send_bell_fd(fd, 1, 100);
X                    set_bell_fd(fd, 2000, 1);
X                    send_bell_fd(fd, 1, 100);
X                    set_bell_fd(fd, 4000, 1);
X                    send_bell_fd(fd, 1, 100);
X                    break;
X                case XBELL_ATTENTION:    /* morse .-.-.- ATTENTION */
X                    for (itmp = 0; itmp < 3; itmp++)
X                    {
X                        set_bell_fd(fd, 2000, 1);
X                        send_bell_fd(fd, 1, 140);
X                        set_bell_fd(fd, 2000, 3);
X                        send_bell_fd(fd, 1, 340);
X                    }
X                    break;
X                case XBELL_C:    /* morse -.-. C */
X                    for (itmp = 0; itmp < 2; itmp++)
X                    {
X                        set_bell_fd(fd, 2000, 3);
X                        send_bell_fd(fd, 1, 320);
X                        set_bell_fd(fd, 2000, 1);
X                        send_bell_fd(fd, 1, 120);
X                    }
X                    break;
X                case XBELL_3T:    /* 3 morse T's */
X                    set_bell_fd(fd, 2000, 3);
X                    send_bell_fd(fd, 3, 460);
X                    break;
X                default:
X                    set_bell_fd(fd, 2000, 4);
X                    send_bell_fd(fd, 1, 100);
X                    break;
X            }
X        }
X    }
X
X    set_bell_fd(fd, 4000, 1);
X#endif
X}                             /* end of xbell_fd */
X
X/*+-------------------------------------------------------------------------
X    morse_bell(xbell_type,count)
X--------------------------------------------------------------------------*/
X#if defined(MORSE)
Xmorse_bell(xbell_type, count)
Xint xbell_type;
Xint count;
X{
X    register morse_fd;
X    int morse_frequency = 800;
X    char morse_char;
X    static int morse_ticks = 0;
X
X#if !defined(WHT)
X    if (!tty_is_multiscreen)
X    {
X        ring_bell();
X        return (0);
X    }
X#endif
X
X    if (!morse_ticks)
X        morse_ticks = hz / 25;
X
X    if ((morse_fd = open("/dev/morse", O_WRONLY, 0)) < 0)
X        return (-1);
X
X    ioctl(morse_fd, MORSE_SET_SPEED, &morse_ticks);
X    ioctl(morse_fd, MORSE_SET_FREQUENCY, &morse_frequency);
X    switch (xbell_type)
X    {
X        case XBELL_DONE:
X            morse_char = 'd';
X/*
X            morse_frequency = 400;
X            ioctl(morse_fd,MORSE_SET_FREQUENCY,&morse_frequency);
X*/
X            break;
X        case XBELL_ATTENTION:
X            morse_char = '.';
X            break;
X        case XBELL_C:
X            morse_char = 'c';
X            break;
X        case XBELL_3T:
X            morse_char = 'o';
X            break;
X        default:
X            morse_char = BT;
X            break;
X    }
X    while (count--)
X        write(morse_fd, &morse_char, 1);
X    close(morse_fd);
X    return (0);
X}                             /* end of morse_bell */
X#endif
X
X/*+-------------------------------------------------------------------------
X    xbell(type,count)
X--------------------------------------------------------------------------*/
Xvoid
Xxbell(type, count)
Xint type;
Xint count;
X{
X#if defined(WHT) && defined(MORSE)
X    if (morse_bell(type, count))
X        ring_bell();
X#else
X#if defined(WHT) && defined(AUDIO)
X    void audio_notify();
X
X    audio_notify(type);
X#else
X    if (!tty_is_multiscreen)
X    {
X        ring_bell();
X        return;
X    }
X
X#if defined(MORSE)
X    if (morse_bell(type, count))
X#endif
X        xbell_fd(1, type, count);
X#endif /* WHT && AUDIO */
X#endif /* WHT && MORSE */
X
X}                             /* end of xbell */
X
X/*+-------------------------------------------------------------------------
X    bell_alarm(xbell_type)
X  ring bell on multiscreens; if morse driver included, use it instead
X--------------------------------------------------------------------------*/
Xint
Xbell_alarm(xbell_type)
Xint xbell_type;
X{
X#if defined(M_SYSV)
X    register notify_fd;
X    register fork_pid;
X    static long notify_time = 0L;
X    char *get_ttyname();
X    char devname[64];
X    int devnum;
X    int ttnum;
X
X#if !(defined(WHT) && defined(MORSE))
X    if (!tty_is_multiscreen)
X    {
X        ring_bell();
X        return (1);
X    }
X#endif
X
X    ttnum = atoi(get_ttyname() + 8);
X
X/* if happened less than 15 secs ago, forget it */
X    if ((time((long *)0) - notify_time) < 15L)
X        return (0);
X
X    notify_time = time((long *)0);
X
X#if defined(MORSE)
X    if (morse_bell(xbell_type, 1))
X    {
X#endif
X        if ((fork_pid = smart_fork()) != 0)
X        {
X#if defined(FORK_DEBUG)
X            sprintf(devname, "DEBUG bell notify pid %d", fork_pid);
X            ecu_log_event(getpid(), devname);    /* bell notify */
X#endif
X            return (fork_pid > 0);
X        }
X
X        for (devnum = 1; devnum < 13; devnum++)
X        {
X            if (devnum == ttnum)    /* don't bell notify ecu's tty */
X                continue;
X            sprintf(devname, "/dev/tty%02d", devnum);
X            if ((notify_fd = open(devname, O_WRONLY, 0)) >= 0)
X            {
X                xbell_fd(notify_fd, xbell_type, 1);
X                close(notify_fd);
X            }
X        }
X
X        _exit(0);             /* end of child tine (of the fork, naturally) */
X#if defined(MORSE)
X    }
X    /* NOTREACHED */
X#endif
X#else /* not SCO (M_SYSV) */
X    ring_bell();
X#endif
X    return (1);
X}                             /* end of bell_alarm */
X
X/*+-------------------------------------------------------------------------
X    bell_notify(xbell_type)
X--------------------------------------------------------------------------*/
Xvoid
Xbell_notify(xbell_type)
Xint xbell_type;
X{
X#if defined(M_SYSV)
X    if (
X#if !defined(WHT) && !defined(PTY_BELL_NOTIFY)
X        tty_is_multiscreen &&
X#endif
X        shm->bell_notify_state)
X    {
X        bell_alarm(xbell_type);
X    }
X#endif
X}                             /* end of bell_notify */
X
X/*+-------------------------------------------------------------------------
X    parse_bell_notify_argument(strarg) - parse "bell notify" argument
X
X  Returns 0,1,2 according to parsing rules
X          -1 on error
X--------------------------------------------------------------------------*/
Xint
Xparse_bell_notify_argument(strarg)
Xchar *strarg;
X{
X    static STR_CLASSIFY sc[] =
X    {
X        {"off", 3, 0},
X        {"on", 2, 1},
X        {"alert", 1, 2},
X        {(char *)0, 0, -1},
X    };
X    int itmp;
X
X    if (isdigit(*strarg))
X    {
X        if (((itmp = atoi(strarg)) >= 0) && (itmp < 3))
X            return (itmp);
X        return (-1);
X    }
X
X    return (str_classify(sc, strarg));
X
X}                             /* end of parse_bell_notify_argument */
X
X/*+-------------------------------------------------------------------------
X    bell_notify_text(bn) - text for bell notify status
X--------------------------------------------------------------------------*/
Xchar *
Xbell_notify_text(bn)
Xint bn;
X{
X    char *cptr = "?";
X
X    switch (bn)
X    {
X        case 0:
X            cptr = "OFF";
X            break;
X        case 1:
X            cptr = "ON";
X            break;
X        case 2:
X            cptr = "ON+ALERT";
X            break;
X        default:
X            cptr = "???";
X            break;
X    }
X    return (cptr);
X}                             /* end of bell_notify_text */
X
X/*+-------------------------------------------------------------------------
X    signal_name_text(sig)
X--------------------------------------------------------------------------*/
Xchar *
Xsignal_name_text(sig)
Xint sig;
X{
X    register char *cptr;
X    static char sigunknown[20];
X
X    sig &= 0x7F;
X    switch (sig)
X    {
X        case SIGHUP:
X            cptr = "SIGHUP";
X            break;
X        case SIGINT:
X            cptr = "SIGINT";
X            break;
X        case SIGQUIT:
X            cptr = "SIGQUIT";
X            break;
X        case SIGILL:
X            cptr = "SIGILL";
X            break;
X        case SIGTRAP:
X            cptr = "SIGTRAP";
X            break;
X#ifdef SIGIOT
X        case SIGIOT:
X            cptr = "SIGIOT";
X            break;
X#endif
X#ifdef SIGEMT
X        case SIGEMT:
X            cptr = "SIGEMT";
X            break;
X#endif
X        case SIGFPE:
X            cptr = "SIGFPE";
X            break;
X        case SIGKILL:
X            cptr = "SIGKILL";
X            break;
X#if    defined(SIGBUS)
X        case SIGBUS:
X            cptr = "SIGBUS";
X            break;
X#endif
X        case SIGSEGV:
X            cptr = "SIGSEGV";
X            break;
X#if    defined(SIGSYS)
X        case SIGSYS:
X            cptr = "SIGSYS";
X            break;
X#endif
X        case SIGPIPE:
X            cptr = "SIGPIPE";
X            break;
X        case SIGALRM:
X            cptr = "SIGALRM";
X            break;
X        case SIGTERM:
X            cptr = "SIGTERM";
X            break;
X        case SIGUSR1:
X            cptr = "SIGUSR1";
X            break;
X        case SIGUSR2:
X            cptr = "SIGUSR2";
X            break;
X        case SIGCLD:
X            cptr = "SIGCLD";
X            break;
X#if    defined(SIGPWR)
X        case SIGPWR:
X            cptr = "SIGPWR";
X            break;
X#endif
X#if    defined(SIGSTOP)
X        case SIGSTOP:
X            cptr = "SIGSTOP";
X            break;
X#endif
X#if    defined(SIGTSOP)
X        case SIGTSTP:
X            cptr = "SIGTSTP";
X            break;
X#endif
X#if    defined(SIGCONT)
X        case SIGCONT:
X            cptr = "SIGCONT";
X            break;
X#endif
X#if    defined(SIGTTIN)
X        case SIGTTIN:
X            cptr = "SIGTTIN";
X            break;
X#endif
X#if    defined(SIGTTOU)
X        case SIGTTOU:
X            cptr = "SIGTTOU";
X            break;
X#endif
X        default:
X            sprintf(sigunknown, "SIGNAL %u", sig);
X            return (sigunknown);
X    }
X    return (cptr);
X
X}                             /* end of signal_name_text */
X
X/*+-------------------------------------------------------------------------
X    rename(from,to)
X--------------------------------------------------------------------------*/
X#if defined(M_XENIX) && !defined(BUILDING_LINT_ARGS)
Xint
Xrename(from, to)
Xchar *from;
Xchar *to;
X{
X    struct stat ss;
X    int save_errno;
X    extern int errno;
X
X    if (!stat(to, &ss))         /* if to exists, flunk */
X    {
X        errno = EEXIST;         /* fake "file exists" error */
X        return (-1);
X    }
X
X    if (link(from, to))         /* if cannot link, flunk */
X        return (-1);
X
X    if (unlink(from))         /* if cannot unlink, flunk */
X    {
X        save_errno = errno;
X        unlink(to);
X        errno = save_errno;
X        return (-1);
X    }
X
X    return (0);
X
X}                             /* end of rename */
X#endif
X
X/*+-------------------------------------------------------------------------
X    send_get_response(narg,arg) - send a string, get and log response
X--------------------------------------------------------------------------*/
X/*ARGSUSED*/
Xvoid
Xsend_get_response(narg, arg)
Xint narg;
Xchar **arg;
X{
X    int itmp;
X    int mode;
X    LRWT lr;
X    char buf[1024];
X    FILE *fplog;
X    char *fname = "./ecu.sgr.log";
X    int restart_rcvr = need_rcvr_restart();
X
X    if (narg < 3)
X    {
X        fputs("   usage: sgr <mode> <cmd>\r\n", se);
X        fputs("mode = 0 for sanitized response, 1 == raw\r\n", se);
X        fputs("cmd = 'Send' string (see 'expresp' proc cmd in manual)\r\n", se);
X        return;
X    }
X
X    /*
X     * don't want receiver stealing our response
X     */
X    kill_rcvr_process(SIGUSR1);
X
X    /*
X     * set up for capturing response
X     */
X    mode = atoi(arg[1]) & 0x0F;;
X#ifdef WHT
X    lr.to1 = 30 * 1000L;
X#else
X    lr.to1 = 10 * 1000L;
X#endif
X    lr.to2 = 5 * 1000L;
X    lr.raw_flag = 0x80 + mode;    /* allow interrupts */
X    lr.buffer = buf;
X    lr.bufsize = sizeof(buf);
X    lr.delim = (char *)0;
X    lr.echo_flag = 0;
X
X    /*
X     * stimulus/response
X     */
X    ff(se, "  ... wait ... ");
X    respond(arg[2]);
X    if (!sigint)
X    {
X        lgets_timeout(&lr);
X        if (sigint)
X            goto INTERRUPTED;
X        ff(se, "done\r\n");
X
X        /*
X         * log response if possible and display on screen
X         */
X        if (fplog = fopen(fname, "a"))
X        {
X            itmp = strlen(arg[2]);
X            hex_dump_fp(fplog, arg[2], itmp, "Stimulus", (itmp <= 16));
X            hex_dump_fp(fplog, buf, lr.count, "Response", (lr.count <= 16));
X            fputs("\n", fplog);
X            fclose(fplog);
X            ff(se, "Dialog dump appended to '%s'\r\n", fname);
X        }
X        itmp = strlen(arg[2]);
X        hex_dump_fp(fplog, arg[2], itmp, "Stimulus", (itmp <= 16));
X        hex_dump(buf, lr.count, "Response", (lr.count <= 16));
X    }
X    else
X    {
X      INTERRUPTED:
X        sigint = 0;
X        ff(se, "interrupted\r\n");
X    }
X
X    if (restart_rcvr)
X        start_rcvr_process(0);
X}                             /* end of send_get_response */
X
X/*+-------------------------------------------------------------------------
X    xterm_title(text,code) - experimental - watch this space
X--------------------------------------------------------------------------*/
X#if defined(WHT2) || defined(XTERM_FRIEND)
Xvoid
Xxterm_title(text, code)
Xchar *text;
Xint code;
X{
X    static char *term = (char *)0;
X    static char usrname[L_cuserid] = "";
X    char *getenv();
X    char *cuserid();
X    static char xtstr1[82] = "";
X
X    if (!term)
X        term = getenv("TERM");
X    if (!term)
X    {
X        term = "";
X        return;
X    }
X    if (ulcmpb(term, "xterm") >= 0)
X        return;
X
X    if (!usrname[0])
X        (void)cuserid(usrname);
X
X    switch (code)
X    {
X        case 0:
X        case 1:
X            xtstr1[0] = 0;
X            if (code == 1)
X                strcpy(xtstr1, "ECU: ");
X            strcat(xtstr1, text);
X            if (usrname[0])
X                sprintf(xtstr1 + strlen(xtstr1), " (%s)", usrname);
X        case 2:
X            fputs("\033]0;", se);
X            fputs(xtstr1, se);
X            fputc(7, se);
X            break;
X    }
X}                             /* end of xterm_title */
X#endif
X
X/* end of ecugrabbag.c */
X/* vi: set tabstop=4 shiftwidth=4: */
END_OF_FILE
  if test 19978 -ne `wc -c <'ecu330/ecugrabbag.c'`; then
    echo shar: \"'ecu330/ecugrabbag.c'\" unpacked with wrong size!
  fi
  # end of 'ecu330/ecugrabbag.c'
fi
if test -f 'ecu330/ecusetup.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/ecusetup.c'\"
else
  echo shar: Extracting \"'ecu330/ecusetup.c'\" \(18406 characters\)
  sed "s/^X//" >'ecu330/ecusetup.c' <<'END_OF_FILE'
X/*+-------------------------------------------------------------------------
X    ecusetup.c -- ecu visual "argv"
X    [e-mail]
X
X  0000000000111111111122222222223333333333444444444455555555556666
X  0123456789012345678901234567890123456789012345678901234567890123
X00.--[ ecu rev ]-------------------------------------------------.
X01|                                                              |
X02|  Destination   .......................................       |
X03|    Telephone     ....................                        |
X04|    Description   ........................................    |
X05|                                                              |
X06|  tty: /dev/........   (opened)                               |
X07|                                                              |
X08|  duplex: .  baud: .....  parity: . (data bits .)             |
X09|  add NL to transmitted CR: .                                 |
X10|  add NL to received CR:    .                                 |
X11|                                                              |
X12|                                                              |
X13|   TAB:next ^B:prev END:proceed ^D:phone dir  ESC:quit ecu    |
X14`--------------------------------------------------------------'
X
X  Defined functions:
X    setup_display_baud()
X    setup_display_name()
X    setup_display_screen(write_lits)
X    setup_display_single_char()
X    setup_display_tty()
X    setup_line_open()
X    setup_screen(argv_logical)
X    setw_bot_msg(msg)
X    setw_err_msg(msg)
X    setw_get_single(nondelim_list)
X    setw_msg(msg,y,fillch,last_msglen)
X
X  All readers cannot be leaders, but all leaders must be readers.
X  - Harry Truman
X
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:39-wht@n4hgf-ECU release 3.30 */
X/*:12-02-1993-14:34-wht@n4hgf-line lock retries from 8 to 20 */
X/*:11-12-1993-11:00-wht@n4hgf-Linux changes by [e-mail] */
X/*:05-29-1993-20:21-wht@n4hgf-change linst_err_text to LINST_text */
X/*:04-12-1993-12:16-wht@n4hgf-if delim == ^D, do not parse input */
X/*:09-10-1992-13:58-wht@n4hgf-ECU release 3.20 */
X/*:09-05-1992-14:49-wht@n4hgf-parity field was one to the left of proper pos */
X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
X/*:04-28-1992-01:34-wht@n4hgf-default tty in tty prompt had slash */
X/*:04-24-1992-21:59-wht@n4hgf-more SCO tty name normalizing */
X/*:08-28-1991-14:07-wht@n4hgf2-SVR4 cleanup by aega84!lh */
X/*:08-25-1991-14:39-wht@n4hgf-SVR4 port thanks to aega84!lh */
X/*:08-12-1991-00:58-wht@n4hgf-ISC tty names */
X/*:07-25-1991-12:56-wht@n4hgf-ECU release 3.10 */
X/*:07-17-1991-07:04-wht@n4hgf-avoid SCO UNIX nap bug */
X/*:06-05-1991-18:07-wht@n4hgf-rework */
X/*:04-27-1991-01:52-wht@n4hgf-overhaul revision numbers */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#include "ecucurses.h"
X
X#define STDIO_H_INCLUDED
X#define OMIT_TERMIO_REFERENCES
X#include "ecu.h"
X#include "ecukey.h"
X#include "ecuxkey.h"
X#include "ecupde.h"
X#include "pc_scr.h"
X
XPDE *logical_telno_to_pde();
X
X#define SETW_LINES    15
X#define SETW_COLS    64
X#define SETW_TLY    1
X#define SETW_TLX    ((80 - SETW_COLS) / 2)
X
X#define NAME_Y        2
X#define NAME_X        17
X#define NAME_LEN    DESTREF_LEN
X#define NAME_LX        3
X
X#define PHNUM_Y        3
X#define PHNUM_X        19
X#define PHNUM_LEN    DESTREF_LEN
X#define PHNUM_LX    5
X
X#define DESCR_Y        4
X#define DESCR_X        19
X#define DESCR_LEN    PDE_DESCR_LEN
X#define DESCR_LX    5
X
X#define TTY_Y        6
X#define TTY_X        13
X#define TTY_LEN        8
X#define TTY_LX        3
X
X#define TTYOPN_LY    6
X#define TTYOPN_LX    24
X
X#define DPX_Y        8
X#define DPX_X        11
X#define DPX_LX        3
X
X#define BAUD_Y        8
X#define BAUD_X        20
X#define BAUD_LEN    5
X#define BAUD_LX        14
X
X#define PAR_Y        8
X#define PAR_X        35
X#define PAR_LX        27
X
X#define DB_Y        8
X#define DB_X        48
X#define DB_LX        37
X#define DB_LX2        49
X
X#define XADDNL_Y    9
X#define XADDNL_X    29
X#define XADDNL_LX    3
X
X#define RADDNL_Y    10
X#define RADDNL_X    29
X#define RADDNL_LX    3
X
Xextern char *revstr;         /* ecunumrev.c */
Xextern char errmsg[];
X
XWINDOW *setw;
X
X#define SETW_MSG_LEFTX 2
X#define SETW_MSG_MAXLEN    (SETW_COLS - SETW_MSG_LEFTX - 8)
X#define SETW_MSG_BOT_Y  (SETW_LINES - 1)
X#define SETW_MSG_ERR_Y  (SETW_LINES - 3)
X
X#ifdef LINUX
Xtypedef chtype CHTYPE;
X
X#else
Xtypedef char CHTYPE;
X
X#endif
X
X/*+-------------------------------------------------------------------------
X    setw_msg(msg,y,fillch)
X--------------------------------------------------------------------------*/
Xvoid
Xsetw_msg(msg, y, fillch, last_msglen)
Xchar *msg;
Xint y;
XCHTYPE fillch;
Xint *last_msglen;
X{
X    register itmp;
X    register itmp2;
X    char msg2[80];
X
X    if (!*last_msglen && !strlen(msg))
X        return;
X
X    wmove(setw, y, SETW_MSG_LEFTX);
X
X    if ((itmp = strlen(msg)) == 0)
X    {
X        itmp2 = *last_msglen + 2;
X#if defined(SVR4)
X        whline(setw, (unsigned long)(fillch & 0x00ff), itmp2);
X#else
X#if defined(LINUX)
X        whline(setw, fillch, itmp2);
X#else
X        for (itmp = 0; itmp < itmp2; itmp++)
X            waddch(setw, fillch & 0xFF);
X#endif
X#endif
X        *last_msglen = 0;
X    }
X    else
X    {
X        waddch(setw, ' ');
X        if (itmp > SETW_MSG_MAXLEN)
X        {
X            strncpy(msg2, msg, SETW_MSG_MAXLEN);
X            msg2[SETW_MSG_MAXLEN + 1] = 0;
X            waddstr(setw, msg2);
X            itmp = strlen(msg2);
X        }
X        else
X        {
X            waddstr(setw, msg);
X            itmp = strlen(msg);
X        }
X        waddch(setw, ' ');
X        if ((itmp2 = *last_msglen - itmp) > 0)
X        {
X#if defined(SVR4)
X            whline(setw, (unsigned long)(fillch & 0x00ff), itmp2);
X#else
X#if defined(LINUX)
X            whline(setw, fillch, itmp2);
X#else
X            while (itmp2--)
X                waddch(setw, fillch & 0xFF);
X#endif
X#endif
X        }
X        *last_msglen = itmp; /* remember last message length */
X    }
X    wrefresh(setw);
X}                             /* end of setw_msg */
X
X/*+-------------------------------------------------------------------------
X    setw_bot_msg(msg)
X--------------------------------------------------------------------------*/
Xvoid
Xsetw_bot_msg(msg)
Xchar *msg;
X{
X    static int last_msglen = 0;
X
X    setw_msg(msg, SETW_MSG_BOT_Y, sHR, &last_msglen);
X}                             /* end of setw_bot_msg */
X
X/*+-------------------------------------------------------------------------
X    setw_err_msg(msg)
X--------------------------------------------------------------------------*/
Xvoid
Xsetw_err_msg(msg)
Xchar *msg;
X{
X    static int last_msglen = 0;
X
X    setw_msg(msg, SETW_MSG_ERR_Y, ' ', &last_msglen);
X}                             /* end of setw_err_msg */
X
X/*+-------------------------------------------------------------------------
X    setup_display_name()
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_display_name()
X{
X    clear_area(setw, NAME_Y, NAME_X, NAME_LEN);
X    waddstr(setw, shm->Llogical);
X
X#if 0
X    if (!shm->Llogical[0] && (shm->Liofd < 0))
X    {
X        clear_area(setw, PHNUM_Y, PHNUM_X, PHNUM_LEN);
X        clear_area(setw, DESCR_Y, DESCR_X, DESCR_LEN);
X        return;
X    }
X#endif
X
X    wmove(setw, PHNUM_Y, PHNUM_LX);
X    if (shm->Ltelno[0])
X        waddstr(setw, "Telephone");
X    else
X        waddstr(setw, "         ");
X    clear_area(setw, PHNUM_Y, PHNUM_X, PHNUM_LEN);
X#if 0
X    if (!shm->Ltelno[0])
X    {
X        if (!isdigit(shm->Llogical[0]) && find_procedure(shm->Llogical))
X            waddstr(setw, "<procedure connect>");
X        else
X            waddstr(setw, "<direct connect>");
X    }
X    else
X#endif
X        waddstr(setw, shm->Ltelno);
X
X    wmove(setw, DESCR_Y, DESCR_LX);
X    if (shm->Ldescr[0])
X        waddstr(setw, "Description");
X    else
X        waddstr(setw, "           ");
X    clear_area(setw, DESCR_Y, DESCR_X, DESCR_LEN);
X    waddstr(setw, shm->Ldescr);
X
X}                             /* end of setup_display_name */
X
X/*+-------------------------------------------------------------------------
X    setup_display_tty()
X     00000000
X     01234567
X/dev/........
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_display_tty()
X{
X    char s[TTY_LEN + 1];
X
X    strncpy(s, shm->Lline + 5, TTY_LEN);
X    s[TTY_LEN] = 0;
X    clear_area(setw, TTY_Y, TTY_X, TTY_LEN);
X    waddstr(setw, s);
X    wmove(setw, TTYOPN_LY, TTYOPN_LX);
X    if (shm->Liofd >= 0)
X        waddstr(setw, "(opened)");
X    else
X        waddstr(setw, "        ");
X    wrefresh(setw);
X
X}                             /* end of setup_display_tty */
X
X/*+-------------------------------------------------------------------------
X    setup_display_single_char()
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_display_single_char()
X{
X    wmove(setw, DPX_Y, DPX_X);
X    waddch(setw, (shm->Lfull_duplex) ? 'F' : 'E');
X    wmove(setw, PAR_Y, PAR_X);
X    waddch(setw, (shm->Lparity) ? to_upper(shm->Lparity) : 'N');
X    wmove(setw, DB_Y, DB_X);
X    waddch(setw, (shm->Lparity) ? '7' : '8');
X    wmove(setw, XADDNL_Y, XADDNL_X);
X    waddch(setw, (shm->Ladd_nl_outgoing) ? 'Y' : 'N');
X    wmove(setw, RADDNL_Y, RADDNL_X);
X    waddch(setw, (shm->Ladd_nl_incoming) ? 'Y' : 'N');
X
X}                             /* end of setup_display_single_char */
X
X/*+-------------------------------------------------------------------------
X    setup_display_baud()
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_display_baud()
X{
X    char s8[8];
X
X    clear_area(setw, BAUD_Y, BAUD_X, BAUD_LEN);
X    sprintf(s8, "%u", shm->Lbaud);
X    waddstr(setw, s8);
X
X}                             /* end of setup_display_baud */
X
X/*+-------------------------------------------------------------------------
X    setup_display_screen(write_lits)
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_display_screen(write_lits)
Xint write_lits;
X{
X
X    if (write_lits)
X    {
X        wmove(setw, NAME_Y, NAME_LX);
X        waddstr(setw, "Destination");
X        wmove(setw, TTY_Y, TTY_LX);
X        waddstr(setw, "tty: /dev/");
X        wmove(setw, DPX_Y, DPX_LX);
X        waddstr(setw, "duplex:");
X        wmove(setw, BAUD_Y, BAUD_LX);
X        waddstr(setw, "baud:");
X        wmove(setw, PAR_Y, PAR_LX);
X        waddstr(setw, "parity:");
X        wmove(setw, DB_Y, DB_LX);
X        waddstr(setw, "(data bits");
X        wmove(setw, DB_Y, DB_LX2);
X        waddch(setw, ')');
X        wmove(setw, XADDNL_Y, XADDNL_LX);
X        waddstr(setw, "add NL to transmitted CR:");
X        wmove(setw, RADDNL_Y, RADDNL_LX);
X        waddstr(setw, "add NL to received CR:");
X        wmove(setw, SETW_LINES - 2, 1);
X        wstandout(setw);
X        waddstr(setw,         /* kludge -- must change if setw width does */
X            "   TAB:next ^B:prev END:proceed ^D:phone dir  ESC:quit ecu    ");
X        wstandend(setw);
X    }
X    setup_display_name();
X    setup_display_tty();
X    setup_display_single_char();
X    setup_display_baud();
X    wrefresh(setw);
X}                             /* end of setup_display_screen */
X
X/*+-------------------------------------------------------------------------
X    setup_line_open()
X--------------------------------------------------------------------------*/
Xint
Xsetup_line_open()
X{
X    int itmp;
X    int retries = 20;
X    char *LINST_text();
X    char *cptr;
X    char msg[80];
X    long wait_msec;
X    int displayed_single_char_exit = 0;
X
X    while (itmp = lopen())
X    {
X        if (retries)
X        {
X            if ((itmp != LINST_ENABLED_IN_USE) &&
X                (itmp != LINST_DIALOUT_IN_USE) && (itmp < 0))
X            {
X                goto FAIL;
X            }
X            cptr = LINST_text(itmp);
X            sprintf(msg, "%s - waiting %d sec", cptr, retries);
X            cptr = msg;
X            if (!displayed_single_char_exit)
X            {
X                setw_bot_msg("Press any key to skip retries");
X                displayed_single_char_exit = 1;
X            }
X        }
X        else
X        {
X          FAIL:
X            retries = 0;
X            cptr = LINST_text(itmp);
X            ring_bell();
X        }
X        setw_err_msg(cptr);
X        if (!retries--)
X            break;
X        wait_msec = 1000L;
X        while (wait_msec > 0)
X        {
X            if (ttyrdchk())
X            {
X                (void)ttygetc(1);
X                goto FAIL;
X            }
X            wait_msec -= Nap(100L);
X        }
X        setw_err_msg("");
X    }
X
X#ifdef SHARE_DEBUG
X    {
X        char s256[256];
X
X        sprintf(s256, "SETUP-OPENED line=%s fd=%d", shm->Lline, shm->Liofd);
X        ecu_log_event((int)xmtr_pid, s256);
X    }
X#endif
X
X    setup_display_tty();
X    lopen_error_reset();     /* clear static error area */
X    return (itmp);
X
X}                             /* end of setup_line_open */
X
X/*+-------------------------------------------------------------------------
X    setw_get_single(nondelim_list)
Xassumes cursor is already positioned
X--------------------------------------------------------------------------*/
Xuint
Xsetw_get_single(nondelim_list)
Xregister char *nondelim_list;
X{
X    register uint itmp;
X    static uchar setw_nondelim_list[] =
X    {
X        CRET, NL, CTL_B, CTL_D, TAB, ESC, CTL_L, CTL_R, XFend, XFcurup, XFcurdn
X    };
X
X    itmp = winget_single(setw, nondelim_list, setw_nondelim_list);
X    if ((itmp & 0xFF) == CRET)
X        itmp = NL | 0x1000;
X    return (itmp);
X}                             /* end of setw_get_single */
X
X/*+-------------------------------------------------------------------------
X    setup_screen(argv_logical)
X--------------------------------------------------------------------------*/
Xvoid
Xsetup_screen(argv_logical)
Xchar *argv_logical;
X{
X    register itmp;
X    register input_state = 0;
X    char s128[128];
X    char *cptr;
X    char logical[NAME_LEN + 1];
X    int done = 0;
X    uint baud;
X    uchar delim;             /* important to be unsigned to avoid sign
X                              * extension */
X    PDE *tpde;
X    WINDOW *window_create();
X    static uchar use_input_delim[] =
X    {TAB, NL, XFcurdn, XFcurup, XFend, CTL_D, 0};
X
X    windows_start();
X    sprintf(s128, "ecu %s", revstr);
X    setw = window_create(s128, -3, SETW_TLY, SETW_TLX, SETW_LINES, SETW_COLS);
X    shm->Llogical[0] = 0;
X    logical[0] = 0;
X    setup_display_screen(1);
X
X#ifdef TURNKEY
X    if (!argv_logical)
X    {
X        done = 1;
X        delim = CTL_D;
X    }
X#endif /* TURNKEY */
X
X  REENTER_INPUT_LOOP:
X    while (!done)
X    {
X        wrefresh(setw);
X        switch (input_state)
X        {
X            case 0:
X                if (argv_logical)
X                {
X                    itmp = 0;/* 'ecu -' means dont dial */
X                    if (strcmp(argv_logical, "-"))    /* if not "-" */
X                    {
X                        strncpy(s128, argv_logical, NAME_LEN + 1);
X                        s128[NAME_LEN + 1] = 0;
X                        itmp = strlen(s128);
X                    }
X                    argv_logical = (char *)0;
X                    delim = XFend;
X                }
X                else
X                {
X                    if (logical[0])
X                        strcpy(s128, logical);
X                    setw_bot_msg(
X                        "logical phone directory entry, phone number or empty");
X                    itmp = wingets(setw, NAME_Y, NAME_X, s128,
X                        NAME_LEN + 1, &delim,
X                        (logical[0] != 0), (int *)0);
X                    setw_err_msg("");
X                }
X                if (delim == CTL_D)    /* do not process if going to
X                                     * directory */
X                    break;
X                if (strchr((char *)use_input_delim, (uchar) delim))
X                {
X                    strcpy(logical, s128);
X                    if ((tpde = logical_telno_to_pde(logical)) &&
X                        !copy_pde_to_Lvariables(tpde, 1))
X                    {
X                        strcpy(logical, tpde->logical);
X                        setup_display_screen(0);
X                        break;
X                    }
X                    else
X                    {
X                        setw_err_msg(errmsg);
X                        setup_display_screen(0);
X                        ring_bell();
X                        argv_logical = (char *)0;
X                        continue;
X                    }
X                }
X                setup_display_name();
X                break;
X
X            case 1:
X                cptr = strrchr(DEFAULT_TTY, '/');
X                if (!cptr)     /* cover unlikely bug */
X                    cptr = "/ttya";
X                cptr++;
X                sprintf(s128, "comm line: i.e., %s", cptr);
X                setw_bot_msg(s128);
X                setup_display_tty();
X                strcpy(s128, "/dev/");
X                strcpy(s128, &shm->Lline[5]);
X                itmp = wingets(setw, TTY_Y, TTY_X, s128, TTY_LEN + 1, &delim,
X                    1, (int *)0);
X                setw_err_msg("");
X                if (delim == CTL_D)    /* do not process if going to
X                                     * directory */
X                    break;
X                if (strchr((char *)use_input_delim, (uchar) delim))
X                {
X                    strcpy(shm->Lline, "/dev/");
X                    strcpy(&shm->Lline[5], s128);
X                }
X                setup_display_tty();
X                break;
X
X            case 2:
X                setw_bot_msg("duplex F:full H:half");
X                wmove(setw, DPX_Y, DPX_X);
X                wrefresh(setw);
X                delim = NL;
X                switch (itmp = setw_get_single("fh"))
X                {
X                    case 0:
X                    case 1:
X                        shm->Lfull_duplex = itmp;
X                        break;
X                    default:
X                        delim = itmp & 0xFF;
X                        break;
X                }
X                break;
X
X            case 3:         /* baud */
X                setw_bot_msg(
X                    "rates: 110,300,600,1200,2400,41280,9600,19200,38400");
X              CASE_3:
X                sprintf(s128, "%u", shm->Lbaud);
X                itmp = wingets(setw, BAUD_Y, BAUD_X, s128, BAUD_LEN + 1, &delim,
X                    1, (int *)0);
X                if (delim == CTL_D)    /* do not process if going to
X                                     * directory */
X                    break;
X                if (strchr((char *)use_input_delim, (uchar) delim))
X                {
X                    if (valid_baud_rate(baud = atoi(s128)) < 0)
X                    {
X                        setup_display_baud();
X                        ring_bell();
X                        goto CASE_3;
X                    }
X                    shm->Lbaud = baud;
X                }
X                setup_display_baud();
X                break;
X
X            case 4:
X                setw_bot_msg("parity: N:none E:even O:odd");
X                wmove(setw, PAR_Y, PAR_X);
X                wrefresh(setw);
X                delim = NL;
X                switch (itmp = setw_get_single("neo"))
X                {
X                    case 0:
X                        shm->Lparity = 0;
X                        break;
X                    case 1:
X                        shm->Lparity = 'e';
X                        break;
X                    case 2:
X                        shm->Lparity = 'o';
X                        break;
X                    default:
X                        delim = itmp & 0xFF;
X                        break;
X                }
X                wmove(setw, DB_Y, DB_X);
X                waddch(setw, (shm->Lparity) ? '7' : '8');
X                break;
X
X            case 5:
X                setw_bot_msg("");
X                wmove(setw, XADDNL_Y, XADDNL_X);
X                wrefresh(setw);
X                delim = NL;
X                switch (itmp = setw_get_single("ny"))
X                {
X                    case 0:
X                    case 1:
X                        shm->Ladd_nl_outgoing = itmp;
X                        break;
X                    default:
X                        delim = itmp & 0xFF;
X                }
X                break;
X
X            case 6:
X                setw_bot_msg("");
X                wmove(setw, RADDNL_Y, RADDNL_X);
X                wrefresh(setw);
X                delim = NL;
X                switch (itmp = setw_get_single("ny"))
X                {
X                    case 0:
X                    case 1:
X                        shm->Ladd_nl_incoming = itmp;
X                        break;
X                    default:
X                        delim = itmp & 0xFF;
X                        break;
X                }
X                break;
X        }
X
X        if (argv_logical && (delim != CTL_D))
X            break;
X
X        switch (delim)
X        {
X            case XFcurup:
X            case CTL_B:
X                if (input_state)
X                    input_state--;
X                else
X                    input_state = 6;
X                break;
X
X            case XFcurdn:
X            case TAB:
X            case NL:
X                input_state++;
X                input_state %= 7;
X                break;
X
X            case ESC:
X                if (shm->Liofd >= 0)
X                    lclose();
X                setw_bot_msg("");
X                setup_display_tty();
X                termecu(0);
X                break;
X
X            case CTL_L:
X            case CTL_R:
X                tcap_clear_screen();
X                touchwin(stdscr);
X                wrefresh(stdscr);
X                setup_display_screen(1);
X                touchwin(setw);
X                wrefresh(setw);
X                break;
X
X            case XFend:
X            case CTL_D:
X                done = 1;
X                break;
X        }
X    }
X
X    if (shm->Liofd < 0)
X    {
X        wmove(setw, TTY_Y, TTY_X);
X        wrefresh(setw);
X        if (setup_line_open())
X        {
X            done = 0;
X            input_state = 1;
X            argv_logical = (char *)0;
X            goto REENTER_INPUT_LOOP;
X        }
X    }
X
X    wmove(setw, SETW_LINES - 2, 1);
X    wstandout(setw);
X    waddstr(setw,             /* kludge -- must change if setw width does */
X        "------- Press HOME then 'help' for further assistance --------");
X    wstandend(setw);
X    setw_bot_msg("");
X    wrefresh(setw);
X    delwin(setw);
X    windows_end(0);
X    ttymode(1);
X    tcap_cursor(SETW_TLY + SETW_LINES + 2, 0);
X    rcvr_pid = -2;
X    if (delim == CTL_D)
X        phdir_manager();
X    else if (logical[0])
X    {
X        tpde = logical_telno_to_pde(logical);    /* error return not likely
X                                                 * now */
X        pde_dial(tpde);
X    }
X    else
X        start_rcvr_process(1);
X
X#ifdef SHARE_DEBUG
X    {
X        char s256[256];
X
X        sprintf(s256, "SETUP-DONE line=%s fd=%d", shm->Lline, shm->Liofd);
X        ecu_log_event((int)xmtr_pid, s256);
X    }
X#endif
X
X}                             /* end of setup_screen */
X
X/* vi: set tabstop=4 shiftwidth=4: */
END_OF_FILE
  if test 18406 -ne `wc -c <'ecu330/ecusetup.c'`; then
    echo shar: \"'ecu330/ecusetup.c'\" unpacked with wrong size!
  fi
  # end of 'ecu330/ecusetup.c'
fi
if test -f 'ecu330/esdutil.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/esdutil.c'\"
else
  echo shar: Extracting \"'ecu330/esdutil.c'\" \(20092 characters\)
  sed "s/^X//" >'ecu330/esdutil.c' <<'END_OF_FILE'
X/*+----------------------------------------------------------------
X    esdutil.c - ecu extended string descriptor manipulation
X    [e-mail]
X
X  Defined functions:
X    end_of_cmd(tesd)
X    esd_null_terminate(tesd)
X    esd_strip_trail_break(ztext)
X    esdalloc(maxcb)
X    esdcat(dest,suffix,realloc_ok)
X    esdfgets(tesd,fileptr)
X    esdfputs(tesd,fileptr,index_flag,nl_flag)
X    esdfree(tesd)
X    esdinit(tesd,cptr,maxcb)
X    esdrealloc(tesd,maxcb)
X    esdshow(tesd,title)
X    esdstrcat(tesd,zstr)
X    esdstrindex(esd1,esd2,index1_flag,index2_flag)
X    esdzero(tesd)
X    get_alpha_zstr(tesd,strbuf,strbuf_maxcb)
X    get_alphanum_zstr(tesd,strbuf,strbuf_maxcb)
X    get_cmd_char(tesd,pchar)
X    get_numeric_value(tesd,value)
X    get_numeric_zstr(tesd,strbuf,strbuf_maxcb)
X    get_switches(tesd,switches,switches_max)
X    get_word_zstr(tesd,strbuf,strbuf_maxcb)
X    keyword_lookup(ktable,keywd)
X    skip_cmd_break(tesd)
X    skip_cmd_char(tesd,skipchar)
X    skip_colon(tesd)
X    skip_comma(tesd)
X    skip_paren(tesd,fLeft)
X    strindex(str1,str2)
X
X  This is old code; give me a break
X
X-----------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:39-wht@n4hgf-ECU release 3.30 */
X/*:12-19-1992-16:30-wht@n4hgf-rectification of names in keyword_lookup */
X/*:09-10-1992-13:59-wht@n4hgf-ECU release 3.20 */
X/*:08-22-1992-15:38-wht@n4hgf-ECU release 3.20 BETA */
X/*:03-20-1992-06:26-wht@n4hgf-esdstrcat will grow an esd */
X/*:08-25-1991-23:20-root@n4hgf2-get_switches could overflow result string */
X/*:07-25-1991-12:57-wht@n4hgf-ECU release 3.10 */
X/*:05-02-1991-04:12-wht@n4hgf-how did esdrealloc ever work? */
X/*:04-23-1991-04:33-wht@n4hgf-function name reorganization */
X/*:04-23-1991-04:33-wht@n4hgf-add esdcat */
X/*:01-31-1991-14:49-wht@n4hgf-rework esdrealloc for speed */
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
Xextern int errno;
X
X/*+-------------------------------------------------------------------------
X    esd_null_terminate(&esd)
X    puts null at 'cb' position of string (standard esd always
X    has one more byte in buffer than maxcb says)
X--------------------------------------------------------------------------*/
Xvoid
Xesd_null_terminate(tesd)
Xregister ESD *tesd;
X{
X    tesd->pb[tesd->cb] = 0;
X}                             /* end of esd_null_terminate */
X
X/*+-----------------------------------------------------------------------
X    esdzero(tesd)  zero an esd
X------------------------------------------------------------------------*/
Xvoid
Xesdzero(tesd)
Xregister ESD *tesd;
X{
X    tesd->cb = 0;             /* current count == 0 */
X    tesd->index = 0;         /* parse index to first position */
X    tesd->old_index = 0;     /* parse index to first position */
X    *tesd->pb = 0;             /* start with null terminated string */
X
X}                             /* end of esdzero */
X
X/*+-----------------------------------------------------------------------
X    esdinit(tesd,cptr,maxcb)  init an esd
X------------------------------------------------------------------------*/
Xvoid
Xesdinit(tesd, cptr, maxcb)
Xregister ESD *tesd;
Xchar *cptr;
Xregister maxcb;
X{
X    tesd->pb = cptr;         /* pointer to string */
X    tesd->maxcb = maxcb;     /* max characters in buffer */
X    esdzero(tesd);
X
X}                             /* end of esdinit */
X
X/*+-----------------------------------------------------------------------
X    esdptr = esdalloc(maxcb)    allocate an esd and buffer
X------------------------------------------------------------------------*/
XESD *
Xesdalloc(maxcb)
Xregister maxcb;                 /* desired maxcb */
X{
X    register ESD *tesd;
X    register actual_cb;
X
X    /* we get an extra character to ensure room for null past maxcb */
X    actual_cb = maxcb + 1;
X    if (actual_cb & 1)         /* even allocation */
X        ++actual_cb;
X
X    if (!(tesd = (ESD *) malloc(sizeof(ESD))))
X        return ((ESD *) 0);     /* return NULL if failure */
X
X    if (!(tesd->pb = malloc(actual_cb)))
X    {
X        free((char *)tesd);
X        return ((ESD *) 0);     /* return NULL if failure */
X    }
X
X    esdinit(tesd, tesd->pb, maxcb);
X    return (tesd);
X
X}                             /* end of esdalloc */
X
X/*+-----------------------------------------------------------------------
X    esdptr = esdrealloc(maxcb)    - realloc an esd buffer
X
Xmay only be used to enlarge an esd buffer
Xthis used to use realloc(), which did a lot of unnecessary copying
Xalso no more abnormal program termination on memory failure
X------------------------------------------------------------------------*/
Xint
Xesdrealloc(tesd, maxcb)
XESD *tesd;
Xregister maxcb;                 /* desired maxcb */
X{
X    register actual_cb;
X    char *newpb;
X
X    if (!tesd || (tesd->maxcb > maxcb))
X        return (eInternalLogicError);
X
X    /* enforce our limit */
X    if (maxcb > ESD_MAXSZ)
X        return (eBufferTooSmall);
X
X    /* we get an extra character to ensure room for null past maxcb */
X    actual_cb = maxcb + 1;
X    if (actual_cb & 1)         /* even allocation */
X        ++actual_cb;
X
X    if (!(newpb = malloc(actual_cb)))
X        return (eNoMemory);
X
X    if (tesd->cb)
X        memcpy(newpb, tesd->pb, tesd->cb);
X
X    free(tesd->pb);
X    tesd->pb = newpb;
X    tesd->maxcb = actual_cb;
X    esd_null_terminate(tesd);
X    return (0);
X
X}                             /* end of esdrealloc */
X
X/*+-----------------------------------------------------------------------
X    esdfree(esdptr)
X------------------------------------------------------------------------*/
Xvoid
Xesdfree(tesd)
Xregister ESD *tesd;
X{
X    if (tesd && tesd->pb)
X    {
X        free(tesd->pb);
X        free((char *)tesd);
X    }
X    else
X    {
X        errno = ENOMEM;
X        ff(se, "\r\n\r\nFREE_ESD FAILED. FATAL ERROR. SORRY.\r\n");
X        termecu(TERMECU_XMTR_FATAL_ERROR);
X    }
X}
X
X/*+-------------------------------------------------------------------------
X    esdcat(dest,suffix,realloc_ok) - "strcat" for ESDs
X
X  Append 'suffix' contents to 'dest'
X  if realloc_ok true, expand 'dest' as necessary
X
X  Returns: 0 - success
X           eNoMemory
X           eBufferTooSmall
X--------------------------------------------------------------------------*/
Xint
Xesdcat(dest, suffix, realloc_ok)
XESD *dest;
XESD *suffix;
Xint realloc_ok;
X{
X    int erc = 0;
X    int new_maxcb = dest->cb + suffix->cb;
X
X    if (dest->maxcb < new_maxcb)
X    {
X        if (!realloc_ok)
X            return (eBufferTooSmall);
X        if (erc = esdrealloc(dest, new_maxcb))
X            return (erc);
X    }
X
X    memcpy(dest->pb + dest->cb, suffix->pb, suffix->cb + 1);    /* catch null too */
X    dest->cb += suffix->cb;
X
X    return (0);
X
X}                             /* end of esdcat */
X
X/*+-------------------------------------------------------------------------
X    esdstrcat(tesd,zstr) - "strcat" for ESDs
X
Xsimilar to esdcat(), but with automatic esd growth
X--------------------------------------------------------------------------*/
Xint
Xesdstrcat(tesd, zstr)
XESD *tesd;
Xchar *zstr;
X{
X    register zstrlen = strlen(zstr);
X    register erc = 0;
X
X    if (zstrlen > (tesd->maxcb - tesd->cb))
X    {
X        if (erc = esdrealloc(tesd, tesd->cb + zstrlen))
X            return (erc);
X    }
X
X    if (zstrlen)
X    {
X        strncpy(tesd->pb + tesd->cb, zstr, zstrlen);
X        tesd->cb += zstrlen;
X        esd_null_terminate(tesd);
X    }
X
X    return (erc);
X
X}                             /* end of esdstrcat */
X
X/*+-------------------------------------------------------------------------
X    esdshow(tesd,title)
X--------------------------------------------------------------------------*/
Xvoid
Xesdshow(tesd, title)
XESD *tesd;
Xchar *title;
X{
X    register itmp;
X
X    if (title && *title)
X    {
X        pputs(title);
X        pputs("\n");
X    }
X    esd_null_terminate(tesd);
X    pputs(tesd->pb);
X    pputs("\n");
X    for (itmp = 0; itmp <= tesd->cb; itmp++)
X    {
X        if (itmp == tesd->old_index)
X            pputc('^');
X        else if (itmp == tesd->index)
X            pputc('^');
X        else
X            pputc(' ');
X        if ((itmp > tesd->old_index) && (itmp > tesd->index))
X            break;
X    }
X#if 0
X    pprintf(" o%d i%d c%d\n", tesd->old_index, tesd->index, tesd->cb);
X#else
X    pputs("\n");
X#endif
X
X}                             /* end of esdshow */
X
X/*+----------------------------------------------------------------
X    strindex:  string index function
X
X  Returns position of 'str2' in 'str1' if found
X  If 'str2' is null, then 0 is returned (null matches anything)
X  Returns -1 if not found
X-----------------------------------------------------------------*/
Xint
Xstrindex(str1, str2)
Xchar *str1;                     /* the (target) string to search */
Xchar *str2;                     /* the (comparand) string to search for */
X{
X    register istr1 = 0;
X    register lstr2 = strlen(str2);
X    register char *mstr = str1;    /* the (target) string to search */
X
X    if (*str2 == 0)             /* null string matches anything */
X        return (0);
X
X    while (*mstr)
X    {
X        if (*mstr == *str2)
X        {                     /* we have a first char match... does rest of
X                              * string match? */
X            if (!strncmp(mstr, str2, lstr2))
X                return (istr1);    /* if so, return match position */
X        }
X        mstr++;
X        istr1++;
X    }
X
X    return (-1);             /* if we exhaust target string, flunk */
X
X}                             /* end of strindex */
X
X/*+-------------------------------------------------------------------------
X    esdstrindex(esd1,esd2,index1_flag,index2_flag)
X
X  Call strindex with esd1->pb and esd2->pb.
X  If index1_flag != 0, esd1->pb + esd1->index passed
X  If index2_flag != 0, esd2->pb + esd2->index passed
X--------------------------------------------------------------------------*/
Xesdstrindex(esd1, esd2, index1_flag, index2_flag)
Xregister ESD *esd1;
Xregister ESD *esd2;
Xregister index1_flag;
Xregister index2_flag;
X{
X    return (strindex((index1_flag) ? esd1->pb : esd1->pb + esd1->index,
X            (index2_flag) ? esd2->pb : esd2->pb + esd2->index));
X
X}                             /* end of esdstrindex */
X
X/*+----------------------------------------------------------------
X    keyword_lookup(ktable,keywd)
X
X  Lookup string in keyword_table struct array
X  Returns table->key_token if 'keywd' found in
X  'table', else -1
X
X  Beware substrings.  "type","typedef" will both match "type"
X  This procedure fell in here and it too late to move it.
X-----------------------------------------------------------------*/
Xkeyword_lookup(ktable, keywd)
Xregister KEYTAB *ktable;
Xregister char *keywd;
X{
X/* register plen = strlen(keywd); */
X
X    while (ktable->key_word)
X    {
X/*        if(!strncmp(ktable->key_word,keywd,plen)) */
X        if (!strcmp(ktable->key_word, keywd))
X            return (ktable->key_token);
X        ++ktable;
X    }                         /* end of while */
X
X    return (-1);             /* search failed */
X
X}                             /* end of keyword_lookup */
X
X/*+----------------------------------------------------------------
X    skip_cmd_break(tesd)
X
X  Finds next non-break
X
X  'tesd' is an esd with valid 'index' field
X  Returns  0             index field points to non-break character
X           eNoParameter  end of command found
X-----------------------------------------------------------------*/
Xint
Xskip_cmd_break(tesd)
Xregister ESD *tesd;
X{
X    register cb = tesd->cb;
X    register idx = tesd->index;
X    register char *pb = tesd->pb;
X
X    while (idx < cb)
X    {
X        if (!isspace(*(pb + idx)))
X            break;
X        idx++;
X    }
X    tesd->old_index = tesd->index = idx;
X    if (idx >= cb)
X        return (eNoParameter);
X    return (0);
X
X}                             /* end of skip_cmd_break */
X
X/*+-------------------------------------------------------------------------
X    end_of_cmd(tesd) - return 1 if at end of command
X--------------------------------------------------------------------------*/
Xint
Xend_of_cmd(tesd)
Xregister ESD *tesd;
X{
X    if (skip_cmd_break(tesd) || (*(tesd->pb + tesd->index) == ';') ||
X        (*(tesd->pb + tesd->index) == '#'))
X        return (1);
X    return (0);
X}                             /* end of end_of_cmd */
X
X/*+-------------------------------------------------------------------------
X    erc = skip_cmd_char(tesd,skipchar)
X--------------------------------------------------------------------------*/
Xint
Xskip_cmd_char(tesd, skipchar)
Xregister ESD *tesd;
Xregister char skipchar;
X{
X    int erc;
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X
X    if (tesd->pb[tesd->index] == skipchar)
X    {
X        ++tesd->index;
X        return (0);
X    }
X
X    return (eSyntaxError);
X
X}                             /* end of skip_cmd_char */
X
X/*+-------------------------------------------------------------------------
X    erc = skip_colon(tesd)
X--------------------------------------------------------------------------*/
Xint
Xskip_colon(tesd)
Xregister ESD *tesd;
X{
X    register erc;
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X
X    if (tesd->pb[tesd->index] == ':')
X    {
X        ++tesd->index;
X        return (0);
X    }
X
X    return (eCommaExpected);
X
X}                             /* end of skip_colon */
X
X/*+-------------------------------------------------------------------------
X    erc = skip_comma(tesd)
X--------------------------------------------------------------------------*/
Xint
Xskip_comma(tesd)
Xregister ESD *tesd;
X{
X    register erc;
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X
X    if (tesd->pb[tesd->index] == ',')
X    {
X        ++tesd->index;
X        return (0);
X    }
X
X    return (eCommaExpected);
X
X}                             /* end of skip_comma */
X
X/*+-------------------------------------------------------------------------
X    erc = skip_paren(fparam,LEFT or RIGHT)
X--------------------------------------------------------------------------*/
Xint
Xskip_paren(tesd, fLeft)
Xregister ESD *tesd;
Xint fLeft;
X{
X    register erc;
X    register char search = (fLeft) ? '(' : ')';
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X
X    if (tesd->pb[tesd->index] == search)
X    {
X        tesd->index++;
X        return (0);
X    }
X    return ((fLeft) ? eMissingLeftParen : eMissingRightParen);
X
X}                             /* end of skip_paren */
X
X/*+-------------------------------------------------------------------------
X    get_cmd_char(tesd,pchar)
X--------------------------------------------------------------------------*/
Xint
Xget_cmd_char(tesd, pchar)
Xregister ESD *tesd;
Xchar *pchar;
X{
X    int erc;
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X    *pchar = tesd->pb[tesd->index++];
X    return (0);
X
X}                             /* end of get_cmd_char */
X
X/*+----------------------------------------------------------------
X    get_alpha_zstr(&esd,&strbuf,strbuf_maxcb)
X
X  places next alphabetic string token [A-Za-z_] into
X  the null-terminated 'strbuf' string.  returns 0 or -1
X  or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_alpha_zstr(tesd, strbuf, strbuf_maxcb)
XESD *tesd;
Xregister char *strbuf;
Xint strbuf_maxcb;
X{
X    register izstr;
X    register schar;
X    register char *pb = tesd->pb;
X
X    if (izstr = skip_cmd_break(tesd))
X        return (izstr);
X    izstr = 0;
X    while ((izstr < strbuf_maxcb - 1) && (tesd->index < tesd->cb))
X    {
X        schar = pb[tesd->index];
X        if ((!isalpha(schar)) && (schar != '_'))
X            break;
X        strbuf[izstr++] = schar;
X        tesd->index++;
X    }
X
X    strbuf[izstr] = 0;
X    return (izstr ? 0 : eBadParameter);
X
X}                             /* end of get_alpha_zstr */
X
X/*+----------------------------------------------------------------
X    get_alphanum_zstr(&esd,&strbuf,strbuf_maxcb)
X
X  places next alphanumeric string token [A-Za-z0-9_]
X  into the null-terminated 'strbuf' string.  returns 0
X  or -1 or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_alphanum_zstr(tesd, strbuf, strbuf_maxcb)
Xregister ESD *tesd;
Xregister char *strbuf;
Xint strbuf_maxcb;
X{
X    int izstr = 0;
X    int schar;
X    register cb = tesd->cb;
X    register idx;
X
X    if (izstr = skip_cmd_break(tesd))
X        return (izstr);
X
X    idx = tesd->index;
X    while ((izstr < strbuf_maxcb - 1) && (idx < cb))
X    {
X        schar = tesd->pb[idx++];
X        if (isalnum(schar) || (schar == '_'))
X            strbuf[izstr++] = schar;
X        else
X        {
X            --idx;
X            break;
X        }
X    }
X
X    tesd->index = idx;
X    strbuf[izstr] = 0;
X    return (izstr ? 0 : eBadParameter);
X
X}                             /* end of get_alphanum_zstr */
X
X/*+----------------------------------------------------------------
X    get_numeric_zstr(&esd,&strbuf,strbuf_maxcb)
X    gets next numeric string token places it
X    into the null-terminated 'strbuf' string.  returns 0 or -1
X    or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_numeric_zstr(tesd, strbuf, strbuf_maxcb)
Xregister ESD *tesd;
Xregister char *strbuf;
Xregister strbuf_maxcb;
X{
X    register izstr;
X    register schar;
X
X    if (izstr = skip_cmd_break(tesd))
X        return (izstr);
X
X    while ((izstr < strbuf_maxcb - 1) && (tesd->index < tesd->cb))
X    {
X        schar = tesd->pb[tesd->index++];
X        if (isdigit(schar))
X            strbuf[izstr++] = schar;
X        else
X        {
X            --tesd->index;
X            break;
X        }
X    }
X
X    strbuf[izstr] = 0;
X    return (izstr ? 0 : eBadParameter);
X
X}                             /* end of get_numeric_zstr */
X
X/*+-----------------------------------------------------------------------
X    get_numeric_value(tesd,&long_var)
X------------------------------------------------------------------------*/
Xget_numeric_value(tesd, value)
Xregister ESD *tesd;
Xregister long *value;
X{
X    register erc;
X    char buf[32];
X
X    if (erc = get_numeric_zstr(tesd, buf, sizeof(buf)))
X        return (erc);
X    sscanf(buf, "%ld", value);
X    return (0);
X
X}                             /* end of get_numeric_value */
X
X/*+----------------------------------------------------------------
X    get_word_zstr(&esd,&strbuf,strbuf_maxcb)
X
X  gets next word (continuous string of characters without spaces
X  or tabs) returns 0 or -1 or skip_cmd_break error codes
X-----------------------------------------------------------------*/
Xint
Xget_word_zstr(tesd, strbuf, strbuf_maxcb)
Xregister ESD *tesd;
Xregister char *strbuf;
Xregister strbuf_maxcb;
X{
X    register izstr;
X    register schar;
X
X    if (izstr = skip_cmd_break(tesd))
X        return (izstr);
X
X    strbuf_maxcb--;
X    while ((izstr < strbuf_maxcb) && (tesd->index < tesd->cb))
X    {
X        schar = tesd->pb[tesd->index++];
X        if ((schar > 0x20) && (schar <= 0x7e))
X            strbuf[izstr++] = schar;
X        else
X        {
X            --tesd->index;
X            break;
X        }
X    }
X
X    strbuf[izstr] = 0;
X    return (izstr ? 0 : eBadParameter);
X
X}                             /* end of get_word_zstr */
X
X/*+-------------------------------------------------------------------------
X    esd_strip_trail_break(tesd)
X--------------------------------------------------------------------------*/
Xvoid
Xesd_strip_trail_break(ztext)
Xregister ESD *ztext;
X{
X    while (ztext->cb &&
X        ((ztext->pb[ztext->cb - 1] == 0x20) || (ztext->pb[ztext->cb - 1] == 0x20)))
X    {
X        ztext->cb--;
X    }
X}                             /* end of esd_strip_trail_break */
X
X/*+-------------------------------------------------------------------------
X    esdfgets(&esd,fileptr)
X
X  stdio read from FILE *fileptr into esd
X  returns tesd->cb set up not including trailing nl, tesd->index == 0
X--------------------------------------------------------------------------*/
Xint
Xesdfgets(tesd, fileptr)
Xregister ESD *tesd;
Xregister FILE *fileptr;
X{
X    register char *cptr;
X
X    tesd->cb = 0;
X    if (!fgets(tesd->pb, tesd->maxcb + 1, fileptr))
X        return (eEOF);
X    if (!(cptr = strchr(tesd->pb, 0x0A)))
X        return (eBufferTooSmall);
X    tesd->cb = (int)(cptr - tesd->pb);
X    esd_null_terminate(tesd);
X    tesd->index = 0;
X    tesd->old_index = 0;
X    return (0);
X
X}                             /* end of esdfgets */
X
X/*+-------------------------------------------------------------------------
X    esdfputs(&esd,fileptr,index_flag,nl_flag)
X
X  write esd contents to stdio FILE *fileptr
X  if index_flag is true, write from tesd->index thru end of esd
X  otherwise, from start of esd
X  if nl_flag is true, append nl to write, else just esd contents
X--------------------------------------------------------------------------*/
Xint
Xesdfputs(tesd, fileptr, index_flag, nl_flag)
Xregister ESD *tesd;
XFILE *fileptr;
Xint index_flag;
Xint nl_flag;
X{
X    register char *cptr;
X    register write_length;
X
X    if (index_flag)
X    {
X        cptr = &tesd->pb[tesd->index];
X        write_length = tesd->cb - tesd->index;
X    }
X    else
X    {
X        cptr = tesd->pb;
X        write_length = tesd->cb;
X    }
X
X    if (write_length)
X        fwrite(cptr, write_length, 1, fileptr);
X
X    if (nl_flag)
X        fputc(0x0A, fileptr);
X
X    return (0);
X}                             /* end of esdfputs */
X
X/*+-------------------------------------------------------------------------
X    get_switches(tesd,switches,switches_max)
X--------------------------------------------------------------------------*/
Xint
Xget_switches(tesd, switches, switches_max)
XESD *tesd;
Xchar *switches;
Xint switches_max;
X{
X    register erc;
X    register idx;
X    register char *pb = tesd->pb;
X    int cb = tesd->cb;
X    char schar;
X
X    *switches = 0;
X
X    if (erc = skip_cmd_break(tesd))
X        return (erc);
X
X    idx = tesd->index;
X    if (*(pb + idx) != '-')
X        return (eNoSwitches);
X
X    if (switches_max < 3)
X        return (eSwitchesTooLong);
X
X    switches_max--;             /* for trailing null */
X    *switches++ = '-';
X    switches_max--;
X    idx++;
X    while (idx < cb)
X    {
X        schar = *(pb + idx++);
X        if (switches_max > 0)
X            *switches++ = schar;
X        switches_max--;
X        if (isspace(schar))
X            break;
X    }
X
X    tesd->index = idx;
X    *switches = 0;
X    return ((switches_max < 0) ? eSwitchesTooLong : 0);
X
X}                             /* end of get_switches() */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of esdutil.c */
END_OF_FILE
  if test 20092 -ne `wc -c <'ecu330/esdutil.c'`; then
    echo shar: \"'ecu330/esdutil.c'\" unpacked with wrong size!
  fi
  # end of 'ecu330/esdutil.c'
fi
if test -f 'ecu330/pc_scr.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'ecu330/pc_scr.h'\"
else
  echo shar: Extracting \"'ecu330/pc_scr.h'\" \(1856 characters\)
  sed "s/^X//" >'ecu330/pc_scr.h' <<'END_OF_FILE'
X/*+-------------------------------------------------------------------------
X    pc_scr.h - PC/AT screen definitions
X    [e-mail]
X--------------------------------------------------------------------------*/
X/*+:EDITS:*/
X/*:05-04-1994-04:39-wht@n4hgf-ECU release 3.30 */
X/*:11-12-1993-11:00-wht@n4hgf-Linux changes by [e-mail] */
X/*:09-10-1992-14:00-wht@n4hgf-ECU release 3.20 */
X/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
X/*:03-27-1992-16:21-wht@n4hgf-re-include protection for all .h files */
X/*:07-25-1991-12:58-wht@n4hgf-ECU release 3.10 */
X/*:12-04-1990-02:48-wht@n4hgf-for nonansi terminals provide either ruling set */
X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
X
X#ifndef _pc_scr_h
X#define _pc_scr_h
X
X/*
X * AT ROM ruling characters
X */
X#define at_TL        0xDA     /* top left single rule */
X#define at_TR        0xBF     /* top right single rule */
X#define at_BL        0xC0     /* bottom left single rule */
X#define at_BR        0xD9     /* bottom right single rule */
X#define at_LT        0xC3     /* left hand T */
X#define at_RT        0xB4     /* right hand T */
X#define at_VR        0xB3     /* vertical rule */
X#define at_HR        0xC4     /* horizontal rule */
X/*
X * non-ANSI equivalents
X */
X#define vanilla_TL        '.'
X#define vanilla_TR        '.'
X#define vanilla_BL        '`'
X#define vanilla_BR        '\''
X#define vanilla_LT        '+'
X#define vanilla_RT        '+'
X#define vanilla_VR        '|'
X#define vanilla_HR        '-'
X
X#ifdef LINUX
Xextern chtype sTL;
Xextern chtype sTR;
Xextern chtype sBL;
Xextern chtype sBR;
Xextern chtype sLT;
Xextern chtype sRT;
Xextern chtype sVR;
Xextern chtype sHR;
X
X#else
Xextern unsigned char sTL;
Xextern unsigned char sTR;
Xextern unsigned char sBL;
Xextern unsigned char sBR;
Xextern unsigned char sLT;
Xextern unsigned char sRT;
Xextern unsigned char sVR;
Xextern unsigned char sHR;
X
X#endif
X
X#endif /* _pc_scr_h */
X
X/* vi: set tabstop=4 shiftwidth=4: */
X/* end of pc_scr.h */
END_OF_FILE
  if test 1856 -ne `wc -c <'ecu330/pc_scr.h'`; then
    echo shar: \"'ecu330/pc_scr.h'\" unpacked with wrong size!
  fi
  # end of 'ecu330/pc_scr.h'
fi
echo shar: End of archive 22 \(of 37\).
cp /dev/null ark22isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 37 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0
exit 0 # Just in case...