1/*	$OpenBSD: util.c,v 1.50 2023/04/28 10:02:03 op Exp $	*/
2
3/* This file is in the public domain. */
4
5/*
6 *		Assorted commands.
7 * This file contains the command processors for a large assortment of
8 * unrelated commands.  The only thing they have in common is that they
9 * are all command processors.
10 */
11
12#include <sys/queue.h>
13#include <ctype.h>
14#include <signal.h>
15#include <stdio.h>
16
17#include "def.h"
18
19int	doindent(int);
20
21/*
22 * Compute next tab stop, with `col' being the a column number and
23 * `tabw' the tab width.
24 */
25int
26ntabstop(int col, int tabw)
27{
28	return (((col + tabw) / tabw) * tabw);
29}
30
31/*
32 * Display a bunch of useful information about the current location of dot.
33 * The character under the cursor (in octal), the current line, row, and
34 * column, and approximate position of the cursor in the file (as a
35 * percentage) is displayed.
36 * Also included at the moment are some values in parenthesis for debugging
37 * explicit newline inclusion into the buffer.
38 * The column position assumes an infinite
39 * position display; it does not truncate just because the screen does.
40 * This is normally bound to "C-x =".
41 */
42int
43showcpos(int f, int n)
44{
45	struct line	*clp;
46	char		*msg;
47	long	 nchar, cchar;
48	int	 nline, row;
49	int	 cline, cbyte;		/* Current line/char/byte */
50	int	 ratio;
51
52	/* collect the data */
53	clp = bfirstlp(curbp);
54	msg = "Char:";
55	cchar = 0;
56	cline = 0;
57	cbyte = 0;
58	nchar = 0;
59	nline = 0;
60	for (;;) {
61		/* count lines and display total as (raw) 'lines' and
62		   compare with b_lines */
63		++nline;
64		if (clp == curwp->w_dotp) {
65			/* obtain (raw) dot line # and compare with w_dotline */
66			cline = nline;
67			cchar = nchar + curwp->w_doto;
68			if (curwp->w_doto == llength(clp))
69				/* fake a \n at end of line */
70				cbyte = *curbp->b_nlchr;
71			else
72				cbyte = lgetc(clp, curwp->w_doto);
73		}
74		/* include # of chars in this line for point-thru-buff ratio */
75		nchar += llength(clp);
76		clp = lforw(clp);
77		if (clp == curbp->b_headp) {
78			if (cbyte == *curbp->b_nlchr &&
79			    cline == curbp->b_lines) {
80				/* swap faked \n for EOB msg */
81				cbyte = EOF;
82				msg = "(EOB)";
83			}
84			break;
85		}
86		/* count the implied newline */
87		nchar++;
88	}
89	/* determine row # within current window */
90	row = curwp->w_toprow + 1;
91	clp = curwp->w_linep;
92	while (clp != curbp->b_headp && clp != curwp->w_dotp) {
93		++row;
94		clp = lforw(clp);
95	}
96	ratio = nchar ? (100L * cchar) / nchar : 100;
97	ewprintf("%s %c (0%o)  point=%ld(%d%%)  line=%d  row=%d  col=%d" \
98            "  (blines=%d rlines=%d l_size=%d)", msg,
99	    cbyte, cbyte, cchar, ratio, cline, row, getcolpos(curwp),
100	    curbp->b_lines, nline, clp->l_size);
101	return (TRUE);
102}
103
104int
105getcolpos(struct mgwin *wp)
106{
107	int	col, i, c;
108	char tmp[5];
109
110	/* determine column */
111	col = 0;
112
113	for (i = 0; i < wp->w_doto; ++i) {
114		c = lgetc(wp->w_dotp, i);
115		if (c == '\t') {
116			col = ntabstop(col, wp->w_bufp->b_tabw);
117		} else if (ISCTRL(c) != FALSE)
118			col += 2;
119		else if (isprint(c)) {
120			col++;
121		} else {
122			col += snprintf(tmp, sizeof(tmp), "\\%o", c);
123		}
124
125	}
126	return (col);
127}
128
129/*
130 * Twiddle the two characters in front of and under dot, then move forward
131 * one character.  Treat new-line characters the same as any other.
132 * Normally bound to "C-t".  This always works within a line, so "WFEDIT"
133 * is good enough.
134 */
135int
136twiddle(int f, int n)
137{
138	struct line	*dotp;
139	int	 doto, cr;
140
141	if (n == 0)
142		return (TRUE);
143
144	dotp = curwp->w_dotp;
145	doto = curwp->w_doto;
146
147	/* Don't twiddle if the dot is on the first char of buffer */
148	if (doto == 0 && lback(dotp) == curbp->b_headp) {
149		dobeep();
150		ewprintf("Beginning of buffer");
151		return(FALSE);
152	}
153	/* Don't twiddle if the dot is on the last char of buffer */
154	if (doto == llength(dotp) && lforw(dotp) == curbp->b_headp) {
155		dobeep();
156		return(FALSE);
157	}
158	undo_boundary_enable(FFRAND, 0);
159	if (doto == 0 && doto == llength(dotp)) { /* only '\n' on this line */
160		(void)forwline(FFRAND, 1);
161		curwp->w_doto = 0;
162	} else {
163		if (doto == 0) { /* 1st twiddle is on 1st character of a line */
164			cr = lgetc(dotp, doto);
165			(void)backdel(FFRAND, 1);
166			(void)forwchar(FFRAND, 1);
167			lnewline();
168			linsert(1, cr);
169			(void)backdel(FFRAND, 1);
170		} else {	/* twiddle is elsewhere in line */
171			cr = lgetc(dotp, doto - 1);
172			(void)backdel(FFRAND, 1);
173			(void)forwchar(FFRAND, 1);
174			linsert(1, cr);
175		}
176	}
177	undo_boundary_enable(FFRAND, 1);
178	lchange(WFEDIT);
179	return (TRUE);
180}
181
182/*
183 * Open up some blank space.  The basic plan is to insert a bunch of
184 * newlines, and then back up over them.  Everything is done by the
185 * subcommand processors.  They even handle the looping.  Normally this
186 * is bound to "C-o".
187 */
188int
189openline(int f, int n)
190{
191	int	i, s;
192
193	if (n < 0)
194		return (FALSE);
195	if (n == 0)
196		return (TRUE);
197
198	/* insert newlines */
199	undo_boundary_enable(FFRAND, 0);
200	i = n;
201	do {
202		s = lnewline();
203	} while (s == TRUE && --i);
204
205	/* then go back up overtop of them all */
206	if (s == TRUE)
207		s = backchar(f | FFRAND, n);
208	undo_boundary_enable(FFRAND, 1);
209	return (s);
210}
211
212/*
213 * Insert a newline.
214 */
215int
216enewline(int f, int n)
217{
218	int	 s;
219
220	if (n < 0)
221		return (FALSE);
222
223	while (n--) {
224		if ((s = lnewline()) != TRUE)
225			return (s);
226	}
227	return (TRUE);
228}
229
230/*
231 * Delete blank lines around dot. What this command does depends if dot is
232 * sitting on a blank line. If dot is sitting on a blank line, this command
233 * deletes all the blank lines above and below the current line. If it is
234 * sitting on a non blank line then it deletes all of the blank lines after
235 * the line. Normally this command is bound to "C-x C-o". Any argument is
236 * ignored.
237 */
238int
239deblank(int f, int n)
240{
241	struct line	*lp1, *lp2;
242	RSIZE	 nld;
243
244	lp1 = curwp->w_dotp;
245	while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_headp)
246		lp1 = lp2;
247	lp2 = lp1;
248	nld = (RSIZE)0;
249	while ((lp2 = lforw(lp2)) != curbp->b_headp && llength(lp2) == 0)
250		++nld;
251	if (nld == 0)
252		return (TRUE);
253	curwp->w_dotp = lforw(lp1);
254	curwp->w_doto = 0;
255	return (ldelete((RSIZE)nld, KNONE));
256}
257
258/*
259 * Delete any whitespace around dot, then insert a space.
260 */
261int
262justone(int f, int n)
263{
264	undo_boundary_enable(FFRAND, 0);
265	(void)delwhite(f, n);
266	linsert(1, ' ');
267	undo_boundary_enable(FFRAND, 1);
268	return (TRUE);
269}
270
271/*
272 * Delete any whitespace around dot.
273 */
274int
275delwhite(int f, int n)
276{
277	int	col, s;
278
279	col = curwp->w_doto;
280
281	while (col < llength(curwp->w_dotp) &&
282	    (isspace(lgetc(curwp->w_dotp, col))))
283		++col;
284	do {
285		if (curwp->w_doto == 0) {
286			s = FALSE;
287			break;
288		}
289		if ((s = backchar(FFRAND, 1)) != TRUE)
290			break;
291	} while (isspace(lgetc(curwp->w_dotp, curwp->w_doto)));
292
293	if (s == TRUE)
294		(void)forwchar(FFRAND, 1);
295	(void)ldelete((RSIZE)(col - curwp->w_doto), KNONE);
296	return (TRUE);
297}
298
299/*
300 * Delete any leading whitespace on the current line
301 */
302int
303delleadwhite(int f, int n)
304{
305	int soff, ls;
306	struct line *slp;
307
308	/* Save current position */
309	slp = curwp->w_dotp;
310	soff = curwp->w_doto;
311
312	for (ls = 0; ls < llength(slp); ls++)
313                 if (!isspace(lgetc(slp, ls)))
314                        break;
315	gotobol(FFRAND, 1);
316	forwdel(FFRAND, ls);
317	soff -= ls;
318	if (soff < 0)
319		soff = 0;
320	forwchar(FFRAND, soff);
321
322	return (TRUE);
323}
324
325/*
326 * Delete any trailing whitespace on the current line
327 */
328int
329deltrailwhite(int f, int n)
330{
331	int soff;
332
333	/* Save current position */
334	soff = curwp->w_doto;
335
336	gotoeol(FFRAND, 1);
337	delwhite(FFRAND, 1);
338
339	/* restore original position, if possible */
340	if (soff < curwp->w_doto)
341		curwp->w_doto = soff;
342
343	return (TRUE);
344}
345
346/*
347 * Raw indent routine.  Use spaces and tabs to fill the given number of
348 * cols, but respect no-tab-mode.
349 */
350int
351doindent(int cols)
352{
353	int n;
354
355	if (curbp->b_flag & BFNOTAB)
356		return (linsert(cols, ' '));
357	if ((n = cols / 8) != 0 && linsert(n, '\t') == FALSE)
358		return (FALSE);
359	if ((n = cols % 8) != 0 && linsert(n, ' ') == FALSE)
360		return (FALSE);
361	return (TRUE);
362}
363
364/*
365 * Insert a newline, then enough tabs and spaces to duplicate the indentation
366 * of the previous line, respecting no-tab-mode and the buffer tab width.
367 * Figure out the indentation of the current line.  Insert a newline by
368 * calling the standard routine.  Insert the indentation by inserting the
369 * right number of tabs and spaces.  Return TRUE if all ok.  Return FALSE if
370 * one of the subcommands failed. Normally bound to "C-m".
371 */
372int
373lfindent(int f, int n)
374{
375	int	c, i, nicol;
376	int	s = TRUE;
377
378	if (n < 0)
379		return (FALSE);
380
381	undo_boundary_enable(FFRAND, 0);
382	while (n--) {
383		nicol = 0;
384		for (i = 0; i < llength(curwp->w_dotp); ++i) {
385			c = lgetc(curwp->w_dotp, i);
386			if (c != ' ' && c != '\t')
387				break;
388			if (c == '\t')
389				nicol = ntabstop(nicol, curwp->w_bufp->b_tabw);
390			else
391				++nicol;
392		}
393		(void)delwhite(FFRAND, 1);
394
395		if (lnewline() == FALSE || doindent(nicol) == FALSE) {
396			s = FALSE;
397			break;
398		}
399	}
400	undo_boundary_enable(FFRAND, 1);
401	return (s);
402}
403
404/*
405 * Indent the current line. Delete existing leading whitespace,
406 * and use tabs/spaces to achieve correct indentation. Try
407 * to leave dot where it started.
408 */
409int
410indent(int f, int n)
411{
412	int soff;
413
414	if (n < 0)
415		return (FALSE);
416
417	delleadwhite(FFRAND, 1);
418
419	/* If not invoked with a numerical argument, done */
420	if (!(f & FFARG))
421		return (TRUE);
422
423	/* insert appropriate whitespace */
424	soff = curwp->w_doto;
425	(void)gotobol(FFRAND, 1);
426	if (doindent(n) == FALSE)
427		return (FALSE);
428
429	forwchar(FFRAND, soff);
430
431	return (TRUE);
432}
433
434
435/*
436 * Delete forward.  This is real easy, because the basic delete routine does
437 * all of the work.  Watches for negative arguments, and does the right thing.
438 * If any argument is present, it kills rather than deletes, to prevent loss
439 * of text if typed with a big argument.  Normally bound to "C-d".
440 */
441int
442forwdel(int f, int n)
443{
444	if (n < 0)
445		return (backdel(f | FFRAND, -n));
446
447	/* really a kill */
448	if (f & FFARG) {
449		if ((lastflag & CFKILL) == 0)
450			kdelete();
451		thisflag |= CFKILL;
452	}
453
454	return (ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE));
455}
456
457/*
458 * Delete backwards.  This is quite easy too, because it's all done with
459 * other functions.  Just move the cursor back, and delete forwards.  Like
460 * delete forward, this actually does a kill if presented with an argument.
461 */
462int
463backdel(int f, int n)
464{
465	int	s;
466
467	if (n < 0)
468		return (forwdel(f | FFRAND, -n));
469
470	/* really a kill */
471	if (f & FFARG) {
472		if ((lastflag & CFKILL) == 0)
473			kdelete();
474		thisflag |= CFKILL;
475	}
476	if ((s = backchar(f | FFRAND, n)) == TRUE)
477		s = ldelete((RSIZE)n, (f & FFARG) ? KFORW : KNONE);
478
479	return (s);
480}
481
482int
483space_to_tabstop(int f, int n)
484{
485	int	col, target;
486
487	if (n < 0)
488		return (FALSE);
489	if (n == 0)
490		return (TRUE);
491
492	col = target = getcolpos(curwp);
493	while (n-- > 0)
494		target = ntabstop(target, curbp->b_tabw);
495	return (linsert(target - col, ' '));
496}
497
498/*
499 * Move the dot to the first non-whitespace character of the current line.
500 */
501int
502backtoindent(int f, int n)
503{
504	gotobol(FFRAND, 1);
505	while (curwp->w_doto < llength(curwp->w_dotp) &&
506	    (isspace(lgetc(curwp->w_dotp, curwp->w_doto))))
507		++curwp->w_doto;
508	return (TRUE);
509}
510
511/*
512 * Join the current line to the previous, or with arg, the next line
513 * to the current one.  If the former line is not empty, leave exactly
514 * one space at the joint.  Otherwise, leave no whitespace.
515 */
516int
517joinline(int f, int n)
518{
519	int doto;
520
521	undo_boundary_enable(FFRAND, 0);
522	if (f & FFARG) {
523		gotoeol(FFRAND, 1);
524		forwdel(FFRAND, 1);
525	} else {
526		gotobol(FFRAND, 1);
527		backdel(FFRAND, 1);
528	}
529
530	delwhite(FFRAND, 1);
531
532	if ((doto = curwp->w_doto) > 0) {
533		linsert(1, ' ');
534		curwp->w_doto = doto;
535	}
536	undo_boundary_enable(FFRAND, 1);
537
538	return (TRUE);
539}
540