Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/basic.c	Lines:	0	242	0.0 %
Date:	2017-11-07	Branches:	0	138	0.0 %


/*	$OpenBSD: basic.c,v 1.47 2015/10/10 09:13:14 lum Exp $	*/

/* This file is in the public domain */

/*
 *		Basic cursor motion commands.
 *
 * The routines in this file are the basic
 * command functions for moving the cursor around on
 * the screen, setting mark, and swapping dot with
 * mark. Only moves between lines, which might make the
 * current buffer framing bad, are hard.
 */

#include <sys/queue.h>
#include <ctype.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

#include "def.h"

/*
 * Go to beginning of line.
 */
/* ARGSUSED */
int
gotobol(int f, int n)
{
	if (n == 0)
		return (TRUE);

	curwp->w_doto = 0;
	return (TRUE);
}

/*
 * Move cursor backwards. Do the
 * right thing if the count is less than
 * 0. Error if you try to move back from
 * the beginning of the buffer.
 */
/* ARGSUSED */
int
backchar(int f, int n)
{
	struct line   *lp;

	if (n < 0)
		return (forwchar(f, -n));
	while (n--) {
		if (curwp->w_doto == 0) {
			if ((lp = lback(curwp->w_dotp)) == curbp->b_headp) {
				if (!(f & FFRAND)) {
					dobeep();
					ewprintf("Beginning of buffer");
				}
				return (FALSE);
			}
			curwp->w_dotp = lp;
			curwp->w_doto = llength(lp);
			curwp->w_rflag |= WFMOVE;
			curwp->w_dotline--;
		} else
			curwp->w_doto--;
	}
	return (TRUE);
}

/*
 * Go to end of line.
 */
/* ARGSUSED */
int
gotoeol(int f, int n)
{
	if (n == 0)
		return (TRUE);

	curwp->w_doto = llength(curwp->w_dotp);
	return (TRUE);
}

/*
 * Move cursor forwards. Do the
 * right thing if the count is less than
 * 0. Error if you try to move forward
 * from the end of the buffer.
 */
/* ARGSUSED */
int
forwchar(int f, int n)
{
	if (n < 0)
		return (backchar(f, -n));
	while (n--) {
		if (curwp->w_doto == llength(curwp->w_dotp)) {
			curwp->w_dotp = lforw(curwp->w_dotp);
			if (curwp->w_dotp == curbp->b_headp) {
				curwp->w_dotp = lback(curwp->w_dotp);
				if (!(f & FFRAND)) {
					dobeep();
					ewprintf("End of buffer");
				}
				return (FALSE);
			}
			curwp->w_doto = 0;
			curwp->w_dotline++;
			curwp->w_rflag |= WFMOVE;
		} else
			curwp->w_doto++;
	}
	return (TRUE);
}

/*
 * Go to the beginning of the
 * buffer. Setting WFFULL is conservative,
 * but almost always the case.
 */
int
gotobob(int f, int n)
{
	(void) setmark(f, n);
	curwp->w_dotp = bfirstlp(curbp);
	curwp->w_doto = 0;
	curwp->w_rflag |= WFFULL;
	curwp->w_dotline = 1;
	return (TRUE);
}

/*
 * Go to the end of the buffer. Leave dot 3 lines from the bottom of the
 * window if buffer length is longer than window length; same as emacs.
 * Setting WFFULL is conservative, but almost always the case.
 */
int
gotoeob(int f, int n)
{
	struct line	*lp;

	(void) setmark(f, n);
	curwp->w_dotp = blastlp(curbp);
	curwp->w_doto = llength(curwp->w_dotp);
	curwp->w_dotline = curwp->w_bufp->b_lines;

	lp = curwp->w_dotp;
	n = curwp->w_ntrows - 3;

	if (n < curwp->w_bufp->b_lines && n >= 3) {
		while (n--)
			curwp->w_dotp = lback(curwp->w_dotp);

		curwp->w_linep = curwp->w_dotp;
		curwp->w_dotp = lp;
	}
	curwp->w_rflag |= WFFULL;
	return (TRUE);
}

