Vile 17/17 - vi feel-alike (multi-window)
Paul Fox
pgf at cayman.COM
Sat Jun 8 08:10:29 AEST 1991
#!/bin/sh
# this is vileshar.17 (part 17 of Vile)
# do not concatenate these parts, unpack them in order with /bin/sh
# file window.c continued
#
if test ! -r _shar_seq_.tmp; then
echo 'Please unpack part 1 first!'
exit 1
fi
(read Scheck
if test "$Scheck" != 17; then
echo Please unpack part "$Scheck" next!
exit 1
else
exit 0
fi
) < _shar_seq_.tmp || exit 1
echo 'x - continuing file window.c'
sed 's/^X//' << 'SHAR_EOF' >> 'window.c' &&
X * all the hard work. You don't just set "force reframe" because dot would
X * move.
X */
enlargewind(f, n)
{
X register WINDOW *adjwp;
X register LINE *lp;
X register int i;
X
X if (n < 0)
X return (shrinkwind(f, -n));
X if (wheadp->w_wndp == NULL) {
X mlwrite("Only one window");
X return (FALSE);
X }
X if ((adjwp=curwp->w_wndp) == NULL) {
X adjwp = wheadp;
X while (adjwp->w_wndp != curwp)
X adjwp = adjwp->w_wndp;
X }
X if (adjwp->w_ntrows <= n) {
X mlwrite("Impossible change");
X return (FALSE);
X }
X if (curwp->w_wndp == adjwp) { /* Shrink below. */
X lp = adjwp->w_linep;
X for (i=0; i<n && lp!=adjwp->w_bufp->b_linep; ++i)
X lp = lforw(lp);
X adjwp->w_linep = lp;
X adjwp->w_toprow += n;
X } else { /* Shrink above. */
X lp = curwp->w_linep;
X for (i=0; i<n && lback(lp)!=curbp->b_linep; ++i)
X lp = lback(lp);
X curwp->w_linep = lp;
X curwp->w_toprow -= n;
X }
X curwp->w_ntrows += n;
X adjwp->w_ntrows -= n;
X curwp->w_flag |= WFMODE|WFHARD|WFINS;
X adjwp->w_flag |= WFMODE|WFHARD|WFKILLS;
X return (TRUE);
}
X
/*
X * Shrink the current window. Find the window that gains space. Hack at the
X * window descriptions. Ask the redisplay to do all the hard work.
X */
shrinkwind(f, n)
{
X register WINDOW *adjwp;
X register LINE *lp;
X register int i;
X
X if (n < 0)
X return (enlargewind(f, -n));
X if (wheadp->w_wndp == NULL) {
X mlwrite("Only one window");
X return (FALSE);
X }
X if ((adjwp=curwp->w_wndp) == NULL) {
X adjwp = wheadp;
X while (adjwp->w_wndp != curwp)
X adjwp = adjwp->w_wndp;
X }
X if (curwp->w_ntrows <= n) {
X mlwrite("Impossible change");
X return (FALSE);
X }
X if (curwp->w_wndp == adjwp) { /* Grow below. */
X lp = adjwp->w_linep;
X for (i=0; i<n && lback(lp)!=adjwp->w_bufp->b_linep; ++i)
X lp = lback(lp);
X adjwp->w_linep = lp;
X adjwp->w_toprow -= n;
X } else { /* Grow above. */
X lp = curwp->w_linep;
X for (i=0; i<n && lp!=curbp->b_linep; ++i)
X lp = lforw(lp);
X curwp->w_linep = lp;
X curwp->w_toprow += n;
X }
X curwp->w_ntrows -= n;
X adjwp->w_ntrows += n;
X curwp->w_flag |= WFMODE|WFHARD|WFKILLS;
X adjwp->w_flag |= WFMODE|WFHARD|WFINS;
X return (TRUE);
}
X
#if !SMALLER
X
/* Resize the current window to the requested size */
resize(f, n)
int f, n; /* default flag and numeric argument */
{
X int clines; /* current # of lines in window */
X
X /* must have a non-default argument, else ignore call */
X if (f == FALSE)
X return(TRUE);
X
X /* find out what to do */
X clines = curwp->w_ntrows;
X
X /* already the right size? */
X if (clines == n)
X return(TRUE);
X
X return(enlargewind(TRUE, n - clines));
}
#endif
X
/*
X * Pick a window for a pop-up. Split the screen if there is only one window.
X * Pick the uppermost window that isn't the current window. An LRU algorithm
X * might be better. Return a pointer, or NULL on error.
X */
WINDOW *
wpopup()
{
X register WINDOW *wp;
X
X if (wheadp->w_wndp == NULL /* Only 1 window */
X && splitwind(FALSE, 0) == FALSE) /* and it won't split */
X return (NULL);
X wp = wheadp; /* Find window to use */
X while (wp!=NULL && wp==curwp)
X wp = wp->w_wndp;
X return (wp);
}
X
scrnextup(f, n) /* scroll the next window up (back) a page */
{
X nextwind(FALSE, 1);
X backhpage(f, n);
X prevwind(FALSE, 1);
}
X
scrnextdw(f, n) /* scroll the next window down (forward) a page */
{
X nextwind(FALSE, 1);
X forwhpage(f, n);
X prevwind(FALSE, 1);
}
X
#if ! SMALLER
savewnd(f, n) /* save ptr to current window */
{
X swindow = curwp;
X return(TRUE);
}
X
restwnd(f, n) /* restore the saved screen */
{
X register WINDOW *wp;
X
X /* find the window */
X wp = wheadp;
X while (wp != NULL) {
X if (wp == swindow) {
X curwp = wp;
X make_current(curwp->w_bufp);
X upmode();
X return (TRUE);
X }
X wp = wp->w_wndp;
X }
X
X mlwrite("[No such window exists]");
X return(FALSE);
}
#endif
X
newlength(f,n) /* resize the screen, re-writing the screen */
int n; /* numeric argument */
{
X WINDOW *wp; /* current window being examined */
X WINDOW *nextwp; /* next window to scan */
X WINDOW *lastwp; /* last window scanned */
X int lastline; /* screen line of last line of current window */
X
X if (!f) {
X mlwrite("No length given");
X return FALSE;
X }
X
X /* make sure it's in range */
X if (n < 3 || n > term.t_mrow + 1) {
X mlwrite("Screen size out of range");
X return(FALSE);
X }
X
X if (term.t_nrow == n - 1)
X return(TRUE);
X else if (term.t_nrow < n - 1) {
X
X /* go to the last window */
X wp = wheadp;
X while (wp->w_wndp != NULL)
X wp = wp->w_wndp;
X
X /* and enlarge it as needed */
X wp->w_ntrows = n - wp->w_toprow - 2;
X wp->w_flag |= WFHARD|WFMODE;
X
X } else {
X
X /* rebuild the window structure */
X nextwp = wheadp;
X wp = NULL;
X lastwp = NULL;
X while (nextwp != NULL) {
X wp = nextwp;
X nextwp = wp->w_wndp;
X
X /* get rid of it if it is too low */
X if (wp->w_toprow > n - 2) {
X
X if (--wp->w_bufp->b_nwnd == 0) {
X undispbuff(wp->w_bufp,wp);
X }
X
X /* update curwp and lastwp if needed */
X if (wp == curwp)
X curwp = wheadp;
X make_current(curwp->w_bufp);
X if (lastwp != NULL)
X lastwp->w_wndp = NULL;
X
X /* free the structure */
X free((char *)wp);
X wp = NULL;
X
X } else {
X /* need to change this window size? */
X lastline = wp->w_toprow + wp->w_ntrows - 1;
X if (lastline >= n - 2) {
X wp->w_ntrows = n - wp->w_toprow - 2;
X wp->w_flag |= WFHARD|WFMODE;
X }
X }
X
X lastwp = wp;
X }
X }
X
X /* screen is garbage */
X term.t_nrow = n - 1;
X sgarbf = TRUE;
X return(TRUE);
}
X
newwidth(f,n) /* resize the screen, re-writing the screen */
int n; /* numeric argument */
{
X register WINDOW *wp;
X
X if (!f) {
X mlwrite("No width given");
X return FALSE;
X }
X
X /* make sure it's in range */
X if (n < 10 || n > term.t_mcol) {
#if NeWS /* serious error for NeWS, halt */
X fprintf(stderr, "Screen width out of range\n") ;
X newsclose() ;
X exit(1) ;
#else
X mlwrite("Screen width out of range");
X return(FALSE);
#endif
X }
X
X /* otherwise, just re-width it (no big deal) */
X term.t_ncol = n;
X term.t_margin = n / 10;
X term.t_scrsiz = n - (term.t_margin * 2);
X
X /* force all windows to redraw */
X wp = wheadp;
X while (wp) {
X wp->w_flag |= WFHARD | WFMOVE | WFMODE;
X wp = wp->w_wndp;
X }
X sgarbf = TRUE;
X
X return(TRUE);
}
X
#if ! SMALLER
int getwpos() /* get screen offset of current line in current window */
{
X register int sline; /* screen line from top of window */
X register LINE *lp; /* scannile line pointer */
X
X /* search down the line we want */
X lp = curwp->w_linep;
X sline = 1;
X while (lp != curwp->w_dotp) {
X ++sline;
X lp = lforw(lp);
X }
X
X /* and return the value */
X return(sline);
}
#endif
X
/*
X * Initialize all of the windows.
X */
winit()
{
X register WINDOW *wp;
X
X wp = (WINDOW *) malloc(sizeof(WINDOW)); /* First window */
X if (wp==NULL )
X exit(1);
X wheadp = wp;
X curwp = wp;
X wp->w_wndp = NULL; /* Initialize window */
X wp->w_doto = 0;
X wp->w_mkp = NULL;
X wp->w_mko = 0;
X wp->w_ldmkp = NULL;
X wp->w_ldmko = 0;
X wp->w_toprow = 0;
X wp->w_sideways = 0;
#if COLOR
X /* initalize colors to global defaults */
X wp->w_fcolor = gfcolor;
X wp->w_bcolor = gbcolor;
#endif
X wp->w_ntrows = term.t_nrow-1; /* "-1" for mode line. */
X wp->w_force = 0;
X wp->w_flag = WFMODE|WFHARD; /* Full. */
}
X
X
SHAR_EOF
echo 'File window.c is complete' &&
chmod 0444 window.c ||
echo 'restore of window.c failed'
Wc_c="`wc -c < 'window.c'`"
test 20419 -eq "$Wc_c" ||
echo 'window.c: original size 20419, current size' "$Wc_c"
# ============= word.c ==============
echo 'x - extracting word.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'word.c' &&
/*
X * The routines in this file implement commands that work word or a
X * paragraph at a time. There are all sorts of word mode commands. If I
X * do any sentence mode commands, they are likely to be put in this file.
X */
X
#include <stdio.h>
#include "estruct.h"
#include "edef.h"
X
/* Word wrap on n-spaces. Back-over whatever precedes the point on the current
X * line and stop on the first word-break or the beginning of the line. If we
X * reach the beginning of the line, jump back to the end of the word and start
X * a new line. Otherwise, break the line at the word-break, eat it, and jump
X * back to the end of the word.
X * Returns TRUE on success, FALSE on errors.
X */
wrapword()
{
X register int cnt; /* size of word wrapped to next line */
X register int c; /* charector temporary */
X
X /* backup from the <NL> 1 char */
X if (!backchar(0, 1))
X return(FALSE);
X
X /* back up until we aren't in a word,
X make sure there is a break in the line */
X cnt = 0;
X while (c = lgetc(curwp->w_dotp, curwp->w_doto), !isspace(c)) {
X cnt++;
X if (!backchar(0, 1))
X return(FALSE);
X /* if we make it to the beginning, start a new line */
X if (curwp->w_doto == 0) {
X gotoeol(FALSE, 0);
X return(lnewline());
X }
X }
X
X /* delete the forward white space */
X if (!ldelete(1L, FALSE))
X return(FALSE);
X
X /* put in a end of line */
X if (!newline(TRUE,1))
X return FALSE;
X
X /* and past the first word */
X while (cnt-- > 0) {
X if (forwchar(FALSE, 1) == FALSE)
X return(FALSE);
X }
X return(TRUE);
}
X
X
/*
X * Move the cursor forward by the specified number of words. All of the motion
X * is done by "forwchar". Error if you try and move beyond the buffer's end.
X *
X * Returns of SORTOFTRUE result if we're doing a non-delete operation.
X * Whitespace after a word is always included on deletes (and non-operations,
X * of course), but only on intermediate words for other operations, for
X * example. The last word of non-delete ops does _not_ include its whitespace.
X */
X
forwviword(f, n)
{
X int s;
X
X if (n < 0)
X return (backword(f, -n));
X setchartype();
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X while (n--) {
X while (((s = isnewviwordf()) == FALSE) ||
X (s == SORTOFTRUE && n != 0)) {
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X }
X return TRUE;
}
X
/*
X * Move the cursor forward by the specified number of words. All of the motion
X * is done by "forwchar". Error if you try and move beyond the buffer's end.
X */
forwword(f, n)
{
X int s;
X
X if (n < 0)
X return (backword(f, -n));
X setchartype();
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X while (n--) {
X while (((s = isnewwordf()) == FALSE) ||
X (s == SORTOFTRUE && n != 0)) {
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X }
X return(TRUE);
}
X
/*
X * Move the cursor forward by the specified number of words. All of the motion
X * is done by "forwchar". Error if you try and move beyond the buffer's end.
X */
forwviendw(f, n)
{
X int s;
X if (n < 0)
X return (FALSE);
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X setchartype();
X while (n--) {
X while ((s = isendviwordf()) == FALSE) {
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X
X }
X if (s == SORTOFTRUE)
X return TRUE;
X else
X return backchar(FALSE, 1);
}
X
/*
X * Move the cursor forward by the specified number of words. All of the motion
X * is done by "forwchar". Error if you try and move beyond the buffer's end.
X */
forwendw(f, n)
{
X int s;
X if (n < 0)
X return (FALSE);
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X setchartype();
X while (n--) {
X while ((s = isendwordf()) == FALSE) {
X if (forwchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X
X }
X if (s == SORTOFTRUE)
X return TRUE;
X else
X return backchar(FALSE, 1);
}
X
/*
X * Move the cursor backward by "n" words. All of the details of motion are
X * performed by the "backchar" and "forwchar" routines. Error if you try to
X * move beyond the buffers.
X */
backviword(f, n)
{
X if (n < 0)
X return (forwword(f, -n));
X if (backchar(FALSE, 1) == FALSE)
X return (FALSE);
X setchartype();
X while (n--) {
X while (isnewviwordb() == FALSE) {
X if (backchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X }
X return (forwchar(FALSE, 1));
}
X
/*
X * Move the cursor backward by "n" words. All of the details of motion are
X * performed by the "backchar" and "forwchar" routines. Error if you try to
X * move beyond the buffers.
X */
backword(f, n)
{
X if (n < 0)
X return (forwword(f, -n));
X if (backchar(FALSE, 1) == FALSE)
X return (FALSE);
X setchartype();
X while (n--) {
X while (isnewwordb() == FALSE) {
X if (backchar(FALSE, 1) == FALSE)
X return (FALSE);
X }
X }
X return (forwchar(FALSE, 1));
}
X
/*
X * Return TRUE if the character at dot is a character that is considered to be
X * part of a word. The word character list is hard coded. Should be setable.
X */
inword()
{
X register int c;
X
X if (curwp->w_doto == llength(curwp->w_dotp))
X return (FALSE);
X c = lgetc(curwp->w_dotp, curwp->w_doto);
X if (islower(c))
X return (TRUE);
X if (isupper(c))
X return (TRUE);
X if (isdigit(c))
X return (TRUE);
X return (FALSE);
}
X
join(f,n)
{
X register int s;
X register int doto;
X
X if (n < 0) return FALSE;
X if (n == 0) return TRUE;
X if (lforw(curwp->w_dotp) == curbp->b_linep)
X return FALSE;
X while(n--) {
X s = lastnonwhite(f,n);
X if (s == TRUE) s = forwchar(FALSE,1);
X if (s == TRUE) s = setmark();
X if (s == TRUE) s = forwline(f,1);
X if (s == TRUE) s = firstnonwhite(f,1);
X if (s == TRUE) s = killregion(f,1);
X if (s != TRUE)
X return s ;
X
X doto = curwp->w_doto;
X if (doto == 0)
X return TRUE;
X if (lgetc(curwp->w_dotp,doto) == ')')
X return TRUE;
X if (lgetc(curwp->w_dotp,doto-1) == '.')
X s = linsert(2,' ');
X else
X s = linsert(1,' ');
X }
X
X return s;
}
X
formatregion(f,n)
{
X register int c; /* current char durring scan */
X register int wordlen; /* length of current word */
X register int clength; /* position on line during fill */
X register int i; /* index during word copy */
X register int newlength; /* tentative new line length */
X register int finished; /* Are we at the End-Of-Paragraph? */
X register int firstflag; /* first word? (needs no space) */
X register LINE *pastline; /* pointer to line just past EOP */
X register int sentence; /* was the last char a period? */
X char wbuf[NSTRING]; /* buffer for current word */
X int secondindent;
X REGION region;
X int s;
X
X if (curbp->b_mode & MDVIEW) /* don't allow this command if */
X return(rdonly()); /* we are in read only mode */
X
X if (curwp->w_mkp != curwp->w_dotp) {
X getregion(®ion);
X if (region.r_linep == curwp->w_mkp)
X swapmark();
X }
X pastline = curwp->w_mkp;
X if (pastline != curbp->b_linep)
X pastline = lforw(pastline);
X
X secondindent = indentlen(curwp->w_dotp);
X
X /* go forward to get the indent for the second and following lines */
X curwp->w_dotp = lforw(curwp->w_dotp);
X
X if (curwp->w_dotp != pastline) {
X secondindent = indentlen(curwp->w_dotp);
X }
X
X /* and back where we should be */
X curwp->w_dotp = lback(curwp->w_dotp);
X firstnonwhite(FALSE,1);
X
X clength = indentlen(curwp->w_dotp);
X wordlen = 0;
X sentence = FALSE;
X
X /* scan through lines, filling words */
X firstflag = TRUE;
X finished = FALSE;
X while (!finished) {
X
X if (interrupted) return ABORT;
X
X /* get the next character in the paragraph */
X if (curwp->w_doto == llength(curwp->w_dotp)) {
X c = ' ';
X if (lforw(curwp->w_dotp) == pastline)
X finished = TRUE;
X } else {
X c = lgetc(curwp->w_dotp, curwp->w_doto);
X }
X /* and then delete it */
X if (!finished) {
X s = ldelete(1L, FALSE);
X if (s != TRUE) return s;
X }
X
X /* if not a separator, just add it in */
X if (c != ' ' && c != '\t') {
X /* was it the end of a "sentence"? */
X sentence = (c == '.' || c == '?' || c == '!');
X if (wordlen < NSTRING - 1)
X wbuf[wordlen++] = c;
X } else if (wordlen) {
X /* at a word break with a word waiting */
X /* calculate tentative new length with word added */
X newlength = clength + 1 + wordlen;
X if (newlength <= fillcol) {
X /* add word to current line */
X if (!firstflag) {
X s = linsert(1, ' '); /* the space */
X if (s != TRUE) return s;
X ++clength;
X }
X firstflag = FALSE;
X } else {
X if (lnewline() == FALSE
X || ((i=secondindent/TABVAL)!=0 &&
X linsert(i, '\t')==FALSE)
X || ((i=secondindent%TABVAL)!=0 &&
X linsert(i, ' ')==FALSE)) {
X return FALSE;
X }
X clength = secondindent;
X }
X
X /* and add the word in in either case */
X for (i=0; i<wordlen; i++) {
X s = linsert(1, wbuf[i]);
X if (s != TRUE) return s;
X ++clength;
X }
X if (sentence) {
X s = linsert(1, ' ');
X if (s != TRUE) return s;
X ++clength;
X }
X wordlen = 0;
X }
X }
X return(TRUE);
}
X
X
#if WORDCOUNT /* who cares? -pgf */
/* wordcount: count the # of words in the marked region,
X along with average word sizes, # of chars, etc,
X and report on them. */
wordcount(f, n)
{
X register LINE *lp; /* current line to scan */
X register int offset; /* current char to scan */
X long size; /* size of region left to count */
X register int ch; /* current character to scan */
X register int wordflag; /* are we in a word now? */
X register int lastword; /* were we just in a word? */
X long nwords; /* total # of words */
X long nchars; /* total number of chars */
X int nlines; /* total number of lines in region */
X int avgch; /* average number of chars/word */
X int status; /* status return code */
X REGION region; /* region to look at */
X
X /* make sure we have a region to count */
X if ((status = getregion(®ion)) != TRUE)
X return(status);
X lp = region.r_linep;
X offset = region.r_offset;
X size = region.r_size;
X
X /* count up things */
X lastword = FALSE;
X nchars = 0L;
X nwords = 0L;
X nlines = 0;
X while (size--) {
X
X /* get the current character */
X if (offset == llength(lp)) { /* end of line */
X ch = '\n';
X lp = lforw(lp);
X offset = 0;
X ++nlines;
X } else {
X ch = lgetc(lp, offset);
X ++offset;
X }
X
X /* and tabulate it */
X wordflag = ((ch >= 'a' && ch <= 'z') ||
X (ch >= 'A' && ch <= 'Z') ||
X (ch >= '0' && ch <= '9'));
X if (wordflag == TRUE && lastword == FALSE)
X ++nwords;
X lastword = wordflag;
X ++nchars;
X }
X
X /* and report on the info */
X if (nwords > 0L)
X avgch = (int)((100L * nchars) / nwords);
X else
X avgch = 0;
X
X mlwrite("lines %d, words, %D chars %D avg chars/word %f",
X nlines + 1, nwords, nchars, avgch);
X return(TRUE);
}
#endif
SHAR_EOF
chmod 0444 word.c ||
echo 'restore of word.c failed'
Wc_c="`wc -c < 'word.c'`"
test 10449 -eq "$Wc_c" ||
echo 'word.c: original size 10449, current size' "$Wc_c"
# ============= wordmov.c ==============
echo 'x - extracting wordmov.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'wordmov.c' &&
X
#include <stdio.h>
#include "estruct.h"
#include "edef.h"
X
/* These routines report on transitions between word boundaries, both
X in the punctuated vi sense, and in the whitespace/darkspace
X sense. The transition is reported _after_ it has occurred. You
X need to back up to get to the char. before the transition.
X Written for vile by Paul Fox, (c)1990
*/
X
#define WASSPACE 0
#define ISSPACE 0
#define WASIDENT 1
#define ISIDENT 1
#define WASOTHER 2
#define ISOTHER 2
#define WASNL 3
#define ISNL 3
X
static int ochartype;
X
setchartype()
{
X ochartype = getchartype();
}
X
getchartype()
{
X register int c;
X
X if (curwp->w_doto == llength(curwp->w_dotp))
X return (ISNL);
X else
X c = lgetc(curwp->w_dotp, curwp->w_doto);
X return (isspace(c) ? ISSPACE :
X ( isident(c) ? ISIDENT : ISOTHER ) );
}
X
X
isnewwordf()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X switch (type) {
X case ISNL: if (doingopcmd) { ret = SORTOFTRUE; break;}
X case ISSPACE: ret = FALSE; break;
X case ISIDENT:
X case ISOTHER: ret = TRUE; break;
X }
X break;
X case WASIDENT:
X case WASOTHER:
X switch (type) {
X case ISNL: if (doingopcmd) { ret = SORTOFTRUE; break;}
X case ISSPACE: if (doingopcmd && opcmd != OPDEL)
X { ret = SORTOFTRUE; break;}
X case ISIDENT:
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
isnewwordb()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X ret = FALSE; break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE: ret = TRUE; break;
X case ISIDENT:
X case ISOTHER: ret = FALSE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE: ret = TRUE; break;
X case ISIDENT:
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
isnewviwordf()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X switch (type) {
X case ISNL: if (doingopcmd) { ret = SORTOFTRUE; break;}
X case ISSPACE: ret = FALSE; break;
X case ISIDENT:
X case ISOTHER: ret = TRUE; break;
X }
X break;
X case WASIDENT:
X switch (type) {
X case ISNL: if (doingopcmd) { ret = SORTOFTRUE; break;}
X case ISSPACE: if (doingopcmd && opcmd != OPDEL)
X { ret = SORTOFTRUE; break;}
X case ISIDENT: ret = FALSE; break;
X case ISOTHER: ret = TRUE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL: if (doingopcmd) { ret = SORTOFTRUE; break;}
X case ISSPACE: if (doingopcmd && opcmd != OPDEL)
X { ret = SORTOFTRUE; break;}
X case ISOTHER: ret = FALSE; break;
X case ISIDENT: ret = TRUE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
isnewviwordb()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X ret = FALSE; break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISOTHER: ret = TRUE; break;
X case ISIDENT: ret = FALSE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISIDENT: ret = TRUE; break;
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
X
isendwordb()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X switch (type) {
X case ISNL:
X case ISSPACE: ret = FALSE; break;
X case ISIDENT:
X case ISOTHER: ret = TRUE; break;
X }
X break;
X case WASIDENT:
X case WASOTHER:
X ret = FALSE; break;
X }
X ochartype = type;
X return (ret);
}
X
isendviwordb()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X switch (type) {
X case ISNL:
X case ISSPACE: ret = FALSE; break;
X case ISOTHER:
X case ISIDENT: ret = TRUE; break;
X }
X break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISOTHER: ret = TRUE; break;
X case ISIDENT: ret = FALSE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISIDENT: ret = TRUE; break;
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
isendwordf()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X ret = FALSE; break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE:
X if (doingopcmd) ret = SORTOFTRUE;
X else ret = TRUE;
X break;
X case ISIDENT:
X case ISOTHER: ret = FALSE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE:
X if (doingopcmd) ret = SORTOFTRUE;
X else ret = TRUE;
X break;
X case ISIDENT:
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
isendviwordf()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X ret = FALSE; break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISOTHER:
X if (doingopcmd) ret = SORTOFTRUE;
X else ret = TRUE;
X break;
X case ISIDENT: ret = FALSE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE:
X case ISIDENT:
X if (doingopcmd) ret = SORTOFTRUE;
X else ret = TRUE;
X break;
X case ISOTHER: ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
X
#ifdef template
isANYTHING()
{
X register int ret;
X register int type;
X
X type = getchartype();
X
X switch (ochartype) {
X case WASNL:
X case WASSPACE:
X switch (type) {
X case ISNL:
X case ISSPACE:
X ret = FALSE; break;
X case ISIDENT:
X ret = FALSE; break;
X case ISOTHER:
X ret = FALSE; break;
X }
X break;
X case WASIDENT:
X switch (type) {
X case ISNL:
X case ISSPACE:
X ret = TRUE; break;
X case ISIDENT:
X ret = FALSE; break;
X case ISOTHER:
X ret = TRUE; break;
X }
X break;
X case WASOTHER:
X switch (type) {
X case ISNL:
X case ISSPACE:
X ret = TRUE; break;
X case ISIDENT:
X ret = TRUE; break;
X case ISOTHER:
X ret = FALSE; break;
X }
X break;
X }
X ochartype = type;
X return (ret);
}
#endif /* template */
X
SHAR_EOF
chmod 0444 wordmov.c ||
echo 'restore of wordmov.c failed'
Wc_c="`wc -c < 'wordmov.c'`"
test 6094 -eq "$Wc_c" ||
echo 'wordmov.c: original size 6094, current size' "$Wc_c"
# ============= z100bios.asm ==============
echo 'x - extracting z100bios.asm (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'z100bios.asm' &&
;History:46,1
X
_TEXT SEGMENT BYTE PUBLIC 'CODE'
_TEXT ENDS
_DATA SEGMENT WORD PUBLIC 'DATA'
_DATA ENDS
CONST SEGMENT WORD PUBLIC 'CONST'
CONST ENDS
_BSS SEGMENT WORD PUBLIC 'BSS'
_BSS ENDS
X
bios_seg segment at 40h
X org 9
bios_conout label far
bios_seg ends
X
DGROUP GROUP CONST, _BSS, _DATA
X ASSUME CS: _TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
X
parm equ ss:[bp]
X
_TEXT SEGMENT
X
X public _asmputc
X
putc_stack struc
X putc_bp dw ?
X putc_return dd ?
X char db ?
putc_stack ends
X
_asmputc proc far
X push bp
X mov bp,sp
X mov al,parm.char
X call bios_conout
X pop bp
X ret
_asmputc endp
X
_TEXT ends
X end
X
SHAR_EOF
chmod 0444 z100bios.asm ||
echo 'restore of z100bios.asm failed'
Wc_c="`wc -c < 'z100bios.asm'`"
test 652 -eq "$Wc_c" ||
echo 'z100bios.asm: original size 652, current size' "$Wc_c"
# ============= z309.c ==============
echo 'x - extracting z309.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'z309.c' &&
/*
X * The routines in this file provide support for the Zenith Z-100 PC
X * family. It goes directly to the graphics RAM to do screen output.
X * It compiles into nothing if not a Zenith driver.
X */
X
#define termdef 1 /* don't define "term" external */
X
#include <stdio.h>
#include "estruct.h"
#include "edef.h"
X
#if Z309
X
/* set NROW to 25 for 25-line interlaced mode */
#define NROW 50 /* Screen size. */
#define NCOL 80 /* Edit if you want to. */
#define MARGIN 8 /* size of minimim margin and */
#define SCRSIZ 64 /* scroll size for extended lines */
#define NPAUSE 200 /* # times thru update to pause */
#define BEL 0x07 /* BEL character. */
#define ESC 0x1B /* ESC character. */
#define SPACE 32 /* space character */
X
#define SCADC 0xb8000000L /* CGA address of screen RAM */
#define SCADM 0xb0000000L /* MONO address of screen RAM */
X
#define CDMONO 0 /* monochrome text card */
#define CDCGA50 1 /* 50-line color graphics card */
#define CDCGI25 2 /* 25-line interlaced CGA text */
#define CDCGA25 3 /* 25-line color graphics card */
#define CDSENSE 9 /* detect the card type */
X
int dtype = CDCGA50; /* current display type */
long scadd; /* address of screen ram */
int *scptr[NROW]; /* pointer to screen lines */
int sline[NCOL]; /* screen line image */
extern union REGS rg; /* cpu register for use of DOS calls */
X
extern int ttopen(); /* Forward references. */
extern int ttgetc();
extern int ttputc();
extern int ttflush();
extern int ttclose();
extern int z309move();
extern int z309eeol();
extern int z309eeop();
extern int z309beep();
extern int z309open();
extern int z309rev();
extern int z309cres();
extern int z309close();
extern int z309putc();
extern int z309kopen();
extern int z309kclose();
X
#if COLOR
extern int z309fcol();
extern int z309bcol();
X
int cfcolor = -1; /* current forground color */
int cbcolor = -1; /* current background color */
int ctrans[] = /* ansi to z309 color translation table */
X {0, 4, 2, 6, 1, 5, 3, 7};
#endif
X
/*
X * Standard terminal interface dispatch table. Most of the fields point into
X * "termio" code.
X */
TERM term = {
X NROW-1,
X NROW-1,
X NCOL,
X NCOL,
X MARGIN,
X SCRSIZ,
X NPAUSE,
X z309open,
X z309close,
X z309kopen,
X z309kclose,
X ttgetc,
X z309putc,
X ttflush,
X z309move,
X z309eeol,
X z309eeop,
X z309beep,
X z309rev,
X z309cres
#if COLOR
X , z309fcol,
X z309bcol
#endif
};
X
extern union REGS rg;
X
#if COLOR
z309fcol(color) /* set the current output color */
X
int color; /* color to set */
X
{
X cfcolor = ctrans[color];
}
X
z309bcol(color) /* set the current background color */
X
int color; /* color to set */
X
{
X cbcolor = ctrans[color];
}
#endif
z309move(row, col)
{
X rg.h.ah = 2; /* set cursor position function code */
X rg.h.dl = col;
X rg.h.dh = row;
X rg.h.bh = 0; /* set screen page number */
X int86(0x10, &rg, &rg);
}
X
z309eeol() /* erase to the end of the line */
X
{
X int attr; /* attribute byte mask to place in RAM */
X int *lnptr; /* pointer to the destination line */
X int i;
X int ccol; /* current column cursor lives */
X int crow; /* row */
X
X /* find the current cursor position */
X rg.h.ah = 3; /* read cursor position function code */
X rg.h.bh = 0; /* current video page */
X int86(0x10, &rg, &rg);
X ccol = rg.h.dl; /* record current column */
X crow = rg.h.dh; /* and row */
X
X /* build the attribute byte and setup the screen pointer */
#if COLOR
X if (dtype != CDMONO)
X attr = (((cbcolor & 15) << 4) | (cfcolor & 15)) << 8;
X else
X attr = 0x0700;
#else
X attr = 0x0700;
#endif
X lnptr = &sline[0];
X for (i=0; i < term.t_ncol; i++)
X *lnptr++ = SPACE | attr;
X
#if 0 /* Heath/Zenith builds flicker-less CGAs */
X if (flickcode) {
X /* wait for vertical retrace to be off */
X while ((inp(0x3da) & 8))
X ;
X
X /* and to be back on */
X while ((inp(0x3da) & 8) == 0)
X ;
X }
#endif
X
X /* and send the string out */
X movmem(&sline[0], scptr[crow]+ccol, (term.t_ncol-ccol)*2);
X
}
X
z309putc(ch) /* put a character at the current position in the
X current colors */
X
int ch;
X
{
X rg.h.ah = 14; /* write char to screen with current attrs */
X rg.h.al = ch;
#if COLOR
X if (dtype != CDMONO)
X rg.h.bl = cfcolor;
X else
X rg.h.bl = 0x07;
#else
X rg.h.bl = 0x07;
#endif
X int86(0x10, &rg, &rg);
}
X
z309eeop()
{
X int attr; /* attribute to fill screen with */
X
X rg.h.ah = 6; /* scroll page up function code */
X rg.h.al = 0; /* # lines to scroll (clear it) */
X rg.x.cx = 0; /* upper left corner of scroll */
/*HERE*/ rg.x.dx = 0x184f; /* lower right corner of scroll */
#if COLOR
X if (dtype != CDMONO)
X attr = ((ctrans[gbcolor] & 15) << 4) | (ctrans[gfcolor] & 15);
X else
X attr = 0;
#else
X attr = 0;
#endif
X rg.h.bh = attr;
X int86(0x10, &rg, &rg);
}
X
z309rev(state) /* change reverse video state */
X
int state; /* TRUE = reverse, FALSE = normal */
X
{
X /* This never gets used under the z309-PC driver */
}
X
z309cres(res) /* change screen resolution */
X
char *res; /* resolution to change to */
X
{
X if (strcmp(res, "CGA50") == 0) {
X scinit(CDCGA50);
X return(TRUE);
X } else if (strcmp(res, "MONO") == 0) {
X scinit(CDMONO);
X return(TRUE);
X } else
X return(FALSE);
}
X
z309beep()
{
#if MWC86
X putcnb(BEL);
#else
X bdos(6, BEL, 0);
#endif
}
X
z309open()
{
X scinit(CDSENSE);
X revexist = TRUE;
X ttopen();
}
X
z309close()
X
{
X rg.h.ah = 101;
X rg.h.al = 1; /* 25-line interlace mode */
X int86(0x10, &rg, &rg);
#if COLOR
X z309fcol(7);
X z309bcol(0);
#endif
X ttclose();
}
X
z309kopen() /* open the keyboard */
X
{
}
X
z309kclose() /* close the keyboard */
X
{
}
X
scinit(type) /* initialize the screen head pointers */
X
int type; /* type of adapter to init for */
X
{
X union {
X long laddr; /* long form of address */
X int *paddr; /* pointer form of address */
X } addr;
X int i;
X
X /* if asked...find out what display is connected */
X int86(0x11, &rg, &rg);
X dtype = CDCGA50;
X scadd = SCADC;
X strcpy(sres, "CGA50");
X if ((((rg.x.ax >> 4) & 11) == 3) || type == CDMONO) {
X strcpy(sres, "MONO");
X dtype = CDMONO;
X scadd = SCADM;
X }
X else {
X rg.h.ah = 101;
/* set al = 1 for 25-line interlace mode */
X rg.h.al = 2; /* 50-line interlace mode */
X int86(0x10, &rg, &rg);
X }
X
X /* initialize the screen pointer array */
X for (i = 0; i < NROW; i++) {
X addr.laddr = scadd + (long)(NCOL * i * 2);
X scptr[i] = addr.paddr;
X }
}
X
scwrite(row, outstr, forg, bacg) /* write a line out*/
X
int row; /* row of screen to place outstr on */
char *outstr; /* string to write out (must be term.t_ncol long) */
int forg; /* forground color of string to write */
int bacg; /* background color */
X
{
X int attr; /* attribute byte mask to place in RAM */
X int *lnptr; /* pointer to the destination line */
X int i;
X
X /* build the attribute byte and setup the screen pointer */
#if COLOR
X if (dtype != CDMONO)
X attr = (((ctrans[bacg] & 15) << 4) | (ctrans[forg] & 15)) << 8;
X else
X attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
#else
X attr = (((bacg & 15) << 4) | (forg & 15)) << 8;
#endif
X lnptr = &sline[0];
X for (i=0; i<term.t_ncol; i++)
X *lnptr++ = (outstr[i] & 255) | attr;
X
#if 0 /* Heath/Zenith builds flicker-less CGAs */
X if (flickcode) {
X /* wait for vertical retrace to be off */
X while ((inp(0x3da) & 8))
X ;
X
X /* and to be back on */
X while ((inp(0x3da) & 8) == 0)
X ;
X }
#endif
X
X /* and send the string out */
X movmem(&sline[0], scptr[row],term.t_ncol*2);
}
X
#if FLABEL
fnclabel(f, n) /* label a function key */
X
int f,n; /* default flag, numeric argument [unused] */
X
{
X /* on machines with no function keys...don't bother */
X return(TRUE);
}
#endif
#else
z309hello()
{
}
#endif
SHAR_EOF
chmod 0444 z309.c ||
echo 'restore of z309.c failed'
Wc_c="`wc -c < 'z309.c'`"
test 7806 -eq "$Wc_c" ||
echo 'z309.c: original size 7806, current size' "$Wc_c"
rm -f _shar_seq_.tmp
echo You have unpacked the last part
exit 0
--
paul fox, pgf at cayman.com, (617)494-1999
Cayman Systems, 26 Landsdowne St., Cambridge, MA 02139
More information about the Alt.sources
mailing list