BEAV, a full featured binary file editor, part 09 of 11
Peter Reilley
pvr at wang.com
Thu Feb 28 07:53:24 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 9 (of 11)."
# Contents: random.c
# Wrapped by pvr at elf on Wed Feb 27 14:16:50 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'random.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'random.c'\"
else
echo shar: Extracting \"'random.c'\" \(30672 characters\)
sed "s/^X//" >'random.c' <<'END_OF_FILE'
X/*
X* Assorted commands.
X* The file contains the command
X* processors for a large assortment of unrelated
X* commands. The only thing they have in common is
X* that they are all command processors.
X*/
X
X#include "def.h"
X
Xchar backdel ();
Xbool fill_out ();
Xvoid bad_key ();
X
X
X
Xextern char MSG_sh_pos[];
Xextern char MSG_sh_pos1[];
Xextern char MSG_f_str[];
Xextern char MSG_3u[];
Xextern char MSG_5u[];
Xextern char MSG_lu[];
Xextern char MSG_03u[];
Xextern char MSG_05u[];
Xextern char MSG_010lu[];
Xextern char MSG_lnk[];
Xextern char MSG_unlink[];
Xextern char MSG_link[];
Xextern char MSG_bad_key[];
Xextern char MSG_esc[];
Xextern char MSG_ctl_x[];
Xextern char MSG_ctl[];
Xextern char MSG_key_code[];
Xextern char char_str[];
X
X#if RUNCHK
Xextern char ERR_rnd_1[];
Xextern char ERR_rnd_2[];
Xextern char ERR_rnd_3[];
Xextern char ERR_rnd_4[];
Xextern char MSG_rnd_5[];
Xextern char ERR_rnd_6[];
Xextern char ERR_rnd_7[];
X#endif
X#include "lintfunc.dec"
X
Xextern ROW_FMT ascii_fmt;
Xextern ROW_FMT ebcdic_fmt;
Xextern ROW_FMT binary_8_fmt;
Xextern ROW_FMT binary_16_fmt;
Xextern ROW_FMT binary_32_fmt;
Xextern ROW_FMT octal_8_fmt;
Xextern ROW_FMT octal_16_fmt;
Xextern ROW_FMT octal_32_fmt;
Xextern ROW_FMT decimal_8_fmt;
Xextern ROW_FMT decimal_16_fmt;
Xextern ROW_FMT decimal_32_fmt;
Xextern ROW_FMT hex_8_fmt;
Xextern ROW_FMT hex_16_fmt;
Xextern ROW_FMT hex_32_fmt;
X
Xextern bool read_pat_mode;
Xextern bool dont_repeat;
X
Xchar dec_chr_ok ();
Xulong get_long ();
X
X/*
X* Display a bunch of useful information about
X* the current location of dot and mark.
X* The position of the dot and mark and the difference between them.
X* The total buffer size is displayed.
X* This is normally bound to "C-X =".
X*/
Xbool showcpos (f, n, k)
X{
X
X A32 dotoff,
X markoff,
X fsize,
X bsize;
X char buf[80], buf1[80];
X
X dotoff = curwp -> w_dotp -> l_file_offset;
X dotoff += curwp -> w_doto;
X
X if (curwp -> w_markp != NULL)
X {
X markoff = curwp -> w_markp -> l_file_offset;
X markoff += curwp -> w_marko;
X }
X
X bsize = curwp -> w_bufp -> b_linep -> l_bp -> l_file_offset;
X bsize += curwp -> w_bufp -> b_linep -> l_bp -> l_used;
X fsize = curbp -> b_file_size;
X
X if (curwp -> w_markp != NULL)
X {
X /* build format string */
X sprintf (buf1, MSG_sh_pos, R_POS_FMT(curwp), R_POS_FMT(curwp),
X R_POS_FMT(curwp), R_POS_FMT(curwp));
X sprintf (buf, buf1, dotoff, markoff, bsize, fsize);
X }
X else
X {
X /* build format string */
X sprintf (buf1, MSG_sh_pos1, R_POS_FMT(curwp), R_POS_FMT(curwp),
X R_POS_FMT(curwp));
X sprintf (buf, buf1, dotoff, bsize, fsize);
X }
X
X sprintf (&buf[strlen(buf)], MSG_f_str, curbp -> b_fname);
X writ_echo (buf);
X
X return (TRUE);
X}
X
X
X/*
X* Twiddle the two characters on either side of
X* dot. If dot is at the end of the line twiddle the
X* two characters before it. Return with an error if dot
X* is at the beginning of line; it seems to be a bit
X* pointless to make this work. This fixes up a very
X* common typo with a single stroke. Normally bound
X* to "C-T". This always works within a line, so
X* "WFEDIT" is good enough.
X*/
Xbool twiddle ()
X{
X
X register LINE * dotp;
X register short doto;
X register int cl;
X register int cr;
X char b_per_u,
X f_buf[4],
X s_buf[4],
X i;
X
X dotp = curwp -> w_dotp;
X doto = curwp -> w_doto;
X b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
X /* try to move back one unit */
X if (!move_ptr (curwp, (long) - b_per_u, TRUE, TRUE, TRUE))
X {
X curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
X curwp -> w_doto = doto;
X ttbeep ();
X return (FALSE);
X }
X /* pick up first unit byte by byte */
X for (i = 0; i < b_per_u; i++)
X {
X f_buf[i] = DOT_CHAR(curwp);
X move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
X }
X /* move to the end of the second unit */
X if (!move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE))
X {
X curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
X curwp -> w_doto = doto;
X ttbeep ();
X return (FALSE);
X }
X /* pick up second unit (reverse order) and deposit second unit */
X for (i = 0; i < b_per_u; i++)
X {
X s_buf[i] = DOT_CHAR(curwp);
X DOT_CHAR(curwp) = f_buf[b_per_u - 1 - i];
X move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
X }
X /* deposit first unit */
X for (i = 0; i < b_per_u; i++)
X {
X DOT_CHAR(curwp) = s_buf[i];
X move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
X }
X curwp -> w_dotp = dotp;
X curwp -> w_doto = doto;
X lchange (WFHARD);
X return (TRUE);
X}
X
X/*
X* Quote the next character, and
X* insert it into the buffer. All the characters
X* are taken literally.
X* The character
X* is always read, even if it is inserted 0 times, for
X* regularity.
X*/
Xbool quote (f, n, k)
X{
X
X register int s;
X register int c;
X
X if (kbdmop != NULL)
X c = *kbdmop++;
X else
X {
X c = ttgetc ();
X if (kbdmip != NULL)
X {
X if (kbdmip > &kbdm[NKBDM - 4])
X {
X ctrlg (FALSE, 0, KRANDOM);
X return (ABORT);
X }
X
X *kbdmip++ = c;
X }
X
X }
X
X if (n < 0)
X return (FALSE);
X if (n == 0)
X return (TRUE);
X
X return (linsert (n, c));
X}
X
X/*
X* Toggle the insert mode. Insert mode is used only in ASCII or EBCDIC modes.
X*/
Xbool insert_toggle () /* toggle routine for selfinsert */
X{
X register WINDOW * wp;
X
X if (curbp -> b_flag & BFSLOCK)
X return (TRUE);
X
X if (read_pat_mode)
X dont_repeat = TRUE;
X
X insert_mode = !insert_mode;
X for (wp = wheadp; wp; wp = wp -> w_wndp)
X wp -> w_flag |= WFMODE; /* force mode line update */
X return (TRUE);
X}
X
X/*
X* Ordinary text characters are bound to this function,
X* which inserts them into the buffer. Characters marked as control
X* characters (using the CTRL flag) may be remapped to their ASCII
X* equivalent. This makes TAB (C-I) work right, and also makes the
X* world look reasonable if a control character is bound to this
X* this routine by hand. Any META or CTLX flags on the character
X* are discarded.
X*
X* Edit the unit under the cursor.
X* Check that the character is valid for the current display mode.
X*/
X
Xbool selfinsert (f, n, k)
X{
X
X register int c;
X register int s;
X char edt_buf[4],
X i_chr,
X b_per_u,
X u_offs,
X u_roffs,
X bit_shf,
X bit_mask,
X i;
X LINE * l_ptr;
X short d_offs;
X int bytes,
X temp_int;
X long dot_shf,
X l_mask,
X l_val;
X char text_buf[12];
X static char max_dec_8[] = "255";
X static char max_dec_16[] = "65535";
X static char max_dec_32[] = "4294967295";
X int cur_col;
X
X bool intel;
X
X if (n < 0)
X {
X ttbeep ();
X return (FALSE);
X }
X if (n == 0)
X {
X ttbeep ();
X return (TRUE);
X }
X c = k & KCHAR;
X if ((k & KCTRL) != 0 && c >= '@' && c <= '_')/* ASCII-ify. */
X c -= '@';
X b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
X u_offs = curwp -> w_unit_offset;
X u_roffs = curwp -> w_fmt_ptr -> r_chr_per_u - u_offs - 1;
X intel = curwp -> w_intel_mode;
X
X cur_col = ttcol;
X
X switch (curwp -> w_fmt_ptr -> r_type)
X {
X case EBCDIC:
X c = to_ebcdic (c); /* convert ASCII to EBCDIC */
X case ASCII:
X if ((insert_mode) || (DOT_POS(curwp) == BUF_SIZE(curwp)))
X {
X s = linsert (n, c);
X if (read_pat_mode)
X forwchar (0, 1, KRANDOM);/* advance the cursor */
X }
X else
X s = lreplace (n, c);
X break;
X
X case HEX:
X if ((c >= '0') && (c <= '9'))
X {
X i_chr = c - '0';/* convert to binary */
X }
X else
X if ((c >= 'A') && (c <= 'F'))
X {
X i_chr = c - 'A' + 10;/* convert to binary */
X }
X else
X if ((c >= 'a') && (c <= 'f'))
X {
X i_chr = c - 'a' + 10;/* convert to binary */
X }
X else
X {
X bad_key (k);
X return (FALSE);
X }
X fill_out (); /* expand buffer if necessary */
X
X /* position dot to byte to be altered */
X if (intel)
X dot_shf = u_roffs >> 1;
X else
X dot_shf = u_offs >> 1;
X
X /* save dot position for later */
X l_ptr = curwp -> w_dotp;
X d_offs = curwp -> w_doto;
X move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
X
X if (u_offs & 1)
X { /* lower nibble in byte */
X i_chr &= 0x0f;
X DOT_CHAR(curwp) &= 0xf0;
X DOT_CHAR(curwp) |= i_chr;
X }
X else
X { /* upper nibble in byte */
X i_chr <<= 4;
X i_chr &= 0xf0;
X DOT_CHAR(curwp) &= 0x0f;
X DOT_CHAR(curwp) |= i_chr;
X }
X
X /* restore dot position */
X curwp -> w_dotp = l_ptr;
X curwp -> w_doto = d_offs;
X forwchar (0, 1, KRANDOM);/* advance the cursor */
X break;
X
X case BINARY:
X if ((c != '0') && (c != '1'))
X {
X bad_key (k);
X return (FALSE);
X }
X
X /* position dot to byte to be altered */
X if (intel)
X dot_shf = u_roffs >> 3;
X else
X dot_shf = u_offs >> 3;
X
X fill_out (); /* expand buffer if necessary */
X
X /* save dot position for later */
X l_ptr = curwp -> w_dotp;
X d_offs = curwp -> w_doto;
X move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
X
X bit_shf = u_roffs & 0x07;
X
X if (c == '0')
X {
X DOT_CHAR(curwp) &= ~(1 << bit_shf);
X }
X else
X {
X DOT_CHAR(curwp) |= 1 << bit_shf;
X }
X
X /* restore dot position */
X curwp -> w_dotp = l_ptr;
X curwp -> w_doto = d_offs;
X forwchar (0, 1, KRANDOM);/* advance the cursor */
X break;
X
X case OCTAL:
X if (c < '0')
X {
X bad_key (k);
X return (FALSE);
X }
X else
X if ((c > '1') && (u_offs == 0) &&
X ((curwp -> w_fmt_ptr -> r_size) == WORDS))
X {
X bad_key (k);
X return (FALSE);
X }
X else
X if ((c > '3') && (u_offs == 0))
X {
X bad_key (k);
X return (FALSE);
X }
X else
X if (c > '7')
X {
X bad_key (k);
X return (FALSE);
X }
X
X dot_shf = (c - '0') & 7;/* get binary value */
X l_mask = 7; /* create bit mask */
X
X dot_shf <<= (u_roffs * 3);
X l_mask <<= (u_roffs * 3);
X
X fill_out (); /* expand buffer if necessary */
X
X /* save dot position for later */
X l_ptr = curwp -> w_dotp;
X d_offs = curwp -> w_doto;
X
X /* position dot to the byte to be altered */
X if (intel)
X {
X for (i = 0; i < b_per_u; i++)
X {
X DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
X DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
X l_mask >>= 8;
X dot_shf >>= 8;
X move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
X }
X }
X else
X {
X move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE);
X /* move to last byte */
X for (i = 0; i < b_per_u; i++)
X {
X DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
X DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
X l_mask >>= 8;
X dot_shf >>= 8;
X move_ptr (curwp, -1L, TRUE, FALSE, TRUE);/* step back one byte */
X }
X }
X
X /* restore dot position */
X curwp -> w_dotp = l_ptr;
X curwp -> w_doto = d_offs;
X forwchar (0, 1, KRANDOM);/* advance the cursor */
X break;
X
X case DECIMAL:
X fill_out (); /* expand buffer if necessary */
X
X /* save dot position for later */
X l_ptr = curwp -> w_dotp;
X d_offs = curwp -> w_doto;
X
X bytes = fill_buf (curwp, l_ptr, d_offs, edt_buf, b_per_u);
X /* if last unit is not full and must be extended */
X for (; bytes < b_per_u; bytes++)
X {
X edt_buf[3] = edt_buf[2];/* shuffle bytes down */
X edt_buf[2] = edt_buf[1];
X edt_buf[1] = edt_buf[0];
X edt_buf[0] = 0;
X }
X switch (curwp -> w_fmt_ptr -> r_size)
X {
X case BYTES:
X sprintf (text_buf, MSG_03u, (int) (edt_buf[0] & 0xff));
X if (!dec_chr_ok (text_buf, max_dec_8, c, u_offs))
X {
X bad_key (k);
X return (TRUE); /* TRUE so that mask will be same len */
X }
X sscanf (text_buf, MSG_3u, &i);/* convert back to binary */
X l_val = (long) i & 0xff;
X break;
X
X case WORDS:
X l_val = get_int (edt_buf);/* do intel swap */
X sprintf (text_buf, MSG_05u, (int) (l_val & 0xFFFF));
X if (!dec_chr_ok (text_buf, max_dec_16, c, u_offs))
X {
X bad_key (k);
X return (TRUE); /* TRUE so that mask will be same len */
X }
X sscanf (text_buf, MSG_5u, &temp_int);
X /* convert back to binary */
X l_val = get_int ((char *) & temp_int);/* do intel swap */
X break;
X
X case DWORDS:
X l_val = get_long (edt_buf);/* do intel swap */
X sprintf (text_buf, MSG_010lu, l_val);
X if (!dec_chr_ok (text_buf, max_dec_32, c, u_offs))
X {
X bad_key (k);
X return (TRUE); /* TRUE so that mask will be same len */
X }
X sscanf (text_buf, MSG_lu, &l_val);
X /* convert back to binary */
X l_val = get_long ((char *) & l_val);/* do intel swap */
X break;
X#if RUNCHK
X default:
X writ_echo (ERR_rnd_2);
X break;
X#endif
X }
X DOT_CHAR(curwp) = (char) l_val & 0xff;
X for (i = 1; i < b_per_u; i++)
X {
X l_val >>= 8;
X move_ptr (curwp, 1L, TRUE, FALSE, TRUE);/* step forward one byte */
X DOT_CHAR(curwp) = (char) l_val & 0xff;
X }
X
X /* restore dot position */
X curwp -> w_dotp = l_ptr;
X curwp -> w_doto = d_offs;
X forwchar (0, 1, KRANDOM);/* advance the cursor */
X break;
X
X#if RUNCHK
X default:
X writ_echo (ERR_rnd_3);
X break;
X#endif
X }
X /* if cursor has wrapped to the next line then previous line
X will not be refreshed with WFEDIT so do a WFHARD */
X if (cur_col > get_curcol(curwp))
X lchange (WFHARD);
X else
X lchange (WFEDIT);
X
X return (TRUE);
X}
X
X/*
X* Insert one unit of zeros at the current dot position.
X*/
Xbool insertunit (f, n, k)
X{
X lchange (WFEDIT);
X linsert ((R_B_PER_U(curwp) * n), 0);
X return (TRUE);
X}
X
X/*
X* Increase the size of the buffer if necessary.
X* If dot is at the byte after the last full unit
X* then add enough bytes to the buffer to create
X* a full unit at the end.
X*/
X
Xbool fill_out ()
X{
X long buf_size, dot_pos, l_val, last_unit;
X int b_per_u;
X char stat, shift;
X int insert_val;
X
X buf_size = BUF_SIZE(curwp);
X dot_pos = DOT_POS(curwp);
X b_per_u = R_B_PER_U(curwp);
X shift = curwp -> w_disp_shift;
X stat = TRUE;
X insert_val = 0;
X last_unit = buf_size & ~((long)(b_per_u - 1));
X /* there is an even number of units step back one */
X if (last_unit == buf_size)
X last_unit -= b_per_u;
X last_unit += shift;
X
X /* if dot is one byte past the end of the buffer */
X if (dot_pos > last_unit)
X {
X insert_val = b_per_u;
X }
X
X /* if dot is pointed at the end of the buffer */
X else if (dot_pos == last_unit)
X {
X insert_val = b_per_u - (buf_size - last_unit);
X }
X
X /* if insert is necessary then do it */
X if (insert_val != 0)
X {
X lchange (WFHARD);
X move_ptr (curwp, buf_size, TRUE, FALSE, FALSE); /* move dot to end */
X stat = linsert (insert_val, 0);
X move_ptr (curwp, dot_pos, TRUE, TRUE, FALSE); /* put dot back */
X }
X return (stat);
X}
X
X/*
X* This checks that an entered character is ok
X* for the position given.
X*/
X
Xchar dec_chr_ok (char_buf, max_str, chr, pos)
X
Xchar chr,
X pos,
X *char_buf,
X *max_str;
X
X{
X char i;
X
X if ((chr < '0') || (chr > '9'))
X return (FALSE);
X
X char_buf[pos] = chr; /* insert typed char */
X
X /* check if number is too big */
X for (i = 0; max_str[i] != 0; i++)
X {
X if (char_buf[i] < max_str[i])
X break; /* if char is smaller then must be ok */
X
X if (char_buf[i] > max_str[i])
X return (FALSE); /* val is too large; ERROR */
X }
X return (TRUE);
X}
X
X/*
X* Set the rest of the variables for the mode change.
X*/
Xvoid set_mode_vars ()
X{
X curwp -> w_disp_shift = 0; /* shift to 0 when changing mode */
X curwp -> w_unit_offset = 0; /* go to end of unit */
X /* if we are in the middle of a search then use the proper format struc */
X if (read_pat_mode)
X curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
X
X wind_on_dot (curwp);
X curwp -> w_flag = WFHARD;
X update ();
X}
X
X/*
X* Change the display mode to ASCII.
X* The default binding is META C-A.
X*/
Xbool asciimode ()
X{
X curwp -> w_fmt_ptr = &ascii_fmt;
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display mode to EBCDIC.
X* The default binding is META C-E.
X*/
Xbool ebcdicmode ()
X{
X curwp -> w_fmt_ptr = &ebcdic_fmt;
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display mode to DECIMAL.
X* The default binding is META C-D.
X*/
Xbool decimalmode ()
X{
X switch (curwp -> w_fmt_ptr -> r_size)
X {
X case BYTES:
X curwp -> w_fmt_ptr = &decimal_8_fmt;
X break;
X case WORDS:
X curwp -> w_fmt_ptr = &decimal_16_fmt;
X break;
X
X case DWORDS:
X curwp -> w_fmt_ptr = &decimal_32_fmt;
X break;
X#if RUNCHK
X default:
X writ_echo (ERR_rnd_4);
X break;
X#endif
X }
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display mode to HEXADECIMAL.
X* The default binding is META C-H.
X*/
Xbool hexmode ()
X{
X switch (curwp -> w_fmt_ptr -> r_size)
X {
X case BYTES:
X curwp -> w_fmt_ptr = &hex_8_fmt;
X break;
X case WORDS:
X curwp -> w_fmt_ptr = &hex_16_fmt;
X break;
X case DWORDS:
X curwp -> w_fmt_ptr = &hex_32_fmt;
X break;
X#if RUNCHK
X default:
X writ_echo (MSG_rnd_5);
X break;
X#endif
X }
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display mode to OCTAL.
X* The default binding is META C-O.
X*/
Xbool octalmode ()
X{
X switch (curwp -> w_fmt_ptr -> r_size)
X {
X case BYTES:
X curwp -> w_fmt_ptr = &octal_8_fmt;
X break;
X
X case WORDS:
X curwp -> w_fmt_ptr = &octal_16_fmt;
X break;
X
X case DWORDS:
X curwp -> w_fmt_ptr = &octal_32_fmt;
X break;
X#if RUNCHK
X default:
X writ_echo (ERR_rnd_6);
X break;
X#endif
X }
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display mode to BINARY.
X* The default binding is META C-B.
X*/
Xbool binarymode ()
X{
X switch (curwp -> w_fmt_ptr -> r_size)
X {
X case BYTES:
X curwp -> w_fmt_ptr = &binary_8_fmt;
X break;
X case WORDS:
X curwp -> w_fmt_ptr = &binary_16_fmt;
X break;
X case DWORDS:
X curwp -> w_fmt_ptr = &binary_32_fmt;
X break;
X#if RUNCHK
X default:
X writ_echo (ERR_rnd_7);
X break;
X#endif
X }
X set_mode_vars ();
X return (TRUE);
X}
X
X/*
X* Change the display shift.
X* Circularly rotate through display shift of 0 through 3.
X* This value is used to shift the display by the designated number of bytes.
X* This is used to cause WORD and DWORD values to be calculated
X* from the correct offset.
X*/
Xbool dispshift (f, n, k)
X{
X char mode,
X size;
X
X if (read_pat_mode)
X return (TRUE); /* no shift is allowed in search mode */
X
X mode = curwp -> w_fmt_ptr -> r_type;
X size = curwp -> w_fmt_ptr -> r_size;
X
X if (((mode == HEX) ||
X (mode == DECIMAL) ||
X (mode == BINARY) ||
X (mode == OCTAL)) &&
X (size != BYTES))
X {
X if ((size == WORDS) &&
X (curwp -> w_disp_shift >= 1))
X { /* roll over on words */
X curwp -> w_disp_shift = 0;
X }
X else
X if ((size == DWORDS) &&
X (curwp -> w_disp_shift >= 3))
X { /* roll over on double words */
X curwp -> w_disp_shift = 0;
X }
X else
X {
X curwp -> w_disp_shift++;/* increment shift */
X }
X }
X else
X {
X curwp -> w_disp_shift = 0;/* set to no shift */
X }
X move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
X wind_on_dot (curwp);
X curwp -> w_flag = WFHARD; /* force full window refresh */
X return (TRUE);
X}
X
X/*
X* Delete forward. This is real
X* easy, because the basic delete routine does
X* all of the work. Watches for negative arguments,
X* and does the right thing. If any argument is
X* present, it kills rather than deletes, to prevent
X* loss of text if typed with a big argument.
X* Normally bound to "C-D".
X*/
Xchar forwdel (f, n, k)
X{
X char s;
X
X if (n < 0)
X return (backdel (f, -n, KRANDOM));
X
X s = FALSE;
X if (R_SIZE(curwp) == BYTES)
X {
X if (f != FALSE)
X {
X /* Really a kill. */
X if ((lastflag & CFKILL) == 0)
X kdelete ();
X thisflag |= CFKILL;
X }
X s = ldelete (n, f);
X curwp -> w_unit_offset = 0;
X }
X return (s);
X}
X
X
X/*
X* Delete backwards. This is quite easy too,
X* because it's all done with other functions. Just
X* move the cursor back, and delete forwards.
X* Like delete forward, this actually does a kill
X* if presented with an argument.
X*/
Xchar backdel (f, n, k)
X{
X
X int u_off;
X char s;
X
X if (n < 0)
X return (forwdel (f, -n, KRANDOM));
X
X s = FALSE;
X if (R_SIZE(curwp) == BYTES)
X {
X u_off = curwp -> w_unit_offset;
X curwp -> w_unit_offset = 0;
X if ((s = backchar (f, n * R_CHR_PER_U(curwp), KRANDOM)) == TRUE)
X {
X s = ldelete (n, f);
X if (f != FALSE)
X {
X /* Really a kill. */
X if ((lastflag & CFKILL) == 0)
X kdelete ();
X thisflag |= CFKILL;
X }
X }
X curwp -> w_unit_offset = u_off;
X }
X return (s);
X}
X
X
X/*
X* Change the size of the display unit to BYTE.
X* Adjust byte shift to the allowable range.
X* Normally bound to "META-1".
X*/
Xbool dispsize1 ()
X{
X curwp -> w_disp_shift = 0; /* shift to 0 when changing size */
X curwp -> w_unit_offset = 0; /* go to end of unit */
X
X switch (R_TYPE(curwp))
X {
X case OCTAL:
X curwp -> w_fmt_ptr = &octal_8_fmt;
X break;
X
X case DECIMAL:
X curwp -> w_fmt_ptr = &decimal_8_fmt;
X break;
X
X case HEX:
X curwp -> w_fmt_ptr = &hex_8_fmt;
X break;
X
X case BINARY:
X curwp -> w_fmt_ptr = &binary_8_fmt;
X break;
X
X default:
X return (TRUE);
X break;
X }
X
X /* if we are in the middle of a search then use the proper format struc */
X if (read_pat_mode)
X curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
X
X move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
X wind_on_dot (curwp);
X curwp -> w_flag = WFHARD;
X update ();
X return (TRUE);
X}
X
X/*
X* Change the size of the display unit to WORD.
X* Adjust byte shift to the allowable range.
X* Normally bound to "META-2".
X*/
Xbool dispsize2 ()
X{
X curwp -> w_disp_shift = 0; /* shift to 0 when changing size */
X curwp -> w_unit_offset = 0; /* go to end of unit */
X
X switch (R_TYPE(curwp))
X {
X case OCTAL:
X curwp -> w_fmt_ptr = &octal_16_fmt;
X break;
X
X case DECIMAL:
X curwp -> w_fmt_ptr = &decimal_16_fmt;
X break;
X
X case HEX:
X curwp -> w_fmt_ptr = &hex_16_fmt;
X break;
X
X case BINARY:
X curwp -> w_fmt_ptr = &binary_16_fmt;
X break;
X
X default:
X return (TRUE);
X break;
X }
X
X /* if we are in the middle of a search then use the proper format struc */
X if (read_pat_mode)
X curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
X
X move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
X wind_on_dot (curwp);
X curwp -> w_flag = WFHARD;
X update ();
X return (TRUE);
X}
X
X/*
X* Change the size of the display unit to DOUBLE WORD.
X* Adjust byte shift to the allowable range.
X* Normally bound to "META-4".
X*/
Xbool dispsize4 ()
X{
X curwp -> w_disp_shift = 0; /* shift to 0 when changing size */
X curwp -> w_unit_offset = 0; /* go to end of unit */
X
X switch (R_TYPE(curwp))
X {
X case OCTAL:
X curwp -> w_fmt_ptr = &octal_32_fmt;
X break;
X
X case DECIMAL:
X curwp -> w_fmt_ptr = &decimal_32_fmt;
X break;
X
X case HEX:
X curwp -> w_fmt_ptr = &hex_32_fmt;
X break;
X
X case BINARY:
X curwp -> w_fmt_ptr = &binary_32_fmt;
X break;
X
X default:
X return (TRUE);
X break;
X }
X
X /* if we are in the middle of a search then use the proper format struc */
X if (read_pat_mode)
X curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
X
X move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
X wind_on_dot (curwp);
X curwp -> w_flag = WFHARD;
X update ();
X return (TRUE);
X}
X
X/*
X* Display byte swaped. This command causes the bytes
X* that are displayed in WORD and DWORD mode to be swaped
X* in the way that the INTEL microprocessors do it.
X*/
Xbool dispswapbyte (f, n, k)
X{
X if ((curwp -> w_fmt_ptr -> r_size) == BYTES)
X return (TRUE);
X
X if (curwp -> w_intel_mode)
X curwp -> w_intel_mode = FALSE;
X else
X curwp -> w_intel_mode = TRUE;
X
X curwp -> w_flag = WFHARD;
X update ();
X return (TRUE);
X}
X
X/*
X* Yank text back from the kill buffer. This
X* is really easy. All of the work is done by the
X* standard insert routines. All you do is run the loop,
X* and check for errors.
X* An attempt has been made to fix the cosmetic bug
X* associated with a yank when dot is on the top line of
X* the window (nothing moves, because all of the new
X* text landed off screen).
X*/
Xbool yank (f, n, k)
X{
X register int c;
X register int i;
X register LINE * lp;
X
X if (n < 0)
X return (FALSE);
X while (n--)
X {
X i = 0;
X while ((c = kremove (i)) >= 0)
X {
X if (linsert (1, c) == FALSE)
X return (FALSE);
X ++i;
X }
X }
X curwp -> w_flag |= WFHARD;
X return (TRUE);
X}
X
X/*
X* Link windows. pvr
X* This function toggles the window linking function.
X* When linking is enabled all windows that look at
X* the same buffer will be forced to have the same
X* dot position. Each window is then moved to be
X* positioned on the dot. Thus when a user moves
X* arround a buffer all other views into that buffer
X* will follow.
X*/
X
Xbool linkwind ()
X
X{
X char buf[80];
X
X if (curwp -> w_bufp -> b_flag & BFLINK)
X {
X curwp -> w_bufp -> b_flag &= ~(BFLINK & 0xff);
X sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_unlink);
X }
X else
X {
X curwp -> w_bufp -> b_flag |= BFLINK;
X sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_link);
X }
X writ_echo (buf);
X return (TRUE);
X}
X/*
X* Print all bad keys to the screen and beep
X*/
Xvoid bad_key (key)
Xint key;
X {
X char buf[80], buf1[40];
X
X ttbeep ();
X sprintf (buf, MSG_bad_key);
X if (key & KMETA)
X sprintf (&buf[strlen (buf)], MSG_esc);
X if (key & KCTLX)
X sprintf (&buf[strlen (buf)], MSG_ctl_x);
X if (key & KCTRL)
X sprintf (&buf[strlen (buf)], MSG_ctl);
X sprintf (buf1, MSG_key_code, char_str, R_BYTE_FMT(curwp));
X sprintf (&buf[strlen (buf)], buf1, (key & KCHAR), key);
X writ_echo (buf);
X }
END_OF_FILE
if test 30672 -ne `wc -c <'random.c'`; then
echo shar: \"'random.c'\" unpacked with wrong size!
fi
chmod +x 'random.c'
# end of 'random.c'
fi
echo shar: End of archive 9 \(of 11\).
cp /dev/null ark9isdone
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