/*
 * Move forward by full lines.
 * If the number of lines to move is less
 * than zero, call the backward line function to
 * actually do it. The last command controls how
 * the goal column is set.
 */
/* ARGSUSED */
int
forwline(int f, int n)
{
	struct line  *dlp;

	if (n < 0)
		return (backline(f | FFRAND, -n));
	if ((dlp = curwp->w_dotp) == curbp->b_headp) {
		if (!(f & FFRAND)) {
			dobeep();
			ewprintf("End of buffer");
		}
		return(TRUE);
	}
	if ((lastflag & CFCPCN) == 0)	/* Fix goal. */
		setgoal();
	thisflag |= CFCPCN;
	if (n == 0)
		return (TRUE);
	while (n--) {
		dlp = lforw(dlp);
		if (dlp == curbp->b_headp) {
			curwp->w_dotp = lback(dlp);
			curwp->w_doto = llength(curwp->w_dotp);
			curwp->w_rflag |= WFMOVE;
			if (!(f & FFRAND)) {
				dobeep();
				ewprintf("End of buffer");
			}
			return (TRUE);
		}
		curwp->w_dotline++;
	}
	curwp->w_rflag |= WFMOVE;
	curwp->w_dotp = dlp;
	curwp->w_doto = getgoal(dlp);

	return (TRUE);
}

/*
 * This function is like "forwline", but
 * goes backwards. The scheme is exactly the same.
 * Check for arguments that are less than zero and
 * call your alternate. Figure out the new line and
 * call "movedot" to perform the motion.
 */
/* ARGSUSED */
int
backline(int f, int n)
{
	struct line   *dlp;

	if (n < 0)
		return (forwline(f | FFRAND, -n));
	if ((lastflag & CFCPCN) == 0)	/* Fix goal. */
		setgoal();
	thisflag |= CFCPCN;
	dlp = curwp->w_dotp;
	if (lback(dlp) == curbp->b_headp)  {
		if (!(f & FFRAND)) {
			dobeep();
			ewprintf("Beginning of buffer");
		}
		return(TRUE);
	}
	while (n-- && lback(dlp) != curbp->b_headp) {
		dlp = lback(dlp);
		curwp->w_dotline--;
	}
	if (n > 0 && !(f & FFRAND)) {
		dobeep();
		ewprintf("Beginning of buffer");
	}
	curwp->w_dotp = dlp;
	curwp->w_doto = getgoal(dlp);
	curwp->w_rflag |= WFMOVE;
	return (TRUE);
}

/*
 * Set the current goal column, which is saved in the external variable
 * "curgoal", to the current cursor column. The column is never off
 * the edge of the screen; it's more like display then show position.
 */
void
setgoal(void)
{
	curgoal = getcolpos(curwp);	/* Get the position. */
	/* we can now display past end of display, don't chop! */
}

/*
 * This routine looks at a line (pointed
 * to by the LINE pointer "dlp") and the current
 * vertical motion goal column (set by the "setgoal"
 * routine above) and returns the best offset to use
 * when a vertical motion is made into the line.
 */
int
getgoal(struct line *dlp)
{
	int c, i, col = 0;
	char tmp[5];


	for (i = 0; i < llength(dlp); i++) {
		c = lgetc(dlp, i);
		if (c == '\t'
#ifdef	NOTAB
		    && !(curbp->b_flag & BFNOTAB)
#endif
			) {
			col |= 0x07;
			col++;
		} else if (ISCTRL(c) != FALSE) {
			col += 2;
		} else if (isprint(c))
			col++;
		else {
			col += snprintf(tmp, sizeof(tmp), "\\%o", c);
		}
		if (col > curgoal)
			break;
	}
	return (i);
}

/*
 * Scroll forward by a specified number
 * of lines, or by a full page if no argument.
 * The "2" is the window overlap (this is the default
 * value from ITS EMACS). Because the top line in
 * the window is zapped, we have to do a hard
 * update and get it back.
 */
