kirkenda@eecs.cs.pdx.edu (Steve Kirkendall) (12/04/90)
# --------------------------- cut here ----------------------------
# This is a shar archive. To unpack it, save it to a file, and delete
# anything above the "cut here" line. Then run sh on the file.
#
# -rw-r--r-- 1 kirkenda 8819 Dec 2 17:57 curses.h
# -rw-r--r-- 1 kirkenda 13222 Dec 2 17:57 cut.c
# -rw-r--r-- 1 kirkenda 15130 Dec 2 17:57 ex.c
# -rw-r--r-- 1 kirkenda 16368 Dec 2 17:57 input.c
# -rw-r--r-- 1 kirkenda 7778 Dec 2 17:57 main.c
# -rw-r--r-- 1 kirkenda 2166 Dec 2 17:57 misc.c
#
if test -f curses.h -a "$1" != -f
then
echo Will not overwrite curses.h
else
echo Extracting curses.h
sed 's/^X//' >curses.h <<\eof
X/* curses.h */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This is the header file for a small, fast, fake curses package */
X
X/* termcap stuff */
Xextern char *tgoto();
Xextern char *tgetstr();
Xextern void tputs();
X
X#if MSDOS
X/* BIOS interface used instead of termcap for MS-DOS */
Xextern int vmode;
Xextern void v_up();
Xextern void v_cb();
Xextern void v_cs();
Xextern void v_ce();
Xextern void v_cl();
Xextern void v_cd();
Xextern void v_al();
Xextern void v_dl();
Xextern void v_sr();
Xextern void v_move();
X#endif
X
X/* faddch() is a function. a pointer to it is passed to tputs() */
Xextern int faddch();
X
X/* data types */
X#define WINDOW char
X
X/* CONSTANTS & SYMBOLS */
X#define TRUE 1
X#define FALSE 0
X#define A_NORMAL 0
X#define A_STANDOUT 1
X#define A_BOLD 2
X#define A_UNDERLINE 3
X#define A_ALTCHARSET 4
X#if MSDOS
X#define KBSIZ (10*1024)
X#else
X#define KBSIZ (6*1024)
X#endif
X
X/* extern variables, defined in curses.c */
Xextern short ospeed; /* tty speed, eg B2400 */
X#if OSK
Xextern char PC_; /* Pad char */
Xextern char *BC; /* Backspace char string */
X#else
Xextern char PC; /* Pad char */
X#endif
Xextern WINDOW *stdscr; /* pointer into kbuf[] */
Xextern WINDOW kbuf[KBSIZ]; /* a very large output buffer */
Xextern int LINES; /* :li#: number of rows */
Xextern int COLS; /* :co#: number of columns */
Xextern int AM; /* :am: boolean: auto margins? */
Xextern int PT; /* :pt: boolean: physical tabs? */
Xextern char *VB; /* :vb=: visible bell */
Xextern char *UP; /* :up=: move cursor up */
Xextern char *SO; /* :so=: standout start */
Xextern char *SE; /* :se=: standout end */
Xextern char *US; /* :us=: underline start */
Xextern char *UE; /* :ue=: underline end */
Xextern char *MD; /* :md=: bold start */
Xextern char *ME; /* :me=: bold end */
Xextern char *AS; /* :as=: alternate (italic) start */
Xextern char *AE; /* :ae=: alternate (italic) end */
Xextern char *CM; /* :cm=: cursor movement */
Xextern char *CE; /* :ce=: clear to end of line */
Xextern char *CD; /* :cd=: clear to end of screen */
Xextern char *AL; /* :al=: add a line */
Xextern char *DL; /* :dl=: delete a line */
X#if OSK
Xextern char *SR_; /* :sr=: scroll reverse */
X#else
Xextern char *SR; /* :sr=: scroll reverse */
X#endif
Xextern char *KS; /* :ks=: init string for cursor */
Xextern char *KE; /* :ke=: restore string for cursor */
Xextern char *KU; /* :ku=: sequence sent by up key */
Xextern char *KD; /* :kd=: sequence sent by down key */
Xextern char *KL; /* :kl=: sequence sent by left key */
Xextern char *KR; /* :kr=: sequence sent by right key */
Xextern char *PU; /* :PU=: key sequence sent by PgUp key */
Xextern char *PD; /* :PD=: key sequence sent by PgDn key */
Xextern char *HM; /* :HM=: key sequence sent by Home key */
Xextern char *EN; /* :EN=: key sequence sent by End key */
Xextern char *IM; /* :im=: insert mode start */
Xextern char *IC; /* :ic=: insert following char */
Xextern char *EI; /* :ei=: insert mode end */
Xextern char *DC; /* :dc=: delete a character */
Xextern char *TI; /* :ti=: terminal init */ /* GB */
Xextern char *TE; /* :te=: terminal exit */ /* GB */
X#ifndef NO_CURSORSHAPE
Xextern char *CQ; /* :cQ=: normal cursor */
Xextern char *CX; /* :cX=: cursor used for EX command/entry */
Xextern char *CV; /* :cV=: cursor used for VI command mode */
Xextern char *CI; /* :cI=: cursor used for VI input mode */
Xextern char *CR; /* :cR=: cursor used for VI replace mode */
X#endif
Xextern char *aend; /* end an attribute -- either UE or ME */
Xextern char ERASEKEY; /* taken from the ioctl structure */
X
X/* Msdos-versions may use bios; others always termcap.
X * Will emit some 'code has no effect' warnings in unix.
X */
X
X#if MSDOS
Xextern char o_pcbios[1]; /* BAH! */
X#define CHECKBIOS(x,y) (*o_pcbios ? (x) : (y))
X#define VOIDBIOS(x,y) {if (*o_pcbios) {x;} else {y;}}
X#else
X#define CHECKBIOS(x,y) (y)
X#define VOIDBIOS(x,y) {y;}
X#endif
X
X#define do_VB() VOIDBIOS(;, tputs(VB, 1, faddch))
X#define do_UP() VOIDBIOS(v_up(), tputs(UP, 1, faddch))
X#define do_SO() VOIDBIOS((vmode=A_STANDOUT), tputs(SO, 1, faddch))
X#define do_SE() VOIDBIOS((vmode=A_NORMAL), tputs(SE, 1, faddch))
X#define do_US() VOIDBIOS((vmode=A_UNDERLINE), tputs(US, 1, faddch))
X#define do_UE() VOIDBIOS((vmode=A_NORMAL), tputs(UE, 1, faddch))
X#define do_MD() VOIDBIOS((vmode=A_BOLD), tputs(MD, 1, faddch))
X#define do_ME() VOIDBIOS((vmode=A_NORMAL), tputs(ME, 1, faddch))
X#define do_AS() VOIDBIOS((vmode=A_ALTCHARSET), tputs(AS, 1, faddch))
X#define do_AE() VOIDBIOS((vmode=A_NORMAL), tputs(AE, 1, faddch))
X#undef do_CM /* move */
X#define do_CE() VOIDBIOS(v_ce(), tputs(CE, 1, faddch))
X#define do_CD() VOIDBIOS(v_cd(), tputs(CD, 1, faddch))
X#define do_AL() VOIDBIOS(v_al(), tputs(AL, LINES, faddch))
X#define do_DL() VOIDBIOS(v_dl(), tputs(DL, LINES, faddch))
X#if OSK
X#define do_SR() VOIDBIOS(v_sr(), tputs(SR_, 1, faddch))
X#else
X#define do_SR() VOIDBIOS(v_sr(), tputs(SR, 1, faddch))
X#endif
X#define do_KS() VOIDBIOS(1, tputs(KS, 1, faddch))
X#define do_KE() VOIDBIOS(1, tputs(KE, 1, faddch))
X#define do_IM() VOIDBIOS(;, tputs(IM, 1, faddch))
X#define do_IC() VOIDBIOS(;, tputs(IC, 1, faddch))
X#define do_EI() VOIDBIOS(;, tputs(EI, 1, faddch))
X#define do_DC() VOIDBIOS(;, tputs(DC, COLS, faddch))
X#define do_TI() VOIDBIOS(;, (void)ttywrite(TI, (unsigned)strlen(TI)))
X#define do_TE() VOIDBIOS(;, (void)ttywrite(TE, (unsigned)strlen(TE)))
X#ifndef NO_CURSORSHAPE
X# define do_CQ() VOIDBIOS(v_cs(), tputs(CQ, 1, faddch))
X# define do_CX() VOIDBIOS(v_cs(), tputs(CX, 1, faddch))
X# define do_CV() VOIDBIOS(v_cs(), tputs(CV, 1, faddch))
X# define do_CI() VOIDBIOS(v_cb(), tputs(CI, 1, faddch))
X# define do_CR() VOIDBIOS(v_cb(), tputs(CR, 1, faddch))
X#endif
X#define do_aend() VOIDBIOS((vmode=A_NORMAL), tputs(aend, 1, faddch))
X
X#define has_AM CHECKBIOS(1, AM)
X#define has_PT CHECKBIOS(0, PT)
X#define has_VB CHECKBIOS((char *)0, VB)
X#define has_UP CHECKBIOS((char *)1, UP)
X#define has_SO CHECKBIOS((char)1, (*SO))
X#define has_SE CHECKBIOS((char)1, (*SE))
X#define has_US CHECKBIOS((char)1, (*US))
X#define has_UE CHECKBIOS((char)1, (*UE))
X#define has_MD CHECKBIOS((char)1, (*MD))
X#define has_ME CHECKBIOS((char)1, (*ME))
X#define has_AS CHECKBIOS((char)1, (*AS))
X#define has_AE CHECKBIOS((char)1, (*AE))
X#undef has_CM /* cursor move: don't need */
X#define has_CB CHECKBIOS(1, 0)
X#define has_CS CHECKBIOS(1, 0)
X#define has_CE CHECKBIOS((char *)1, CE)
X#define has_CD CHECKBIOS((char *)1, CD)
X#define has_AL CHECKBIOS((char *)1, AL)
X#define has_DL CHECKBIOS((char *)1, DL)
X#if OSK
X#define has_SR CHECKBIOS((char *)1, SR_)
X#else
X#define has_SR CHECKBIOS((char *)1, SR)
X#endif
X#define has_KS CHECKBIOS((char)1, (*KS))
X#define has_KE CHECKBIOS((char)1, (*KE))
X#define has_KU CHECKBIOS("#H", KU)
X#define has_KD CHECKBIOS("#P", KD)
X#define has_KL CHECKBIOS("#K", KL)
X#define has_KR CHECKBIOS("#M", KR)
X#define has_HM CHECKBIOS("#G", HM)
X#define has_EN CHECKBIOS("#O", EN)
X#define has_PU CHECKBIOS("#I", PU)
X#define has_PD CHECKBIOS("#Q", PD)
X#define has_IM CHECKBIOS((char)0, (*IM))
X#define has_IC CHECKBIOS((char)0, (*IC))
X#define has_EI CHECKBIOS((char)0, (*EI))
X#define has_DC CHECKBIOS((char *)0, DC)
X#define has_TI CHECKBIOS((char)0, (*TI))
X#define has_TE CHECKBIOS((char)0, (*TE))
X#ifndef NO_CURSORSHAPE
X#define has_CQ CHECKBIOS((char *)1, CQ)
X#endif
X
X/* (pseudo)-Curses-functions */
X
X#ifdef lint
X# define _addCR VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\r') : (stdscr[-1] = '\n')))
X#else
X# if OSK
X# define _addCR VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\l') : (stdscr[-1] = stdscr[-1])))
X# else
X# define _addCR VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\r') : 0))
X#endif
X#endif
X#define qaddch(ch) CHECKBIOS(v_put(ch), (*stdscr++ = (ch)))
X#if OSK
X#define addch(ch) if (qaddch(ch) == '\n') qaddch('\l'); else
X#else
X#define addch(ch) if (qaddch(ch) == '\n') qaddch('\r'); else
X#endif
X
Xextern void initscr();
Xextern void endwin();
Xextern void suspend_curses();
Xextern void resume_curses();
Xextern void attrset();
Xextern void insch();
Xextern void qaddstr();
X#define addstr(str) {qaddstr(str); _addCR;}
X#define move(y,x) VOIDBIOS(v_move(x,y), \
X tputs(tgoto(CM, x, y), 1, faddch))
X#define mvaddch(y,x,ch) {move(y,x); addch(ch);}
X#define refresh() VOIDBIOS(;, wrefresh(stdscr))
X#define wrefresh(w) if ((w) != kbuf) VOIDBIOS((w) = kbuf, {ttywrite(kbuf, (unsigned)((w) - kbuf)); (w) = kbuf;}) else
X#define wqrefresh(w) if ((w) - kbuf > 2000) VOIDBIOS((w) = kbuf, {ttywrite(kbuf, (unsigned)((w) - kbuf)); (w) = kbuf;}) else
X#define standout() do_SO()
X#define standend() do_SE()
X#define clrtoeol() do_CE()
X#define clrtobot() do_CD()
X#define insertln() do_AL()
X#define deleteln() do_DL()
X#define delch() do_DC()
X#define scrollok(w,b)
X#define raw()
X#define echo()
X#define cbreak()
X#define noraw()
X#define noecho()
X#define nocbreak()
eof
if test `wc -c <curses.h` -ne 8819
then
echo curses.h damaged!
fi
fi
if test -f cut.c -a "$1" != -f
then
echo Will not overwrite cut.c
else
echo Extracting cut.c
sed 's/^X//' >cut.c <<\eof
X/* cut.c */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This file contains function which manipulate the cut buffers. */
X
X#include "config.h"
X#include "vi.h"
X#if TURBOC
X#include <process.h> /* needed for getpid */
X#endif
X#if TOS
X#include <osbind.h>
X#define rename(a,b) Frename(0,a,b)
X#endif
X
X# define NANNONS 9 /* number of annonymous buffers */
X
Xstatic struct cutbuf
X{
X short *phys; /* pointer to an array of #s of BLKs containing text */
X int nblks; /* number of blocks in phys[] array */
X int start; /* offset into first block of start of cut */
X int end; /* offset into last block of end of cut */
X int fd; /* fd of tmp file, or -1 to use tmpfd */
X char lnmode; /* boolean: line-mode cut? (as opposed to char-mode) */
X}
X named[27], /* cut buffers "a through "z and ". */
X annon[NANNONS]; /* annonymous cut buffers */
X
Xstatic char cbname; /* name chosen for next cut/paste operation */
X
X
X#ifndef NO_RECYCLE
X/* This function builds a list of all blocks needed in the current tmp file
X * for the contents of cut buffers.
X * !!! WARNING: if you have more than ~450000 bytes of text in all of the
X * cut buffers, then this will fail disastrously, because buffer overflow
X * is *not* allowed for.
X */
Xint cutneeds(need)
X BLK *need; /* this is where we deposit the list */
X{
X struct cutbuf *cb; /* used to count through cut buffers */
X int i; /* used to count through blocks of a cut buffer */
X int n; /* total number of blocks in list */
X
X n = 0;
X
X /* first the named buffers... */
X for (cb = named; cb < &named[27]; cb++)
X {
X if (cb->fd > 0)
X continue;
X
X for (i = cb->nblks; i-- > 0; )
X {
X need->n[n++] = cb->phys[i];
X }
X }
X
X /* then the anonymous buffers */
X for (cb = annon; cb < &annon[NANNONS]; cb++)
X {
X if (cb->fd > 0)
X continue;
X
X for (i = cb->nblks; i-- > 0; )
X {
X need->n[n++] = cb->phys[i];
X }
X }
X
X return n;
X}
X#endif
X
X/* This function frees a cut buffer */
Xstatic void cutfree(buf)
X struct cutbuf *buf;
X{
X char cutfname[50];
X int i;
X
X /* return immediately if the buffer is already empty */
X if (buf->nblks <= 0)
X {
X return;
X }
X
X /* else free up stuff */
X buf->nblks = 0;
X#ifdef DEBUG
X if (!buf->phys)
X msg("cutfree() tried to free an NULL buf->phys pointer.");
X#endif
X free((char *)buf->phys);
X
X /* see if anybody else needs this tmp file */
X if (buf->fd >= 0)
X {
X for (i = 0; i < 27; i++)
X {
X if (named[i].nblks > 0 && named[i].fd == buf->fd)
X {
X break;
X }
X }
X }
X
X /* if nobody else needs it, then discard the tmp file */
X if (buf->fd >= 0 && i == 27)
X {
X close(buf->fd);
X#if MSDOS || TOS
X strcpy(cutfname, o_directory);
X if ((i = strlen(cutfname)) && !strchr(":/\\", cutfname[i-1]))
X cutfname[i++]=SLASH;
X sprintf(cutfname+i, CUTNAME+3, getpid(), buf->fd);
X#else
X sprintf(cutfname, CUTNAME, o_directory, getpid(), buf->fd);
X#endif
X unlink(cutfname);
X }
X}
X
X/* This function is called when we are about to abort a tmp file. If any
X * cut buffers still need the file, then a copy of the file should be
X * created for use by the cut buffers.
X *
X * To minimize the number of extra files lying around, only named cut buffers
X * are preserved in a file switch; the annonymous buffers just go away.
X */
Xvoid cutswitch(tmpname)
X char *tmpname; /* name of the tmp file */
X{
X char cutfname[50]; /* used to build a new name for the tmp file */
X int fd; /* a new fd for the current tmp file */
X int i;
X#if MSDOS || TOS
X int j;
X#endif
X
X /* discard all annonymous cut buffers */
X for (i = 0; i < NANNONS; i++)
X {
X cutfree(&annon[i]);
X }
X
X /* find the first named buffer that uses this tmp file */
X for (i = 0; i < 27; i++)
X {
X if (named[i].nblks > 0 && named[i].fd < 0)
X {
X break;
X }
X }
X
X /* if none of them use this tmp file, then we're done */
X if (i == 27)
X {
X return;
X }
X
X /* else we'll need this file and an fd a little longer */
X#if MSDOS || TOS
X strcpy(cutfname, o_directory);
X if ((j = strlen(cutfname)) && !strchr(":/\\", cutfname[j-1]))
X cutfname[j++]=SLASH;
X close(tmpfd);
X fd = open(tmpname, O_RDONLY|O_BINARY);
X close(fd);
X sprintf(cutfname+j, CUTNAME+3, getpid(), fd);
X rename(tmpname, cutfname);
X fd = open(cutfname, O_RDONLY|O_BINARY);
X tmpfd = -1; /* we'll try to close this in tmp.c, but who cares? */
X#else
X fd = dup(tmpfd);
X# if OSK
X sprintf(cutfname, CUTNAME, "", getpid(), fd);
X if (!link(tmpname, &cutfname[1])) /* skip slash */
X unlink(tmpname);
X# else
X sprintf(cutfname, CUTNAME, o_directory, getpid(), fd);
X link(tmpname, cutfname) || unlink(tmpname);
X# endif
X#endif
X
X /* have all cut buffers use the new fd instead */
X for (; i < 27; i++)
X {
X if (named[i].nblks > 0 && named[i].fd < 0)
X {
X named[i].fd = fd;
X }
X }
X}
X
X/* This function should be called just before termination of vi */
Xvoid cutend()
X{
X int i;
X
X /* free all named cut buffers, since they might be forcing an older
X * tmp file to be retained.
X */
X for (i = 0; i < 27; i++)
X {
X cutfree(&named[i]);
X }
X}
X
X
X/* This function is used to select the cut buffer to be used next */
Xvoid cutname(name)
X int name; /* a single character */
X{
X cbname = name;
X}
X
X
X
X
X/* This function copies a selected segment of text to a cut buffer */
Xvoid cut(from, to)
X MARK from; /* start of text to cut */
X MARK to; /* end of text to cut */
X{
X int first; /* logical number of first block in cut */
X int last; /* logical number of last block used in cut */
X long line; /* a line number */
X int lnmode; /* boolean: will this be a line-mode cut? */
X MARK delthru;/* end of text temporarily inserted for apnd */
X REG struct cutbuf *cb;
X REG long l;
X REG int i;
X REG char *scan;
X char *blkc;
X
X /* detect whether this must be a line-mode cut or char-mode cut */
X if (markidx(from) == 0 && markidx(to) == 0)
X lnmode = TRUE;
X else
X lnmode = FALSE;
X
X /* by default, we don't "delthru" anything */
X delthru = MARK_UNSET;
X
X /* decide which cut buffer to use */
X if (!cbname)
X {
X /* free up the last annonymous cut buffer */
X cutfree(&annon[NANNONS - 1]);
X
X /* shift the annonymous cut buffers */
X for (i = NANNONS - 1; i > 0; i--)
X {
X annon[i] = annon[i - 1];
X }
X
X /* use the first annonymous cut buffer */
X cb = annon;
X cb->nblks = 0;
X }
X else if (cbname >= 'a' && cbname <= 'z')
X {
X cb = &named[cbname - 'a'];
X cutfree(cb);
X }
X#ifndef CRUNCH
X else if (cbname >= 'A' && cbname <= 'Z')
X {
X cb = &named[cbname - 'A'];
X if (cb->nblks > 0)
X {
X /* resolve linemode/charmode differences */
X if (!lnmode && cb->lnmode)
X {
X from &= ~(BLKSIZE - 1);
X if (markidx(to) != 0 || to == from)
X {
X to = to + BLKSIZE - markidx(to);
X }
X lnmode = TRUE;
X }
X
X /* insert the old cut-buffer before the new text */
X mark[28] = to;
X delthru = paste(from, FALSE, TRUE);
X if (delthru == MARK_UNSET)
X {
X return;
X }
X delthru++;
X to = mark[28];
X }
X cutfree(cb);
X }
X#endif /* not CRUNCH */
X else if (cbname == '.')
X {
X cb = &named[26];
X cutfree(cb);
X }
X else
X {
X msg("Invalid cut buffer name: \"%c", cbname);
X cbname = '\0';
X return;
X }
X cbname = '\0';
X cb->fd = -1;
X
X /* detect whether we're doing a line mode cut */
X cb->lnmode = lnmode;
X
X /* ---------- */
X
X /* Reporting... */
X if (markidx(from) == 0 && markidx(to) == 0)
X {
X rptlines = markline(to) - markline(from);
X rptlabel = "yanked";
X }
X
X /* ---------- */
X
X /* make sure each block has a physical disk address */
X blksync();
X
X /* find the first block in the cut */
X line = markline(from);
X for (first = 1; line > lnum[first]; first++)
X {
X }
X
X /* fetch text of the block containing that line */
X blkc = scan = blkget(first)->c;
X
X /* find the mark in the block */
X for (l = lnum[first - 1]; ++l < line; )
X {
X while (*scan++ != '\n')
X {
X }
X }
X scan += markidx(from);
X
X /* remember the offset of the start */
X cb->start = scan - blkc;
X
X /* ---------- */
X
X /* find the last block in the cut */
X line = markline(to);
X for (last = first; line > lnum[last]; last++)
X {
X }
X
X /* fetch text of the block containing that line */
X if (last != first)
X {
X blkc = scan = blkget(last)->c;
X }
X else
X {
X scan = blkc;
X }
X
X /* find the mark in the block */
X for (l = lnum[last - 1]; ++l < line; )
X {
X while (*scan++ != '\n')
X {
X }
X }
X if (markline(to) <= nlines)
X {
X scan += markidx(to);
X }
X
X /* remember the offset of the end */
X cb->end = scan - blkc;
X
X /* ------- */
X
X /* remember the physical block numbers of all included blocks */
X cb->nblks = last - first;
X if (cb->end > 0)
X {
X cb->nblks++;
X }
X#ifdef lint
X cb->phys = (short *)0;
X#else
X cb->phys = (short *)malloc((unsigned)(cb->nblks * sizeof(short)));
X#endif
X for (i = 0; i < cb->nblks; i++)
X {
X cb->phys[i] = hdr.n[first++];
X }
X
X#ifndef CRUNCH
X /* if we temporarily inserted text for appending, then delete that
X * text now -- before the user sees it.
X */
X if (delthru)
X {
X line = rptlines;
X delete(from, delthru);
X rptlines = line;
X rptlabel = "yanked";
X }
X#endif /* not CRUNCH */
X}
X
X
Xstatic void readcutblk(cb, blkno)
X struct cutbuf *cb;
X int blkno;
X{
X int fd; /* either tmpfd or cb->fd */
X
X /* decide which fd to use */
X if (cb->fd >= 0)
X {
X fd = cb->fd;
X }
X else
X {
X fd = tmpfd;
X }
X
X /* get the block */
X lseek(fd, (long)cb->phys[blkno] * (long)BLKSIZE, 0);
X if (read(fd, tmpblk.c, (unsigned)BLKSIZE) != BLKSIZE)
X {
X msg("Error reading back from tmp file for pasting!");
X }
X}
X
X
X/* This function inserts text from a cut buffer, and returns the MARK where
X * insertion ended. Return MARK_UNSET on errors.
X */
XMARK paste(at, after, retend)
X MARK at; /* where to insert the text */
X int after; /* boolean: insert after mark? (rather than before) */
X int retend; /* boolean: return end of text? (rather than start) */
X{
X REG struct cutbuf *cb;
X REG int i;
X
X /* decide which cut buffer to use */
X if (cbname >= 'A' && cbname <= 'Z')
X {
X cb = &named[cbname - 'A'];
X }
X else if (cbname >= 'a' && cbname <= 'z')
X {
X cb = &named[cbname - 'a'];
X }
X else if (cbname >= '1' && cbname <= '9')
X {
X cb = &annon[cbname - '1'];
X }
X else if (cbname == '.')
X {
X cb = &named[26];
X }
X else if (!cbname)
X {
X cb = annon;
X }
X else
X {
X msg("Invalid cut buffer name: \"%c", cbname);
X cbname = '\0';
X return MARK_UNSET;
X }
X
X /* make sure it isn't empty */
X if (cb->nblks == 0)
X {
X if (cbname)
X msg("Cut buffer \"%c is empty", cbname);
X else
X msg("Cut buffer is empty");
X cbname = '\0';
X return MARK_UNSET;
X }
X cbname = '\0';
X
X /* adjust the insertion MARK for "after" and line-mode cuts */
X if (cb->lnmode)
X {
X at &= ~(BLKSIZE - 1);
X if (after)
X {
X at += BLKSIZE;
X }
X }
X else if (after)
X {
X /* careful! if markidx(at) == 0 we might be pasting into an
X * empty line -- so we can't blindly increment "at".
X */
X if (markidx(at) == 0)
X {
X pfetch(markline(at));
X if (plen != 0)
X {
X at++;
X }
X }
X else
X {
X at++;
X }
X }
X
X /* put a copy of the "at" mark in the mark[] array, so it stays in
X * sync with changes made via add().
X */
X mark[27] = at;
X
X /* simple one-block paste? */
X if (cb->nblks == 1)
X {
X /* get the block */
X readcutblk(cb, 0);
X
X /* isolate the text we need within it */
X if (cb->end)
X {
X tmpblk.c[cb->end] = '\0';
X }
X
X /* insert it */
X ChangeText
X {
X add(at, &tmpblk.c[cb->start]);
X }
X }
X else
X {
X /* multi-block paste */
X
X ChangeText
X {
X i = cb->nblks - 1;
X
X /* add text from the last block first */
X if (cb->end > 0)
X {
X readcutblk(cb, i);
X tmpblk.c[cb->end] = '\0';
X add(at, tmpblk.c);
X i--;
X }
X
X /* add intervening blocks */
X while (i > 0)
X {
X readcutblk(cb, i);
X add(at, tmpblk.c);
X i--;
X }
X
X /* add text from the first cut block */
X readcutblk(cb, 0);
X add(at, &tmpblk.c[cb->start]);
X }
X }
X
X /* Reporting... */
X rptlines = markline(mark[27]) - markline(at);
X rptlabel = "pasted";
X
X /* return the mark at the beginning/end of inserted text */
X if (retend)
X {
X return mark[27] - 1L;
X }
X return at;
X}
X
X
X
X
X#ifndef NO_AT
X
X/* This function copies characters from a cut buffer into a string.
X * It returns the number of characters in the cut buffer. If the cut
X * buffer is too large to fit in the string (i.e. if cb2str() returns
X * a number >= size) then the characters will not have been copied.
X * It returns 0 if the cut buffer is empty, and -1 for invalid cut buffers.
X */
Xint cb2str(name, buf, size)
X int name; /* the name of a cut-buffer to get: a-z only! */
X char *buf; /* where to put the string */
X unsigned size; /* size of buf */
X{
X REG struct cutbuf *cb;
X REG char *src;
X REG char *dest;
X
X /* decide which cut buffer to use */
X if (name >= 'a' && name <= 'z')
X {
X cb = &named[name - 'a'];
X }
X else
X {
X return -1;
X }
X
X /* if the buffer is empty, return 0 */
X if (cb->nblks == 0)
X {
X return 0;
X }
X
X /* !!! if not a single-block cut, then fail */
X if (cb->nblks != 1)
X {
X return size;
X }
X
X /* if too big, return the size now, without doing anything */
X if (cb->end - cb->start >= size)
X {
X return cb->end - cb->start;
X }
X
X /* get the block */
X readcutblk(cb, 0);
X
X /* isolate the string within that blk */
X if (cb->start == 0)
X {
X tmpblk.c[cb->end] = '\0';
X }
X else
X {
X for (dest = tmpblk.c, src = dest + cb->start; src < tmpblk.c + cb->end; )
X {
X *dest++ = *src++;
X }
X *dest = '\0';
X }
X
X /* copy the string into the buffer */
X if (buf != tmpblk.c)
X {
X strcpy(buf, tmpblk.c);
X }
X
X /* return the length */
X return cb->end - cb->start;
X}
X#endif
eof
if test `wc -c <cut.c` -ne 13222
then
echo cut.c damaged!
fi
fi
if test -f ex.c -a "$1" != -f
then
echo Will not overwrite ex.c
else
echo Extracting ex.c
sed 's/^X//' >ex.c <<\eof
X/* ex.c */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This file contains the code for reading ex commands. */
X
X#include "config.h"
X#include <ctype.h>
X#include "vi.h"
X
X#ifndef isascii
X# define isascii(c) !((c)&~0x7f)
X#endif
X
X/* This data type is used to describe the possible argument combinations */
Xtypedef short ARGT;
X#define FROM 1 /* allow a linespec */
X#define TO 2 /* allow a second linespec */
X#define BANG 4 /* allow a ! after the command name */
X#define EXTRA 8 /* allow extra args after command name */
X#define XFILE 16 /* expand wildcards in extra part */
X#define NOSPC 32 /* no spaces allowed in the extra part */
X#define DFLALL 64 /* default file range is 1,$ */
X#define DFLNONE 128 /* no default file range */
X#define NODFL 256 /* do not default to the current file name */
X#define EXRCOK 512 /* can be in a .exrc file */
X#define NL 1024 /* if mode!=MODE_EX, then write a newline first */
X#define PLUS 2048 /* allow a line number, as in ":e +32 foo" */
X#define ZERO 4096 /* allow 0 to be given as a line number */
X#define FILES (XFILE + EXTRA) /* multiple extra files allowed */
X#define WORD1 (EXTRA + NOSPC) /* one extra word allowed */
X#define FILE1 (FILES + NOSPC) /* 1 file allowed, defaults to current file */
X#define NAMEDF (FILE1 + NODFL) /* 1 file allowed, defaults to "" */
X#define NAMEDFS (FILES + NODFL) /* multiple files allowed, default is "" */
X#define RANGE (FROM + TO) /* range of linespecs allowed */
X#define NONE 0 /* no args allowed at all */
X
X/* This array maps ex command names to command codes. The order in which
X * command names are listed below is significant -- ambiguous abbreviations
X * are always resolved to be the first possible match. (e.g. "r" is taken
X * to mean "read", not "rewind", because "read" comes before "rewind")
X */
Xstatic struct
X{
X char *name; /* name of the command */
X CMD code; /* enum code of the command */
X void (*fn)();/* function which executes the command */
X ARGT argt; /* command line arguments permitted/needed/used */
X}
X cmdnames[] =
X{ /* cmd name cmd code function arguments */
X {"append", CMD_APPEND, cmd_append, FROM+ZERO },
X#ifdef DEBUG
X {"bug", CMD_DEBUG, cmd_debug, RANGE+BANG+EXTRA+NL},
X#endif
X {"change", CMD_CHANGE, cmd_append, RANGE },
X {"delete", CMD_DELETE, cmd_delete, RANGE+WORD1 },
X {"edit", CMD_EDIT, cmd_edit, BANG+FILE1+PLUS },
X {"file", CMD_FILE, cmd_file, NAMEDF },
X {"global", CMD_GLOBAL, cmd_global, RANGE+BANG+EXTRA+DFLALL},
X {"insert", CMD_INSERT, cmd_append, FROM },
X {"join", CMD_INSERT, cmd_join, RANGE },
X {"k", CMD_MARK, cmd_mark, FROM+WORD1 },
X {"list", CMD_LIST, cmd_print, RANGE+NL },
X {"move", CMD_MOVE, cmd_move, RANGE+EXTRA },
X {"next", CMD_NEXT, cmd_next, BANG+NAMEDFS },
X {"Next", CMD_PREVIOUS, cmd_next, BANG },
X {"print", CMD_PRINT, cmd_print, RANGE+NL },
X {"quit", CMD_QUIT, cmd_xit, BANG },
X {"read", CMD_READ, cmd_read, FROM+ZERO+NAMEDF},
X {"substitute", CMD_SUBSTITUTE, cmd_substitute, RANGE+EXTRA },
X {"to", CMD_COPY, cmd_move, RANGE+EXTRA },
X {"undo", CMD_UNDO, cmd_undo, NONE },
X {"vglobal", CMD_VGLOBAL, cmd_global, RANGE+EXTRA+DFLALL},
X {"write", CMD_WRITE, cmd_write, RANGE+BANG+FILE1+DFLALL},
X {"xit", CMD_XIT, cmd_xit, BANG+NL },
X {"yank", CMD_YANK, cmd_delete, RANGE+WORD1 },
X
X {"!", CMD_BANG, cmd_shell, EXRCOK+RANGE+NAMEDFS+DFLNONE+NL},
X {"<", CMD_SHIFTL, cmd_shift, RANGE },
X {">", CMD_SHIFTR, cmd_shift, RANGE },
X {"=", CMD_EQUAL, cmd_file, RANGE },
X {"&", CMD_SUBAGAIN, cmd_substitute, RANGE },
X#ifndef NO_AT
X {"@", CMD_AT, cmd_at, EXTRA },
X#endif
X
X#ifndef NO_ABBR
X {"abbreviate", CMD_ABBR, cmd_abbr, EXRCOK+EXTRA },
X#endif
X {"args", CMD_ARGS, cmd_args, EXRCOK+NAMEDFS },
X#ifndef NO_ERRLIST
X {"cc", CMD_CC, cmd_make, BANG+FILES },
X#endif
X {"cd", CMD_CD, cmd_cd, EXRCOK+NAMEDF },
X {"copy", CMD_COPY, cmd_move, RANGE+EXTRA },
X#ifndef NO_DIGRAPH
X {"digraph", CMD_DIGRAPH, cmd_digraph, EXRCOK+BANG+EXTRA},
X#endif
X#ifndef NO_ERRLIST
X {"errlist", CMD_ERRLIST, cmd_errlist, BANG+NAMEDF },
X#endif
X {"ex", CMD_EDIT, cmd_edit, BANG+FILE1 },
X {"map", CMD_MAP, cmd_map, EXRCOK+BANG+EXTRA},
X#ifndef NO_MKEXRC
X {"mkexrc", CMD_MKEXRC, cmd_mkexrc, NAMEDF },
X#endif
X {"number", CMD_NUMBER, cmd_print, RANGE+NL },
X {"put", CMD_PUT, cmd_put, FROM+ZERO+WORD1 },
X {"set", CMD_SET, cmd_set, EXRCOK+EXTRA },
X {"shell", CMD_SHELL, cmd_shell, NL },
X {"source", CMD_SOURCE, cmd_source, EXRCOK+NAMEDF },
X {"tag", CMD_TAG, cmd_tag, BANG+WORD1 },
X {"version", CMD_VERSION, cmd_version, EXRCOK+NONE },
X {"visual", CMD_VISUAL, cmd_visual, NONE },
X {"wq", CMD_WQUIT, cmd_xit, NL },
X
X#ifdef DEBUG
X {"debug", CMD_DEBUG, cmd_debug, RANGE+BANG+EXTRA+NL},
X {"validate", CMD_VALIDATE, cmd_validate, BANG+NL },
X#endif
X {"chdir", CMD_CD, cmd_cd, EXRCOK+NAMEDF },
X#ifndef NO_ERRLIST
X {"make", CMD_MAKE, cmd_make, BANG+NAMEDFS },
X#endif
X {"mark", CMD_MARK, cmd_mark, FROM+WORD1 },
X {"previous", CMD_PREVIOUS, cmd_next, BANG },
X {"rewind", CMD_REWIND, cmd_next, BANG },
X {"unmap", CMD_UNMAP, cmd_map, EXRCOK+BANG+EXTRA},
X#ifndef NO_ABBR
X {"unabbreviate",CMD_UNABBR, cmd_abbr, EXRCOK+WORD1 },
X#endif
X
X {(char *)0}
X};
X
X
X/* This function parses a search pattern - given a pointer to a / or ?,
X * it replaces the ending / or ? with a \0, and returns a pointer to the
X * stuff that came after the pattern.
X */
Xchar *parseptrn(ptrn)
X REG char *ptrn;
X{
X REG char *scan;
X
X for (scan = ptrn + 1;
X *scan && *scan != *ptrn;
X scan++)
X {
X /* allow backslashed versions of / and ? in the pattern */
X if (*scan == '\\' && scan[1] != '\0')
X {
X scan++;
X }
X }
X if (*scan)
X {
X *scan++ = '\0';
X }
X
X return scan;
X}
X
X
X/* This function parses a line specifier for ex commands */
Xchar *linespec(s, markptr)
X REG char *s; /* start of the line specifier */
X MARK *markptr; /* where to store the mark's value */
X{
X long num;
X REG char *t;
X
X /* parse each ;-delimited clause of this linespec */
X do
X {
X /* skip an initial ';', if any */
X if (*s == ';')
X {
X s++;
X }
X
X /* skip leading spaces */
X while (isascii(*s) && isspace(*s))
X {
X s++;
X }
X
X /* dot means current position */
X if (*s == '.')
X {
X s++;
X *markptr = cursor;
X }
X /* '$' means the last line */
X else if (*s == '$')
X {
X s++;
X *markptr = MARK_LAST;
X }
X /* digit means an absolute line number */
X else if (isascii(*s) && isdigit(*s))
X {
X for (num = 0; isascii(*s) && isdigit(*s); s++)
X {
X num = num * 10 + *s - '0';
X }
X *markptr = MARK_AT_LINE(num);
X }
X /* appostrophe means go to a set mark */
X else if (*s == '\'')
X {
X s++;
X *markptr = m_tomark(cursor, 1L, (int)*s);
X s++;
X }
X /* slash means do a search */
X else if (*s == '/' || *s == '?')
X {
X /* put a '\0' at the end of the search pattern */
X t = parseptrn(s);
X
X /* search for the pattern */
X *markptr &= ~(BLKSIZE - 1);
X if (*s == '/')
X {
X pfetch(markline(*markptr));
X if (plen > 0)
X *markptr += plen - 1;
X *markptr = m_fsrch(*markptr, s);
X }
X else
X {
X *markptr = m_bsrch(*markptr, s);
X }
X
X /* adjust command string pointer */
X s = t;
X }
X
X /* if linespec was faulty, quit now */
X if (!*markptr)
X {
X return s;
X }
X
X /* maybe add an offset */
X t = s;
X if (*t == '-' || *t == '+')
X {
X s++;
X for (num = 0; *s >= '0' && *s <= '9'; s++)
X {
X num = num * 10 + *s - '0';
X }
X if (num == 0)
X {
X num = 1;
X }
X *markptr = m_updnto(*markptr, num, *t);
X }
X } while (*s == ';' || *s == '+' || *s == '-');
X
X return s;
X}
X
X
X
X/* This function reads an ex command and executes it. */
Xvoid ex()
X{
X char cmdbuf[80];
X REG int cmdlen;
X static long oldline;
X
X significant = FALSE;
X oldline = markline(cursor);
X
X while (mode == MODE_EX)
X {
X /* read a line */
X cmdlen = vgets(':', cmdbuf, sizeof cmdbuf);
X if (cmdlen < 0)
X {
X return;
X }
X
X /* if empty line, assume ".+1" */
X if (cmdlen == 0)
X {
X strcpy(cmdbuf, ".+1");
X qaddch('\r');
X clrtoeol();
X }
X else
X {
X addch('\n');
X }
X refresh();
X
X /* parse & execute the command */
X doexcmd(cmdbuf);
X
X /* handle autoprint */
X if (significant || markline(cursor) != oldline)
X {
X significant = FALSE;
X oldline = markline(cursor);
X if (*o_autoprint && mode == MODE_EX)
X {
X cmd_print(cursor, cursor, CMD_PRINT, FALSE, "");
X }
X }
X }
X}
X
Xvoid doexcmd(cmdbuf)
X char *cmdbuf; /* string containing an ex command */
X{
X REG char *scan; /* used to scan thru cmdbuf */
X MARK frommark; /* first linespec */
X MARK tomark; /* second linespec */
X REG int cmdlen; /* length of the command name given */
X CMD cmd; /* what command is this? */
X ARGT argt; /* argument types for this command */
X short forceit; /* bang version of a command? */
X REG int cmdidx; /* index of command */
X REG char *build; /* used while copying filenames */
X int iswild; /* boolean: filenames use wildcards? */
X int isdfl; /* using default line ranges? */
X int didsub; /* did we substitute file names for % or # */
X
X
X /* ex commands can't be undone via the shift-U command */
X U_line = 0L;
X
X /* ignore command lines that start with a double-quote */
X if (*cmdbuf == '"')
X {
X return;
X }
X
X /* permit extra colons at the start of the line */
X while (*cmdbuf == ':')
X {
X cmdbuf++;
X }
X
X /* parse the line specifier */
X scan = cmdbuf;
X if (nlines < 1)
X {
X /* no file, so don't allow addresses */
X }
X else if (*scan == '%')
X {
X /* '%' means all lines */
X frommark = MARK_FIRST;
X tomark = MARK_LAST;
X scan++;
X }
X else if (*scan == '0')
X {
X frommark = tomark = MARK_UNSET;
X scan++;
X }
X else
X {
X frommark = cursor;
X scan = linespec(scan, &frommark);
X tomark = frommark;
X if (frommark && *scan == ',')
X {
X scan++;
X scan = linespec(scan, &tomark);
X }
X if (!tomark)
X {
X /* faulty line spec -- fault already described */
X return;
X }
X if (frommark > tomark)
X {
X msg("first address exceeds the second");
X return;
X }
X }
X isdfl = (scan == cmdbuf);
X
X /* skip whitespace */
X while (isascii(*scan) && isspace(*scan))
X {
X scan++;
X }
X
X /* if no command, then just move the cursor to the mark */
X if (!*scan)
X {
X cursor = tomark;
X return;
X }
X
X /* figure out how long the command name is */
X if (isascii(*scan) && !isalpha(*scan))
X {
X cmdlen = 1;
X }
X else
X {
X for (cmdlen = 1;
X !isascii(scan[cmdlen]) || isalpha(scan[cmdlen]);
X cmdlen++)
X {
X }
X }
X
X /* lookup the command code */
X for (cmdidx = 0;
X cmdnames[cmdidx].name && strncmp(scan, cmdnames[cmdidx].name, cmdlen);
X cmdidx++)
X {
X }
X argt = cmdnames[cmdidx].argt;
X cmd = cmdnames[cmdidx].code;
X if (cmd == CMD_NULL)
X {
X#if OSK
X msg("Unknown command \"%s\"", scan);
X#else
X msg("Unknown command \"%.*s\"", cmdlen, scan);
X#endif
X return;
X }
X
X /* if the command ended with a bang, set the forceit flag */
X scan += cmdlen;
X if ((argt & BANG) && *scan == '!')
X {
X scan++;
X forceit = 1;
X }
X else
X {
X forceit = 0;
X }
X
X /* skip any more whitespace, to leave scan pointing to arguments */
X while (isascii(*scan) && isspace(*scan))
X {
X scan++;
X }
X
X /* a couple of special cases for filenames */
X if (argt & XFILE)
X {
X /* if names were given, process them */
X if (*scan)
X {
X for (build = tmpblk.c, iswild = didsub = FALSE; *scan; scan++)
X {
X switch (*scan)
X {
X case '%':
X if (!*origname)
X {
X msg("No filename to substitute for %%");
X return;
X }
X strcpy(build, origname);
X while (*build)
X {
X build++;
X }
X didsub = TRUE;
X break;
X
X case '#':
X if (!*prevorig)
X {
X msg("No filename to substitute for #");
X return;
X }
X strcpy(build, prevorig);
X while (*build)
X {
X build++;
X }
X didsub = TRUE;
X break;
X
X case '*':
X case '?':
X#if !(MSDOS || TOS)
X case '[':
X case '`':
X case '{': /* } */
X case '$':
X case '~':
X#endif
X *build++ = *scan;
X iswild = TRUE;
X break;
X
X default:
X *build++ = *scan;
X }
X }
X *build = '\0';
X
X if (cmd == CMD_BANG
X || cmd == CMD_READ && tmpblk.c[0] == '!'
X || cmd == CMD_WRITE && tmpblk.c[0] == '!')
X {
X if (didsub)
X {
X if (mode != MODE_EX)
X {
X addch('\n');
X }
X addstr(tmpblk.c);
X addch('\n');
X exrefresh();
X }
X }
X else
X {
X if (iswild && tmpblk.c[0] != '>')
X {
X scan = wildcard(tmpblk.c);
X }
X }
X }
X else /* no names given, maybe assume origname */
X {
X if (!(argt & NODFL))
X {
X strcpy(tmpblk.c, origname);
X }
X else
X {
X *tmpblk.c = '\0';
X }
X }
X
X scan = tmpblk.c;
X }
X
X /* bad arguments? */
X if (!(argt & EXRCOK) && nlines < 1L)
X {
X msg("Can't use the \"%s\" command in a %s file", cmdnames[cmdidx].name, EXRC);
X return;
X }
X if (!(argt & (ZERO | EXRCOK)) && frommark == MARK_UNSET)
X {
X msg("Can't use address 0 with \"%s\" command.", cmdnames[cmdidx].name);
X return;
X }
X if (!(argt & FROM) && frommark != cursor && nlines >= 1L)
X {
X msg("Can't use address with \"%s\" command.", cmdnames[cmdidx].name);
X return;
X }
X if (!(argt & TO) && tomark != frommark && nlines >= 1L)
X {
X msg("Can't use a range with \"%s\" command.", cmdnames[cmdidx].name);
X return;
X }
X if (!(argt & EXTRA) && *scan)
X {
X msg("Extra characters after \"%s\" command.", cmdnames[cmdidx].name);
X return;
X }
X if ((argt & NOSPC) && !(cmd == CMD_READ && (forceit || *scan == '!')))
X {
X build = scan;
X#ifndef CRUNCH
X if ((argt & PLUS) && *build == '+')
X {
X while (*build && !(isascii(*build) && isspace(*build)))
X {
X build++;
X }
X while (*build && isascii(*build) && isspace(*build))
X {
X build++;
X }
X }
X#endif /* not CRUNCH */
X for (; *build; build++)
X {
X if (isspace(*build))
X {
X msg("Too many %s to \"%s\" command.",
X (argt & XFILE) ? "filenames" : "arguments",
X cmdnames[cmdidx].name);
X return;
X }
X }
X }
X
X /* some commands have special default ranges */
X if (isdfl && (argt & DFLALL))
X {
X frommark = MARK_FIRST;
X tomark = MARK_LAST;
X }
X else if (isdfl && (argt & DFLNONE))
X {
X frommark = tomark = 0L;
X }
X
X /* write a newline if called from visual mode */
X if ((argt & NL) && mode != MODE_EX && !exwrote)
X {
X addch('\n');
X exrefresh();
X }
X
X /* act on the command */
X (*cmdnames[cmdidx].fn)(frommark, tomark, cmd, forceit, scan);
X}
X
X
X/* This function executes EX commands from a file. It returns 1 normally, or
X * 0 if the file could not be opened for reading.
X */
Xint doexrc(filename)
X char *filename; /* name of a ".exrc" file */
X{
X int fd; /* file descriptor */
X int len; /* length of the ".exrc" file */
X char buf[MAXRCLEN]; /* buffer, holds the entire .exrc file */
X
X /* open the file, read it, and close */
X fd = open(filename, O_RDONLY);
X if (fd < 0)
X {
X return 0;
X }
X len = tread(fd, buf, MAXRCLEN);
X close(fd);
X
X /* execute the string */
X exstring(buf, len);
X
X return 1;
X}
X
Xvoid exstring(buf, len)
X char *buf; /* the commands to execute */
X int len; /* the length of the string */
X{
X char *cmd; /* start of a command */
X char *end; /* used to search for the end of cmd */
X
X /* find & do each command */
X for (cmd = buf; cmd < &buf[len]; cmd = end + 1)
X {
X /* find the end of the command */
X for (end = cmd; end < &buf[len] && *end != '\n' && *end != '|'; end++)
X {
X }
X *end = '\0';
X
X /* do it */
X doexcmd(cmd);
X }
X}
eof
if test `wc -c <ex.c` -ne 15130
then
echo ex.c damaged!
fi
fi
if test -f input.c -a "$1" != -f
then
echo Will not overwrite input.c
else
echo Extracting input.c
sed 's/^X//' >input.c <<\eof
X/* input.c */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This file contains the input() function, which implements vi's INPUT mode.
X * It also contains the code that supports digraphs.
X */
X
X#include <ctype.h>
X#include "config.h"
X#include "vi.h"
X
X
X#ifndef NO_DIGRAPH
Xstatic struct _DIG
X{
X struct _DIG *next;
X char key1;
X char key2;
X char dig;
X char save;
X} *digs;
X
Xchar digraph(key1, key2)
X char key1; /* the underlying character */
X char key2; /* the second character */
X{
X int newkey;
X REG struct _DIG *dp;
X
X /* if digraphs are disabled, then just return the new char */
X if (!*o_digraph)
X {
X return key2;
X }
X
X /* remember the new key, so we can return it if this isn't a digraph */
X newkey = key2;
X
X /* sort key1 and key2, so that their original order won't matter */
X if (key1 > key2)
X {
X key2 = key1;
X key1 = newkey;
X }
X
X /* scan through the digraph chart */
X for (dp = digs;
X dp && (dp->key1 != key1 || dp->key2 != key2);
X dp = dp->next)
X {
X }
X
X /* if this combination isn't in there, just use the new key */
X if (!dp)
X {
X return newkey;
X }
X
X /* else use the digraph key */
X return dp->dig;
X}
X
X/* this function lists or defines digraphs */
Xvoid do_digraph(bang, extra)
X int bang;
X char extra[];
X{
X int dig;
X REG struct _DIG *dp;
X struct _DIG *prev;
X static int user_defined = FALSE; /* boolean: are all later digraphs user-defined? */
X char listbuf[8];
X
X /* if "extra" is NULL, then we've reached the end of the built-ins */
X if (!extra)
X {
X user_defined = TRUE;
X return;
X }
X
X /* if no args, then display the existing digraphs */
X if (*extra < ' ')
X {
X listbuf[0] = listbuf[1] = listbuf[2] = listbuf[5] = ' ';
X listbuf[7] = '\0';
X for (dig = 0, dp = digs; dp; dp = dp->next)
X {
X if (dp->save || bang)
X {
X dig += 7;
X if (dig >= COLS)
X {
X addch('\n');
X exrefresh();
X dig = 7;
X }
X listbuf[3] = dp->key1;
X listbuf[4] = dp->key2;
X listbuf[6] = dp->dig;
X qaddstr(listbuf);
X }
X }
X addch('\n');
X exrefresh();
X return;
X }
X
X /* make sure we have at least two characters */
X if (!extra[1])
X {
X msg("Digraphs must be composed of two characters");
X return;
X }
X
X /* sort key1 and key2, so that their original order won't matter */
X if (extra[0] > extra[1])
X {
X dig = extra[0];
X extra[0] = extra[1];
X extra[1] = dig;
X }
X
X /* locate the new digraph character */
X for (dig = 2; extra[dig] == ' ' || extra[dig] == '\t'; dig++)
X {
X }
X dig = extra[dig];
X if (!bang && dig)
X {
X dig |= 0x80;
X }
X
X /* search for the digraph */
X for (prev = (struct _DIG *)0, dp = digs;
X dp && (dp->key1 != extra[0] || dp->key2 != extra[1]);
X prev = dp, dp = dp->next)
X {
X }
X
X /* deleting the digraph? */
X if (!dig)
X {
X if (!dp)
X {
X#ifndef CRUNCH
X msg("%c%c not a digraph", extra[0], extra[1]);
X#endif
X return;
X }
X if (prev)
X prev->next = dp->next;
X else
X digs = dp->next;
X free(dp);
X return;
X }
X
X /* if necessary, create a new digraph struct for the new digraph */
X if (dig && !dp)
X {
X dp = (struct _DIG *)malloc(sizeof *dp);
X if (!dp)
X {
X msg("Out of space in the digraph table");
X return;
X }
X if (prev)
X prev->next = dp;
X else
X digs = dp;
X dp->next = (struct _DIG *)0;
X }
X
X /* assign it the new digraph value */
X dp->key1 = extra[0];
X dp->key2 = extra[1];
X dp->dig = dig;
X dp->save = user_defined;
X}
X
X# ifndef NO_MKEXRC
Xvoid savedigs(fd)
X int fd;
X{
X static char buf[] = "digraph! XX Y\n";
X REG struct _DIG *dp;
X
X for (dp = digs; dp; dp = dp->next)
X {
X if (dp->save)
X {
X buf[9] = dp->key1;
X buf[10] = dp->key2;
X buf[12] = dp->dig;
X write(fd, buf, (unsigned)14);
X }
X }
X}
X# endif
X#endif
X
X
X#ifndef NO_ABBR
Xstatic struct _AB
X{
X struct _AB *next;
X char *large; /* the expanded form */
X char small[1]; /* the abbreviated form (appended to struct) */
X}
X *abbrev;
X
X/* This functions lists or defines abbreviations */
Xvoid do_abbr(extra)
X char *extra;
X{
X int smlen; /* length of the small form */
X int lrg; /* index of the start of the large form */
X REG struct _AB *ab; /* used to move through the abbrev list */
X struct _AB *prev;
X
X /* no arguments? */
X if (!*extra)
X {
X /* list all current abbreviations */
X for (ab = abbrev; ab; ab = ab->next)
X {
X qaddstr("abbr ");
X qaddstr(ab->small);
X qaddch(' ');
X qaddstr(ab->large);
X addch('\n');
X exrefresh();
X }
X return;
X }
X
X /* else one or more arguments. Parse the first & look up in abbrev[] */
X for (smlen = 0; extra[smlen] && isalnum(extra[smlen]); smlen++)
X {
X }
X for (prev = (struct _AB *)0, ab = abbrev; ab; prev = ab, ab = ab->next)
X {
X if (!strncmp(extra, ab->small, smlen) && !ab->small[smlen])
X {
X break;
X }
X }
X
X /* locate the start of the large form, if any */
X for (lrg = smlen; extra[lrg] && isascii(extra[lrg]) && isspace(extra[lrg]); lrg++)
X {
X }
X
X /* only one arg? */
X if (!extra[lrg])
X {
X /* trying to undo an abbreviation which doesn't exist? */
X if (!ab)
X {
X#ifndef CRUNCH
X msg("\"%s\" not an abbreviation", extra);
X#endif
X return;
X }
X
X /* undo the abbreviation */
X if (prev)
X prev->next = ab->next;
X else
X abbrev = ab->next;
X free(ab->large);
X free(ab);
X
X return;
X }
X
X /* multiple args - [re]define an abbreviation */
X if (ab)
X {
X /* redefining - free the old large form */
X free(ab->large);
X }
X else
X {
X /* adding a new definition - make a new struct */
X ab = (struct _AB *)malloc((unsigned)(smlen + sizeof *ab));
X#ifndef CRUNCH
X if (!ab)
X {
X msg("Out of memory -- Sorry");
X return;
X }
X#endif
X strncpy(ab->small, extra, smlen);
X ab->small[smlen] = '\0';
X ab->next = (struct _AB *)0;
X if (prev)
X prev->next = ab;
X else
X abbrev = ab;
X }
X
X /* store the new form */
X ab->large = (char *)malloc((unsigned)(strlen(&extra[lrg]) + 1));
X strcpy(ab->large, &extra[lrg]);
X}
X
X
X# ifndef NO_MKEXRC
X/* This function is called from cmd_mkexrc() to save the abbreviations */
Xvoid saveabbr(fd)
X int fd; /* fd to which the :abbr commands should be written */
X{
X REG struct _AB *ab;
X
X for (ab = abbrev; ab; ab = ab->next)
X {
X twrite(fd, "abbr ", 5);
X twrite(fd, ab->small, strlen(ab->small));
X twrite(fd, " ", 1);
X twrite(fd, ab->large, strlen(ab->large));
X twrite(fd, "\n", 1);
X }
X}
X# endif
X
X/* This function should be called before each char is inserted. If the next
X * char is non-alphanumeric and we're at the end of a word, then that word
X * is checked against the abbrev[] array and expanded, if appropriate. Upon
X * returning from this function, the new char still must be inserted.
X */
Xstatic MARK expandabbr(m, ch)
X MARK m; /* the cursor position */
X int ch; /* the character to insert */
X{
X char *word; /* where the word starts */
X int len; /* length of the word */
X REG struct _AB *ab;
X
X /* if no abbreviations are in effect, or ch is aphanumeric, then
X * don't do anything
X */
X if (!abbrev || !isascii(ch) || isalnum(ch))
X {
X return m;
X }
X
X /* see where the preceding word starts */
X pfetch(markline(m));
X for (word = ptext + markidx(m), len = 0;
X --word >= ptext && (!isascii(*word) || isalnum(*word));
X len++)
X {
X }
X word++;
X
X /* if zero-length, then it isn't a word, really -- so nothing */
X if (len == 0)
X {
X return m;
X }
X
X /* look it up in the abbrev list */
X for (ab = abbrev; ab; ab = ab->next)
X {
X if (!strncmp(ab->small, word, len) && !ab->small[len])
X {
X break;
X }
X }
X
X /* not an abbreviation? then do nothing */
X if (!ab)
X {
X return m;
X }
X
X /* else replace the small form with the large form */
X add(m, ab->large);
X delete(m - len, m);
X
X /* return with the cursor after the end of the large form */
X return m - len + strlen(ab->large);
X}
X#endif
X
X
X/* This function allows the user to replace an existing (possibly zero-length)
X * chunk of text with typed-in text. It returns the MARK of the last character
X * that the user typed in.
X */
XMARK input(from, to, when)
X MARK from; /* where to start inserting text */
X MARK to; /* extent of text to delete */
X int when; /* either WHEN_VIINP or WHEN_VIREP */
X{
X char key[2]; /* key char followed by '\0' char */
X char *build; /* used in building a newline+indent string */
X char *scan; /* used while looking at the indent chars of a line */
X MARK m; /* some place in the text */
X#ifndef NO_EXTENSIONS
X int quit = FALSE; /* boolean: are we exiting after this? */
X#endif
X
X#ifdef DEBUG
X /* if "from" and "to" are reversed, complain */
X if (from > to)
X {
X msg("ERROR: input(%ld:%d, %ld:%d)",
X markline(from), markidx(from),
X markline(to), markidx(to));
X return MARK_UNSET;
X }
X#endif
X
X key[1] = 0;
X
X /* if we're replacing text with new text, save the old stuff */
X /* (Alas, there is no easy way to save text for replace mode) */
X if (from != to)
X {
X cut(from, to);
X }
X
X ChangeText
X {
X /* if doing a dot command, then reuse the previous text */
X if (doingdot)
X {
X /* delete the text that's there now */
X if (from != to)
X {
X delete(from, to);
X }
X
X /* insert the previous text */
X cutname('.');
X cursor = paste(from, FALSE, TRUE) + 1L;
X }
X else /* interactive version */
X {
X /* if doing a change within the line... */
X if (from != to && markline(from) == markline(to))
X {
X /* mark the end of the text with a "$" */
X change(to - 1, to, "$");
X }
X else
X {
X /* delete the old text right off */
X if (from != to)
X {
X delete(from, to);
X }
X to = from;
X }
X
X /* handle autoindent of the first line, maybe */
X cursor = from;
X if (*o_autoindent && markline(cursor) > 1L && markidx(cursor) == 0)
X {
X /* Only autoindent blank lines. */
X pfetch(markline(cursor));
X if (plen == 0)
X {
X /* Okay, we really want to autoindent */
X pfetch(markline(cursor) - 1L);
X for (scan = ptext, build = tmpblk.c;
X *scan == ' ' || *scan == '\t';
X )
X {
X *build++ = *scan++;
X }
X if (build > tmpblk.c)
X {
X *build = '\0';
X add(cursor, tmpblk.c);
X cursor += (build - tmpblk.c);
X }
X }
X }
X
X /* repeatedly add characters from the user */
X for (;;)
X {
X /* Get a character */
X redraw(cursor, TRUE);
X#ifdef DEBUG
X msg("cursor=%ld.%d, to=%ld.%d",
X markline(cursor), markidx(cursor),
X markline(to), markidx(to));
X#endif
X key[0] = getkey(when);
X
X /* if whitespace & wrapmargin is set & we're
X * past the warpmargin, then change the
X * whitespace character into a newline
X */
X if ((*key == ' ' || *key == '\t')
X && *o_wrapmargin != 0)
X {
X pfetch(markline(cursor));
X if (idx2col(cursor, ptext, TRUE) > COLS - (*o_wrapmargin & 0xff))
X {
X *key = '\n';
X }
X }
X
X /* process it */
X switch (*key)
X {
X#ifndef NO_EXTENSIONS
X case 0: /* special movement mapped keys */
X *key = getkey(0);
X switch (*key)
X {
X case 'h': m = m_left(cursor, 0L); break;
X case 'j':
X case 'k': m = m_updnto(cursor, 0L, *key); break;
X case 'l': m = cursor + 1; break;
X case 'b': m = m_bword(cursor, 0L); break;
X case 'w': m = m_fword(cursor, 0L); break;
X case '^': m = m_front(cursor, 0L); break;
X case '$': m = m_rear(cursor, 0L); break;
X case ctrl('B'):
X case ctrl('F'):
X m = m_scroll(cursor, 0L, *key); break;
X case 'x': m = v_xchar(cursor, 0L); break;
X case 'i': m = to = from = cursor; break;
X default: m = MARK_UNSET; break;
X }
X /* adjust the moved cursor */
X m = adjmove(cursor, m, (*key == 'j' || *key == 'k' ? 0x20 : 0));
X if (*key == '$' || (*key == 'l' && m <= cursor))
X {
X m++;
X }
X /* if the cursor is reasonable, use it */
X if (m == MARK_UNSET)
X {
X beep();
X }
X else
X {
X if (to > cursor)
X {
X delete(cursor, to);
X redraw(cursor, TRUE);
X }
X from = to = cursor = m;
X }
X break;
X
X case ctrl('Z'):
X if (getkey(0) == ctrl('Z'))
X {
X quit = TRUE;
X goto BreakBreak;
X }
X break;
X#endif
X
X case ctrl('['):
X#ifndef NO_ABBR
X cursor = expandabbr(cursor, ctrl('['));
X#endif
X goto BreakBreak;
X
X case ctrl('U'):
X if (markline(cursor) == markline(from))
X {
X cursor = from;
X }
X else
X {
X cursor &= ~(BLKSIZE - 1);
X }
X break;
X
X case ctrl('D'):
X case ctrl('T'):
X if (to > cursor)
X {
X delete(cursor, to);
X }
X mark[27] = cursor;
X cmd_shift(cursor, cursor, *key == ctrl('D') ? CMD_SHIFTL : CMD_SHIFTR, TRUE, "");
X if (mark[27])
X {
X cursor = mark[27];
X }
X else
X {
X cursor = m_front(cursor, 0L);
X }
X to = cursor;
X break;
X
X case '\b':
X if (cursor <= from)
X {
X beep();
X }
X else if (markidx(cursor) == 0)
X {
X cursor -= BLKSIZE;
X pfetch(markline(cursor));
X cursor += plen;
X }
X else
X {
X cursor--;
X }
X break;
X
X case ctrl('W'):
X m = m_bword(cursor, 1L);
X if (markline(m) == markline(cursor) && m >= from)
X {
X cursor = m;
X if (from > cursor)
X {
X from = cursor;
X }
X }
X else
X {
X beep();
X }
X break;
X
X case '\n':
X#if OSK
X case '\l':
X#else
X case '\r':
X#endif
X#ifndef NO_ABBR
X cursor = expandabbr(cursor, '\n');
X#endif
X build = tmpblk.c;
X *build++ = '\n';
X if (*o_autoindent)
X {
X /* figure out indent for next line */
X pfetch(markline(cursor));
X for (scan = ptext; *scan == ' ' || *scan == '\t'; )
X {
X *build++ = *scan++;
X }
X
X /* remove indent from this line, if blank */
X if (!*scan && plen > 0)
X {
X to = cursor &= ~(BLKSIZE - 1);
X delete(cursor, cursor + plen);
X }
X }
X *build = 0;
X if (cursor >= to && when != WHEN_VIREP)
X {
X add(cursor, tmpblk.c);
X }
X else
X {
X change(cursor, to, tmpblk.c);
X }
X redraw(cursor, TRUE);
X to = cursor = (cursor & ~(BLKSIZE - 1))
X + BLKSIZE
X + (int)(build - tmpblk.c) - 1;
X break;
X
X case ctrl('A'):
X case ctrl('P'):
X if (cursor < to)
X {
X delete(cursor, to);
X }
X if (*key == ctrl('A'))
X {
X cutname('.');
X }
X to = cursor = paste(cursor, FALSE, TRUE) + 1L;
X break;
X
X case ctrl('V'):
X if (cursor >= to && when != WHEN_VIREP)
X {
X add(cursor, "^");
X }
X else
X {
X change(cursor, to, "^");
X to = cursor + 1;
X }
X redraw(cursor, TRUE);
X *key = getkey(0);
X if (*key == '\n')
X {
X /* '\n' too hard to handle */
X#if OSK
X *key = '\l';
X#else
X *key = '\r';
X#endif
X }
X change(cursor, cursor + 1, key);
X cursor++;
X if (cursor > to)
X {
X to = cursor;
X }
X break;
X
X case ctrl('L'):
X case ctrl('R'):
X redraw(MARK_UNSET, FALSE);
X break;
X
X default:
X if (cursor >= to && when != WHEN_VIREP)
X {
X#ifndef NO_ABBR
X cursor = expandabbr(cursor, *key);
X#endif
X add(cursor, key);
X cursor++;
X to = cursor;
X }
X else
X {
X pfetch(markline(cursor));
X if (markidx(cursor) == plen)
X {
X#ifndef NO_ABBR
X cursor = expandabbr(cursor, *key);
X#endif
X add(cursor, key);
X }
X else
X {
X#ifndef NO_DIGRAPH
X *key = digraph(ptext[markidx(cursor)], *key);
X#endif
X#ifndef NO_ABBR
X cursor = expandabbr(cursor, *key);
X#endif
X change(cursor, cursor + 1, key);
X }
X cursor++;
X }
X#ifndef NO_SHOWMATCH
X /* show matching "({[" if neceesary */
X if (*o_showmatch && strchr(")}]", *key))
X {
X redraw(cursor, TRUE);
X m = m_match(cursor - 1, 0L);
X if (markline(m) >= topline
X && markline(m) <= botline)
X {
X redraw(m, TRUE);
X refresh();
X sleep(1);
X }
X }
X#endif
X } /* end switch(*key) */
X } /* end for(;;) */
XBreakBreak:;
X
X /* delete any excess characters */
X if (cursor < to)
X {
X delete(cursor, to);
X }
X
X } /* end if doingdot else */
X
X } /* end ChangeText */
X
X /* put the new text into a cut buffer for possible reuse */
X if (!doingdot)
X {
X blksync();
X cutname('.');
X cut(from, cursor);
X }
X
X /* move to last char that we inputted, unless it was newline */
X if (markidx(cursor) != 0)
X {
X cursor--;
X }
X redraw(cursor, FALSE);
X
X#ifndef NO_EXTENSIONS
X if (quit)
X {
X /* if this is a nested "do", then cut it short */
X abortdo();
X
X /* exit, unless we can't write out the file */
X cursor = v_xit(cursor, 0L, 'Z');
X }
X#endif
X
X rptlines = 0L;
X return cursor;
X}
eof
if test `wc -c <input.c` -ne 16368
then
echo input.c damaged!
fi
fi
if test -f main.c -a "$1" != -f
then
echo Will not overwrite main.c
else
echo Extracting main.c
sed 's/^X//' >main.c <<\eof
X/* main.c */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This file contains the main() function of vi */
X
X#include "config.h"
X#include <signal.h>
X#include <setjmp.h>
X#include "vi.h"
X
Xextern trapint(); /* defined below */
Xextern char *getenv();
Xjmp_buf jmpenv;
X
X#ifndef NO_DIGRAPH
Xstatic init_digraphs();
X#endif
X
X/*---------------------------------------------------------------------*/
X
Xvoid main(argc, argv)
X int argc;
X char *argv[];
X{
X int i;
X char *cmd = (char *)0;
X char *tag = (char *)0;
X char *err = (char *)0;
X char *str;
X#if MSDOS || TOS
X char firstarg[256];
X#else
X char *firstarg;
X#endif
X
X /* set mode to MODE_VI or MODE_EX depending on program name */
X switch (argv[0][strlen(argv[0]) - 1])
X {
X case 'x': /* "ex" */
X mode = MODE_EX;
X break;
X
X case 'w': /* "view" */
X mode = MODE_VI;
X *o_readonly = TRUE;
X break;
X#ifndef NO_EXTENSIONS
X case 't': /* "edit" or "input" */
X mode = MODE_VI;
X *o_inputmode = TRUE;
X break;
X#endif
X default: /* "vi" or "elvis" */
X mode = MODE_VI;
X }
X
X#ifndef DEBUG
X# ifdef SIGQUIT
X /* normally, we ignore SIGQUIT. SIGINT is trapped later */
X signal(SIGQUIT, SIG_IGN);
X# endif
X#endif
X
X /* temporarily ignore SIGINT */
X signal(SIGINT, SIG_IGN);
X
X /* start curses */
X initscr();
X cbreak();
X noecho();
X scrollok(stdscr, TRUE);
X
X /* initialize the options */
X initopts();
X
X /* map the arrow keys. The KU,KD,KL,and KR variables correspond to
X * the :ku=: (etc.) termcap capabilities. The variables are defined
X * as part of the curses package.
X */
X if (has_KU) mapkey(has_KU, "k", WHEN_VICMD|WHEN_INMV, "<Up>");
X if (has_KD) mapkey(has_KD, "j", WHEN_VICMD|WHEN_INMV, "<Down>");
X if (has_KL) mapkey(has_KL, "h", WHEN_VICMD|WHEN_INMV, "<Left>");
X if (has_KR) mapkey(has_KR, "l", WHEN_VICMD|WHEN_INMV, "<Right>");
X if (has_HM) mapkey(has_HM, "^", WHEN_VICMD|WHEN_INMV, "<Home>");
X if (has_EN) mapkey(has_EN, "$", WHEN_VICMD|WHEN_INMV, "<End>");
X if (has_PU) mapkey(has_PU, "\002", WHEN_VICMD|WHEN_INMV, "<PgUp>");
X if (has_PD) mapkey(has_PD, "\006", WHEN_VICMD|WHEN_INMV, "<PgDn>");
X#if MSDOS
X if (*o_pcbios)
X {
X mapkey("#R", "i", WHEN_VICMD|WHEN_INMV, "<Insrt>");
X mapkey("#S", "x", WHEN_VICMD|WHEN_INMV, "<Del>");
X mapkey("#s", "B", WHEN_VICMD|WHEN_INMV, "^<left>");
X mapkey("#t", "W", WHEN_VICMD|WHEN_INMV, "^<right>");
X }
X#else
X if (ERASEKEY != '\177')
X {
X mapkey("\177", "x", WHEN_VICMD|WHEN_INMV, "<Del>");
X }
X#endif
X
X#ifndef NO_DIGRAPH
X init_digraphs();
X#endif /* NO_DIGRAPH */
X
X /* process any flags */
X for (i = 1; i < argc && *argv[i] == '-'; i++)
X {
X switch (argv[i][1])
X {
X case 'R': /* readonly */
X *o_readonly = TRUE;
X break;
X
X case 'r': /* recover */
X msg("Use the `virec` program to recover lost files");
X endmsgs();
X refresh();
X endwin();
X exit(0);
X break;
X
X case 't': /* tag */
X if (argv[i][2])
X {
X tag = argv[i] + 2;
X }
X else
X {
X i++;
X tag = argv[i];
X }
X break;
X
X case 'v': /* vi mode */
X mode = MODE_VI;
X break;
X
X case 'e': /* ex mode */
X mode = MODE_EX;
X break;
X#ifndef NO_EXTENSIONS
X case 'i': /* input mode */
X *o_inputmode = TRUE;
X break;
X#endif
X#ifndef NO_ERRLIST
X case 'm': /* use "errlist" as the errlist */
X if (argv[i][2])
X {
X err = argv[i] + 2;
X }
X else if (i + 1 < argc)
X {
X i++;
X err = argv[i];
X }
X else
X {
X err = "";
X }
X break;
X#endif
X default:
X msg("Ignoring unknown flag \"%s\"", argv[i]);
X }
X }
X
X /* if we were given an initial ex command, save it... */
X if (i < argc && *argv[i] == '+')
X {
X if (argv[i][1])
X {
X cmd = argv[i++] + 1;
X }
X else
X {
X cmd = "$"; /* "vi + file" means start at EOF */
X i++;
X }
X }
X
X /* the remaining args are file names. */
X nargs = argc - i;
X if (nargs > 0)
X {
X#if ! ( MSDOS || TOS )
X firstarg = argv[i];
X#endif
X strcpy(args, argv[i]);
X while (++i < argc && strlen(args) + 1 + strlen(argv[i]) < sizeof args)
X {
X strcat(args, " ");
X strcat(args, argv[i]);
X }
X }
X#if ! ( MSDOS || TOS )
X else
X {
X firstarg = "";
X }
X#endif
X argno = 0;
X
X#if MSDOS || TOS
X if (nargs > 0)
X {
X strcpy(args, wildcard(args));
X nargs = 1;
X for (i = 0; args[i]; i++)
X {
X if (args[i] == ' ')
X {
X nargs++;
X }
X }
X for (i = 0; args[i] && args[i] != ' '; i++)
X {
X firstarg[i] = args[i];
X }
X firstarg[i] = '\0';
X }
X else
X {
X firstarg[0] = '\0';
X }
X#endif
X
X /* perform the .exrc files and EXINIT environment variable */
X#ifdef SYSEXRC
X doexrc(SYSEXRC);
X#endif
X#ifdef HMEXRC
X str = getenv("HOME");
X if (str)
X {
X sprintf(tmpblk.c, "%s%c%s", str, SLASH, HMEXRC);
X doexrc(tmpblk.c);
X }
X#endif
X doexrc(EXRC);
X#ifdef EXINIT
X str = getenv(EXINIT);
X if (str)
X {
X exstring(str, strlen(str));
X }
X#endif
X
X /* search for a tag (or an error) now, if desired */
X blkinit();
X if (tag)
X {
X cmd_tag(MARK_FIRST, MARK_FIRST, CMD_TAG, 0, tag);
X }
X#ifndef NO_ERRLIST
X else if (err)
X {
X cmd_errlist(MARK_FIRST, MARK_FIRST, CMD_ERRLIST, 0, err);
X }
X#endif
X
X /* if no tag/err, or tag failed, then start with first arg */
X if (tmpfd < 0 && tmpstart(firstarg) == 0 && *origname)
X {
X ChangeText
X {
X }
X clrflag(file, MODIFIED);
X }
X
X /* now we do the immediate ex command that we noticed before */
X if (cmd)
X {
X doexcmd(cmd);
X }
X
X /* repeatedly call ex() or vi() (depending on the mode) until the
X * mode is set to MODE_QUIT
X */
X while (mode != MODE_QUIT)
X {
X if (setjmp(jmpenv))
X {
X /* Maybe we just aborted a change? */
X abortdo();
X }
X#if TURBOC
X signal(SIGINT, (void(*)()) trapint);
X#else
X signal(SIGINT, trapint);
X#endif
X
X switch (mode)
X {
X case MODE_VI:
X vi();
X break;
X
X case MODE_EX:
X ex();
X break;
X#ifdef DEBUG
X default:
X msg("mode = %d?", mode);
X mode = MODE_QUIT;
X#endif
X }
X }
X
X /* free up the cut buffers */
X cutend();
X
X /* end curses */
X#ifndef NO_CURSORSHAPE
X if (has_CQ)
X do_CQ();
X#endif
X endmsgs();
X move(LINES - 1, 0);
X clrtoeol();
X refresh();
X endwin();
X
X exit(0);
X /*NOTREACHED*/
X}
X
X
X/*ARGSUSED*/
Xint trapint(signo)
X int signo;
X{
X resume_curses(FALSE);
X abortdo();
X#if OSK
X sigmask(-1);
X#endif
X#if TURBO_C
X signal(signo, (void (*)())trapint);
X#else
X signal(signo, trapint);
X#endif
X longjmp(jmpenv, 1);
X
X return 0;
X}
X
X
X#ifndef NO_DIGRAPH
X
X/* This stuff us used to build the default digraphs table. */
Xstatic char digtable[][4] =
X{
X# if CS_IBMPC
X "C,\200", "u\"\1", "e'\2", "a^\3",
X "a\"\4", "a`\5", "a@\6", "c,\7",
X "e^\10", "e\"\211", "e`\12", "i\"\13",
X "i^\14", "i`\15", "A\"\16", "A@\17",
X "E'\20", "ae\21", "AE\22", "o^\23",
X "o\"\24", "o`\25", "u^\26", "u`\27",
X "y\"\30", "O\"\31", "U\"\32", "a'\240",
X "i'!", "o'\"", "u'#", "n~$",
X "N~%", "a-&", "o-'", "~?(",
X "~!-", "\"<.", "\">/",
X# if CS_SPECIAL
X "2/+", "4/,", "^+;", "^q<",
X "^c=", "^r>", "^t?", "pp]",
X "^^^", "oo_", "*a`", "*ba",
X "*pc", "*Sd", "*se", "*uf",
X "*tg", "*Ph", "*Ti", "*Oj",
X "*dk", "*Hl", "*hm", "*En",
X "*No", "eqp", "pmq", "ger",
X "les", "*It", "*iu", "*/v",
X "*=w", "sq{", "^n|", "^2}",
X "^3~", "^_\377",
X# endif /* CS_SPECIAL */
X# endif /* CS_IBMPC */
X# if CS_LATIN1
X "~!!", "a-*", "\">+", "o-:",
X "\"<>", "~??",
X
X "A`@", "A'A", "A^B", "A~C",
X "A\"D", "A@E", "AEF", "C,G",
X "E`H", "E'I", "E^J", "E\"K",
X "I`L", "I'M", "I^N", "I\"O",
X "-DP", "N~Q", "O`R", "O'S",
X "O^T", "O~U", "O\"V", "O/X",
X "U`Y", "U'Z", "U^[", "U\"\\",
X "Y'_",
X
X "a``", "a'a", "a^b", "a~c",
X "a\"d", "a@e", "aef", "c,g",
X "e`h", "e'i", "e^j", "e\"k",
X "i`l", "i'm", "i^n", "i\"o",
X "-dp", "n~q", "o`r", "o's",
X "o^t", "o~u", "o\"v", "o/x",
X "u`y", "u'z", "u^{", "u\"|",
X "y'~",
X# endif /* CS_LATIN1 */
X ""
X};
X
Xstatic init_digraphs()
X{
X int i;
X
X for (i = 0; *digtable[i]; i++)
X {
X do_digraph(FALSE, digtable[i]);
X }
X do_digraph(FALSE, (char *)0);
X}
X#endif /* NO_DIGRAPH */
eof
if test `wc -c <main.c` -ne 7778
then
echo main.c damaged!
fi
fi
if test -f misc.c -a "$1" != -f
then
echo Will not overwrite misc.c
else
echo Extracting misc.c
sed 's/^X//' >misc.c <<\eof
X/* misc.c */
X
X/* Author:
X * Steve Kirkendall
X * 14407 SW Teal Blvd. #C
X * Beaverton, OR 97005
X * kirkenda@cs.pdx.edu
X */
X
X
X/* This file contains functions which didn't seem happy anywhere else */
X
X#include "config.h"
X#include "vi.h"
X
X
X/* find a particular line & return a pointer to a copy of its text */
Xchar *fetchline(line)
X long line; /* line number of the line to fetch */
X{
X int i;
X REG char *scan; /* used to search for the line in a BLK */
X long l; /* line number counter */
X static BLK buf; /* holds ONLY the selected line (as string) */
X REG char *cpy; /* used while copying the line */
X static long nextline; /* } These four variables are used */
X static long chglevel; /* } to implement a shortcut when */
X static char *nextscan; /* } consecutive lines are fetched */
X static long nextlnum; /* } */
X
X /* can we do a shortcut? */
X if (changes == chglevel && line == nextline)
X {
X scan = nextscan;
X }
X else
X {
X /* scan lnum[] to determine which block its in */
X for (i = 1; line > lnum[i]; i++)
X {
X }
X nextlnum = lnum[i];
X
X /* fetch text of the block containing that line */
X scan = blkget(i)->c;
X
X /* find the line in the block */
X for (l = lnum[i - 1]; ++l < line; )
X {
X while (*scan++ != '\n')
X {
X }
X }
X }
X
X /* copy it into a block by itself, with no newline */
X for (cpy = buf.c; *scan != '\n'; )
X {
X *cpy++ = *scan++;
X }
X *cpy = '\0';
X
X /* maybe speed up the next call to fetchline() ? */
X if (line < nextlnum)
X {
X nextline = line + 1;
X chglevel = changes;
X nextscan = scan + 1;
X }
X else
X {
X nextline = 0;
X }
X
X /* Calls to fetchline() interfere with calls to pfetch(). Make sure
X * that pfetch() resets itself on its next invocation.
X */
X pchgs = 0L;
X
X /* Return a pointer to the line's text */
X return buf.c;
X}
X
X
X/* error message from the regexp code */
Xvoid regerror(txt)
X char *txt; /* an error message */
X{
X msg("RE error: %s", txt);
X}
X
X/* This function is equivelent to the pfetch() macro */
Xvoid pfetch(l)
X long l; /* line number of line to fetch */
X{
X if(l != pline || changes != pchgs)
X {
X pline = (l);
X ptext = fetchline(pline);
X plen = strlen(ptext);
X pchgs = changes;
X }
X}
eof
if test `wc -c <misc.c` -ne 2166
then
echo misc.c damaged!
fi
fi
exit 0
-------------------------------------------------------------------------------
Steve Kirkendall kirkenda@cs.pdx.edu Grad student at Portland State U.