BEAV, a full featured binary file editor, part 02 of 11
Peter Reilley
pvr at wang.com
Thu Feb 28 07:46:33 AEST 1991
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 11)."
# Contents: echo.c extend.c format.c ttykbd.c window.c
# Wrapped by pvr at elf on Wed Feb 27 14:16:46 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'echo.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'echo.c'\"
else
echo shar: Extracting \"'echo.c'\" \(9451 characters\)
sed "s/^X//" >'echo.c' <<'END_OF_FILE'
X/*
X* Echo line reading and writing.
X* Common routines for reading
X* and writing characters in the echo line area
X* of the display screen. Used by the entire
X* known universe.
X*/
X#include "def.h"
X
Xvoid eerase ();
Xchar ereply ();
Xchar eread ();
Xvoid eformat ();
Xvoid eputi ();
Xvoid eputs ();
Xvoid eputc ();
X
X
Xextern char MSG_null[];
Xextern char MSG_y_n[];
Xextern char MSG_hex_dig[];
X
X#include "lintfunc.dec"
Xint epresf = FALSE; /* Stuff in echo line flag. */
X
X/*
X* Erase the echo line.
X*/
Xvoid eerase ()
X{
X writ_echo (MSG_null); /* clear the echo line */
X epresf = FALSE;
X}
X
X
X/*
X* Ask "yes" or "no" question.
X* Return ABORT if the user answers the question
X* with the abort ("^G") character. Return FALSE
X* for "no" and TRUE for "yes". No formatting
X* services are available.
X*/
Xchar eyesno (sp)
Xchar *sp;
X{
X
X register char s;
X char buf[64];
X
X for (;;)
X {
X
X s = ereply (MSG_y_n, buf, sizeof (buf), sp);
X if (s == ABORT)
X return (ABORT);
X if (s != FALSE)
X {
X
X if (buf[0] == 'y' || buf[0] == 'Y')
X return (TRUE);
X if (buf[0] == 'n' || buf[0] == 'N')
X return (FALSE);
X }
X
X }
X
X}
X
X
X/*
X* Write out a prompt, and read back a
X* reply. The prompt is now written out with full "eprintf"
X* formatting, although the arguments are in a rather strange
X* place. This is always a new message, there is no auto
X* completion, and the return is echoed as such.
X*/
X/* VARARGS3 */
Xchar ereply (fp, buf, nbuf, arg)
Xchar *fp;
Xchar *buf;
Xint nbuf;
Xchar *arg;
X{
X return (eread (fp, buf, nbuf, EFNEW | EFCR, arg));
X}
X
X
X/*
X* This is the general "read input from the
X* echo line" routine. The basic idea is that the prompt
X* string "prompt" is written to the echo line, and a one
X* line reply is read back into the supplied "buf" (with
X* maximum length "len"). The "flag" contains EFNEW (a
X* new prompt), an EFAUTO (autocomplete), or EFCR (echo
X* the carriage return as CR).
X*/
Xchar eread (fp, buf, nbuf, flag, ap)
Xchar *fp;
Xchar *buf;
Xchar *ap;
X{
X
X register int cpos;
X register SYMBOL * sp1;
X register SYMBOL * sp2;
X register int i;
X register int c;
X register int h;
X register int nhits;
X register int nxtra;
X register int bxtra;
X
X int quote_flag;
X
X quote_flag = 0;
X cpos = 0;
X if (kbdmop != NULL)
X {
X /* In a macro. */
X while ((c = *kbdmop++) != '\0')
X buf[cpos++] = c;
X buf[cpos] = '\0';
X goto done;
X }
X
X if ((flag & EFNEW) != 0 || ttrow != nrow - 1)
X {
X
X ttcolor (CTEXT);
X ttmove (nrow - 1, 0);
X epresf = TRUE;
X }
X else
X eputc (' ');
X eformat (fp, ap);
X tteeol ();
X ttflush ();
X for (;;)
X {
X c = getkey ();
X if (c == ' ' && (flag & EFAUTO) != 0)
X {
X nhits = 0;
X nxtra = HUGE;
X for (h = 0; h < NSHASH; ++h)
X {
X sp1 = symbol[h];
X while (sp1 != NULL)
X {
X for (i = 0; i < cpos; ++i)
X {
X if (buf[i] != sp1 -> s_name[i])
X break;
X }
X
X if (i == cpos)
X {
X if (nhits == 0)
X sp2 = sp1;
X ++nhits;
X bxtra = getxtra (sp1, sp2, cpos);
X if (bxtra < nxtra)
X nxtra = bxtra;
X }
X
X sp1 = sp1 -> s_symp;
X }
X }
X
X if (nhits == 0) /* No completion. */
X continue;
X for (i = 0; i < nxtra && cpos < nbuf - 1; ++i)
X {
X c = sp2 -> s_name[cpos];
X buf[cpos++] = c;
X eputc (c);
X }
X
X ttflush ();
X if (nhits != 1) /* Fake a CR if there */
X continue; /* is 1 choice. */
X c = (KCTRL | 'M');
X }
X if (quote_flag)
X {
X c = c & 0x1f;
X quote_flag = 0;
X }
X
X
X switch (c)
X {
X case (KCTRL | 'Q'):
X quote_flag = 1;
X break;
X case (KCTRL | 'M'): /* Return, done. */
X buf[cpos] = '\0';
X if (kbdmip != NULL)
X {
X if (kbdmip + cpos + 1 > &kbdm[NKBDM - 3])
X {
X (void) ctrlg (FALSE, 0, KRANDOM);
X ttflush ();
X return (ABORT);
X }
X
X for (i = 0; i < cpos; ++i)
X *kbdmip++ = buf[i];
X *kbdmip++ = '\0';
X }
X
X if ((flag & EFCR) != 0)
X {
X ttputc (0x0D);
X ttflush ();
X }
X
X goto done;
X
X case (KCTRL | 'G'): /* Bell, abort. */
X eputc (0x07);
X (void) ctrlg (FALSE, 0, KRANDOM);
X ttflush ();
X return (ABORT);
X
X case 0x7F: /* Rubout, erase. */
X case (KCTRL | 'H'): /* Backspace, erase. */
X if (cpos != 0)
X {
X ttputc ('\b');
X ttputc (' ');
X ttputc ('\b');
X --ttcol;
X if (ISCTRL (buf[--cpos]) != FALSE)
X {
X ttputc ('\b');
X ttputc (' ');
X ttputc ('\b');
X --ttcol;
X }
X
X ttflush ();
X }
X break;
X
X case (KCTRL | 'U'): /* C-U, kill line. */
X while (cpos != 0)
X {
X ttputc ('\b');
X ttputc (' ');
X ttputc ('\b');
X --ttcol;
X if (ISCTRL (buf[--cpos]) != FALSE)
X {
X ttputc ('\b');
X ttputc (' ');
X ttputc ('\b');
X --ttcol;
X }
X
X }
X
X ttflush ();
X break;
X
X default: /* All the rest. */
X if ((cpos < nbuf - 1) && ((c & ~KCHAR) == 0))
X {
X buf[cpos++] = c;
X eputc (c);
X ttflush ();
X }
X } /* End switch */
X
X }
X
Xdone:
X if (buf[0] == '\0')
X return (FALSE);
X return (TRUE);
X}
X
X
X/*
X* The "sp1" and "sp2" point to extended command
X* symbol table entries. The "cpos" is a horizontal position
X* in the name. Return the longest block of characters that can
X* be autocompleted at this point. Sometimes the two symbols
X* are the same, but this is normal.
X*/
Xint getxtra (sp1, sp2, cpos)
XSYMBOL * sp1;
XSYMBOL * sp2;
X{
X
X register int i;
X
X i = cpos;
X for (;;)
X {
X
X if (sp1 -> s_name[i] != sp2 -> s_name[i])
X break;
X if (sp1 -> s_name[i] == '\0')
X break;
X ++i;
X }
X
X return (i - cpos);
X}
X
X/*
X* Printf style formatting. This is
X* called by both "eprintf" and "ereply", to provide
X* formatting services to their clients. The move to the
X* start of the echo line, and the erase to the end of
X* the echo line, is done by the caller.
X*/
Xvoid eformat (fp, ap)
Xchar *fp;
Xchar *ap;
X{
X
X register int c;
X
X while ((c = *fp++) != '\0')
X {
X
X if (c != '%')
X eputc (c);
X else
X {
X
X c = *fp++;
X switch (c)
X {
X
X case 'd':
X eputi (*(int *) ap, 10);
X ap += sizeof (int);
X break;
X
X case 'x': /* krw */
X eputi (*(int *) ap, 16);
X ap += sizeof (int);
X break;
X
X case 'o':
X eputi (*(int *) ap, 8);
X ap += sizeof (int);
X break;
X
X case 's':
X eputs (ap);
X ap += sizeof (char *);
X break;
X
X default:
X eputc (c);
X }
X
X }
X
X }
X
X}
X
X
X/*
X* Put integer, in radix "r".
X*/
Xvoid eputi (i, r)
Xint i;
Xint r;
X{
X static char *convert =
X {
X MSG_hex_dig
X }
X ;
X
X register int q;
X
X if ((q = i / r) != 0)
X eputi (q, r);
X eputc (convert[i % r]);
X
X}
X
X
X/*
X* Put string.
X*/
Xvoid eputs (s)
Xchar *s;
X{
X register int c;
X
X while ((c = *s++) != '\0')
X eputc (c);
X}
X
X
X/*
X* Put character. Watch for
X* control characters, and for the line
X* getting too long.
X*/
Xvoid eputc (c)
Xint c;
X{
X
X if (ttcol < ncol)
X {
X
X if (ISCTRL (c) != FALSE)
X {
X
X eputc ('^');
X c ^= 0x40;
X }
X
X ttputc (c);
X ++ttcol;
X }
X
X}
X
END_OF_FILE
if test 9451 -ne `wc -c <'echo.c'`; then
echo shar: \"'echo.c'\" unpacked with wrong size!
fi
chmod +x 'echo.c'
# end of 'echo.c'
fi
if test -f 'extend.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'extend.c'\"
else
echo shar: Extracting \"'extend.c'\" \(8301 characters\)
sed "s/^X//" >'extend.c' <<'END_OF_FILE'
X/*
X* Extended (M-X) commands.
X*/
X#include "def.h"
X
Xextern char MSG_not_now[];
Xextern char MSG_func[];
Xextern char MSG_unk_func[];
Xextern char MSG_cmd_t_ex[];
Xextern char MSG_unk_ext[];
Xextern char MSG_d_b[];
Xextern char MSG_unbd[];
Xextern char MSG_bnd_to[];
Xextern char MSG_ins_self[];
Xextern char MSG_bnd_file[];
Xextern char MSG_bld_wall[];
Xextern char MSG_null[];
X
X#include "lintfunc.dec"
X#ifdef CUSTOMIZE
Xstatic char *bindnm =
X{0
X}; /* file name for customized key bindings */
X#endif
X
X/*
X* This function modifies the keyboard
X* binding table, by adjusting the entries in the
X* big "bindings" array. Most of the grief deals with the
X* prompting for additional arguments. This code does not
X* work right if there is a keyboard macro floating around.
X* Should be fixed.
X*/
Xbool bindtokey ()
X{
X
X register int s;
X register char *cp;
X register SYMBOL * sp;
X register int c;
X char xname[NXNAME];
X#ifdef CUSTOMIZE
X char xname2[NXNAME];
X FILE * bindf;
X#endif
X
X if (kbdmip != NULL || kbdmop != NULL)
X {
X writ_echo (MSG_not_now);
X return (FALSE);
X }
X
X if ((s = eread (MSG_func, xname, NXNAME, EFAUTO, NULL)) != TRUE)
X return (s);
X if ((sp = symlookup (xname)) == NULL)
X {
X writ_echo (MSG_unk_func);
X return (FALSE);
X }
X
X#ifdef CUSTOMIZE
X strcpy (xname2, xname);
X#endif
X eputc (' ');
X eputc ('K');
X eputc ('e');
X eputc ('y');
X eputc (':');
X eputc (' ');
X ttflush ();
X c = getkey (); /* Read key. */
X keyname (xname, c); /* Display keyname. */
X eputs (xname);
X ttflush ();
X if (binding[c] != NULL) /* Unbind old, and */
X --binding[c] -> s_nkey;
X binding[c] = sp; /* rebind new. */
X ++sp -> s_nkey;
X
X#ifdef CUSTOMIZE
X /* save the stuff in the beavfil * (hack !! internal file io !) */
X if (bindf = fopen (bindnm, "a"))
X {
X fprintf (bindf, "%-16s %-16s %04x\n", xname, xname2, c);
X fclose (bindf);
X }
X#endif
X return (TRUE);
X}
X
X
X/*
X* Extended command. Call the message line
X* routine to read in the command name and apply autocompletion
X* to it. When it comes back, look the name up in the symbol table
X* and run the command if it is found and has the right type.
X* Print an error if there is anything wrong.
X*/
Xchar extend (f, n, k)
X{
X
X register SYMBOL * sp;
X register char s;
X char xname[NXNAME];
X
X if ((s = eread (MSG_cmd_t_ex, xname, NXNAME, EFNEW | EFAUTO, NULL)) != TRUE)
X return (s);
X if ((sp = symlookup (xname)) != NULL)
X return ((*sp -> s_funcp) (f, n, KRANDOM));
X writ_echo (MSG_unk_ext);
X return (ABORT);
X}
X
X
X/*
X* Read a key from the keyboard, and look it
X* up in the binding table. Display the name of the function
X* currently bound to the key. Say that the key is not bound
X* if it is indeed not bound, or if the type is not a
X* "builtin". This is a bit of overkill, because this is the
X* only kind of function there is.
X*/
Xbool help ()
X{
X register SYMBOL * sp;
X register int c;
X char b[20];
X char buf[80];
X
X writ_echo (MSG_d_b);
X
X c = getkey ();
X keyname (b, c);
X if ((sp = binding[c]) == NULL)
X {
X sprintf (buf, MSG_unbd, b);
X writ_echo (buf);
X }
X else
X {
X sprintf (buf, MSG_bnd_to, b, sp -> s_name);
X writ_echo (buf);
X }
X return (TRUE);
X}
X
X/*
X* Sort the lines in the buffer.
X*/
Xvoid sort_buf (b_ptr, cnt)
XBUFFER *b_ptr;
Xint cnt;
X {
X LINE *lp1, *lp2;
X bool no_swap;
X int loop1, loop2;
X
X for (loop1 = cnt; loop1 > 0; loop1--)
X {
X no_swap = TRUE;
X lp1 = b_ptr -> b_linep -> l_fp; /* point to first line */
X lp2 = lp1 -> l_fp; /* point to next line */
X for (loop2 = 0; loop2 <= loop1; loop2++)
X {
X /* compare strings and swap if necessary */
X if (0 < strcmp (lp1 -> l_text, lp2 -> l_text))
X {
X lp1 -> l_bp -> l_fp = lp2; /* get pointer to first string */
X lp2 -> l_fp -> l_bp = lp1; /* make it point to second string */
X
X lp1 -> l_fp = lp2 -> l_fp;
X lp2 -> l_bp = lp1 -> l_bp;
X
X lp1 -> l_bp = lp2;
X lp2 -> l_fp = lp1;
X
X lp2 -> l_file_offset = lp1 -> l_file_offset;
X lp1 -> l_file_offset = lp2 -> l_file_offset + lp2 -> l_used;
X
X no_swap = FALSE;
X }
X else
X {
X /* if no swap then advance both pointers */
X lp1 = lp2;
X }
X lp2 = lp1 -> l_fp;
X }
X /* quick exit if sort is finished sooner than expected */
X if (no_swap)
X {
X return;
X }
X }
X }
X
X/*
X* This function creates a table, listing all
X* of the command keys and their current bindings, and stores
X* the table in the standard pop-op buffer (the one used by the
X* directory list command, the buffer list command, etc.). This
X* lets the editor produce it's own wall chart. The bindings to
X* "ins-self" are only displayed if there is an argument.
X*/
Xchar wallchart (f, n, k)
X{
X
X register char s;
X register int key, i;
X register SYMBOL * sp;
X register char *cp1;
X register char *cp2;
X char buf[64];
X WINDOW *wp;
X
X if ((s = bclear (blistp)) != TRUE)/* Clear it out. */
X return (s);
X i = 0;
X (void) strcpy (blistp -> b_fname, MSG_null);
X blistp -> b_flag = BFVIEW;
X writ_echo (MSG_bld_wall);
X for (key = 0; key < NKEYS; ++key)
X {
X /* For all keys. */
X sp = binding[key];
X if (sp != NULL &&
X (f != FALSE || strcmp (sp -> s_name, MSG_ins_self) != 0))
X {
X cp1 = &buf[0];
X cp2 = sp -> s_name; /* Add function name. */
X while (*cp1++ = *cp2++)
X ;
X cp1--;
X while (cp1 < &buf[32])/* Goto column 32. */
X *cp1++ = ' ';
X keyname (&buf[32], key);
X if (addline (buf) == FALSE)
X break; /* lets go with what we have */
X i++;
X }
X }
X sort_buf (blistp, i); /* sort buffer lines */
X popblist ();
X writ_echo (MSG_null);
X /* make new window the current window */
X wp = wheadp;
X while (wp != NULL)
X {
X if (wp -> w_bufp == blistp)
X {
X curwp = wp;
X curbp = wp -> w_bufp;
X return (TRUE);
X }
X wp = wp -> w_wndp;
X }
X return (TRUE);
X}
X
X/* check for BEAVFIL and read it in if found
X* - also, set local file variable for bindtokey for saving new defs
X* (this is some what of a hack as it only handles 'bindtokey' changes at
X* this time - also local file io !!!)
X*/
Xvoid check_extend (nm)
Xchar *nm;
X{
X
X#ifdef CUSTOMIZE
X register SYMBOL * sp;
X char buff[NXNAME + 1];
X char keybuf[NXNAME + 1];
X int keyval;
X FILE * bindf;
X
X if (!(bindnm = nm))
X return;
X if (!(bindf = fopen (bindnm, "r")))
X return;
X while (fscanf (bindf, "%s %s %x", keybuf, buff, &keyval) != EOF)
X {
X if (sp = symlookup (buff))
X {
X if (binding[keyval] != NULL)/* Unbind old, and */
X --binding[keyval] -> s_nkey;
X binding[keyval] = sp;/* rebind new. */
X ++sp -> s_nkey;
X }
X }
X
X fclose (bindf);
X#endif
X}
X
X
X
X/* interactive method for loading binding file
X* (uses above routine, obviously)
X*/
Xchar load_extend ()
X{
X
X#ifdef CUSTOMIZE
X register char s;
X char fname[NFILEN];
X
X if ((s = ereply (MSG_bnd_file, fname, NFILEN, NULL)) != TRUE)
X return (s);
X check_extend (fname);
X writ_echo (okmsg);
X#endif
X return (TRUE);
X}
X
Xint find_keyval (name)
Xchar *name;
X{
X SYMBOL * sp;
X int key;
X
X for (key = 0; key < NKEYS; ++key)
X {
X /* For all keys. */
X sp = binding[key];
X if (sp != NULL && (strcmp (sp -> s_name, name) == 0))
X return (key);
X }
X return (0);
X}
END_OF_FILE
if test 8301 -ne `wc -c <'extend.c'`; then
echo shar: \"'extend.c'\" unpacked with wrong size!
fi
chmod +x 'extend.c'
# end of 'extend.c'
fi
if test -f 'format.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'format.c'\"
else
echo shar: Extracting \"'format.c'\" \(8417 characters\)
sed "s/^X//" >'format.c' <<'END_OF_FILE'
X/*
X* The module devines the format of the screen display.
X*/
X
X#define LINT_ARGS 1 /* enable lint type checking */
X#include "def.h"
X#include "lintfunc.dec"
X
X
Xextern char hex_str[];
Xextern char hex_l_str[];
Xextern char octal_str[];
Xextern char octal_l_str[];
Xextern char decimal_str[];
Xextern char decimal_l_str[];
Xextern char char_str[];
X
X
X/* These structures contain the format for the displayed line */
X
X
X#define FC 13
X#define FS 0
X
Xuchar ascii_s_posn[] =
X{FS+0, FS+1, FS+2, FS+3, FS+4, FS+5, FS+6, FS+7, FS+8, FS+9,
XFS+10, FS+11, FS+12, FS+13, FS+14, FS+15, FS+16, FS+17, FS+18, FS+19,
XFS+20, FS+21, FS+22, FS+23, FS+24, FS+25, FS+26, FS+27, FS+28, FS+29,
XFS+30, FS+31, FS+32, FS+33, FS+34, FS+35, FS+36, FS+37, FS+38, FS+39,
XFS+40, FS+41, FS+42, FS+43, FS+44, FS+45, FS+46, FS+47, FS+48, FS+49,
XFS+50, FS+51, FS+52, FS+53, FS+54, FS+55, FS+56, FS+57, FS+58, FS+59,
XFS+60, FS+61, FS+62, FS+63, FS+64, FS+65, FS+66, FS+67, FS+68, FS+69,
XFS+70, FS+71, FS+72, FS+73, FS+74, FS+75, FS+76, FS+77, FS+78, FS+79,
X};
X
XROW_FMT text_fmt =
X{TEXT, BYTES, 128, 128, 128, 1, 1, FALSE, char_str, hex_l_str, hex_str,
X ascii_s_posn, 0};
X
XROW_FMT ascii_fmt =
X{ASCII, BYTES, 64, 64, 64, 1, 1, FALSE, char_str, hex_l_str, hex_str,
X &ascii_s_posn[FC], 0};
X
XROW_FMT ascii_s_fmt =
X{ASCII, BYTES, 32, 32, 1, 1, 1, FALSE, char_str, hex_l_str, hex_str,
X ascii_s_posn, 0};
X
XROW_FMT ebcdic_fmt =
X{EBCDIC, BYTES, 64, 64, 64, 1, 1, FALSE, char_str, hex_l_str, hex_str,
X &ascii_s_posn[FC], 0};
X
XROW_FMT ebcdic_s_fmt =
X{EBCDIC, BYTES, 32, 32, 1, 1, 1, FALSE, char_str, hex_l_str, hex_str,
X ascii_s_posn, 0};
X
Xuchar octal_8_posn[] =
X{FC, FC + 4, FC + 8, FC + 12, FC + 16, FC + 20,
X FC + 24, FC + 28, FC + 33, FC + 37, FC + 41,
X FC + 45, FC + 49, FC + 53, FC + 57, FC + 61
X};
X
XROW_FMT octal_8_fmt =
X{OCTAL, BYTES, 16, 16, 16, 1, 3, TRUE, octal_str, octal_l_str, octal_str,
X octal_8_posn, 0};
X
Xuchar octal_s_8_posn[] =
X{FS, FS + 4, FS + 8, FS + 12, FS + 16, FS + 20,
X FS + 24, FS + 28, FS + 32, FS + 36, FS + 40,
X FS + 44, FS + 48, FS + 52, FS + 56, FS + 60,
X FS + 64, FS + 68, FS + 72, FS + 76, FS + 80
X};
XROW_FMT octal_s_8_fmt =
X{OCTAL, BYTES, 8, 8, 1, 1, 3, TRUE, octal_str, octal_l_str, octal_str,
X octal_s_8_posn, 0};
X
Xuchar octal_16_posn[] =
X{FC, FC + 7, FC + 14, FC + 21, FC + 29, FC + 36, FC + 43, FC + 50
X};
X
XROW_FMT octal_16_fmt =
X{OCTAL, WORDS, 8, 16, 16, 2, 6, TRUE, octal_str, octal_l_str, octal_str,
X octal_16_posn, 0};
X
Xuchar octal_s_16_posn[] =
X{FS, FS + 7, FS + 14, FS + 21, FS + 28, FS + 35,
X FS + 42, FS + 49, FS + 56, FS + 63, FS + 70, FS + 77
X};
XROW_FMT octal_s_16_fmt =
X{OCTAL, WORDS, 4, 8, 2, 2, 6, TRUE, octal_str, octal_l_str, octal_str,
X octal_s_16_posn, 0};
X
Xuchar octal_32_posn[] =
X{FC, FC + 12, FC + 25, FC + 37
X};
X
XROW_FMT octal_32_fmt =
X{OCTAL, DWORDS, 4, 16, 16, 4, 11, TRUE, octal_l_str, octal_l_str, octal_str,
X octal_32_posn, 0};
X
Xuchar octal_s_32_posn[] =
X{FS, FS + 12, FS + 24, FS + 36, FS + 48, FS + 60, FS + 72
X};
XROW_FMT octal_s_32_fmt =
X{OCTAL, DWORDS, 2, 8, 4, 4, 11, TRUE, octal_l_str, octal_l_str, octal_str,
X octal_s_32_posn, };
X
XROW_FMT decimal_8_fmt =
X{DECIMAL, BYTES, 16, 16, 16, 1, 3, TRUE, decimal_str, decimal_l_str, decimal_str,
X octal_8_posn, 0};
X
XROW_FMT decimal_s_8_fmt =
X{DECIMAL, BYTES, 8, 8, 1, 1, 3, TRUE, decimal_str, decimal_l_str, decimal_str,
X octal_s_8_posn, 0};
X
Xuchar decimal_16_posn[] =
X{FC, FC + 6, FC + 12, FC + 18, FC + 25,
X FC + 31, FC + 37, FC + 43
X};
X
XROW_FMT decimal_16_fmt =
X{DECIMAL, WORDS, 8, 16, 16, 2, 5, TRUE, decimal_str, decimal_l_str, decimal_str,
X decimal_16_posn, 0};
X
Xuchar decimal_s_16_posn[] =
X{FS, FS + 6, FS + 12, FS + 18, FS + 24,
X FS + 30, FS + 36, FS + 42, FS + 48,
X FS + 54, FS + 60, FS + 66, FS + 72, FS + 78
X};
XROW_FMT decimal_s_16_fmt =
X{DECIMAL, WORDS, 4, 8, 2, 2, 5, TRUE, decimal_str, decimal_l_str, decimal_str,
X decimal_s_16_posn, 0};
X
Xuchar decimal_32_posn[] =
X{FC, FC + 11, FC + 23, FC + 34
X};
X
XROW_FMT decimal_32_fmt =
X{DECIMAL, DWORDS, 4, 16, 16, 4, 10, TRUE, decimal_l_str, decimal_l_str, decimal_str,
X decimal_32_posn, 0};
X
Xuchar decimal_s_32_posn[] =
X{FS, FS + 11, FS + 22, FS + 33, FS + 44, FS + 55, FS + 66, FS + 77
X};
XROW_FMT decimal_s_32_fmt =
X{DECIMAL, DWORDS, 4, 16, 4, 4, 10, TRUE, decimal_l_str, decimal_l_str, decimal_str,
X decimal_s_32_posn, 0};
X
Xuchar hex_8_posn[] =
X{FC, FC + 3, FC + 6, FC + 9, FC + 12, FC + 15,
X FC + 18, FC + 21, FC + 25, FC + 28, FC + 31,
X FC + 34, FC + 37, FC + 40, FC + 43, FC + 46,
X FC + 50, FC + 51, FC + 52, FC + 53, FC + 54,
X FC + 55, FC + 56, FC + 57, FC + 58, FC + 59,
X FC + 60, FC + 61, FC + 62, FC + 63, FC + 64,
X FC + 65
X};
X
XROW_FMT hex_8_fmt =
X{HEX, BYTES, 16, 16, 16, 1, 2, TRUE, hex_str, hex_l_str, hex_str,
X hex_8_posn, 0};
X
X
Xuchar hex_s_8_posn[] =
X{FS, FS + 3, FS + 6, FS + 9, FS + 12, FS + 15,
X FS + 18, FS + 21, FS + 24, FS + 27, FS + 30,
X FS + 33, FS + 36, FS + 39, FS + 42, FS + 45,
X FS + 48, FS + 51, FS + 54, FS + 57, FS + 60,
X FS + 63, FS + 66, FS + 69, FS + 72, FS + 75,
X FS + 78, FS + 80, FS + 80, FS + 80, FS + 80,
X FS + 80
X};
XROW_FMT hex_s_8_fmt =
X{HEX, BYTES, 8, 8, 1, 1, 2, TRUE, hex_str, hex_l_str, hex_str,
X hex_s_8_posn, 0};
X
Xuchar hex_16_posn[] =
X{FC, FC + 5, FC + 10, FC + 15, FC + 21, FC + 26, FC + 31, FC + 36
X};
X
XROW_FMT hex_16_fmt =
X{HEX, WORDS, 8, 16, 16, 2, 4, TRUE, hex_str, hex_l_str, hex_str,
X hex_16_posn, 0};
X
Xuchar hex_s_16_posn[] =
X{FS, FS + 5, FS + 10, FS + 15, FS + 20, FS + 25,
X FS + 30, FS + 35, FS + 40, FS + 45, FS + 50,
X FS + 55, FS + 60, FS + 65, FS + 70, FS + 75
X};
XROW_FMT hex_s_16_fmt =
X{HEX, WORDS, 8, 16, 2, 2, 4, TRUE, hex_str, hex_l_str, hex_str,
X hex_s_16_posn, 0};
X
Xuchar hex_32_posn[] =
X{FC, FC + 9, FC + 19, FC + 28
X};
X
XROW_FMT hex_32_fmt =
X{HEX, DWORDS, 4, 16, 16, 4, 8, TRUE, hex_l_str, hex_l_str, hex_str,
X hex_32_posn, 0};
X
Xuchar hex_s_32_posn[] =
X{FS, FS + 9, FS + 18, FS + 27, FS + 36, FS + 45, FS + 54, FS + 63, FS + 72
X};
XROW_FMT hex_s_32_fmt =
X{HEX, DWORDS, 4, 16, 4, 4, 8, TRUE, hex_l_str, hex_l_str, hex_str,
X hex_s_32_posn, 0};
X
XROW_FMT binary_8_fmt =
X{BINARY, BYTES, 4, 4, 4, 1, 8, FALSE, hex_str, hex_l_str, hex_str,
X hex_32_posn, 0}; /* use the hex position array */
X
XROW_FMT binary_s_8_fmt =
X{BINARY, BYTES, 4, 4, 1, 1, 8, FALSE, hex_str, hex_l_str, hex_str,
X hex_s_32_posn, 0}; /* use the hex position array */
X
Xuchar binary_16_posn[] =
X{FC, FC + 17, FC + 34, FC + 51
X};
X
XROW_FMT binary_16_fmt =
X{BINARY, WORDS, 4, 8, 8, 2, 16, FALSE, hex_str, hex_l_str, hex_str,
X binary_16_posn, 0};
X
Xuchar binary_s_16_posn[] =
X{FS, FS + 17, FS + 34, FS + 51, FS + 68
X};
XROW_FMT binary_s_16_fmt =
X{BINARY, WORDS, 2, 4, 2, 2, 16, FALSE, hex_str, hex_l_str, hex_str,
X binary_s_16_posn, 0};
X
Xuchar binary_32_posn[] =
X{FC, FC + 33
X};
X
XROW_FMT binary_32_fmt =
X{BINARY, DWORDS, 2, 8, 8, 4, 32, FALSE, hex_l_str, hex_l_str, hex_str,
X binary_32_posn, 0};
X
Xuchar binary_s_32_posn[] =
X{FS, FS + 33
X};
XROW_FMT binary_s_32_fmt =
X{BINARY, DWORDS, 1, 4, 4, 4, 32, FALSE, hex_l_str, hex_l_str, hex_str,
X binary_s_32_posn, 0};
X
X/* I must do this because C does not allow forward initialization of
X structures */
Xinit_fmt()
X {
X text_fmt.r_srch_fmt = &text_fmt;
X ascii_fmt.r_srch_fmt = &ascii_s_fmt;
X ascii_s_fmt.r_srch_fmt = &ascii_fmt;
X ebcdic_fmt.r_srch_fmt = &ebcdic_s_fmt;
X ebcdic_s_fmt.r_srch_fmt = &ebcdic_fmt;
X octal_8_fmt.r_srch_fmt = &octal_s_8_fmt;
X octal_s_8_fmt.r_srch_fmt = &octal_8_fmt;
X octal_16_fmt.r_srch_fmt = &octal_s_16_fmt;
X octal_s_16_fmt.r_srch_fmt = &octal_16_fmt;
X octal_32_fmt.r_srch_fmt = &octal_s_32_fmt;
X octal_s_32_fmt.r_srch_fmt = &octal_32_fmt;
X decimal_8_fmt.r_srch_fmt = &decimal_s_8_fmt;
X decimal_s_8_fmt.r_srch_fmt = &decimal_8_fmt;
X decimal_16_fmt.r_srch_fmt = &decimal_s_16_fmt;
X decimal_s_16_fmt.r_srch_fmt = &decimal_16_fmt;
X decimal_32_fmt.r_srch_fmt = &decimal_s_32_fmt;
X decimal_s_32_fmt.r_srch_fmt = &decimal_32_fmt;
X hex_8_fmt.r_srch_fmt = &hex_s_8_fmt;
X hex_s_8_fmt.r_srch_fmt = &hex_8_fmt;
X hex_16_fmt.r_srch_fmt = &hex_s_16_fmt;
X hex_s_16_fmt.r_srch_fmt = &hex_16_fmt;
X hex_32_fmt.r_srch_fmt = &hex_s_32_fmt;
X hex_s_32_fmt.r_srch_fmt = &hex_32_fmt;
X binary_8_fmt.r_srch_fmt = &binary_s_8_fmt;
X binary_s_8_fmt.r_srch_fmt = &binary_8_fmt;
X binary_16_fmt.r_srch_fmt = &binary_s_16_fmt;
X binary_s_16_fmt.r_srch_fmt = &binary_16_fmt;
X binary_32_fmt.r_srch_fmt = &binary_s_32_fmt;
X binary_s_32_fmt.r_srch_fmt = &binary_32_fmt;
X }
END_OF_FILE
if test 8417 -ne `wc -c <'format.c'`; then
echo shar: \"'format.c'\" unpacked with wrong size!
fi
chmod +x 'format.c'
# end of 'format.c'
fi
if test -f 'ttykbd.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ttykbd.c'\"
else
echo shar: Extracting \"'ttykbd.c'\" \(11412 characters\)
sed "s/^X//" >'ttykbd.c' <<'END_OF_FILE'
X/*
X * Wang PC keyboard handler
X */
X#define LINT_ARGS 1 /* enable lint type checking */
X#include "def.h"
X
Xextern char MSG_sp_key[];
Xextern char MSG_byte_shift[];
Xextern char MSG_back_char[];
Xextern char MSG_quit[];
Xextern char MSG_forw_del_char[];
Xextern char MSG_toggle_swap[];
Xextern char MSG_forw_char[];
Xextern char MSG_abort[];
Xextern char MSG_ins_self[];
Xextern char MSG_back_del_char[];
Xextern char MSG_refresh[];
Xextern char MSG_forw_line[];
Xextern char MSG_back_line[];
Xextern char MSG_quote[];
Xextern char MSG_recall[];
Xextern char MSG_twiddle[];
Xextern char MSG_forw_page[];
Xextern char MSG_kill_region[];
Xextern char MSG_yank[];
Xextern char MSG_down_window[];
Xextern char MSG_ins_toggle[];
Xextern char MSG_display_buffers[];
Xextern char MSG_quit[];
Xextern char MSG_exit_flush_all[];
Xextern char MSG_set_file_name[];
Xextern char MSG_file_insert[];
Xextern char MSG_buf_size_lock[];
Xextern char MSG_flush_all[];
Xextern char MSG_down_window[];
Xextern char MSG_up_window[];
Xextern char MSG_file_read[];
Xextern char MSG_file_save[];
Xextern char MSG_file_visit[];
Xextern char MSG_file_write[];
Xextern char MSG_swap_dot_and_mark[];
Xextern char MSG_shrink_window[];
Xextern char MSG_display_position[];
Xextern char MSG_start_macro[];
Xextern char MSG_end_macro[];
Xextern char MSG_help[];
Xextern char MSG_only_window[];
Xextern char MSG_split_window[];
Xextern char MSG_use_buffer[];
Xextern char MSG_spawn_cli[];
Xextern char MSG_execute_macro[];
Xextern char MSG_goto_line[];
Xextern char MSG_ins_unit[];
Xextern char MSG_kill_buffer[];
Xextern char MSG_load_bindings[];
Xextern char MSG_forw_window[];
Xextern char MSG_back_window[];
Xextern char MSG_view_file[];
Xextern char MSG_enlarge_window[];
Xextern char MSG_ascii_mode[];
Xextern char MSG_binary_mode[];
Xextern char MSG_buffer_name[];
Xextern char MSG_decimal_mode[];
Xextern char MSG_ebcdic_mode[];
Xextern char MSG_hex_mode[];
Xextern char MSG_back_del_unit[];
Xextern char MSG_octal_mode[];
Xextern char MSG_display_version[];
Xextern char MSG_unit_size1[];
Xextern char MSG_unit_size2[];
Xextern char MSG_unit_size4[];
Xextern char MSG_reposition_window[];
Xextern char MSG_set_mark[];
Xextern char MSG_goto_eob[];
Xextern char MSG_goto_bob[];
Xextern char MSG_next_buff[];
Xextern char MSG_prev_buff[];
Xextern char MSG_query_replace[];
Xextern char MSG_display_bindings[];
Xextern char MSG_auto_save[];
Xextern char MSG_back_unit[];
Xextern char MSG_compare[];
Xextern char MSG_forw_del_unit[];
Xextern char MSG_forw_unit[];
Xextern char MSG_link_windows[];
Xextern char MSG_print[];
Xextern char MSG_back_search[];
Xextern char MSG_forw_search[];
Xextern char MSG_back_page[];
Xextern char MSG_copy_region[];
Xextern char MSG_extended_command[];
Xextern char MSG_up_window[];
Xextern char MSG_search_again[];
Xextern char MSG_bind_to_key[];
Xextern char MSG_file_visit_split[];
Xextern char MSG_yank_buffer[];
Xextern char MSG_save_region[];
Xextern char MSG_use_buffer_split[];
Xextern char MSG_no_f_tb[];
X
X#include "lintfunc.dec"
X#define SPECIAL 0x1F /* Special keys */
X
Xtypedef struct key_name_array
X {
X int key_code;
X char *func_name_str;
X char *key_name_str;
X } KEY_NAME_ARRAY;
X#if MSDOS
Xextern bool wang_pc;
Xextern bool ibm_pc;
X#endif
X/*
X * The keyboard's special characters, those things that are prefixed with
X * a 0x1F, are placed into the keyboard tables as KCTRL || 0x80 || x, for some
X * x, i.e. they have both the control and 0x80 bits set, so they won't conflict
X * with anything else on the keyboard.
X */
X
X
X/*
X * Names for the keys with basic keycode
X * between KFIRST and KLAST (inclusive). This is used by
X * the key name routine in "kbd.c".
X */
X#if MSDOS
XKEY_NAME_ARRAY wang_keys[] =
X{
X KCTRL | 0x80, MSG_bind_to_key, "Indent",
X/* KCTRL | 0x81, NULL, "Page", */
X KCTRL | 0x82, MSG_reposition_window, "Center",
X/* KCTRL | 0x83, NULL, "DecTab", */
X/* KCTRL | 0x84, NULL, "Format", */
X/* KCTRL | 0x85, NULL, "Merge", */
X/* KCTRL | 0x86, NULL, "Note", */
X KCTRL | 0x87, MSG_set_mark, "Stop",
X KCTRL | 0x88, MSG_forw_search, "Search",
X KCTRL | 0x89, MSG_yank, "Replace",
X KCTRL | 0x8A, MSG_copy_region, "Copy",
X KCTRL | 0x8B, MSG_kill_region, "Move",
X KCTRL | 0x8C, MSG_extended_command, "Command",
X KCTRL | 0x8D, MSG_forw_window, "UpDown",
X/* KCTRL | 0x8E, NULL, "BlankKey", */
X KCTRL | 0x8F, MSG_goto_line, "GoTo",
X/* KCTRL | 0x90, NULL, "Sh-Indent", */
X/* KCTRL | 0x91, NULL, "Sh-Page", */
X/* KCTRL | 0x92, NULL, "Sh-Center", */
X/* KCTRL | 0x93, NULL, "Sh-DecTab", */
X/* KCTRL | 0x94, NULL, "Sh-Format", */
X/* KCTRL | 0x95, NULL, "Sh-Merge", */
X/* KCTRL | 0x96, NULL, "Sh-Note", */
X/* KCTRL | 0x97, NULL, "Sh-Stop", */
X KCTRL | 0x98, MSG_search_again, "Sh-Search",
X KCTRL | 0x99, MSG_query_replace, "Sh-Replace",
X/* KCTRL | 0x9A, NULL, "Sh-Copy", */
X/* KCTRL | 0x9B, NULL, "Sh-Move", */
X/* KCTRL | 0x9C, NULL, "Sh-Command", */
X KCTRL | 0x9D, MSG_split_window, "Sh-UpDown",
X/* KCTRL | 0x9E, NULL, "Sh-BlankKey", */
X/* KCTRL | 0x9F, NULL, "Sh-GoTo", */
X KCTRL | 0xC0, MSG_back_line, "North",
X KCTRL | 0xC1, MSG_forw_char, "East",
X KCTRL | 0xC2, MSG_forw_line, "South",
X KCTRL | 0xC3, MSG_back_char, "West",
X KCTRL | 0xC4, MSG_byte_shift, "Home",
X/* KCTRL | 0xC5, NULL, "Execute", */
X KCTRL | 0xC6, MSG_ins_toggle, "Insert",
X KCTRL | 0xC7, MSG_forw_del_char, "Delete",
X KCTRL | 0xC8, MSG_back_page, "PrevPage",
X KCTRL | 0xC9, MSG_forw_page, "NextPage",
X/* KCTRL | 0xCB, NULL, "Erase", */
X/* KCTRL | 0xCD, NULL, "BackTab", */
X/* KCTRL | 0xD0, NULL, "Sh-North", */
X KCTRL | 0xD1, MSG_forw_unit, "Sh-East",
X/* KCTRL | 0xD2, NULL, "Sh-South", */
X KCTRL | 0xD3, MSG_back_unit, "Sh-West",
X/* KCTRL | 0xD4, NULL, "Sh-Home", */
X KCTRL | 0xD5, MSG_execute_macro, "Sh-Execute",
X/* KCTRL | 0xD6, NULL, "Sh-Insert", */
X KCTRL | 0xD7, MSG_forw_del_unit, "Sh-Delete",
X KCTRL | 0xD8, MSG_goto_bob, "Sh-PrevPage",
X KCTRL | 0xD9, MSG_goto_eob, "Sh-NextPage",
X/* KCTRL | 0xDB, NULL, "Sh-Erase", */
X/* KCTRL | 0xDC, NULL, "Sh-Tab", */
X/* KCTRL | 0xDD, NULL, "Sh-BackTab", */
X KCTRL | 0xE0, MSG_abort, "Cancel",
X KMETA | KCTRL | 0xE0, MSG_abort, "Cancel",
X KCTLX | KCTRL | 0xE0, MSG_abort, "Ctl-X Cancel",
X KCTRL | 0xE1, MSG_display_bindings, "Help",
X/* KCTRL | 0xE2, NULL, "Glossary", */
X KCTRL | 0xE3, MSG_print, "Print",
X KCTRL | 0xF1, MSG_help, "Sh-Help",
X/* KCTRL | 0xF2, NULL, "Sh-Glossary", */
X/* KCTRL | 0xF3, NULL, "Sh-Print", */
X 0, NULL, NULL
X };
X
XKEY_NAME_ARRAY ibm_keys[] =
X {
X KCTLX | 0x80 | 0x3B, MSG_display_bindings, "F1",
X KCTLX | 0x80 | 0x3C, MSG_set_mark, "F2",
X KCTLX | 0x80 | 0x3D, MSG_forw_search, "F3",
X KCTLX | 0x80 | 0x3E, MSG_search_again, "F4",
X KCTLX | 0x80 | 0x3F, MSG_query_replace, "F5",
X KCTLX | 0x80 | 0x40, MSG_yank, "F6",
X KCTLX | 0x80 | 0x41, MSG_copy_region, "F7",
X KCTLX | 0x80 | 0x42, MSG_kill_region, "F8",
X KCTLX | 0x80 | 0x43, MSG_goto_line, "F9",
X KCTLX | 0x80 | 0x44, MSG_abort, "F10",
X KCTLX | 0x80 | 0x54, MSG_help, "Sh-F1",
X KCTLX | 0x80 | 0x55, MSG_file_read, "Sh-F2",
X KCTLX | 0x80 | 0x56, MSG_file_save, "Sh-F3",
X KCTLX | 0x80 | 0x57, MSG_file_visit, "Sh-F4",
X KCTLX | 0x80 | 0x58, MSG_file_write, "Sh-F5",
X KCTLX | 0x80 | 0x59, MSG_flush_all, "Sh-F6",
X KCTLX | 0x80 | 0x5A, MSG_set_file_name, "Sh-F7",
X KCTLX | 0x80 | 0x5B, MSG_file_insert, "Sh-F8",
X KCTLX | 0x80 | 0x5C, MSG_exit_flush_all, "Sh-F9",
X KCTLX | 0x80 | 0x5D, MSG_quit, "Sh-F10",
X KCTLX | 0x80 | 0x5E, MSG_display_buffers, "Ctl-F1",
X KCTLX | 0x80 | 0x5F, MSG_use_buffer, "Ctl-F2",
X KCTLX | 0x80 | 0x60, MSG_kill_buffer, "Ctl-F3",
X KCTLX | 0x80 | 0x61, MSG_next_buff, "Ctl-F4",
X KCTLX | 0x80 | 0x62, MSG_prev_buff, "Ctl-F5",
X KCTLX | 0x80 | 0x63, MSG_yank_buffer, "Ctl-F6",
X KCTLX | 0x80 | 0x64, MSG_set_file_name, "Ctl-F7",
X KCTLX | 0x80 | 0x65, MSG_file_insert, "Ctl-F8",
X KCTLX | 0x80 | 0x66, MSG_exit_flush_all, "Ctl-F9",
X KCTLX | 0x80 | 0x67, MSG_quit, "Ctl-F10",
X KCTLX | 0x80 | 0x48, MSG_back_line, "North",
X KCTLX | 0x80 | 0x4D, MSG_forw_char, "East",
X KCTLX | 0x80 | 0x74, MSG_forw_unit, "Ctl-East",
X KCTLX | 0x80 | 0x50, MSG_forw_line, "South",
X KCTLX | 0x80 | 0x4B, MSG_back_char, "West",
X KCTLX | 0x80 | 0x73, MSG_back_unit, "Ctl-West",
X KCTLX | 0x80 | 0x49, MSG_back_page, "PageDown",
X KCTLX | 0x80 | 0x47, MSG_goto_bob, "Home",
X KCTLX | 0x80 | 0x51, MSG_forw_page, "PageUp",
X KCTLX | 0x80 | 0x4F, MSG_goto_eob, "End",
X KCTLX | 0x80 | 0x52, MSG_ins_toggle, "Insert",
X KCTLX | 0x80 | 0x53, MSG_forw_del_char, "Delete",
X KCTLX | 0x80 | 0x76, MSG_forw_window, "Ctl-PageDown",
X KCTLX | 0x80 | 0x84, MSG_back_window, "Ctl-PageUp",
X KCTLX | 0x80 | 0x72, MSG_print, "Ctl-Print",
X KCTLX | 0x80 | 0x0F, MSG_forw_unit, "Sh-Tab",
X 0, NULL, NULL
X };
X#endif
X/*
X * Read in a key, doing the low level mapping
X * of ASCII code to 11 bit code. This level deals with
X * mapping the special keys into their spots in the C1
X * control area. The C0 controls go right through, and
X * get remapped by "getkey".
X */
Xstatic int unkey = KRANDOM; /* jam - for ungetkey */
Xvoid ungetkey (k)
X{
X unkey = k;
X}
X
Xint getkbd ()
X{
X register int c;
X
X if (unkey == KRANDOM) /* jam */
X c = ttgetc ();
X else
X {
X c = unkey;
X unkey = KRANDOM;
X }
X if (c == SPECIAL)
X {
X c = ttgetc ();
X if ((c == 0xCD) || (c == 0xDD))/* Backtab is meta */
X return (METACH);
X return (c | KCTRL);
X }
X if (c == 0)
X {
X c = ttgetc ();
X return (c | 0x80 | KCTLX);
X }
X return (c);
X}
X
X
X/*
X * Terminal specific keymap initialization.
X * Attach the special keys to the appropriate built
X * in functions.
X * As is the case of all the keymap routines, errors
X * are very fatal.
X */
Xvoid ttykeymapinit ()
X{
XKEY_NAME_ARRAY *ptr;
Xint i;
Xchar buf[60];
X#if MSDOS
X if (wang_pc)
X ptr = wang_keys;
X
X if (ibm_pc)
X ptr = ibm_keys;
X
X if (!wang_pc && !ibm_pc)
X return;
X
X i = 0;
X while (ptr -> key_code != 0)
X {
X if (ptr -> func_name_str != NULL)
X keydup (ptr -> key_code, ptr -> func_name_str);
X ptr++;
X i++;
X }
X sprintf (buf, MSG_sp_key, i);
X writ_echo (buf);
X#endif
X}
X/*
X* Search key name array for given key code.
X* return pointer to key name.
X*/
Xchar *keystrings (key)
Xint key;
X {
X#if MSDOS
X KEY_NAME_ARRAY *ptr;
X
X if (wang_pc)
X ptr = wang_keys;
X
X if (ibm_pc)
X ptr = ibm_keys;
X
X if (!wang_pc && !ibm_pc)
X return(NULL);
X
X while (ptr -> key_code != 0)
X {
X if (key == ptr -> key_code)
X {
X return (ptr -> key_name_str);
X }
X ptr++;
X }
X#endif
X return (NULL);
X }
END_OF_FILE
if test 11412 -ne `wc -c <'ttykbd.c'`; then
echo shar: \"'ttykbd.c'\" unpacked with wrong size!
fi
chmod +x 'ttykbd.c'
# end of 'ttykbd.c'
fi
if test -f 'window.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'window.c'\"
else
echo shar: Extracting \"'window.c'\" \(10469 characters\)
sed "s/^X//" >'window.c' <<'END_OF_FILE'
X/*
X* Window handling.
X*/
X#include "def.h"
X
Xchar mvupwind ();
Xbool shrinkwind ();
X
Xextern char MSG_no_splt[];
Xextern char MSG_cnt_al_w[];
Xextern char MSG_one_w[];
Xextern char MSG_imp_chg[];
X
X#include "lintfunc.dec"
X/*
X* Reposition the window so as to center on the dot.
X*/
Xbool reposition ()
X{
X long l_val;
X
X l_val = DOT_POS(curwp) - (curwp -> w_ntrows * R_BYTES(curwp) / 2);
X move_ptr (curwp, l_val, FALSE, TRUE, FALSE);
X curwp -> w_flag |= WFHARD;
X return (TRUE);
X}
X
X/*
X* The command make the next
X* window (next => down the screen)
X* the current window. There are no real
X* errors, although the command does
X* nothing if there is only 1 window on
X* the screen.
X*/
Xbool nextwind ()
X{
X
X register WINDOW * wp;
X
X if ((wp = curwp -> w_wndp) == NULL)
X wp = wheadp;
X curwp = wp;
X curbp = wp -> w_bufp;
X return (TRUE);
X}
X
X
X/*
X* This command makes the previous
X* window (previous => up the screen) the
X* current window. There arn't any errors,
X* although the command does not do a lot
X* if there is 1 window.
X*/
Xbool prevwind ()
X{
X
X register WINDOW * wp1;
X register WINDOW * wp2;
X
X wp1 = wheadp;
X wp2 = curwp;
X if (wp1 == wp2)
X wp2 = NULL;
X while (wp1 -> w_wndp != wp2)
X wp1 = wp1 -> w_wndp;
X curwp = wp1;
X curbp = wp1 -> w_bufp;
X return (TRUE);
X}
X
X
X/*
X* This command moves the current
X* window down by "arg" lines. Recompute
X* the top line in the window. The move up and
X* move down code is almost completely the same;
X* most of the work has to do with reframing the
X* window, and picking a new dot. We share the
X* code by having "move down" just be an interface
X* to "move up".
X*/
Xchar mvdnwind (f, n, k)
Xregister int n;
X{
X return (mvupwind (f, -n, KRANDOM));
X}
X
X
X/*
X* Move the current window up by "arg"
X* lines. Recompute the new top line of the window.
X* Look to see if "." is still on the screen. If it is,
X* you win. If it isn't, then move "." to center it
X* in the new framing of the window (this command does
X* not really move "."; it moves the frame).
X*/
Xchar mvupwind (f, n, k)
X int n;
X{
X A32 l_val, l_bytes;
X
X l_bytes = (A32)R_BYTES(curwp); /* number of bytes in a row */
X l_val = n * l_bytes; /* number of bytes to move */
X move_ptr (curwp, l_val, FALSE, TRUE, TRUE); /* move window */
X
X /* check that dot is in window */
X while (DOT_POS(curwp) < WIND_POS(curwp))
X {
X /* dot is before the first window line */
X move_ptr (curwp, l_bytes, TRUE, TRUE, TRUE);
X }
X while (DOT_POS (curwp) >=
X ((l_bytes * curwp -> w_ntrows) + WIND_POS(curwp)))
X {
X /* dot is after the last window line */
X move_ptr (curwp, -l_bytes, TRUE, TRUE, TRUE);
X }
X curwp -> w_flag |= WFHARD;
X return (TRUE);
X}
X
X
X/*
X* This command makes the current
X* window the only window on the screen.
X* Try to set the framing
X* so that "." does not have to move on
X* the display. Some care has to be taken
X* to keep the values of dot and mark
X* in the buffer structures right if the
X* distruction of a window makes a buffer
X* become undisplayed.
X*/
Xchar onlywind ()
X{
X
X register WINDOW * wp;
X register LINE * lp;
X register int i;
X
X while (wheadp != curwp)
X {
X
X wp = wheadp;
X wheadp = wp -> w_wndp;
X if (--wp -> w_bufp -> b_nwnd == 0)
X {
X
X wp -> w_bufp -> b_dotp = wp -> w_dotp;
X wp -> w_bufp -> b_doto = wp -> w_doto;
X wp -> w_bufp -> b_markp = wp -> w_markp;
X wp -> w_bufp -> b_marko = wp -> w_marko;
X }
X
X free ((char *) wp);
X }
X
X while (curwp -> w_wndp != NULL)
X {
X
X wp = curwp -> w_wndp;
X curwp -> w_wndp = wp -> w_wndp;
X if (--wp -> w_bufp -> b_nwnd == 0)
X {
X
X wp -> w_bufp -> b_dotp = wp -> w_dotp;
X wp -> w_bufp -> b_doto = wp -> w_doto;
X wp -> w_bufp -> b_markp = wp -> w_markp;
X wp -> w_bufp -> b_marko = wp -> w_marko;
X }
X
X free ((char *) wp);
X }
X
X lp = curwp -> w_linep;
X i = curwp -> w_toprow;
X while (i != 0 && lback (lp) != curbp -> b_linep)
X {
X
X --i;
X lp = lback (lp);
X }
X
X curwp -> w_toprow = 0;
X curwp -> w_ntrows = nrow - 2;/* 2 = mode, echo. */
X curwp -> w_linep = lp;
X curwp -> w_flag |= WFMODE | WFHARD;
X return (TRUE);
X}
X
X
X/*
X* Split the current window. A window
X* smaller than 3 lines cannot be split.
X* The only other error that is possible is
X* a "malloc" failure allocating the structure
X* for the new window.
X*/
Xbool splitwind ()
X{
X
X register WINDOW * wp;
X register int ntru;
X register int ntrl;
X register int ntrd;
X register WINDOW * wp1;
X register WINDOW * wp2;
X char buf[80], buf1[40];
X
X if (curwp -> w_ntrows < 3)
X {
X sprintf (buf1, MSG_no_splt, R_BYTE_FMT(curwp));
X sprintf (buf, buf1, curwp -> w_ntrows);
X writ_echo (buf);
X return (FALSE);
X }
X
X if ((wp = (WINDOW *) malloc (sizeof (WINDOW))) == NULL)
X {
X
X writ_echo (MSG_cnt_al_w);
X return (FALSE);
X }
X
X ++curbp -> b_nwnd; /* Displayed twice. */
X wp -> w_bufp = curbp;
X wp -> w_dotp = curwp -> w_dotp;
X wp -> w_doto = curwp -> w_doto;
X wp -> w_unit_offset = curwp -> w_unit_offset;
X wp -> w_markp = curwp -> w_markp;
X wp -> w_marko = curwp -> w_marko;
X wp -> w_flag = 0;
X wp -> w_disp_shift = curwp -> w_disp_shift;
X wp -> w_intel_mode = curwp -> w_intel_mode;
X wp -> w_fmt_ptr = curwp -> w_fmt_ptr;
X ntru = (curwp -> w_ntrows - 1) / 2;/* Upper size */
X ntrl = (curwp -> w_ntrows - 1) - ntru;/* Lower size */
X
X if (ntrd <= get_currow (curwp))
X {
X /* Old is upper window. */
X curwp -> w_ntrows = ntru;
X wp -> w_wndp = curwp -> w_wndp;
X curwp -> w_wndp = wp;
X wp -> w_toprow = curwp -> w_toprow + ntru + 1;
X wp -> w_ntrows = ntrl;
X }
X else
X {
X /* Old is lower window */
X wp1 = NULL;
X wp2 = wheadp;
X while (wp2 != curwp)
X {
X wp1 = wp2;
X wp2 = wp2 -> w_wndp;
X }
X
X if (wp1 == NULL)
X wheadp = wp;
X else
X wp1 -> w_wndp = wp;
X wp -> w_wndp = curwp;
X wp -> w_toprow = curwp -> w_toprow;
X wp -> w_ntrows = ntru;
X ++ntru; /* Mode line. */
X curwp -> w_toprow += ntru;
X curwp -> w_ntrows = ntrl;
X }
X
X wind_on_dot (curwp); /* put window on the dot */
X wp -> w_loff = curwp -> w_loff;/* do the same for the new window */
X wp -> w_linep = curwp -> w_linep;
X curwp -> w_flag |= WFMODE | WFHARD;
X wp -> w_flag |= WFMODE | WFHARD;
X return (TRUE);
X}
X
X
X/*
X* Enlarge the current window.
X* Find the window that loses space. Make
X* sure it is big enough. If so, hack the window
X* descriptions, and ask redisplay to do all the
X* hard work. You don't just set "force reframe"
X* because dot would move.
X*/
Xbool enlargewind (f, n, k)
X{
X register WINDOW * adjwp;
X register LINE * lp;
X register int i;
X
X if (n < 0)
X return (shrinkwind (f, -n, KRANDOM));
X if (wheadp -> w_wndp == NULL)
X {
X
X writ_echo (MSG_one_w);
X return (FALSE);
X }
X
X if ((adjwp = curwp -> w_wndp) == NULL)
X {
X adjwp = wheadp;
X while (adjwp -> w_wndp != curwp)
X adjwp = adjwp -> w_wndp;
X }
X
X if (adjwp -> w_ntrows <= n)
X {
X writ_echo (MSG_imp_chg);
X return (FALSE);
X }
X
X if (curwp -> w_wndp == adjwp)
X {
X /* 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 }
X else
X {
X /* 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
X curwp -> w_ntrows += n;
X adjwp -> w_ntrows -= n;
X curwp -> w_flag |= WFMODE | WFHARD;
X adjwp -> w_flag |= WFMODE | WFHARD;
X return (TRUE);
X}
X
X
X/*
X* Shrink the current window.
X* Find the window that gains space. Hack at
X* the window descriptions. Ask the redisplay to
X* do all the hard work.
X*/
Xbool shrinkwind (f, n, k)
X{
X register WINDOW * adjwp;
X register LINE * lp;
X register int i;
X
X if (n < 0)
X return (enlargewind (f, -n, KRANDOM));
X if (wheadp -> w_wndp == NULL)
X {
X writ_echo (MSG_one_w);
X return (FALSE);
X }
X
X if ((adjwp = curwp -> w_wndp) == NULL)
X {
X adjwp = wheadp;
X while (adjwp -> w_wndp != curwp)
X adjwp = adjwp -> w_wndp;
X }
X
X if (curwp -> w_ntrows <= n)
X {
X writ_echo (MSG_imp_chg);
X return (FALSE);
X }
X
X if (curwp -> w_wndp == adjwp)
X {
X /* 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 }
X else
X {
X /* 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
X curwp -> w_ntrows -= n;
X adjwp -> w_ntrows += n;
X curwp -> w_flag |= WFMODE | WFHARD;
X adjwp -> w_flag |= WFMODE | WFHARD;
X return (TRUE);
X}
X
X
X/*
X* Pick a window for a pop-up.
X* Split the screen if there is only
X* one window. Pick the uppermost window that
X* isn't the current window. An LRU algorithm
X* might be better. Return a pointer, or
X* NULL on error.
X*/
XWINDOW * wpopup ()
X{
X
X register WINDOW * wp;
X
X if (wheadp -> w_wndp == NULL
X && splitwind () == FALSE)
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}
X
X
X/*
X* Refresh the display.
X* In the normal case the
X* call to "update" in "main.c" refreshes the screen,
X* and all of the windows need not be recomputed.
X*/
Xbool refresh ()
X{
X sgarbf = TRUE;
X return (TRUE);
X}
END_OF_FILE
if test 10469 -ne `wc -c <'window.c'`; then
echo shar: \"'window.c'\" unpacked with wrong size!
fi
chmod +x 'window.c'
# end of 'window.c'
fi
echo shar: End of archive 2 \(of 11\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 11 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
More information about the Alt.sources
mailing list