/* ARGSUSED */
int
forwpage(int f, int n)
{
	struct line  *lp;

	if (!(f & FFARG)) {
		n = curwp->w_ntrows - 2;	/* Default scroll.	 */
		if (n <= 0)			/* Forget the overlap	 */
			n = 1;			/* if tiny window.	 */
	} else if (n < 0)
		return (backpage(f | FFRAND, -n));

	lp = curwp->w_linep;
	while (n--)
		if ((lp = lforw(lp)) == curbp->b_headp) {
			dobeep();
			ewprintf("End of buffer");
			return(TRUE);
		}

	curwp->w_linep = lp;
	curwp->w_rflag |= WFFULL;

	/* if in current window, don't move dot */
	for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
		if (lp == curwp->w_dotp)
			return (TRUE);

	/* Advance the dot the slow way, for line nos */
	while (curwp->w_dotp != curwp->w_linep) {
		curwp->w_dotp = lforw(curwp->w_dotp);
		curwp->w_dotline++;
	}
	curwp->w_doto = 0;
	return (TRUE);
}

/*
 * This command is like "forwpage",
 * but it goes backwards. The "2", like above,
 * is the overlap between the two windows. The
 * value is from the ITS EMACS manual. The
 * hard update is done because the top line in
 * the window is zapped.
 */
/* ARGSUSED */
int
backpage(int f, int n)
{
	struct line  *lp, *lp2;

	if (!(f & FFARG)) {
		n = curwp->w_ntrows - 2;	/* Default scroll.	 */
		if (n <= 0)			/* Don't blow up if the  */
			return (backline(f, 1));/* window is tiny.	 */
	} else if (n < 0)
		return (forwpage(f | FFRAND, -n));

	lp = lp2 = curwp->w_linep;

	while (n-- && lback(lp) != curbp->b_headp) {
		lp = lback(lp);
	}
	if (lp == curwp->w_linep) {
		dobeep();
		ewprintf("Beginning of buffer");
	}
	curwp->w_linep = lp;
	curwp->w_rflag |= WFFULL;

	/* if in current window, don't move dot */
	for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
		if (lp == curwp->w_dotp)
			return (TRUE);

        lp2 = lforw(lp2);

	/* Move the dot the slow way, for line nos */
	while (curwp->w_dotp != lp2) {
                if (curwp->w_dotline <= curwp->w_ntrows)
			goto out;
		curwp->w_dotp = lback(curwp->w_dotp);
		curwp->w_dotline--;
	}
out:
	curwp->w_doto = 0;
	return (TRUE);
}

/*
 * These functions are provided for compatibility with Gosling's Emacs. They
 * are used to scroll the display up (or down) one line at a time.
 */
int
forw1page(int f, int n)
{
	if (!(f & FFARG)) {
		n = 1;
		f = FFUNIV;
	}
	forwpage(f | FFRAND, n);
	return (TRUE);
}

int
back1page(int f, int n)
{
	if (!(f & FFARG)) {
		n = 1;
		f = FFUNIV;
	}
	backpage(f | FFRAND, n);
	return (TRUE);
}

/*
 * Page the other window. Check to make sure it exists, then
 * nextwind, forwpage and restore window pointers.
 */
int
pagenext(int f, int n)
{
	struct mgwin *wp;

	if (wheadp->w_wndp == NULL) {
		dobeep();
		ewprintf("No other window");
		return (FALSE);
	}
	wp = curwp;
	(void) nextwind(f, n);
	(void) forwpage(f, n);
	curwp = wp;
	curbp = wp->w_bufp;
	return (TRUE);
}

/*
 * Internal set mark routine, used by other functions (daveb).
 */
void
isetmark(void)
{
	curwp->w_markp = curwp->w_dotp;
	curwp->w_marko = curwp->w_doto;
	curwp->w_markline = curwp->w_dotline;
}

/*
 * Set the mark in the current window
 * to the value of dot. A message is written to
 * the echo line.  (ewprintf knows about macros)
 */
