File: [local] / src / usr.bin / mg / Attic / random.c (download)
Revision 1.4, Mon Jan 29 01:58:09 2001 UTC (23 years, 3 months ago) by niklas
Branch: MAIN
CVS Tags: OPENBSD_2_9_BASE, OPENBSD_2_9 Changes since 1.3: +2 -0 lines
$OpenBSD$
|
/* $OpenBSD: random.c,v 1.4 2001/01/29 01:58:09 niklas Exp $ */
/*
* Assorted commands.
* This file contains the command processors for a large assortment of
* unrelated commands. The only thing they have in common is that they
* are all command processors.
*/
#include "def.h"
/*
* Display a bunch of useful information about the current location of dot.
* The character under the cursor (in octal), the current line, row, and
* column, and approximate position of the cursor in the file (as a
* percentage) is displayed. The column position assumes an infinite
* position display; it does not truncate just because the screen does.
* This is normally bound to "C-X =".
*/
/* ARGSUSED */
int
showcpos(f, n)
int f, n;
{
LINE *clp;
long nchar;
long cchar;
int nline, row;
int cline, cbyte; /* Current line/char/byte */
int ratio;
/* collect the data */
clp = lforw(curbp->b_linep);
cchar = 0;
cline = 0;
cbyte = 0;
nchar = 0;
nline = 0;
for (;;) {
/* count this line */
++nline;
if (clp == curwp->w_dotp) {
/* mark line */
cline = nline;
cchar = nchar + curwp->w_doto;
if (curwp->w_doto == llength(clp))
cbyte = '\n';
else
cbyte = lgetc(clp, curwp->w_doto);
}
/* now count the chars */
nchar += llength(clp);
clp = lforw(clp);
if (clp == curbp->b_linep)
break;
/* count the newline */
nchar++;
}
/* determine row */
row = curwp->w_toprow + 1;
clp = curwp->w_linep;
while (clp != curbp->b_linep && clp != curwp->w_dotp) {
++row;
clp = lforw(clp);
}
/* NOSTRICT */
ratio = nchar ? (100L * cchar) / nchar : 100;
ewprintf("Char: %c (0%o) point=%ld(%d%%) line=%d row=%d col=%d",
cbyte, cbyte, cchar, ratio, cline, row, getcolpos());
return TRUE;
}
int
getcolpos()
{
int col, i, c;
/* determine column */
col = 1;
for (i = 0; i < curwp->w_doto; ++i) {
c = lgetc(curwp->w_dotp, i);
if (c == '\t'
#ifdef NOTAB
&& !(curbp->b_flag & BFNOTAB)
#endif /* NOTAB */
) {
col |= 0x07;
++col;
} else if (ISCTRL(c) != FALSE)
++col;
++col;
}
return col;
}
/*
* Twiddle the two characters on either side of dot. If dot is at the end
* of the line twiddle the two characters before it. Return with an error
* if dot is at the beginning of line; it seems to be a bit pointless to
* make this work. This fixes up a very common typo with a single stroke.
* Normally bound to "C-T". This always works within a line, so "WFEDIT"
* is good enough.
*/
/* ARGSUSED */
int
twiddle(f, n)
int f, n;
{
LINE *dotp;
int doto, cr;
dotp = curwp->w_dotp;
doto = curwp->w_doto;
if (doto == llength(dotp)) {
if (--doto <= 0)
return FALSE;
} else {
if (doto == 0)
return FALSE;
++curwp->w_doto;
}
cr = lgetc(dotp, doto--);
lputc(dotp, doto + 1, lgetc(dotp, doto));
lputc(dotp, doto, cr);
lchange(WFEDIT);
return TRUE;
}
/*
* Open up some blank space. The basic plan is to insert a bunch of
* newlines, and then back up over them. Everything is done by the
* subcommand procerssors. They even handle the looping. Normally this
* is bound to "C-O".
*/
/* ARGSUSED */
int
openline(f, n)
int f, n;
{
int i;
int s;
if (n < 0)
return FALSE;
if (n == 0)
return TRUE;
/* insert newlines */
i = n;
do {
s = lnewline();
} while (s == TRUE && --i);
/* then go back up overtop of them all */
if (s == TRUE)
s = backchar(f | FFRAND, n);
return s;
}
/*
* Insert a newline. [following "feature" not present in current version of
* Gnu, and now disabled here too] If you are at the end of the line and the
* next line is a blank line, just move into the blank line. This makes
* "C-O" and "C-X C-O" work nicely, and reduces the ammount of screen update
* that has to be done. This would not be as critical if screen update were a
* lot more efficient.
*/
/* ARGSUSED */
int
newline(f, n)
int f, n;
{
LINE *lp;
int s;
if (n < 0)
return FALSE;
while (n--) {
lp = curwp->w_dotp;
#ifdef undef
if (llength(lp) == curwp->w_doto
&& lforw(lp) != curbp->b_linep
&& llength(lforw(lp)) == 0) {
if ((s = forwchar(FFRAND, 1)) != TRUE)
return s;
} else
#endif /* undef */
if ((s = lnewline()) != TRUE)
return s;
}
return TRUE;
}
/*
* Delete blank lines around dot. What this command does depends if dot is
* sitting on a blank line. If dot is sitting on a blank line, this command
* deletes all the blank lines above and below the current line. If it is
* sitting on a non blank line then it deletes all of the blank lines after
* the line. Normally this command is bound to "C-X C-O". Any argument is
* ignored.
*/
/* ARGSUSED */
int
deblank(f, n)
int f, n;
{
LINE *lp1, *lp2;
RSIZE nld;
lp1 = curwp->w_dotp;
while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_linep)
lp1 = lp2;
lp2 = lp1;
nld = (RSIZE)0;
while ((lp2 = lforw(lp2)) != curbp->b_linep && llength(lp2) == 0)
++nld;
if (nld == 0)
return (TRUE);
curwp->w_dotp = lforw(lp1);
curwp->w_doto = 0;
return ldelete((RSIZE)nld, KNONE);
}
/*
* Delete any whitespace around dot, then insert a space.
*/
int
justone(f, n)
int f, n;
{
(VOID)delwhite(f, n);
return linsert(1, ' ');
}
/*
* Delete any whitespace around dot.
*/
/* ARGSUSED */
int
delwhite(f, n)
int f, n;
{
int col, c, s;
col = curwp->w_doto;
while (((c = lgetc(curwp->w_dotp, col)) == ' ' || c == '\t')
&& col < llength(curwp->w_dotp))
++col;
do {
if (curwp->w_doto == 0) {
s = FALSE;
break;
}
if ((s = backchar(FFRAND, 1)) != TRUE)
break;
} while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || c == '\t');
if (s == TRUE)
(VOID)forwchar(FFRAND, 1);
(VOID)ldelete((RSIZE)(col - curwp->w_doto), KNONE);
return TRUE;
}
/*
* Insert a newline, then enough tabs and spaces to duplicate the indentation
* of the previous line. Assumes tabs are every eight characters. Quite
* simple. Figure out the indentation of the current line. Insert a newline
* by calling the standard routine. Insert the indentation by inserting the
* right number of tabs and spaces. Return TRUE if all ok. Return FALSE if
* one of the subcomands failed. Normally bound to "C-J".
*/
/* ARGSUSED */
int
indent(f, n)
int f, n;
{
int nicol;
int c;
int i;
if (n < 0)
return (FALSE);
while (n--) {
nicol = 0;
for (i = 0; i < llength(curwp->w_dotp); ++i) {
c = lgetc(curwp->w_dotp, i);
if (c != ' ' && c != '\t')
break;
if (c == '\t')
nicol |= 0x07;
++nicol;
}
if (lnewline() == FALSE || ((
#ifdef NOTAB
curbp->b_flag & BFNOTAB) ? linsert(nicol, ' ') == FALSE : (
#endif /* NOTAB */
((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) ||
((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE))))
return FALSE;
}
return TRUE;
}
/*
* Delete forward. This is real easy, because the basic delete routine does
* all of the work. Watches for negative arguments, and does the right thing.
* If any argument is present, it kills rather than deletes, to prevent loss
* of text if typed with a big argument. Normally bound to "C-D".
*/
/* ARGSUSED */
int
forwdel(f, n)
int f, n;
{
if (n < 0)
return backdel(f | FFRAND, -n);
/* really a kill */
if (f & FFARG) {
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
}
return ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE);
}
/*
* Delete backwards. This is quite easy too, because it's all done with
* other functions. Just move the cursor back, and delete forwards. Like
* delete forward, this actually does a kill if presented with an argument.
*/
/* ARGSUSED */
int
backdel(f, n)
int f, n;
{
int s;
if (n < 0)
return forwdel(f | FFRAND, -n);
/* really a kill */
if (f & FFARG) {
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
}
if ((s = backchar(f | FFRAND, n)) == TRUE)
s = ldelete((RSIZE)n, (f & FFARG) ? KFORW : KNONE);
return s;
}
/*
* Kill line. If called without an argument, it kills from dot to the end
* of the line, unless it is at the end of the line, when it kills the
* newline. If called with an argument of 0, it kills from the start of the
* line to dot. If called with a positive argument, it kills from dot
* forward over that number of newlines. If called with a negative argument
* it kills any text before dot on the current line, then it kills back
* abs(arg) lines.
*/
/* ARGSUSED */
int
killline(f, n)
int f, n;
{
LINE *nextp;
RSIZE chunk;
int i, c;
/* clear kill buffer if last wasn't a kill */
if ((lastflag & CFKILL) == 0)
kdelete();
thisflag |= CFKILL;
if (!(f & FFARG)) {
for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i)
if ((c = lgetc(curwp->w_dotp, i)) != ' ' && c != '\t')
break;
if (i == llength(curwp->w_dotp))
chunk = llength(curwp->w_dotp) - curwp->w_doto + 1;
else {
chunk = llength(curwp->w_dotp) - curwp->w_doto;
if (chunk == 0)
chunk = 1;
}
} else if (n > 0) {
chunk = llength(curwp->w_dotp) - curwp->w_doto + 1;
nextp = lforw(curwp->w_dotp);
i = n;
while (--i) {
if (nextp == curbp->b_linep)
break;
chunk += llength(nextp) + 1;
nextp = lforw(nextp);
}
} else {
/* n <= 0 */
chunk = curwp->w_doto;
curwp->w_doto = 0;
i = n;
while (i++) {
if (lback(curwp->w_dotp) == curbp->b_linep)
break;
curwp->w_dotp = lback(curwp->w_dotp);
curwp->w_flag |= WFMOVE;
chunk += llength(curwp->w_dotp) + 1;
}
}
/*
* KFORW here is a bug. Should be KBACK/KFORW, but we need to
* rewrite the ldelete code (later)?
*/
return (ldelete(chunk, KFORW));
}
/*
* Yank text back from the kill buffer. This is really easy. All of the work
* is done by the standard insert routines. All you do is run the loop, and
* check for errors. The blank lines are inserted with a call to "newline"
* instead of a call to "lnewline" so that the magic stuff that happens when
* you type a carriage return also happens when a carriage return is yanked
* back from the kill buffer. An attempt has been made to fix the cosmetic
* bug associated with a yank when dot is on the top line of the window
* (nothing moves, because all of the new text landed off screen).
*/
/* ARGSUSED */
int
yank(f, n)
int f, n;
{
LINE *lp;
int c, i, nline;
if (n < 0)
return FALSE;
/* newline counting */
nline = 0;
while (n--) {
/* mark around last yank */
isetmark();
i = 0;
while ((c = kremove(i)) >= 0) {
if (c == '\n') {
if (newline(FFRAND, 1) == FALSE)
return FALSE;
++nline;
} else {
if (linsert(1, c) == FALSE)
return FALSE;
}
++i;
}
}
/* cosmetic adjustment */
lp = curwp->w_linep;
/* if offscreen insert */
if (curwp->w_dotp == lp) {
while (nline-- && lback(lp) != curbp->b_linep)
lp = lback(lp);
/* adjust framing */
curwp->w_linep = lp;
curwp->w_flag |= WFHARD;
}
return TRUE;
}
#ifdef NOTAB
/* ARGSUSED */
int
space_to_tabstop(f, n)
int f, n;
{
if (n < 0)
return FALSE;
if (n == 0)
return TRUE;
return linsert((n << 3) - (curwp->w_doto & 7), ' ');
}
#endif /* NOTAB */