home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Source Code 1992 March
/
Source_Code_CD-ROM_Walnut_Creek_March_1992.iso
/
usenet
/
altsrcs
/
2
/
2198
< prev
next >
Wrap
Internet Message Format
|
1990-12-28
|
67KB
From: kirkenda@eecs.cs.pdx.edu (Steve Kirkendall)
Newsgroups: alt.sources
Subject: Elvis 1.4, part 8 of 8
Message-ID: <832@pdxgate.UUCP>
Date: 3 Dec 90 21:36:52 GMT
# --------------------------- 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 7638 Dec 2 17:57 refont.c
# -rw-r--r-- 1 kirkenda 2957 Dec 2 17:57 vars.c
# -rw-r--r-- 1 kirkenda 13459 Dec 2 17:57 vcmd.c
# -rw-r--r-- 1 kirkenda 20322 Dec 2 17:57 vi.c
# -rw-r--r-- 1 kirkenda 18110 Dec 2 17:57 vi.h
#
if test -f vars.c -a "$1" != -f
then
echo Will not overwrite vars.c
else
echo Extracting vars.c
sed 's/^X//' >vars.c <<\eof
X/* vars.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 variables which weren't happy anyplace else */
X
X#include "config.h"
X#include "vi.h"
X
X/*------------------------------------------------------------------------*/
X
X/* used to remember whether the file has been modified */
Xstruct _viflags viflags;
X
X/* used to access the tmp file */
Xlong lnum[MAXBLKS];
Xlong nlines;
Xint tmpfd = -1;
X
X/* used to keep track of the current file & alternate file */
Xlong origtime;
Xchar origname[256];
Xchar prevorig[256];
Xlong prevline = 1;
X
X/* used to track various places in the text */
XMARK mark[NMARKS]; /* marks 'a through 'z, plus mark '' */
XMARK cursor; /* the cursor position within the file */
X
X/* which mode of the editor we're in */
Xint mode; /* vi mode? ex mode? quitting? */
X
X/* used to manage the args list */
Xchar args[BLKSIZE]; /* list of filenames to edit */
Xint argno; /* index of current file in args list */
Xint nargs; /* number of filenames in args[] */
X
X/* dummy var, never explicitly referenced */
Xint bavar; /* used only in BeforeAfter macros */
X
X/* have we made a multi-line change? */
Xint mustredraw; /* must we redraw the whole screen? */
X
X/* used to detect changes that invalidate cached text/blocks */
Xlong changes; /* incremented when file is changed */
Xint significant; /* boolean: was a *REAL* change made? */
X
X/* used to support the pfetch() macro */
Xint plen; /* length of the line */
Xlong pline; /* line number that len refers to */
Xlong pchgs; /* "changes" level that len refers to */
Xchar *ptext; /* text of previous line, if valid */
X
X/* misc temporary storage - mostly for strings */
XBLK tmpblk; /* a block used to accumulate changes */
X
X/* screen oriented stuff */
Xlong topline; /* file line number of top line */
Xint leftcol; /* column number of left col */
Xint physcol; /* physical column number that cursor is on */
Xint physrow; /* physical row number that cursor is on */
X
X/* used to help minimize that "[Hit a key to continue]" message */
Xint exwrote; /* Boolean: was the last ex command wordy? */
X
X/* This variable affects the behaviour of certain functions -- most importantly
X * the input function.
X */
Xint doingdot; /* boolean: are we doing the "." command? */
X
X/* This variable affects the behaviour of the ":s" command, and it is also
X * used to detect & prohibit nesting of ":g" commands
X */
Xint doingglobal; /* boolean: are doing a ":g" command? */
X/* These are used for reporting multi-line changes to the user */
Xlong rptlines; /* number of lines affected by a command */
Xchar *rptlabel; /* description of how lines were affected */
X
X/* These store info that pertains to the shift-U command */
Xlong U_line; /* line# of the undoable line, or 0l for none */
Xchar U_text[BLKSIZE]; /* contents of the undoable line */
X
X/* Bigger stack req'ed for TOS */
X
X#if TOS
Xlong _stksize = 16384;
X#endif
eof
if test `wc -c <vars.c` -ne 2957
then
echo vars.c damaged!
fi
fi
if test -f vcmd.c -a "$1" != -f
then
echo Will not overwrite vcmd.c
else
echo Extracting vcmd.c
sed 's/^X//' >vcmd.c <<\eof
X/* vcmd.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 functions that handle VI commands */
X
X
X#include "config.h"
X#include "vi.h"
X#if MSDOS
X#include <process.h>
X#include <string.h>
X#endif
X#if TOS
X#include <osbind.h>
X#include <string.h>
X#endif
X#if OSK
X# include <stdio.h>
X#endif
X
X
X/* This function puts the editor in EX mode */
XMARK v_quit()
X{
X move(LINES - 1, 0);
X mode = MODE_EX;
X return cursor;
X}
X
X/* This function causes the screen to be redrawn */
XMARK v_redraw()
X{
X redraw(MARK_UNSET, FALSE);
X return cursor;
X}
X
X/* This function executes a single EX command, and waits for a user keystroke
X * before returning to the VI screen. If that keystroke is another ':', then
X * another EX command is read and executed.
X */
X/*ARGSUSED*/
XMARK v_1ex(m, text)
X MARK m; /* the current line */
X char *text; /* the first command to execute */
X{
X /* run the command. be careful about modes & output */
X exwrote = (mode == MODE_COLON);
X doexcmd(text);
X exrefresh();
X
X /* if mode is no longer MODE_VI, then we should quit right away! */
X if (mode != MODE_VI && mode != MODE_COLON)
X return cursor;
X
X /* The command did some output. Wait for a keystoke. */
X if (exwrote)
X {
X mode = MODE_VI;
X msg("[Hit <RETURN> to continue]");
X if (getkey(0) == ':')
X { mode = MODE_COLON;
X addch('\n');
X }
X else
X redraw(MARK_UNSET, FALSE);
X }
X
X return cursor;
X}
X
X/* This function undoes the last change */
X/*ARGSUSED*/
XMARK v_undo(m)
X MARK m; /* (ignored) */
X{
X if (undo())
X {
X redraw(MARK_UNSET, FALSE);
X }
X return cursor;
X}
X
X/* This function deletes the character(s) that the cursor is on */
XMARK v_xchar(m, cnt, cmd)
X MARK m; /* where to start deletions */
X long cnt; /* number of chars to delete */
X int cmd; /* either 'x' or 'X' */
X{
X DEFAULT(1);
X
X /* for 'X', adjust so chars are deleted *BEFORE* cursor */
X if (cmd == 'X')
X {
X if (markidx(m) < cnt)
X return MARK_UNSET;
X m -= cnt;
X }
X
X /* make sure we don't try to delete more thars than there are */
X pfetch(markline(m));
X if (markidx(m + cnt) > plen)
X {
X cnt = plen - markidx(m);
X }
X if (cnt == 0L)
X {
X return MARK_UNSET;
X }
X
X /* do it */
X ChangeText
X {
X cut(m, m + cnt);
X delete(m, m + cnt);
X }
X return m;
X}
X
X/* This function defines a mark */
X/*ARGSUSED*/
XMARK v_mark(m, count, key)
X MARK m; /* where the mark will be */
X long count; /* (ignored) */
X int key; /* the ASCII label of the mark */
X{
X if (key < 'a' || key > 'z')
X {
X msg("Marks must be from a to z");
X }
X else
X {
X mark[key - 'a'] = m;
X }
X return m;
X}
X
X/* This function toggles upper & lower case letters */
XMARK v_ulcase(m, cnt)
X MARK m; /* where to make the change */
X long cnt; /* number of chars to flip */
X{
X REG char *pos;
X REG int i, j;
X static char flip[] =
X "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ[](){}<>";
X
X DEFAULT(1);
X
X /* fetch the current version of the line */
X pfetch(markline(m));
X
X /* for each position in the line */
X for (j = 0, i = markidx(m); j < cnt && ptext[i]; j++, i++)
X {
X tmpblk.c[j] = 0;
X
X /* one of the standard chars? */
X for (pos = flip; *pos && *pos != ptext[i]; pos++)
X {
X }
X if (*pos)
X {
X tmpblk.c[j] = flip[(int)(pos - flip) ^ 1];
X }
X#ifndef NO_DIGRAPH
X else /* one of the non-standard chars? */
X {
X for (pos = o_flipcase; *pos && *pos != ptext[i]; pos++)
X {
X }
X if (*pos)
X {
X tmpblk.c[j] = o_flipcase[(int)(pos - o_flipcase) ^ 1];
X }
X }
X#endif
X
X /* if nothing special, then don't change it */
X if (tmpblk.c[j] == 0)
X {
X tmpblk.c[j] = ptext[i];
X }
X }
X
X /* if the new text is different from the old, then change it */
X if (strncmp(tmpblk.c, &ptext[markidx(m)], j))
X {
X ChangeText
X {
X tmpblk.c[j] = '\0';
X change(m, m + j, tmpblk.c);
X }
X }
X
X return m + j;
X}
X
X
XMARK v_replace(m, cnt, key)
X MARK m; /* first char to be replaced */
X long cnt; /* number of chars to replace */
X int key; /* what to replace them with */
X{
X REG char *text;
X REG int i;
X
X DEFAULT(1);
X
X /* map ^M to '\n' */
X if (key == '\r')
X {
X key = '\n';
X }
X
X /* make sure the resulting line isn't too long */
X if (cnt > BLKSIZE - 2 - markidx(m))
X {
X cnt = BLKSIZE - 2 - markidx(m);
X }
X
X /* build a string of the desired character with the desired length */
X for (text = tmpblk.c, i = cnt; i > 0; i--)
X {
X *text++ = key;
X }
X *text = '\0';
X
X /* make sure cnt doesn't extend past EOL */
X pfetch(markline(m));
X key = markidx(m);
X if (key + cnt > plen)
X {
X cnt = plen - key;
X }
X
X /* do the replacement */
X ChangeText
X {
X change(m, m + cnt, tmpblk.c);
X }
X
X if (*tmpblk.c == '\n')
X {
X return (m & ~(BLKSIZE - 1)) + cnt * BLKSIZE;
X }
X else
X {
X return m + cnt - 1;
X }
X}
X
XMARK v_overtype(m)
X MARK m; /* where to start overtyping */
X{
X MARK end; /* end of a substitution */
X static long width; /* width of a single-line replace */
X
X /* the "doingdot" version of replace is really a substitution */
X if (doingdot)
X {
X /* was the last one really repeatable? */
X if (width < 0)
X {
X msg("Can't repeat a multi-line overtype command");
X return MARK_UNSET;
X }
X
X /* replacing nothing by nothing? Don't bother */
X if (width == 0)
X {
X return m;
X }
X
X /* replace some chars by repeated text */
X return v_subst(m, width);
X }
X
X /* Normally, we input starting here, in replace mode */
X ChangeText
X {
X end = input(m, m, WHEN_VIREP);
X }
X
X /* if we ended on the same line we started on, then this
X * overtype is repeatable via the dot key.
X */
X if (markline(end) == markline(m) && end >= m - 1L)
X {
X width = end - m + 1L;
X }
X else /* it isn't repeatable */
X {
X width = -1L;
X }
X
X return end;
X}
X
X
X/* This function selects which cut buffer to use */
X/*ARGSUSED*/
XMARK v_selcut(m, cnt, key)
X MARK m;
X long cnt;
X int key;
X{
X cutname(key);
X return m;
X}
X
X/* This function pastes text from a cut buffer */
X/*ARGSUSED*/
XMARK v_paste(m, cnt, cmd)
X MARK m; /* where to paste the text */
X long cnt; /* (ignored) */
X int cmd; /* either 'p' or 'P' */
X{
X ChangeText
X {
X m = paste(m, cmd == 'p', FALSE);
X }
X return m;
X}
X
X/* This function yanks text into a cut buffer */
XMARK v_yank(m, n)
X MARK m, n; /* range of text to yank */
X{
X cut(m, n);
X return m;
X}
X
X/* This function deletes a range of text */
XMARK v_delete(m, n)
X MARK m, n; /* range of text to delete */
X{
X /* illegal to try and delete nothing */
X if (n <= m)
X {
X return MARK_UNSET;
X }
X
X /* Do it */
X ChangeText
X {
X cut(m, n);
X delete(m, n);
X }
X return m;
X}
X
X
X/* This starts input mode without deleting anything */
XMARK v_insert(m, cnt, key)
X MARK m; /* where to start (sort of) */
X long cnt; /* repeat how many times? */
X int key; /* what command is this for? {a,A,i,I,o,O} */
X{
X int wasdot;
X long reps;
X int after; /* are we appending or inserting? */
X
X DEFAULT(1);
X
X ChangeText
X {
X /* tweak the insertion point, based on command key */
X switch (key)
X {
X case 'i':
X after = FALSE;
X break;
X
X case 'a':
X pfetch(markline(m));
X if (plen > 0)
X {
X m++;
X }
X after = TRUE;
X break;
X
X case 'I':
X m = m_front(m, 1L);
X after = FALSE;
X break;
X
X case 'A':
X pfetch(markline(m));
X m = (m & ~(BLKSIZE - 1)) + plen;
X after = TRUE;
X break;
X
X case 'O':
X m &= ~(BLKSIZE - 1);
X add(m, "\n");
X after = FALSE;
X break;
X
X case 'o':
X m = (m & ~(BLKSIZE - 1)) + BLKSIZE;
X add(m, "\n");
X after = FALSE;
X break;
X }
X
X /* insert the same text once or more */
X for (reps = cnt, wasdot = doingdot; reps > 0; reps--, doingdot = TRUE)
X {
X m = input(m, m, WHEN_VIINP);
X if (after)
X {
X m++;
X }
X }
X if (after)
X {
X m--;
X }
X
X doingdot = wasdot;
X }
X
X#ifndef CRUNCH
X# ifndef NO_EXTENSIONS
X if (key == 'i' && *o_inputmode && mode == MODE_VI)
X {
X msg("Now in visual command mode! To return to input mode, hit <i>.");
X }
X# endif
X#endif
X
X return m;
X}
X
X/* This starts input mode with some text deleted */
XMARK v_change(m, n)
X MARK m, n; /* the range of text to change */
X{
X int lnmode; /* is this a line-mode change? */
X
X /* swap them if they're in reverse order */
X if (m > n)
X {
X MARK tmp;
X tmp = m;
X m = n;
X n = tmp;
X }
X
X /* for line mode, retain the last newline char */
X lnmode = (markidx(m) == 0 && markidx(n) == 0 && m != n);
X if (lnmode)
X {
X n -= BLKSIZE;
X pfetch(markline(n));
X n = (n & ~(BLKSIZE - 1)) + plen;
X }
X
X ChangeText
X {
X cut(m, n);
X m = input(m, n, WHEN_VIINP);
X }
X
X return m;
X}
X
X/* This function replaces a given number of characters with input */
XMARK v_subst(m, cnt)
X MARK m; /* where substitutions start */
X long cnt; /* number of chars to replace */
X{
X DEFAULT(1);
X
X /* make sure we don't try replacing past EOL */
X pfetch(markline(m));
X if (markidx(m) + cnt > plen)
X {
X cnt = plen - markidx(m);
X }
X
X /* Go for it! */
X ChangeText
X {
X cut(m, m + cnt);
X m = input(m, m + cnt, WHEN_VIINP);
X }
X return m;
X}
X
X/* This calls the ex "join" command to join some lines together */
XMARK v_join(m, cnt)
X MARK m; /* the first line to be joined */
X long cnt; /* number of other lines to join */
X{
X MARK joint; /* where the lines were joined */
X
X DEFAULT(1);
X
X /* figure out where the joint will be */
X pfetch(markline(m));
X joint = (m & ~(BLKSIZE - 1)) + plen;
X
X /* join the lines */
X cmd_join(m, m + MARK_AT_LINE(cnt), CMD_JOIN, 0, "");
X mustredraw = TRUE;
X
X /* the cursor should be left at the joint */
X return joint;
X}
X
X/* This calls the ex shifter command to shift some lines */
Xstatic MARK shift_help(m, n, excmd)
X MARK m, n; /* range of lines to shift */
X CMD excmd; /* which way do we shift? */
X{
X /* adjust for inclusive endmarks in ex */
X n -= BLKSIZE;
X
X cmd_shift(m, n, excmd, 0, "");
X return m;
X}
X
X/* This calls the ex "<" command to shift some lines left */
XMARK v_lshift(m, n)
X MARK m, n; /* range of lines to shift */
X{
X return shift_help(m, n, CMD_SHIFTL);
X}
X
X/* This calls the ex ">" command to shift some lines right */
XMARK v_rshift(m, n)
X MARK m, n; /* range of lines to shift */
X{
X return shift_help(m, n, CMD_SHIFTR);
X}
X
X/* This runs some lines through a filter program */
XMARK v_filter(m, n)
X MARK m, n; /* range of lines to shift */
X{
X char cmdln[100]; /* a shell command line */
X
X /* adjust for inclusive endmarks in ex */
X n -= BLKSIZE;
X
X if (vgets('!', cmdln, sizeof(cmdln)) > 0)
X {
X filter(m, n, cmdln);
X }
X
X redraw(MARK_UNSET, FALSE);
X return m;
X}
X
X
X/* This function runs the ex "file" command to show the file's status */
XMARK v_status()
X{
X cmd_file(cursor, cursor, CMD_FILE, 0, "");
X return cursor;
X}
X
X
X/* This function runs the ":&" command to repeat the previous :s// */
XMARK v_again(m, n)
X MARK m, n;
X{
X cmd_substitute(m, n - BLKSIZE, CMD_SUBAGAIN, TRUE, "");
X return cursor;
X}
X
X
X
X/* This function switches to the previous file, if possible */
XMARK v_switch()
X{
X if (!*prevorig)
X msg("No previous file");
X else
X { strcpy(tmpblk.c, prevorig);
X cmd_edit(cursor, cursor, CMD_EDIT, 0, tmpblk.c);
X }
X return cursor;
X}
X
X/* This function does a tag search on a keyword */
X/*ARGSUSED*/
XMARK v_tag(keyword, m, cnt)
X char *keyword;
X MARK m;
X long cnt;
X{
X /* move the cursor to the start of the tag name, where m is */
X cursor = m;
X
X /* perform the tag search */
X cmd_tag(cursor, cursor, CMD_TAG, 0, keyword);
X
X return cursor;
X}
X
X#ifndef NO_EXTENSIONS
X/* This function looks up a keyword by calling the helpprog program */
X/*ARGSUSED*/
XMARK v_keyword(keyword, m, cnt)
X char *keyword;
X MARK m;
X long cnt;
X{
X int waswarn;
X char cmdline[130];
X
X move(LINES - 1, 0);
X addstr("---------------------------------------------------------\n");
X clrtoeol();
X refresh();
X sprintf(cmdline, "%s %s", o_keywordprg, keyword);
X waswarn = *o_warn;
X *o_warn = FALSE;
X suspend_curses();
X if (system(cmdline))
X {
X addstr("<<< failed >>>\n");
X }
X resume_curses(FALSE);
X mode = MODE_VI;
X redraw(MARK_UNSET, FALSE);
X *o_warn = waswarn;
X
X return m;
X}
X
X
X
XMARK v_increment(keyword, m, cnt)
X char *keyword;
X MARK m;
X long cnt;
X{
X static sign;
X char newval[12];
X long atol();
X
X DEFAULT(1);
X
X /* get one more keystroke, unless doingdot */
X if (!doingdot)
X {
X sign = getkey(0);
X }
X
X /* adjust the number, based on that second keystroke */
X switch (sign)
X {
X case '+':
X case '#':
X cnt = atol(keyword) + cnt;
X break;
X
X case '-':
X cnt = atol(keyword) - cnt;
X break;
X
X case '=':
X break;
X
X default:
X return MARK_UNSET;
X }
X sprintf(newval, "%ld", cnt);
X
X ChangeText
X {
X change(m, m + strlen(keyword), newval);
X }
X
X return m;
X}
X#endif
X
X
X/* This function acts like the EX command "xit" */
X/*ARGSUSED*/
XMARK v_xit(m, cnt, key)
X MARK m; /* ignored */
X long cnt; /* ignored */
X int key; /* must be a second 'Z' */
X{
X /* if second char wasn't 'Z', fail */
X if (key != 'Z')
X {
X return MARK_UNSET;
X }
X
X /* move the cursor to the bottom of the screen */
X move(LINES - 1, 0);
X clrtoeol();
X
X /* do the xit command */
X cmd_xit(m, m, CMD_XIT, FALSE, "");
X
X /* return the cursor */
X return m;
X}
X
X
X/* This function undoes changes to a single line, if possible */
XMARK v_undoline(m)
X MARK m; /* where we hope to undo the change */
X{
X /* make sure we have the right line in the buffer */
X if (markline(m) != U_line)
X {
X return MARK_UNSET;
X }
X
X /* fix it */
X ChangeText
X {
X strcat(U_text, "\n");
X change(MARK_AT_LINE(U_line), MARK_AT_LINE(U_line + 1), U_text);
X }
X
X /* nothing in the buffer anymore */
X U_line = -1L;
X
X /* return, with the cursor at the front of the line */
X return m & ~(BLKSIZE - 1);
X}
X
X
X#ifndef NO_ERRLIST
XMARK v_errlist(m)
X MARK m;
X{
X cmd_errlist(m, m, CMD_ERRLIST, FALSE, "");
X return cursor;
X}
X#endif
X
X
X#ifndef NO_AT
X/*ARGSUSED*/
XMARK v_at(m, cnt, key)
X MARK m;
X long cnt;
X int key;
X{
X if (!fromcutbuf(key))
X {
X return MARK_UNSET;
X }
X return cursor;
X}
X#endif
eof
if test `wc -c <vcmd.c` -ne 13459
then
echo vcmd.c damaged!
fi
fi
if test -f vi.c -a "$1" != -f
then
echo Will not overwrite vi.c
else
echo Extracting vi.c
sed 's/^X//' >vi.c <<\eof
X/* vi.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#include "config.h"
X#include <ctype.h>
X#include "vi.h"
X
X
X
X/* This array describes what each key does */
X#define NO_FUNC (MARK (*)())0
X#define NO_ARGS 0
X#define CURSOR_COUNT 1
X#define CURSOR 2
X#define CURSOR_CNT_KEY 3
X#define CURSOR_MOVED 4
X#define CURSOR_EOL 5
X#define ZERO 6
X#define DIGIT 7
X#define CURSOR_TEXT 8
X#define CURSOR_CNT_CMD 9
X#define KEYWORD 10
X#define NO_FLAGS 0x00
X#define MVMT 0x01 /* this is a movement command */
X#define PTMV 0x02 /* this can be *part* of a movement command */
X#define FRNT 0x04 /* after move, go to front of line */
X#define INCL 0x08 /* include last char when used with c/d/y */
X#define LNMD 0x10 /* use line mode of c/d/y */
X#define NCOL 0x20 /* this command can't change the column# */
X#define NREL 0x40 /* this is "non-relative" -- set the '' mark */
X#define SDOT 0x80 /* set the "dot" variables, for the "." cmd */
Xstatic struct keystru
X{
X MARK (*func)(); /* the function to run */
X uchar args; /* description of the args needed */
X uchar flags; /* other stuff */
X}
X vikeys[] =
X{
X/* NUL not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^A not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^B page backward */ {m_scroll, CURSOR_CNT_CMD, FRNT},
X/* ^C not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^D scroll dn 1/2page*/ {m_scroll, CURSOR_CNT_CMD, NCOL},
X/* ^E scroll up */ {m_scroll, CURSOR_CNT_CMD, NCOL},
X/* ^F page forward */ {m_scroll, CURSOR_CNT_CMD, FRNT},
X/* ^G show file status */ {v_status, NO_ARGS, NO_FLAGS},
X/* ^H move left, like h*/ {m_left, CURSOR_COUNT, MVMT},
X/* ^I not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^J move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD},
X/* ^K not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^L redraw screen */ {v_redraw, NO_ARGS, NO_FLAGS},
X/* ^M mv front next ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD},
X/* ^N move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD},
X/* ^O not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^P move up */ {m_updnto, CURSOR_CNT_CMD, MVMT|LNMD},
X/* ^Q not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^R redraw screen */ {v_redraw, NO_ARGS, NO_FLAGS},
X/* ^S not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^T not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^U scroll up 1/2page*/ {m_scroll, CURSOR_CNT_CMD, NCOL},
X/* ^V not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^W not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^X not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^Y scroll down */ {m_scroll, CURSOR_CNT_CMD, NCOL},
X/* ^Z not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ESC not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^\ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ^] keyword is tag */ {v_tag, KEYWORD, NO_FLAGS},
X/* ^^ previous file */ {v_switch, CURSOR, NO_FLAGS},
X/* ^_ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* SPC move right,like l*/ {m_right, CURSOR_COUNT, MVMT},
X/* ! run thru filter */ {v_filter, CURSOR_MOVED, FRNT|LNMD|INCL},
X/* " select cut buffer*/ {v_selcut, CURSOR_CNT_KEY, PTMV},
X#ifndef NO_EXTENSIONS
X/* # increment number */ {v_increment, KEYWORD, SDOT},
X#else
X/* # not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* $ move to rear */ {m_rear, CURSOR, MVMT|INCL},
X/* % move to match */ {m_match, CURSOR, MVMT|INCL},
X/* & repeat subst */ {v_again, CURSOR_MOVED, SDOT|NCOL|LNMD|INCL},
X/* ' move to a mark */ {m_tomark, CURSOR_CNT_KEY, MVMT|FRNT|NREL|LNMD|INCL},
X#ifndef NO_SENTENCE
X/* ( mv back sentence */ {m_bsentence, CURSOR_COUNT, MVMT},
X/* ) mv fwd sentence */ {m_fsentence, CURSOR_COUNT, MVMT},
X#else
X/* ( not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ) not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X#ifndef NO_ERRLIST
X/* * errlist */ {v_errlist, CURSOR, FRNT|NREL},
X#else
X/* * not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* + mv front next ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD},
X#ifndef NO_CHARSEARCH
X/* , reverse [fFtT] cmd*/ {m__ch, CURSOR_CNT_CMD, MVMT|INCL},
X#else
X/* , not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* - mv front prev ln */ {m_updnto, CURSOR_CNT_CMD, MVMT|FRNT|LNMD},
X/* . special... */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* / forward search */ {m_fsrch, CURSOR_TEXT, MVMT|NREL},
X/* 0 part of count? */ {NO_FUNC, ZERO, MVMT|PTMV},
X/* 1 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 2 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 3 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 4 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 5 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 6 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 7 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 8 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* 9 part of count */ {NO_FUNC, DIGIT, PTMV},
X/* : run single EX cmd*/ {v_1ex, CURSOR_TEXT, NO_FLAGS},
X#ifndef NO_CHARSEARCH
X/* ; repeat [fFtT] cmd*/ {m__ch, CURSOR_CNT_CMD, MVMT|INCL},
X#else
X/* ; not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* < shift text left */ {v_lshift, CURSOR_MOVED, SDOT|FRNT|LNMD|INCL},
X/* = not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* > shift text right */ {v_rshift, CURSOR_MOVED, SDOT|FRNT|LNMD|INCL},
X/* ? backward search */ {m_bsrch, CURSOR_TEXT, MVMT|NREL},
X#ifndef NO_AT
X/* @ execute a cutbuf */ {v_at, CURSOR_CNT_KEY, NO_FLAGS},
X#else
X/* @ undefined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* A append at EOL */ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* B move back Word */ {m_bword, CURSOR_CNT_CMD, MVMT},
X/* C change to EOL */ {v_change, CURSOR_EOL, SDOT},
X/* D delete to EOL */ {v_delete, CURSOR_EOL, SDOT},
X/* E move end of Word */ {m_eword, CURSOR_CNT_CMD, MVMT|INCL},
X#ifndef NO_CHARSEARCH
X/* F move bk to char */ {m_Fch, CURSOR_CNT_KEY, MVMT|INCL},
X#else
X/* F not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* G move to line # */ {m_updnto, CURSOR_CNT_CMD, MVMT|NREL|LNMD|FRNT|INCL},
X/* H move to row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT},
X/* I insert at front */ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* J join lines */ {v_join, CURSOR_COUNT, SDOT},
X#ifndef NO_EXTENSIONS
X/* K look up keyword */ {v_keyword, KEYWORD, NO_FLAGS},
X#else
X/* K not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* L move to last row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT},
X/* M move to mid row */ {m_row, CURSOR_CNT_CMD, MVMT|FRNT},
X/* N reverse prev srch*/ {m_Nsrch, CURSOR, MVMT},
X/* O insert above line*/ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* P paste before */ {v_paste, CURSOR_CNT_CMD, NO_FLAGS},
X/* Q quit to EX mode */ {v_quit, NO_ARGS, NO_FLAGS},
X/* R overtype */ {v_overtype, CURSOR, SDOT},
X/* S change line */ {v_change, CURSOR_MOVED, SDOT},
X#ifndef NO_CHARSEARCH
X/* T move bk to char */ {m_Tch, CURSOR_CNT_KEY, MVMT|INCL},
X#else
X/* T not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* U undo whole line */ {v_undoline, CURSOR, FRNT},
X/* V not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* W move forward Word*/ {m_fword, CURSOR_CNT_CMD, MVMT},
X/* X delete to left */ {v_xchar, CURSOR_CNT_CMD, SDOT},
X/* Y yank text */ {v_yank, CURSOR_MOVED, NCOL},
X/* Z save file & exit */ {v_xit, CURSOR_CNT_KEY, NO_FLAGS},
X/* [ move back section*/ {m_bsection, CURSOR_CNT_KEY, MVMT|LNMD|NREL},
X/* \ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ] move fwd section */ {m_fsection, CURSOR_CNT_KEY, MVMT|LNMD|NREL},
X/* ^ move to front */ {m_front, CURSOR, MVMT},
X/* _ not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* ` move to mark */ {m_tomark, CURSOR_CNT_KEY, MVMT|NREL},
X/* a append at cursor */ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* b move back word */ {m_bword, CURSOR_CNT_CMD, MVMT},
X/* c change text */ {v_change, CURSOR_MOVED, SDOT},
X/* d delete op */ {v_delete, CURSOR_MOVED, SDOT|NCOL},
X/* e move end word */ {m_eword, CURSOR_CNT_CMD, MVMT|INCL},
X#ifndef NO_CHARSEARCH
X/* f move fwd for char*/ {m_fch, CURSOR_CNT_KEY, MVMT|INCL},
X#else
X/* f not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* g not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* h move left */ {m_left, CURSOR_COUNT, MVMT},
X/* i insert at cursor */ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* j move down */ {m_updnto, CURSOR_CNT_CMD, MVMT|NCOL|LNMD},
X/* k move up */ {m_updnto, CURSOR_CNT_CMD, MVMT|NCOL|LNMD},
X/* l move right */ {m_right, CURSOR_COUNT, MVMT},
X/* m define a mark */ {v_mark, CURSOR_CNT_KEY, NO_FLAGS},
X/* n repeat prev srch */ {m_nsrch, CURSOR, MVMT},
X/* o insert below line*/ {v_insert, CURSOR_CNT_CMD, SDOT},
X/* p paste after */ {v_paste, CURSOR_CNT_CMD, NO_FLAGS},
X/* q not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* r replace chars */ {v_replace, CURSOR_CNT_KEY, SDOT},
X/* s subst N chars */ {v_subst, CURSOR_COUNT, SDOT},
X#ifndef NO_CHARSEARCH
X/* t move fwd to char */ {m_tch, CURSOR_CNT_KEY, MVMT|INCL},
X#else
X/* t not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X#endif
X/* u undo */ {v_undo, CURSOR, NO_FLAGS},
X/* v not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS},
X/* w move fwd word */ {m_fword, CURSOR_CNT_CMD, MVMT},
X/* x delete character */ {v_xchar, CURSOR_CNT_CMD, SDOT},
X/* y yank text */ {v_yank, CURSOR_MOVED, NCOL},
X/* z adjust scrn row */ {m_z, CURSOR_CNT_KEY, NCOL},
X/* { back paragraph */ {m_bparagraph, CURSOR_COUNT, MVMT|LNMD},
X/* | move to column */ {m_tocol, CURSOR_COUNT, NREL},
X/* } fwd paragraph */ {m_fparagraph, CURSOR_COUNT, MVMT|LNMD},
X/* ~ upper/lowercase */ {v_ulcase, CURSOR_COUNT, SDOT},
X/* DEL not defined */ {NO_FUNC, NO_ARGS, NO_FLAGS}
X};
X
X
X
Xvoid vi()
X{
X REG int key; /* keystroke from user */
X long count; /* numeric argument to some functions */
X REG struct keystru *keyptr;/* pointer to vikeys[] element */
X MARK tcurs; /* temporary cursor */
X int prevkey;/* previous key, if d/c/y/</>/! */
X MARK range; /* start of range for d/c/y/</>/! */
X char text[100];
X int dotkey; /* last "key" of a change */
X int dotpkey;/* last "prevkey" of a change */
X int dotkey2;/* last extra "getkey()" of a change */
X int dotcnt; /* last "count" of a change */
X int firstkey;
X REG int i;
X
X /* tell the redraw() function to start from scratch */
X redraw(MARK_UNSET, FALSE);
X
X#ifdef lint
X /* lint says that "range" might be used before it is set. This
X * can't really happen due to the way "range" and "prevkey" are used,
X * but lint doesn't know that. This line is here ONLY to keep lint
X * happy.
X */
X range = 0L;
X#endif
X
X /* safeguard against '.' with no previous command */
X dotkey = 0;
X
X /* go immediately into insert mode, if ":set inputmode" */
X firstkey = 0;
X#ifndef NO_EXTENSIONS
X if (*o_inputmode)
X {
X firstkey = 'i';
X }
X#endif
X
X /* Repeatedly handle VI commands */
X for (count = 0, prevkey = '\0'; mode == MODE_VI; )
X {
X /* if we've moved off the undoable line, then we can't undo it at all */
X if (markline(cursor) != U_line)
X {
X U_line = 0L;
X }
X
X /* report any changes from the previous command */
X if (rptlines >= *o_report)
X {
X redraw(cursor, FALSE);
X msg("%ld lines %s", rptlines, rptlabel);
X }
X rptlines = 0L;
X
X /* get the next command key. It must be ASCII */
X if (firstkey)
X {
X key = firstkey;
X firstkey = 0;
X }
X else
X {
X do
X {
X key = getkey(WHEN_VICMD);
X } while (key < 0 || key > 127);
X }
X
X /* change cw and cW commands to ce and cE, respectively */
X /* (Why? because the real vi does it that way!) */
X if (prevkey == 'c')
X {
X if (key == 'w')
X key = 'e';
X else if (key == 'W')
X key = 'E';
X
X /* wouldn't work right at the end of a word unless we
X * backspace one character before doing the move. This
X * will fix most cases. !!! but not all.
X */
X if (markidx(cursor) > 0 && (key == 'e' || key == 'E'))
X {
X cursor--;
X }
X }
X
X /* look up the structure describing this command */
X keyptr = &vikeys[key];
X
X /* if we're in the middle of a d/c/y/</>/! command, reject
X * anything but movement or a doubled version like "dd".
X */
X if (prevkey && key != prevkey && !(keyptr->flags & (MVMT|PTMV)))
X {
X beep();
X prevkey = 0;
X count = 0;
X continue;
X }
X
X /* set the "dot" variables, if we're supposed to */
X if ((keyptr->flags & SDOT)
X || (prevkey && vikeys[prevkey].flags & SDOT))
X {
X dotkey = key;
X dotpkey = prevkey;
X dotkey2 = '\0';
X dotcnt = count;
X
X /* remember the line before any changes are made */
X if (U_line != markline(cursor))
X {
X U_line = markline(cursor);
X strcpy(U_text, fetchline(U_line));
X }
X }
X
X /* if this is "." then set other vars from the "dot" vars */
X if (key == '.')
X {
X key = dotkey;
X keyptr = &vikeys[key];
X prevkey = dotpkey;
X if (prevkey)
X {
X range = cursor;
X }
X if (count == 0)
X {
X count = dotcnt;
X }
X doingdot = TRUE;
X
X /* remember the line before any changes are made */
X if (U_line != markline(cursor))
X {
X U_line = markline(cursor);
X strcpy(U_text, fetchline(U_line));
X }
X }
X else
X {
X doingdot = FALSE;
X }
X
X /* process the key as a command */
X tcurs = cursor;
X switch (keyptr->args)
X {
X case ZERO:
X if (count == 0)
X {
X tcurs = cursor & ~(BLKSIZE - 1);
X break;
X }
X /* else fall through & treat like other digits... */
X
X case DIGIT:
X count = count * 10 + key - '0';
X break;
X
X case KEYWORD:
X /* if not on a keyword, fail */
X pfetch(markline(cursor));
X key = markidx(cursor);
X if (isascii(ptext[key])
X && !isalnum(ptext[key]) && ptext[key] != '_')
X {
X tcurs = MARK_UNSET;
X break;
X }
X
X /* find the start of the keyword */
X while (key > 0 && (!isascii(ptext[key-1]) ||
X isalnum(ptext[key - 1]) || ptext[key - 1] == '_'))
X {
X key--;
X }
X tcurs = (cursor & ~(BLKSIZE - 1)) + key;
X
X /* copy it into a buffer, and NUL-terminate it */
X i = 0;
X do
X {
X text[i++] = ptext[key++];
X } while (!isascii(ptext[key]) || isalnum(ptext[key]) || ptext[key] == '_');
X text[i] = '\0';
X
X /* call the function */
X tcurs = (*keyptr->func)(text, tcurs, count);
X count = 0L;
X break;
X
X case NO_ARGS:
X if (keyptr->func)
X {
X (*keyptr->func)();
X }
X else
X {
X beep();
X }
X count = 0L;
X break;
X
X case CURSOR_COUNT:
X tcurs = (*keyptr->func)(cursor, count);
X count = 0L;
X break;
X
X case CURSOR:
X tcurs = (*keyptr->func)(cursor);
X count = 0L;
X break;
X
X case CURSOR_CNT_KEY:
X if (doingdot)
X {
X tcurs = (*keyptr->func)(cursor, count, dotkey2);
X }
X else
X {
X /* get a key */
X i = getkey(0);
X if (i == '\033') /* ESC */
X {
X count = 0;
X tcurs = MARK_UNSET;
X break; /* exit from "case CURSOR_CNT_KEY" */
X }
X else if (i == ('V' & 0x1f))
X {
X i = getkey(0);
X }
X
X /* if part of an SDOT command, remember it */
X if (keyptr->flags & SDOT
X || (prevkey && vikeys[prevkey].flags & SDOT))
X {
X dotkey2 = i;
X }
X
X /* do it */
X tcurs = (*keyptr->func)(cursor, count, i);
X }
X count = 0L;
X break;
X
X case CURSOR_MOVED:
X /* '&' and uppercase keys always act like doubled */
X if (key == '&' || isascii(key) && isupper(key))
X {
X prevkey = key;
X }
X
X if (prevkey)
X {
X /* doubling up a command */
X if (!count) count = 1L;
X range = cursor;
X tcurs = range + MARK_AT_LINE(count - 1L);
X count = 0L;
X }
X else
X {
X prevkey = key;
X range = cursor;
X key = -1; /* so we don't think we doubled yet */
X }
X break;
X
X case CURSOR_EOL:
X prevkey = key;
X /* a zero-length line needs special treatment */
X pfetch(markline(cursor));
X if (plen == 0)
X {
X /* act on a zero-length section of text */
X range = tcurs = cursor;
X key = ' ';
X }
X else
X {
X /* act like CURSOR_MOVED with '$' movement */
X range = cursor;
X tcurs = m_rear(cursor, 1L);
X key = '$';
X }
X count = 0L;
X keyptr = &vikeys[key];
X break;
X
X case CURSOR_TEXT:
X do
X {
X text[0] = key;
X if (vgets(key, text + 1, sizeof text - 1) >= 0)
X {
X /* reassure user that <CR> was hit */
X qaddch('\r');
X refresh();
X
X /* call the function with the text */
X tcurs = (*keyptr->func)(cursor, text);
X }
X else
X {
X if (exwrote || mode == MODE_COLON)
X {
X redraw(MARK_UNSET, FALSE);
X }
X mode = MODE_VI;
X }
X } while (mode == MODE_COLON);
X count = 0L;
X break;
X
X case CURSOR_CNT_CMD:
X tcurs = (*keyptr->func)(cursor, count, key);
X count = 0L;
X break;
X }
X
X /* if that command took us out of vi mode, then exit the loop
X * NOW, without tweaking the cursor or anything. This is very
X * important when mode == MODE_QUIT.
X */
X if (mode != MODE_VI)
X {
X break;
X }
X
X /* now move the cursor, as appropriate */
X if (keyptr->args == CURSOR_MOVED)
X {
X /* the < and > keys have FRNT,
X * but it shouldn't be applied yet
X */
X tcurs = adjmove(cursor, tcurs, 0);
X }
X else
X {
X tcurs = adjmove(cursor, tcurs, (int)keyptr->flags);
X }
X
X /* was that the end of a d/c/y/</>/! command? */
X if (prevkey && (prevkey == key || (keyptr->flags & MVMT)) && count == 0L)
X {
X /* if the movement command failed, cancel operation */
X if (tcurs == MARK_UNSET)
X {
X prevkey = 0;
X count = 0;
X continue;
X }
X
X /* make sure range=front and tcurs=rear. Either way,
X * leave cursor=range since that's where we started.
X */
X cursor = range;
X if (tcurs < range)
X {
X range = tcurs;
X tcurs = cursor;
X }
X
X
X /* adjust for line mode & inclusion of last char/line */
X i = (keyptr->flags | vikeys[prevkey].flags);
X if (key == prevkey)
X {
X i |= (INCL|LNMD);
X }
X switch (i & (INCL|LNMD))
X {
X case INCL:
X tcurs++;
X break;
X
X case INCL|LNMD:
X tcurs += BLKSIZE;
X /* fall through... */
X
X case LNMD:
X range &= ~(BLKSIZE - 1);
X tcurs &= ~(BLKSIZE - 1);
X break;
X }
X
X /* run the function */
X tcurs = (*vikeys[prevkey].func)(range, tcurs);
X (void)adjmove(cursor, cursor, 0);
X cursor = adjmove(cursor, tcurs, (int)vikeys[prevkey].flags);
X
X /* cleanup */
X prevkey = 0;
X }
X else if (!prevkey)
X {
X cursor = tcurs;
X }
X }
X}
X
X/* This function adjusts the MARK value that they return; here we make sure
X * it isn't past the end of the line, and that the column hasn't been
X * *accidentally* changed.
X */
XMARK adjmove(old, new, flags)
X MARK old; /* the cursor position before the command */
X REG MARK new; /* the cursor position after the command */
X int flags; /* various flags regarding cursor mvmt */
X{
X static int colno; /* the column number that we want */
X REG char *text; /* used to scan through the line's text */
X REG int i;
X
X#ifdef DEBUG
X watch();
X#endif
X
X /* if the command failed, bag it! */
X if (new == MARK_UNSET)
X {
X beep();
X return old;
X }
X
X /* if this is a non-relative movement, set the '' mark */
X if (flags & NREL)
X {
X mark[26] = old;
X }
X
X /* make sure it isn't past the end of the file */
X if (markline(new) < 1)
X {
X new = MARK_FIRST;
X }
X else if (markline(new) > nlines)
X {
X new = MARK_LAST;
X }
X
X /* fetch the new line */
X pfetch(markline(new));
X
X /* move to the front, if we're supposed to */
X if (flags & FRNT)
X {
X new = m_front(new, 1L);
X }
X
X /* change the column#, or change the mark to suit the column# */
X if (!(flags & NCOL))
X {
X /* change the column# */
X i = markidx(new);
X if (i == BLKSIZE - 1)
X {
X new &= ~(BLKSIZE - 1);
X if (plen > 0)
X {
X new += plen - 1;
X }
X colno = BLKSIZE * 8; /* one heck of a big colno */
X }
X else if (plen > 0)
X {
X if (i >= plen)
X {
X new = (new & ~(BLKSIZE - 1)) + plen - 1;
X }
X colno = idx2col(new, ptext, FALSE);
X }
X else
X {
X new &= ~(BLKSIZE - 1);
X colno = 0;
X }
X }
X else
X {
X /* adjust the mark to get as close as possible to column# */
X for (i = 0, text = ptext; i <= colno && *text; text++)
X {
X if (*text == '\t' && !*o_list)
X {
X i += *o_tabstop - (i % *o_tabstop);
X }
X else if (UCHAR(*text) < ' ' || *text == 127)
X {
X i += 2;
X }
X#ifndef NO_CHARATTR
X else if (*o_charattr && text[0] == '\\' && text[1] == 'f' && text[2])
X {
X text += 2; /* plus one more in "for()" stmt */
X }
X#endif
X else
X {
X i++;
X }
X }
X if (text > ptext)
X {
X text--;
X }
X new = (new & ~(BLKSIZE - 1)) + (int)(text - ptext);
X }
X
X return new;
X}
X
X
X#ifdef DEBUG
Xwatch()
X{
X static wasset;
X
X if (*origname)
X {
X wasset = TRUE;
X }
X else if (wasset)
X {
X msg("origname was clobbered");
X endwin();
X abort();
X }
X
X if (nlines == 0)
X {
X msg("nlines=0");
X endwin();
X abort();
X }
X}
X#endif
eof
if test `wc -c <vi.c` -ne 20322
then
echo vi.c damaged!
fi
fi
if test -f vi.h -a "$1" != -f
then
echo Will not overwrite vi.h
else
echo Extracting vi.h
sed 's/^X//' >vi.h <<\eof
X/* vi.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 my version of vi. */
X
X#define VERSION "ELVIS 1.4, by Steve Kirkendall"
X#define COPYING "This version of ELVIS is freely redistributable."
X
X#include <errno.h>
Xextern int errno;
X#if TOS
X#define ENOENT (-AEFILNF)
X#endif
X
X#if TOS
X# include <types.h>
X# define O_RDONLY 0
X# define O_WRONLY 1
X# define O_RDWR 2
X#else
X# if OSK
X# include <modes.h>
X# define O_RDONLY S_IREAD
X# define O_WRONLY S_IWRITE
X# define O_RDWR (S_IREAD | S_IWRITE)
X# define ENOENT E_PNNF
X# else
X# include <sys/types.h>
X# if COHERENT
X# include <sys/fcntl.h>
X# else
X# include <fcntl.h>
X# endif
X# endif
X#endif
X
X#ifndef O_BINARY
X# define O_BINARY 0
X#endif
X
X#include "curses.h"
X
X/*------------------------------------------------------------------------*/
X/* Miscellaneous constants. */
X
X#define INFINITY 2000000001L /* a very large integer */
X#define LONGKEY 10 /* longest possible raw :map key */
X#ifndef MAXRCLEN
X# define MAXRCLEN 1000 /* longest possible .exrc file */
X#endif
X
X/*------------------------------------------------------------------------*/
X/* These describe how temporary files are divided into blocks */
X
X#define BLKSIZE 1024 /* size of blocks */
X#define MAXBLKS (BLKSIZE / sizeof(unsigned short))
Xtypedef union
X{
X char c[BLKSIZE]; /* for text blocks */
X unsigned short n[MAXBLKS]; /* for the header block */
X}
X BLK;
X
X/*------------------------------------------------------------------------*/
X/* These are used manipulate BLK buffers. */
X
Xextern BLK hdr; /* buffer for the header block */
Xextern BLK *blkget(); /* given index into hdr.c[], reads block */
Xextern BLK *blkadd(); /* inserts a new block into hdr.c[] */
X
X/*------------------------------------------------------------------------*/
X/* These are used to keep track of various flags */
Xextern struct _viflags
X{
X short file; /* file flags */
X}
X viflags;
X
X/* file flags */
X#define NEWFILE 0x0001 /* the file was just created */
X#define READONLY 0x0002 /* the file is read-only */
X#define HADNUL 0x0004 /* the file contained NUL characters */
X#define MODIFIED 0x0008 /* the file has been modified */
X#define NOFILE 0x0010 /* no name is known for the current text */
X#define ADDEDNL 0x0020 /* newlines were added to the file */
X
X/* macros used to set/clear/test flags */
X#define setflag(x,y) viflags.x |= y
X#define clrflag(x,y) viflags.x &= ~y
X#define tstflag(x,y) (viflags.x & y)
X#define initflags() viflags.file = 0;
X
X/* The options */
Xextern char o_autoindent[1];
Xextern char o_autoprint[1];
Xextern char o_autowrite[1];
X#ifndef NO_ERRLIST
Xextern char o_cc[30];
X#endif
X#ifndef NO_CHARATTR
Xextern char o_charattr[1];
X#endif
Xextern char o_columns[3];
Xextern char o_digraph[1];
Xextern char o_directory[30];
Xextern char o_edcompatible[1];
Xextern char o_errorbells[1];
Xextern char o_exrefresh[1];
X#ifndef NO_DIGRAPH
Xextern char o_flipcase[80];
X#endif
X#ifndef NO_SENTENCE
Xextern char o_hideformat[1];
X#endif
Xextern char o_ignorecase[1];
X#ifndef NO_EXTENSIONS
Xextern char o_inputmode[1];
X#endif
Xextern char o_keytime[3];
Xextern char o_keywordprg[80];
Xextern char o_lines[3];
Xextern char o_list[1];
X#ifndef NO_MAGIC
Xextern char o_magic[1];
X#endif
X#ifndef NO_ERRLIST
Xextern char o_make[30];
X#endif
X#ifndef NO_MODELINE
Xextern char o_modeline[1];
X#endif
X#ifndef NO_SENTENCE
Xextern char o_paragraphs[30];
X#endif
X#if MSDOS
Xextern char o_pcbios[1];
X#endif
Xextern char o_readonly[1];
Xextern char o_report[3];
Xextern char o_scroll[3];
X#ifndef NO_SENTENCE
Xextern char o_sections[30];
X#endif
Xextern char o_shell[60];
X#ifndef NO_SHOWMATCH
Xextern char o_showmatch[1];
X#endif
X#ifndef NO_SHOWMODE
Xextern char o_smd[1];
X#endif
Xextern char o_shiftwidth[3];
Xextern char o_sidescroll[3];
Xextern char o_sync[1];
Xextern char o_tabstop[3];
Xextern char o_term[30];
Xextern char o_vbell[1];
Xextern char o_warn[1];
Xextern char o_wrapmargin[3];
Xextern char o_wrapscan[1];
X
X/*------------------------------------------------------------------------*/
X/* These help support the single-line multi-change "undo" -- shift-U */
X
Xextern char U_text[BLKSIZE];
Xextern long U_line;
X
X/*------------------------------------------------------------------------*/
X/* These are used to refer to places in the text */
X
Xtypedef long MARK;
X#define markline(x) (long)((x) / BLKSIZE)
X#define markidx(x) (int)((x) & (BLKSIZE - 1))
X#define MARK_UNSET ((MARK)0)
X#define MARK_FIRST ((MARK)BLKSIZE)
X#define MARK_LAST ((MARK)(nlines * BLKSIZE))
X#define MARK_AT_LINE(x) ((MARK)((x) * BLKSIZE))
X
X#define NMARKS 29
Xextern MARK mark[NMARKS]; /* marks a-z, plus mark ' and two temps */
Xextern MARK cursor; /* mark where line is */
X
X/*------------------------------------------------------------------------*/
X/* These are used to keep track of the current & previous files. */
X
Xextern long origtime; /* modification date&time of the current file */
Xextern char origname[256]; /* name of the current file */
Xextern char prevorig[256]; /* name of the preceding file */
Xextern long prevline; /* line number from preceding file */
X
X/*------------------------------------------------------------------------*/
X/* misc housekeeping variables & functions */
X
Xextern int tmpfd; /* fd used to access the tmp file */
Xextern long lnum[MAXBLKS]; /* last line# of each block */
Xextern long nlines; /* number of lines in the file */
Xextern char args[BLKSIZE]; /* file names given on the command line */
Xextern int argno; /* the current element of args[] */
Xextern int nargs; /* number of filenames in args */
Xextern long changes; /* counts changes, to prohibit short-cuts */
Xextern int significant; /* boolean: was a *REAL* change made? */
Xextern int mustredraw; /* boolean: force total redraw of screen? */
Xextern BLK tmpblk; /* a block used to accumulate changes */
Xextern long topline; /* file line number of top line */
Xextern int leftcol; /* column number of left col */
X#define botline (topline + LINES - 2)
X#define rightcol (leftcol + COLS - 1)
Xextern int physcol; /* physical column number that cursor is on */
Xextern int physrow; /* physical row number that cursor is on */
Xextern int exwrote; /* used to detect verbose ex commands */
Xextern int doingdot; /* boolean: are we doing the "." command? */
Xextern int doingglobal; /* boolean: are doing a ":g" command? */
Xextern long rptlines; /* number of lines affected by a command */
Xextern char *rptlabel; /* description of how lines were affected */
Xextern char *fetchline(); /* read a given line from tmp file */
Xextern char *parseptrn(); /* isolate a regexp in a line */
Xextern MARK paste(); /* paste from cut buffer to a given point */
Xextern char *wildcard(); /* expand wildcards in filenames */
Xextern MARK input(); /* inserts characters from keyboard */
Xextern char *linespec(); /* finds the end of a /regexp/ string */
X#define ctrl(ch) ((ch)&037)
X#ifndef NO_RECYCLE
Xextern long allocate(); /* allocate a free block of the tmp file */
X#endif
Xextern int trapint(); /* trap handler for SIGINT */
Xextern void blkdirty(); /* marks a block as being "dirty" */
Xextern void blkflush(); /* writes a single dirty block to the disk */
Xextern void blksync(); /* forces all "dirty" blocks to disk */
Xextern void blkinit(); /* resets the block cache to "empty" state */
Xextern void beep(); /* rings the terminal's bell */
Xextern void exrefresh(); /* writes text to the screen */
Xextern void msg(); /* writes a printf-style message to the screen */
Xextern void reset_msg(); /* resets the "manymsgs" flag */
Xextern void endmsgs(); /* if "manymsgs" is set, then scroll up 1 line */
Xextern void garbage(); /* reclaims any garbage blocks */
Xextern void redraw(); /* updates the screen after a change */
Xextern void resume_curses();/* puts the terminal in "cbreak" mode */
Xextern void beforedo(); /* saves current revision before a new change */
Xextern void afterdo(); /* marks end of a beforedo() change */
Xextern void abortdo(); /* like "afterdo()" followed by "undo()" */
Xextern int undo(); /* restores file to previous undo() */
Xextern void dumpkey(); /* lists key mappings to the screen */
Xextern void mapkey(); /* defines a new key mapping */
Xextern void savekeys(); /* lists key mappings to a file */
Xextern void redrawrange(); /* records clues from modify.c */
Xextern void cut(); /* saves text in a cut buffer */
Xextern void delete(); /* deletes text */
Xextern void add(); /* adds text */
Xextern void change(); /* deletes text, and then adds other text */
Xextern void cutswitch(); /* updates cut buffers when we switch files */
Xextern void do_abbr(); /* defines or lists abbreviations */
Xextern void do_digraph(); /* defines or lists digraphs */
Xextern void exstring(); /* execute a string as EX commands */
Xextern void dumpopts();
Xextern void setopts();
Xextern void saveopts();
X#ifndef NO_DIGRAPH
Xextern void savedigs();
X#endif
X#ifndef NO_ABBR
Xextern void saveabbr();
X#endif
Xextern void cutname();
Xextern void cutname();
Xextern void initopts();
Xextern void cutend();
X
X/*------------------------------------------------------------------------*/
X/* macros that are used as control structures */
X
X#define BeforeAfter(before, after) for((before),bavar=1;bavar;(after),bavar=0)
X#define ChangeText BeforeAfter(beforedo(FALSE),afterdo())
X
Xextern int bavar; /* used only in BeforeAfter macros */
X
X/*------------------------------------------------------------------------*/
X/* These are the movement commands. Each accepts a mark for the starting */
X/* location & number and returns a mark for the destination. */
X
Xextern MARK m_updnto(); /* k j G */
Xextern MARK m_right(); /* h */
Xextern MARK m_left(); /* l */
Xextern MARK m_tocol(); /* | */
Xextern MARK m_front(); /* ^ */
Xextern MARK m_rear(); /* $ */
Xextern MARK m_fword(); /* w */
Xextern MARK m_bword(); /* b */
Xextern MARK m_eword(); /* e */
Xextern MARK m_fWord(); /* W */
Xextern MARK m_bWord(); /* B */
Xextern MARK m_eWord(); /* E */
Xextern MARK m_fparagraph(); /* } */
Xextern MARK m_bparagraph(); /* { */
Xextern MARK m_fsection(); /* ]] */
Xextern MARK m_bsection(); /* [[ */
Xextern MARK m_match(); /* % */
X#ifndef NO_SENTENCE
X extern MARK m_fsentence(); /* ) */
X extern MARK m_bsentence(); /* ( */
X#endif
Xextern MARK m_tomark(); /* 'm */
Xextern MARK m_nsrch(); /* n */
Xextern MARK m_Nsrch(); /* N */
Xextern MARK m_fsrch(); /* /regexp */
Xextern MARK m_bsrch(); /* ?regexp */
X#ifndef NO_CHARSEARCH
X extern MARK m__ch(); /* ; , */
X extern MARK m_fch(); /* f */
X extern MARK m_tch(); /* t */
X extern MARK m_Fch(); /* F */
X extern MARK m_Tch(); /* T */
X#endif
Xextern MARK m_row(); /* H L M */
Xextern MARK m_z(); /* z */
Xextern MARK m_scroll(); /* ^B ^F ^E ^Y ^U ^D */
X
X/* Some stuff that is used by movement functions... */
X
Xextern MARK adjmove(); /* a helper fn, used by move fns */
X
X/* This macro is used to set the default value of cnt */
X#define DEFAULT(val) if (cnt < 1) cnt = (val)
X
X/* These are used to minimize calls to fetchline() */
Xextern int plen; /* length of the line */
Xextern long pline; /* line number that len refers to */
Xextern long pchgs; /* "changes" level that len refers to */
Xextern char *ptext; /* text of previous line, if valid */
Xextern void pfetch();
Xextern char digraph();
X
X/* This is used to build a MARK that corresponds to a specific point in the
X * line that was most recently pfetch'ed.
X */
X#define buildmark(text) (MARK)(BLKSIZE * pline + (int)((text) - ptext))
X
X
X/*------------------------------------------------------------------------*/
X/* These are used to handle EX commands. */
X
X#define CMD_NULL 0 /* NOT A VALID COMMAND */
X#define CMD_ABBR 1 /* "define an abbreviation" */
X#define CMD_ARGS 2 /* "show me the args" */
X#define CMD_APPEND 3 /* "insert lines after this line" */
X#define CMD_AT 4 /* "execute a cut buffer's contents via EX" */
X#define CMD_BANG 5 /* "run a single shell command" */
X#define CMD_CC 6 /* "run `cc` and then do CMD_ERRLIST" */
X#define CMD_CD 7 /* "change directories" */
X#define CMD_CHANGE 8 /* "change some lines" */
X#define CMD_COPY 9 /* "copy the selected text to a given place" */
X#define CMD_DELETE 10 /* "delete the selected text" */
X#define CMD_DIGRAPH 11 /* "add a digraph, or display them all" */
X#define CMD_EDIT 12 /* "switch to a different file" */
X#define CMD_EQUAL 13 /* "display a line number" */
X#define CMD_ERRLIST 14 /* "locate the next error in a list" */
X#define CMD_FILE 15 /* "show the file's status" */
X#define CMD_GLOBAL 16 /* "globally search & do a command" */
X#define CMD_INSERT 17 /* "insert lines before the current line" */
X#define CMD_JOIN 18 /* "join the selected line & the one after" */
X#define CMD_LIST 19 /* "print lines, making control chars visible" */
X#define CMD_MAKE 20 /* "run `make` and then do CMD_ERRLIST" */
X#define CMD_MAP 21 /* "adjust the keyboard map" */
X#define CMD_MARK 22 /* "mark this line" */
X#define CMD_MKEXRC 23 /* "make a .exrc file" */
X#define CMD_MOVE 24 /* "move the selected text to a given place" */
X#define CMD_NEXT 25 /* "switch to next file in args" */
X#define CMD_NUMBER 26 /* "print lines from the file w/ line numbers" */
X#define CMD_PRESERVE 27 /* "act as though vi crashed" */
X#define CMD_PREVIOUS 28 /* "switch to the previous file in args" */
X#define CMD_PRINT 29 /* "print the selected text" */
X#define CMD_PUT 30 /* "insert any cut lines before this line" */
X#define CMD_QUIT 31 /* "quit without writing the file" */
X#define CMD_READ 32 /* "append the given file after this line */
X#define CMD_RECOVER 33 /* "recover file after vi crashes" - USE -r FLAG */
X#define CMD_REWIND 34 /* "rewind to first file" */
X#define CMD_SET 35 /* "set a variable's value" */
X#define CMD_SHELL 36 /* "run some lines through a command" */
X#define CMD_SHIFTL 37 /* "shift lines left" */
X#define CMD_SHIFTR 38 /* "shift lines right" */
X#define CMD_SOURCE 39 /* "interpret a file's contents as ex commands" */
X#define CMD_STOP 40 /* same as CMD_SUSPEND */
X#define CMD_SUBAGAIN 41 /* "repeat the previous substitution" */
X#define CMD_SUBSTITUTE 42 /* "substitute text in this line" */
X#define CMD_SUSPEND 43 /* "suspend the vi session" */
X#define CMD_TR 44 /* "transliterate chars in the selected lines" */
X#define CMD_TAG 45 /* "go to a particular tag" */
X#define CMD_UNABBR 46 /* "remove an abbreviation definition" */
X#define CMD_UNDO 47 /* "undo the previous command" */
X#define CMD_UNMAP 48 /* "remove a key sequence map */
X#define CMD_VERSION 49 /* "describe which version this is" */
X#define CMD_VGLOBAL 50 /* "apply a cmd to lines NOT containing an RE" */
X#define CMD_VISUAL 51 /* "go into visual mode" */
X#define CMD_WQUIT 52 /* "write this file out (any case) & quit" */
X#define CMD_WRITE 53 /* "write the selected(?) text to a given file" */
X#define CMD_XIT 54 /* "write this file out (if modified) & quit" */
X#define CMD_YANK 55 /* "copy the selected text into the cut buffer" */
X#ifdef DEBUG
X# define CMD_DEBUG 56 /* access to internal data structures */
X# define CMD_VALIDATE 57 /* check for internal consistency */
X#endif
Xtypedef int CMD;
X
Xextern void ex();
Xextern void vi();
Xextern void doexcmd();
X
X#ifndef NO_ABBR
Xextern void cmd_abbr();
X#endif
Xextern void cmd_append();
Xextern void cmd_args();
X#ifndef NO_AT
Xextern void cmd_at();
X#endif
Xextern void cmd_cd();
Xextern void cmd_delete();
X#ifndef NO_DIGRAPH
Xextern void cmd_digraph();
X#endif
Xextern void cmd_edit();
X#ifndef NO_ERRLIST
Xextern void cmd_errlist();
X#endif
Xextern void cmd_file();
Xextern void cmd_global();
Xextern void cmd_join();
Xextern void cmd_mark();
X#ifndef NO_ERRLIST
Xextern void cmd_make();
X#endif
Xextern void cmd_map();
X#ifndef NO_MKEXRC
Xextern void cmd_mkexrc();
X#endif
Xextern void cmd_next();
Xextern void cmd_print();
Xextern void cmd_put();
Xextern void cmd_read();
Xextern void cmd_set();
Xextern void cmd_shell();
Xextern void cmd_shift();
Xextern void cmd_source();
Xextern void cmd_substitute();
Xextern void cmd_tag();
Xextern void cmd_undo();
Xextern void cmd_version();
Xextern void cmd_visual();
Xextern void cmd_write();
Xextern void cmd_xit();
Xextern void cmd_move();
X#ifdef DEBUG
Xextern void cmd_debug();
Xextern void cmd_validate();
X#endif
X
X/*----------------------------------------------------------------------*/
X/* These are used to handle VI commands */
X
Xextern MARK v_1ex(); /* : */
Xextern MARK v_mark(); /* m */
Xextern MARK v_quit(); /* Q */
Xextern MARK v_redraw(); /* ^L ^R */
Xextern MARK v_ulcase(); /* ~ */
Xextern MARK v_undo(); /* u */
Xextern MARK v_xchar(); /* x */
Xextern MARK v_Xchar(); /* X */
Xextern MARK v_replace(); /* r */
Xextern MARK v_overtype(); /* R */
Xextern MARK v_selcut(); /* " */
Xextern MARK v_paste(); /* p P */
Xextern MARK v_yank(); /* y Y */
Xextern MARK v_delete(); /* d D */
Xextern MARK v_join(); /* J */
Xextern MARK v_insert(); /* a A i I o O */
Xextern MARK v_change(); /* c C */
Xextern MARK v_subst(); /* s */
Xextern MARK v_lshift(); /* < */
Xextern MARK v_rshift(); /* > */
Xextern MARK v_filter(); /* ! */
Xextern MARK v_status(); /* ^G */
Xextern MARK v_switch(); /* ^^ */
Xextern MARK v_tag(); /* ^] */
Xextern MARK v_xit(); /* ZZ */
Xextern MARK v_undoline(); /* U */
Xextern MARK v_again(); /* & */
X#ifndef NO_EXTENSIONS
X extern MARK v_keyword(); /* ^K */
X extern MARK v_increment(); /* * */
X#endif
X#ifndef NO_ERRLIST
X extern MARK v_errlist(); /* * */
X#endif
X#ifndef NO_AT
X extern MARK v_at(); /* @ */
X#endif
X
X/*----------------------------------------------------------------------*/
X/* These describe what mode we're in */
X
X#define MODE_EX 1 /* executing ex commands */
X#define MODE_VI 2 /* executing vi commands */
X#define MODE_COLON 3 /* executing an ex command from vi mode */
X#define MODE_QUIT 4
Xextern int mode;
X
X#define WHEN_VICMD 1 /* getkey: we're reading a VI command */
X#define WHEN_VIINP 2 /* getkey: we're in VI's INPUT mode */
X#define WHEN_VIREP 4 /* getkey: we're in VI's REPLACE mode */
X#define WHEN_EX 8 /* getkey: we're in EX mode */
X#define WHEN_MSG 16 /* getkey: we're at a "more" prompt */
X#define WHEN_INMV 256 /* in input mode, interpret the key in VICMD mode */
eof
if test `wc -c <vi.h` -ne 18110
then
echo vi.h damaged!
fi
fi
if test -f refont.c -a "$1" != -f
then
echo Will not overwrite refont.c
else
echo Extracting refont.c
sed 's/^X//' >refont.c <<\eof
X/* refont.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 complete source code for the refont program */
X
X/* The refont program converts font designations to the format of your choice.
X * Known font formats are:
X * -b overtype notation, using backspaces
X * -c overtype notation, using carriage returns
X * -d the "dot" command notation used by nroff (doesn't work well)
X * -e Epson-compatible line printer codes
X * -f the "\f" notation
X * -x none (strip out the font codes)
X *
X * Other flags are:
X * -I recognize \f and dot notations in input
X * -F output a formfeed character between files
X */
X
X#include <stdio.h>
X#include "config.h"
X
X/* the program name, for diagnostics */
Xchar *progname;
X
X/* remembers which output format to use */
Xint outfmt = 'f';
X
X/* do we allow "dot" and "backslash-f" on input? */
Xint infmt = 0;
X
X/* do we insert formfeeds between input files? */
Xint add_form_feed = 0;
X
Xmain(argc, argv)
X int argc; /* number of command-line args */
X char **argv; /* values of the command line args */
X{
X FILE *fp;
X int i, j;
X int retcode;
X
X progname = argv[0];
X
X /* parse the flags */
X i = 1;
X if (i < argc && argv[i][0] == '-' && argv[i][1])
X {
X for (j = 1; argv[i][j]; j++)
X {
X switch (argv[i][j])
X {
X case 'b':
X#if !OSK
X case 'c':
X#endif
X case 'd':
X case 'e':
X case 'f':
X case 'x':
X outfmt = argv[i][j];
X break;
X
X case 'I':
X infmt = 'I';
X break;
X
X case 'F':
X add_form_feed = 1;
X break;
X
X default:
X usage();
X }
X }
X i++;
X }
X
X retcode = 0;
X if (i == argc)
X {
X /* probably shouldn't read from keyboard */
X if (isatty(fileno(stdin)))
X {
X usage();
X }
X
X /* no files named, so use stdin */
X refont(stdin);
X }
X else
X {
X for (; i < argc; i++)
X {
X fp = fopen(argv[i], "r");
X if (!fp)
X {
X perror(argv[i]);
X retcode = 1;
X }
X else
X {
X refont(fp);
X if (i < argc - 1 && add_form_feed)
X {
X putchar('\f');
X }
X fclose(fp);
X }
X }
X }
X
X exit(retcode);
X}
X
Xusage()
X{
X fputs("usage: ", stderr);
X fputs(progname, stderr);
X fputs(" [-bcdefxFI] [filename]...\n", stderr);
X exit(2);
X}
X
X/* This function does the refont thing to a single file */
X/* I apologize for the length of this function. It is gross. */
Xrefont(fp)
X FILE *fp;
X{
X char textbuf[1025]; /* chars of a line of text */
X char fontbuf[1025]; /* fonts of chars in fontbuf */
X int col; /* where we are in the line */
X int font; /* remembered font */
X int more; /* more characters to be output? */
X int ch;
X
X /* reset some stuff */
X for (col = sizeof fontbuf; --col >= 0; )
X {
X fontbuf[col] = 'R';
X textbuf[col] = '\0';
X }
X col = 0;
X font = 'R';
X
X /* get the first char - quit if eof */
X while ((ch = getc(fp)) != EOF)
X {
X /* if "dot" command, read the rest of the command */
X if (infmt == 'I' && ch == '.' && col == 0)
X {
X
X textbuf[col++] = '.';
X textbuf[col++] = getc(fp);
X textbuf[col++] = getc(fp);
X textbuf[col++] = ch = getc(fp);
X
X /* is it a font line? */
X font = 0;
X if (textbuf[1] == 'u' && textbuf[2] == 'l')
X {
X font = 'U';
X }
X else if (textbuf[1] == 'b' && textbuf[2] == 'o')
X {
X font = 'B';
X }
X else if (textbuf[1] == 'i' && textbuf[2] == 't')
X {
X font = 'I';
X }
X
X /* if it is, discard the stuff so far but remember font */
X if (font)
X {
X while (col > 0)
X {
X textbuf[--col] = '\0';
X }
X }
X else /* some other format line - write it literally */
X {
X while (ch != '\n')
X {
X textbuf[col++] = ch = getc(fp);
X }
X fputs(textbuf, fp);
X while (col > 0)
X {
X textbuf[--col] = '\0';
X }
X }
X continue;
X }
X
X /* is it a "\f" formatted font? */
X if (infmt == 'I' && ch == '\\')
X {
X ch = getc(fp);
X if (ch == 'f')
X {
X font = getc(fp);
X }
X else
X {
X textbuf[col++] = '\\';
X textbuf[col++] = ch;
X }
X continue;
X }
X
X /* is it an Epson font? */
X if (ch == '\033')
X {
X ch = getc(fp);
X switch (ch)
X {
X case '4':
X font = 'I';
X break;
X
X case 'E':
X case 'G':
X font = 'B';
X break;
X
X case '5':
X case 'F':
X case 'H':
X font = 'R';
X break;
X
X case '-':
X font = (getc(fp) & 1) ? 'U' : 'R';
X break;
X }
X continue;
X }
X
X /* control characters? */
X if (ch == '\b')
X {
X if (col > 0)
X col--;
X continue;
X }
X else if (ch == '\t')
X {
X do
X {
X if (textbuf[col] == '\0')
X {
X textbuf[col] = ' ';
X }
X col++;
X } while (col & 7);
X continue;
X }
X#if !OSK
X else if (ch == '\r')
X {
X col = 0;
X continue;
X }
X#endif
X else if (ch == ' ')
X {
X if (textbuf[col] == '\0')
X {
X textbuf[col] = ' ';
X fontbuf[col] = font;
X col++;
X }
X continue;
X }
X
X /* newline? */
X if (ch == '\n')
X {
X more = 0;
X for (col = 0, font = 'R'; textbuf[col]; col++)
X {
X if (fontbuf[col] != font)
X {
X switch (outfmt)
X {
X case 'd':
X putchar('\n');
X switch (fontbuf[col])
X {
X case 'B':
X fputs(".bo\n", stdout);
X break;
X
X case 'I':
X fputs(".it\n", stdout);
X break;
X
X case 'U':
X fputs(".ul\n", stdout);
X break;
X }
X while (textbuf[col] == ' ')
X {
X col++;
X }
X break;
X
X case 'e':
X switch (fontbuf[col])
X {
X case 'B':
X fputs("\033E", stdout);
X break;
X
X case 'I':
X fputs("\0334", stdout);
X break;
X
X case 'U':
X fputs("\033-1", stdout);
X break;
X
X default:
X switch (font)
X {
X case 'B':
X fputs("\033F", stdout);
X break;
X
X case 'I':
X fputs("\0335", stdout);
X break;
X
X case 'U':
X fputs("\033-0", stdout);
X break;
X }
X }
X break;
X
X case 'f':
X putchar('\\');
X putchar('f');
X putchar(fontbuf[col]);
X break;
X }
X
X font = fontbuf[col];
X }
X
X if (fontbuf[col] != 'R' && textbuf[col] != ' ')
X {
X switch (outfmt)
X {
X case 'b':
X if (fontbuf[col] == 'B')
X {
X putchar(textbuf[col]);
X }
X else
X {
X putchar('_');
X }
X putchar('\b');
X break;
X#if !OSK
X case 'c':
X more = col + 1;
X break;
X#endif
X }
X }
X
X putchar(textbuf[col]);
X }
X
X#if !OSK
X /* another pass? */
X if (more > 0)
X {
X putchar('\r');
X for (col = 0; col < more; col++)
X {
X switch (fontbuf[col])
X {
X case 'I':
X case 'U':
X putchar('_');
X break;
X
X case 'B':
X putchar(textbuf[col]);
X break;
X
X default:
X putchar(' ');
X }
X }
X }
X#endif /* not OSK */
X
X /* newline */
X if (font != 'R')
X {
X switch (outfmt)
X {
X case 'f':
X putchar('\\');
X putchar('f');
X putchar('R');
X break;
X
X case 'e':
X switch (font)
X {
X case 'B':
X fputs("\033F", stdout);
X break;
X
X case 'I':
X fputs("\0335", stdout);
X break;
X
X case 'U':
X fputs("\033-0", stdout);
X break;
X }
X }
X }
X putchar('\n');
X
X /* reset some stuff */
X for (col = sizeof fontbuf; --col >= 0; )
X {
X fontbuf[col] = 'R';
X textbuf[col] = '\0';
X }
X col = 0;
X font = 'R';
X continue;
X }
X
X /* normal character */
X if (font != 'R')
X {
X textbuf[col] = ch;
X fontbuf[col] = font;
X }
X else if (textbuf[col] == '_')
X {
X textbuf[col] = ch;
X fontbuf[col] = 'U';
X }
X else if (textbuf[col] && textbuf[col] != ' ' && ch == '_')
X {
X fontbuf[col] = 'U';
X }
X else if (textbuf[col] == ch)
X {
X fontbuf[col] = 'B';
X }
X else
X {
X textbuf[col] = ch;
X }
X col++;
X }
X}
eof
if test `wc -c <refont.c` -ne 7638
then
echo refont.c damaged!
fi
fi
exit 0
-------------------------------------------------------------------------------
Steve Kirkendall kirkenda@cs.pdx.edu Grad student at Portland State U.
