/* $OpenBSD: util.c,v 1.44 2022/05/24 16:24:31 op Exp $ */
/* This file is in the public domain. */
/*
* 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 <sys/queue.h>
#include <ctype.h>
#include <signal.h>
#include <stdio.h>
#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.
* Also included at the moment are some values in parenthesis for debugging
* explicit newline inclusion into the buffer.
* 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(int f, int n)
{
struct line *clp;
char *msg;
long nchar, cchar;
int nline, row;
int cline, cbyte; /* Current line/char/byte */
int ratio;
/* collect the data */
clp = bfirstlp(curbp);
msg = "Char:";
cchar = 0;
cline = 0;
cbyte = 0;
nchar = 0;
nline = 0;
for (;;) {
/* count lines and display total as (raw) 'lines' and
compare with b_lines */
++nline;
if (clp == curwp->w_dotp) {
/* obtain (raw) dot line # and compare with w_dotline */
cline = nline;
cchar = nchar + curwp->w_doto;
if (curwp->w_doto == llength(clp))
/* fake a \n at end of line */
cbyte = *curbp->b_nlchr;
else
cbyte = lgetc(clp, curwp->w_doto);
}
/* include # of chars in this line for point-thru-buff ratio */
nchar += llength(clp);
clp = lforw(clp);
if (clp == curbp->b_headp) {
if (cbyte == *curbp->b_nlchr &&
cline == curbp->b_lines) {
/* swap faked \n for EOB msg */
cbyte = EOF;
msg = "(EOB)";
}
break;
}
/* count the implied newline */
nchar++;
}
/* determine row # within current window */
row = curwp->w_toprow + 1;
clp = curwp->w_linep;
while (clp != curbp->b_headp && clp != curwp->w_dotp) {
++row;
clp = lforw(clp);
}
ratio = nchar ? (100L * cchar) / nchar : 100;
ewprintf("%s %c (0%o) point=%ld(%d%%) line=%d row=%d col=%d" \
" (blines=%d rlines=%d l_size=%d)", msg,
cbyte, cbyte, cchar, ratio, cline, row, getcolpos(curwp),
curbp->b_lines, nline, clp->l_size);
return (TRUE);
}
int
getcolpos(struct mgwin *wp)
{
int col, i, c;
char tmp[5];
/* determine column */
col = 0;
for (i = 0; i < wp->w_doto; ++i) {
c = lgetc(wp->w_dotp, i);
if (c == '\t'
#ifdef NOTAB
&& !(wp->w_bufp->b_flag & BFNOTAB)
#endif /* NOTAB */
) {
col |= 0x07;
col++;
} else if (ISCTRL(c) != FALSE)
col += 2;
else if (isprint(c)) {
col++;
} else {
col += snprintf(tmp, sizeof(tmp), "\\%o", c);
}
}
return (col);
}
/*
* Twiddle the two characters in front of and under dot, then move forward
* one character. Treat new-line characters the same as any other.
* Normally bound to "C-t". This always works within a line, so "WFEDIT"
* is good enough.
*/
/* ARGSUSED */
int
twiddle(int f, int n)
{
struct line *dotp;
int doto, cr;
if (n == 0)
return (TRUE);
dotp = curwp->w_dotp;
doto = curwp->w_doto;
/* Don't twiddle if the dot is on the first char of buffer */
if (doto == 0 && lback(dotp) == curbp->b_headp) {
dobeep();
ewprintf("Beginning of buffer");
return(FALSE);
}
/* Don't twiddle if the dot is on the last char of buffer */
if (doto == llength(dotp) && lforw(dotp) == curbp->b_headp) {
dobeep();
return(FALSE);
}
undo_boundary_enable(FFRAND, 0);
if (doto == 0 && doto == llength(dotp)) { /* only '\n' on this line */
(void)forwline(FFRAND, 1);
curwp->w_doto = 0;
} else {
if (doto == 0) { /* 1st twiddle is on 1st character of a line */
cr = lgetc(dotp, doto);
(void)backdel(FFRAND, 1);
(void)forwchar(FFRAND, 1);
lnewline();
linsert(1, cr);
(void)backdel(FFRAND, 1);
} else { /* twiddle is elsewhere in line */
cr = lgetc(dotp, doto - 1);
(void)backdel(FFRAND, 1);
(void)forwchar(FFRAND, 1);
linsert(1, cr);
}
}
undo_boundary_enable(FFRAND, 1);
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 processors. They even handle the looping. Normally this
* is bound to "C-o".
*/
/* ARGSUSED */
int
openline(int f, int n)
{
int i, s;
if (n < 0)
return (FALSE);
if (n == 0)
return (TRUE);
/* insert newlines */
undo_boundary_enable(FFRAND, 0);
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);
undo_boundary_enable(FFRAND, 1);
return (s);
}
/*
* Insert a newline.
*/
/* ARGSUSED */
int
enewline(int f, int n)
{
int s;
if (n < 0)
return (FALSE);
while (n--) {
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(int f, int n)
{
struct line *lp1, *lp2;
RSIZE nld;
lp1 = curwp->w_dotp;
while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_headp)
lp1 = lp2;
lp2 = lp1;
nld = (RSIZE)0;
while ((lp2 = lforw(lp2)) != curbp->b_headp && 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(int f, int n)
{
undo_boundary_enable(FFRAND, 0);
(void)delwhite(f, n);
linsert(1, ' ');
undo_boundary_enable(FFRAND, 1);
return (TRUE);
}
/*
* Delete any whitespace around dot.
*/
/* ARGSUSED */
int
delwhite(int f, int n)
{
int col, s;
col = curwp->w_doto;
while (col < llength(curwp->w_dotp) &&
(isspace(lgetc(curwp->w_dotp, col))))
++col;
do {
if (curwp->w_doto == 0) {
s = FALSE;
break;
}
if ((s = backchar(FFRAND, 1)) != TRUE)
break;
} while (isspace(lgetc(curwp->w_dotp, curwp->w_doto)));
if (s == TRUE)
(void)forwchar(FFRAND, 1);
(void)ldelete((RSIZE)(col - curwp->w_doto), KNONE);
return (TRUE);
}
/*
* Delete any leading whitespace on the current line
*/
int
delleadwhite(int f, int n)
{
int soff, ls;
struct line *slp;
/* Save current position */
slp = curwp->w_dotp;
soff = curwp->w_doto;
for (ls = 0; ls < llength(slp); ls++)
if (!isspace(lgetc(slp, ls)))
break;
gotobol(FFRAND, 1);
forwdel(FFRAND, ls);
soff -= ls;
if (soff < 0)
soff = 0;
forwchar(FFRAND, soff);
return (TRUE);
}
/*
* Delete any trailing whitespace on the current line
*/
int
deltrailwhite(int f, int n)
{
int soff;
/* Save current position */
soff = curwp->w_doto;
gotoeol(FFRAND, 1);
delwhite(FFRAND, 1);
/* restore original position, if possible */
if (soff < curwp->w_doto)
curwp->w_doto = soff;
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 subcommands failed. Normally bound to "C-m".
*/
/* ARGSUSED */
int
lfindent(int f, int n)
{
int c, i, nicol;
int s = TRUE;
if (n < 0)
return (FALSE);
undo_boundary_enable(FFRAND, 0);
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;
}
(void)delwhite(FFRAND, 1);
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)))) {
s = FALSE;
break;
}
}
undo_boundary_enable(FFRAND, 1);
return (s);
}
/*
* Indent the current line. Delete existing leading whitespace,
* and use tabs/spaces to achieve correct indentation. Try
* to leave dot where it started.
*/
int
indent(int f, int n)
{
int soff, i;
if (n < 0)
return (FALSE);
delleadwhite(FFRAND, 1);
/* If not invoked with a numerical argument, done */
if (!(f & FFARG))
return (TRUE);
/* insert appropriate whitespace */
soff = curwp->w_doto;
(void)gotobol(FFRAND, 1);
if (
#ifdef NOTAB
(curbp->b_flag & BFNOTAB) ? linsert(n, ' ') == FALSE :
#endif /* NOTAB */
(((i = n / 8) != 0 && linsert(i, '\t') == FALSE) ||
((i = n % 8) != 0 && linsert(i, ' ') == FALSE)))
return (FALSE);
forwchar(FFRAND, soff);
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(int f, int 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(int f, int 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);
}
#ifdef NOTAB
/* ARGSUSED */
int
space_to_tabstop(int f, int n)
{
if (n < 0)
return (FALSE);
if (n == 0)
return (TRUE);
return (linsert((n << 3) - (curwp->w_doto & 7), ' '));
}
#endif /* NOTAB */
/*
* Move the dot to the first non-whitespace character of the current line.
*/
int
backtoindent(int f, int n)
{
gotobol(FFRAND, 1);
while (curwp->w_doto < llength(curwp->w_dotp) &&
(isspace(lgetc(curwp->w_dotp, curwp->w_doto))))
++curwp->w_doto;
return (TRUE);
}
/*
* Join the current line to the previous, or with arg, the next line
* to the current one. If the former line is not empty, leave exactly
* one space at the joint. Otherwise, leave no whitespace.
*/
int
joinline(int f, int n)
{
int doto;
undo_boundary_enable(FFRAND, 0);
if (f & FFARG) {
gotoeol(FFRAND, 1);
forwdel(FFRAND, 1);
} else {
gotobol(FFRAND, 1);
backdel(FFRAND, 1);
}
delwhite(FFRAND, 1);
if ((doto = curwp->w_doto) > 0) {
linsert(1, ' ');
curwp->w_doto = doto;
}
undo_boundary_enable(FFRAND, 1);
return (TRUE);
}