/* ARGSUSED */
int
setmark(int f, int n)
{
	isetmark();
	ewprintf("Mark set");
	return (TRUE);
}

/* Clear the mark, if set. */
/* ARGSUSED */
int
clearmark(int f, int n)
{
	if (!curwp->w_markp)
		return (FALSE);

	curwp->w_markp = NULL;
	curwp->w_marko = 0;
	curwp->w_markline = 0;

	return (TRUE);
}

/*
 * Swap the values of "dot" and "mark" in
 * the current window. This is pretty easy, because
 * all of the hard work gets done by the standard routine
 * that moves the mark about. The only possible
 * error is "no mark".
 */
/* ARGSUSED */
int
swapmark(int f, int n)
{
	struct line  *odotp;
	int odoto, odotline;

	if (curwp->w_markp == NULL) {
		dobeep();
		ewprintf("No mark in this window");
		return (FALSE);
	}
	odotp = curwp->w_dotp;
	odoto = curwp->w_doto;
	odotline = curwp->w_dotline;
	curwp->w_dotp = curwp->w_markp;
	curwp->w_doto = curwp->w_marko;
	curwp->w_dotline = curwp->w_markline;
	curwp->w_markp = odotp;
	curwp->w_marko = odoto;
	curwp->w_markline = odotline;
	curwp->w_rflag |= WFMOVE;
	return (TRUE);
}

/*
 * Go to a specific line, mostly for
 * looking up errors in C programs, which give the
 * error a line number. If an argument is present, then
 * it is the line number, else prompt for a line number
 * to use.
 */
/* ARGSUSED */
int
gotoline(int f, int n)
{
	char   buf[32], *bufp;
	const char *err;

	if (!(f & FFARG)) {
		if ((bufp = eread("Goto line: ", buf, sizeof(buf),
		    EFNUL | EFNEW | EFCR)) == NULL)
			return (ABORT);
		if (bufp[0] == '\0')
			return (ABORT);
		n = (int)strtonum(buf, INT_MIN, INT_MAX, &err);
		if (err) {
			dobeep();
			ewprintf("Line number %s", err);
			return (FALSE);
		}
	}
	return(setlineno(n));
}

/*
 * Set the line number and switch to it.
 */
int
setlineno(int n)
{
	struct line  *clp;

	if (n >= 0) {
		if (n == 0)
			n++;
		curwp->w_dotline = n;
		clp = lforw(curbp->b_headp);	/* "clp" is first line */
		while (--n > 0) {
			if (lforw(clp) == curbp->b_headp) {
				curwp->w_dotline = curwp->w_bufp->b_lines;
				break;
			}
			clp = lforw(clp);
		}
	} else {
		curwp->w_dotline = curwp->w_bufp->b_lines + n;
		clp = lback(curbp->b_headp);	/* "clp" is last line */
		while (n < 0) {
			if (lback(clp) == curbp->b_headp) {
				curwp->w_dotline = 1;
				break;
			}
			clp = lback(clp);
			n++;
		}
	}
	curwp->w_dotp = clp;
	curwp->w_doto = 0;
	curwp->w_rflag |= WFMOVE;
	return (TRUE);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: basic.c,v 1.47 2015/10/10 09:13:14 lum Exp $ */
2
3			/* This file is in the public domain */
4
5			/*
6			* Basic cursor motion commands.
7			*
8			* The routines in this file are the basic
9			* command functions for moving the cursor around on
10			* the screen, setting mark, and swapping dot with
11			* mark. Only moves between lines, which might make the
12			* current buffer framing bad, are hard.
13			*/
14
15			#include <sys/queue.h>
16			#include <ctype.h>
17			#include <limits.h>
18			#include <signal.h>
19			#include <stdio.h>
20			#include <stdlib.h>
21
22			#include "def.h"
23
24			/*
25			* Go to beginning of line.
26			*/
27			/* ARGSUSED */
28			int
29			gotobol(int f, int n)
30			{
31			if (n == 0)
32			return (TRUE);
33
34			curwp->w_doto = 0;
35			return (TRUE);
36			}
37
38			/*
39			* Move cursor backwards. Do the
40			* right thing if the count is less than
41			* 0. Error if you try to move back from
42			* the beginning of the buffer.
43			*/
44			/* ARGSUSED */
45			int
46			backchar(int f, int n)
47			{
48			struct line *lp;
49
50			if (n < 0)
51			return (forwchar(f, -n));
52			while (n--) {
53			if (curwp->w_doto == 0) {
54			if ((lp = lback(curwp->w_dotp)) == curbp->b_headp) {
55			if (!(f & FFRAND)) {
56			dobeep();
57			ewprintf("Beginning of buffer");
58			}
59			return (FALSE);
60			}
61			curwp->w_dotp = lp;
62			curwp->w_doto = llength(lp);
63			curwp->w_rflag \|= WFMOVE;
64			curwp->w_dotline--;
65			} else
66			curwp->w_doto--;
67			}
68			return (TRUE);
69			}
70
71			/*
72			* Go to end of line.
73			*/
74			/* ARGSUSED */
75			int
76			gotoeol(int f, int n)
77			{
78			if (n == 0)
79			return (TRUE);
80
81			curwp->w_doto = llength(curwp->w_dotp);
82			return (TRUE);
83			}
84
85			/*
86			* Move cursor forwards. Do the
87			* right thing if the count is less than
88			* 0. Error if you try to move forward
89			* from the end of the buffer.
90			*/
91			/* ARGSUSED */
92			int
93			forwchar(int f, int n)
94			{
95			if (n < 0)
96			return (backchar(f, -n));
97			while (n--) {
98			if (curwp->w_doto == llength(curwp->w_dotp)) {
99			curwp->w_dotp = lforw(curwp->w_dotp);
100			if (curwp->w_dotp == curbp->b_headp) {
101			curwp->w_dotp = lback(curwp->w_dotp);
102			if (!(f & FFRAND)) {
103			dobeep();
104			ewprintf("End of buffer");
105			}
106			return (FALSE);
107			}
108			curwp->w_doto = 0;
109			curwp->w_dotline++;
110			curwp->w_rflag \|= WFMOVE;
111			} else
112			curwp->w_doto++;
113			}
114			return (TRUE);
115			}
116
117			/*
118			* Go to the beginning of the
119			* buffer. Setting WFFULL is conservative,
120			* but almost always the case.
121			*/
122			int
123			gotobob(int f, int n)
124			{
125			(void) setmark(f, n);
126			curwp->w_dotp = bfirstlp(curbp);
127			curwp->w_doto = 0;
128			curwp->w_rflag \|= WFFULL;
129			curwp->w_dotline = 1;
130			return (TRUE);
131			}
132
133			/*
134			* Go to the end of the buffer. Leave dot 3 lines from the bottom of the
135			* window if buffer length is longer than window length; same as emacs.
136			* Setting WFFULL is conservative, but almost always the case.
137			*/
138			int
139			gotoeob(int f, int n)
140			{
141			struct line *lp;
142
143			(void) setmark(f, n);
144			curwp->w_dotp = blastlp(curbp);
145			curwp->w_doto = llength(curwp->w_dotp);
146			curwp->w_dotline = curwp->w_bufp->b_lines;
147
148			lp = curwp->w_dotp;
149			n = curwp->w_ntrows - 3;
150
151			if (n < curwp->w_bufp->b_lines && n >= 3) {
152			while (n--)
153			curwp->w_dotp = lback(curwp->w_dotp);
154
155			curwp->w_linep = curwp->w_dotp;
156			curwp->w_dotp = lp;
157			}
158			curwp->w_rflag \|= WFFULL;
159			return (TRUE);
160			}
161
162			/*
163			* Move forward by full lines.
164			* If the number of lines to move is less
165			* than zero, call the backward line function to
166			* actually do it. The last command controls how
167			* the goal column is set.
168			*/
169			/* ARGSUSED */
170			int
171			forwline(int f, int n)
172			{
173			struct line *dlp;
174
175			if (n < 0)
176			return (backline(f \| FFRAND, -n));
177			if ((dlp = curwp->w_dotp) == curbp->b_headp) {
178			if (!(f & FFRAND)) {
179			dobeep();
180			ewprintf("End of buffer");
181			}
182			return(TRUE);
183			}
184			if ((lastflag & CFCPCN) == 0) /* Fix goal. */
185			setgoal();
186			thisflag \|= CFCPCN;
187			if (n == 0)
188			return (TRUE);
189			while (n--) {
190			dlp = lforw(dlp);
191			if (dlp == curbp->b_headp) {
192			curwp->w_dotp = lback(dlp);
193			curwp->w_doto = llength(curwp->w_dotp);
194			curwp->w_rflag \|= WFMOVE;
195			if (!(f & FFRAND)) {
196			dobeep();
197			ewprintf("End of buffer");
198			}
199			return (TRUE);
200			}
201			curwp->w_dotline++;
202			}
203			curwp->w_rflag \|= WFMOVE;
204			curwp->w_dotp = dlp;
205			curwp->w_doto = getgoal(dlp);
206
207			return (TRUE);
208			}
209
210			/*
211			* This function is like "forwline", but
212			* goes backwards. The scheme is exactly the same.
213			* Check for arguments that are less than zero and
214			* call your alternate. Figure out the new line and
215			* call "movedot" to perform the motion.
216			*/
217			/* ARGSUSED */
218			int
219			backline(int f, int n)
220			{
221			struct line *dlp;
222
223			if (n < 0)
224			return (forwline(f \| FFRAND, -n));
225			if ((lastflag & CFCPCN) == 0) /* Fix goal. */
226			setgoal();
227			thisflag \|= CFCPCN;
228			dlp = curwp->w_dotp;
229			if (lback(dlp) == curbp->b_headp) {
230			if (!(f & FFRAND)) {
231			dobeep();
232			ewprintf("Beginning of buffer");
233			}
234			return(TRUE);
235			}
236			while (n-- && lback(dlp) != curbp->b_headp) {
237			dlp = lback(dlp);
238			curwp->w_dotline--;
239			}
240			if (n > 0 && !(f & FFRAND)) {
241			dobeep();
242			ewprintf("Beginning of buffer");
243			}
244			curwp->w_dotp = dlp;
245			curwp->w_doto = getgoal(dlp);
246			curwp->w_rflag \|= WFMOVE;
247			return (TRUE);
248			}
249
250			/*
251			* Set the current goal column, which is saved in the external variable
252			* "curgoal", to the current cursor column. The column is never off
253			* the edge of the screen; it's more like display then show position.
254			*/
255			void
256			setgoal(void)
257			{
258			curgoal = getcolpos(curwp); /* Get the position. */
259			/* we can now display past end of display, don't chop! */
260			}
261
262			/*
263			* This routine looks at a line (pointed
264			* to by the LINE pointer "dlp") and the current
265			* vertical motion goal column (set by the "setgoal"
266			* routine above) and returns the best offset to use
267			* when a vertical motion is made into the line.
268			*/
269			int
270			getgoal(struct line *dlp)
271			{
272			int c, i, col = 0;
273			char tmp[5];
274
275
276			for (i = 0; i < llength(dlp); i++) {
277			c = lgetc(dlp, i);
278			if (c == '\t'
279			#ifdef NOTAB
280			&& !(curbp->b_flag & BFNOTAB)
281			#endif
282			) {
283			col \|= 0x07;
284			col++;
285			} else if (ISCTRL(c) != FALSE) {
286			col += 2;
287			} else if (isprint(c))
288			col++;
289			else {
290			col += snprintf(tmp, sizeof(tmp), "\\%o", c);
291			}
292			if (col > curgoal)
293			break;
294			}
295			return (i);
296			}
297
298			/*
299			* Scroll forward by a specified number
300			* of lines, or by a full page if no argument.
301			* The "2" is the window overlap (this is the default
302			* value from ITS EMACS). Because the top line in
303			* the window is zapped, we have to do a hard
304			* update and get it back.
305			*/
306			/* ARGSUSED */
307			int
308			forwpage(int f, int n)
309			{
310			struct line *lp;
311
312			if (!(f & FFARG)) {
313			n = curwp->w_ntrows - 2; /* Default scroll. */
314			if (n <= 0) /* Forget the overlap */
315			n = 1; /* if tiny window. */
316			} else if (n < 0)
317			return (backpage(f \| FFRAND, -n));
318
319			lp = curwp->w_linep;
320			while (n--)
321			if ((lp = lforw(lp)) == curbp->b_headp) {
322			dobeep();
323			ewprintf("End of buffer");
324			return(TRUE);
325			}
326
327			curwp->w_linep = lp;
328			curwp->w_rflag \|= WFFULL;
329
330			/* if in current window, don't move dot */
331			for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
332			if (lp == curwp->w_dotp)
333			return (TRUE);
334
335			/* Advance the dot the slow way, for line nos */
336			while (curwp->w_dotp != curwp->w_linep) {
337			curwp->w_dotp = lforw(curwp->w_dotp);
338			curwp->w_dotline++;
339			}
340			curwp->w_doto = 0;
341			return (TRUE);
342			}
343
344			/*
345			* This command is like "forwpage",
346			* but it goes backwards. The "2", like above,
347			* is the overlap between the two windows. The
348			* value is from the ITS EMACS manual. The
349			* hard update is done because the top line in
350			* the window is zapped.
351			*/
352			/* ARGSUSED */
353			int
354			backpage(int f, int n)
355			{
356			struct line lp, lp2;
357
358			if (!(f & FFARG)) {
359			n = curwp->w_ntrows - 2; /* Default scroll. */
360			if (n <= 0) /* Don't blow up if the */
361			return (backline(f, 1));/* window is tiny. */
362			} else if (n < 0)
363			return (forwpage(f \| FFRAND, -n));
364
365			lp = lp2 = curwp->w_linep;
366
367			while (n-- && lback(lp) != curbp->b_headp) {
368			lp = lback(lp);
369			}
370			if (lp == curwp->w_linep) {
371			dobeep();
372			ewprintf("Beginning of buffer");
373			}
374			curwp->w_linep = lp;
375			curwp->w_rflag \|= WFFULL;
376
377			/* if in current window, don't move dot */
378			for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
379			if (lp == curwp->w_dotp)
380			return (TRUE);
381
382			lp2 = lforw(lp2);
383
384			/* Move the dot the slow way, for line nos */
385			while (curwp->w_dotp != lp2) {
386			if (curwp->w_dotline <= curwp->w_ntrows)
387			goto out;
388			curwp->w_dotp = lback(curwp->w_dotp);
389			curwp->w_dotline--;
390			}
391			out:
392			curwp->w_doto = 0;
393			return (TRUE);
394			}
395
396			/*
397			* These functions are provided for compatibility with Gosling's Emacs. They
398			* are used to scroll the display up (or down) one line at a time.
399			*/
400			int
401			forw1page(int f, int n)
402			{
403			if (!(f & FFARG)) {
404			n = 1;
405			f = FFUNIV;
406			}
407			forwpage(f \| FFRAND, n);
408			return (TRUE);
409			}
410
411			int
412			back1page(int f, int n)
413			{
414			if (!(f & FFARG)) {
415			n = 1;
416			f = FFUNIV;
417			}
418			backpage(f \| FFRAND, n);
419			return (TRUE);
420			}
421
422			/*
423			* Page the other window. Check to make sure it exists, then
424			* nextwind, forwpage and restore window pointers.
425			*/
426			int
427			pagenext(int f, int n)
428			{
429			struct mgwin *wp;
430
431			if (wheadp->w_wndp == NULL) {
432			dobeep();
433			ewprintf("No other window");
434			return (FALSE);
435			}
436			wp = curwp;
437			(void) nextwind(f, n);
438			(void) forwpage(f, n);
439			curwp = wp;
440			curbp = wp->w_bufp;
441			return (TRUE);
442			}
443
444			/*
445			* Internal set mark routine, used by other functions (daveb).
446			*/
447			void
448			isetmark(void)
449			{
450			curwp->w_markp = curwp->w_dotp;
451			curwp->w_marko = curwp->w_doto;
452			curwp->w_markline = curwp->w_dotline;
453			}
454
455			/*
456			* Set the mark in the current window
457			* to the value of dot. A message is written to
458			* the echo line. (ewprintf knows about macros)
459			*/
460			/* ARGSUSED */
461			int
462			setmark(int f, int n)
463			{
464			isetmark();
465			ewprintf("Mark set");
466			return (TRUE);
467			}
468
469			/* Clear the mark, if set. */
470			/* ARGSUSED */
471			int
472			clearmark(int f, int n)
473			{
474			if (!curwp->w_markp)
475			return (FALSE);
476
477			curwp->w_markp = NULL;
478			curwp->w_marko = 0;
479			curwp->w_markline = 0;
480
481			return (TRUE);
482			}
483
484			/*
485			* Swap the values of "dot" and "mark" in
486			* the current window. This is pretty easy, because
487			* all of the hard work gets done by the standard routine
488			* that moves the mark about. The only possible
489			* error is "no mark".
490			*/
491			/* ARGSUSED */
492			int
493			swapmark(int f, int n)
494			{
495			struct line *odotp;
496			int odoto, odotline;
497
498			if (curwp->w_markp == NULL) {
499			dobeep();
500			ewprintf("No mark in this window");
501			return (FALSE);
502			}
503			odotp = curwp->w_dotp;
504			odoto = curwp->w_doto;
505			odotline = curwp->w_dotline;
506			curwp->w_dotp = curwp->w_markp;
507			curwp->w_doto = curwp->w_marko;
508			curwp->w_dotline = curwp->w_markline;
509			curwp->w_markp = odotp;
510			curwp->w_marko = odoto;
511			curwp->w_markline = odotline;
512			curwp->w_rflag \|= WFMOVE;
513			return (TRUE);
514			}
515
516			/*
517			* Go to a specific line, mostly for
518			* looking up errors in C programs, which give the
519			* error a line number. If an argument is present, then
520			* it is the line number, else prompt for a line number
521			* to use.
522			*/
523			/* ARGSUSED */
524			int
525			gotoline(int f, int n)
526			{
527			char buf[32], *bufp;
528			const char *err;
529
530			if (!(f & FFARG)) {
531			if ((bufp = eread("Goto line: ", buf, sizeof(buf),
532			EFNUL \| EFNEW \| EFCR)) == NULL)
533			return (ABORT);
534			if (bufp[0] == '\0')
535			return (ABORT);
536			n = (int)strtonum(buf, INT_MIN, INT_MAX, &err);
537			if (err) {
538			dobeep();
539			ewprintf("Line number %s", err);
540			return (FALSE);
541			}
542			}
543			return(setlineno(n));
544			}
545
546			/*
547			* Set the line number and switch to it.
548			*/
549			int
550			setlineno(int n)
551			{
552			struct line *clp;
553
554			if (n >= 0) {
555			if (n == 0)
556			n++;
557			curwp->w_dotline = n;
558			clp = lforw(curbp->b_headp); /* "clp" is first line */
559			while (--n > 0) {
560			if (lforw(clp) == curbp->b_headp) {
561			curwp->w_dotline = curwp->w_bufp->b_lines;
562			break;
563			}
564			clp = lforw(clp);
565			}
566			} else {
567			curwp->w_dotline = curwp->w_bufp->b_lines + n;
568			clp = lback(curbp->b_headp); /* "clp" is last line */
569			while (n < 0) {
570			if (lback(clp) == curbp->b_headp) {
571			curwp->w_dotline = 1;
572			break;
573			}
574			clp = lback(clp);
575			n++;
576			}
577			}
578			curwp->w_dotp = clp;
579			curwp->w_doto = 0;
580			curwp->w_rflag \|= WFMOVE;
581			return (TRUE);
582			}