xref: /freebsd/contrib/less/jump.c (revision 2e3f49888ec8851bafb22011533217487764fdb0)
1 /*
2  * Copyright (C) 1984-2023  Mark Nudelman
3  *
4  * You may distribute under the terms of either the GNU General Public
5  * License or the Less License, as specified in the README file.
6  *
7  * For more information, see the README file.
8  */
9 
10 
11 /*
12  * Routines which jump to a new location in the file.
13  */
14 
15 #include "less.h"
16 #include "position.h"
17 
18 extern int jump_sline;
19 extern int squished;
20 extern int screen_trashed;
21 extern int sc_width, sc_height;
22 extern int show_attn;
23 extern int top_scroll;
24 
25 /*
26  * Jump to the end of the file.
27  */
28 public void jump_forw(void)
29 {
30 	POSITION pos;
31 	POSITION end_pos;
32 
33 	if (ch_end_seek())
34 	{
35 		error("Cannot seek to end of file", NULL_PARG);
36 		return;
37 	}
38 	end_pos = ch_tell();
39 	if (position(sc_height-1) == end_pos)
40 	{
41 		eof_bell();
42 		return;
43 	}
44 	/*
45 	 * Note; lastmark will be called later by jump_loc, but it fails
46 	 * because the position table has been cleared by pos_clear below.
47 	 * So call it here before calling pos_clear.
48 	 */
49 	lastmark();
50 	/*
51 	 * Position the last line in the file at the last screen line.
52 	 * Go back one line from the end of the file
53 	 * to get to the beginning of the last line.
54 	 */
55 	pos_clear();
56 	pos = back_line(end_pos);
57 	if (pos == NULL_POSITION)
58 		jump_loc(ch_zero(), sc_height-1);
59 	else
60 	{
61 		jump_loc(pos, sc_height-1);
62 		if (position(sc_height-1) != end_pos)
63 			repaint();
64 	}
65 }
66 
67 /*
68  * Jump to the last buffered line in the file.
69  */
70 public void jump_forw_buffered(void)
71 {
72 	POSITION end;
73 
74 	if (ch_end_buffer_seek())
75 	{
76 		error("Cannot seek to end of buffers", NULL_PARG);
77 		return;
78 	}
79 	end = ch_tell();
80 	if (end != NULL_POSITION && end > 0)
81 		jump_line_loc(end-1, sc_height-1);
82 }
83 
84 /*
85  * Jump to line n in the file.
86  */
87 public void jump_back(LINENUM linenum)
88 {
89 	POSITION pos;
90 	PARG parg;
91 
92 	/*
93 	 * Find the position of the specified line.
94 	 * If we can seek there, just jump to it.
95 	 * If we can't seek, but we're trying to go to line number 1,
96 	 * use ch_beg_seek() to get as close as we can.
97 	 */
98 	pos = find_pos(linenum);
99 	if (pos != NULL_POSITION && ch_seek(pos) == 0)
100 	{
101 		if (show_attn)
102 			set_attnpos(pos);
103 		jump_loc(pos, jump_sline);
104 	} else if (linenum <= 1 && ch_beg_seek() == 0)
105 	{
106 		jump_loc(ch_tell(), jump_sline);
107 		error("Cannot seek to beginning of file", NULL_PARG);
108 	} else
109 	{
110 		parg.p_linenum = linenum;
111 		error("Cannot seek to line number %n", &parg);
112 	}
113 }
114 
115 /*
116  * Repaint the screen.
117  */
118 public void repaint(void)
119 {
120 	struct scrpos scrpos;
121 	/*
122 	 * Start at the line currently at the top of the screen
123 	 * and redisplay the screen.
124 	 */
125 	get_scrpos(&scrpos, TOP);
126 	pos_clear();
127 	if (scrpos.pos == NULL_POSITION)
128 		/* Screen hasn't been drawn yet. */
129 		jump_loc(ch_zero(), 1);
130 	else
131 		jump_loc(scrpos.pos, scrpos.ln);
132 }
133 
134 /*
135  * Jump to a specified percentage into the file.
136  */
137 public void jump_percent(int percent, long fraction)
138 {
139 	POSITION pos, len;
140 
141 	/*
142 	 * Determine the position in the file
143 	 * (the specified percentage of the file's length).
144 	 */
145 	if ((len = ch_length()) == NULL_POSITION)
146 	{
147 		ierror("Determining length of file", NULL_PARG);
148 		ch_end_seek();
149 	}
150 	if ((len = ch_length()) == NULL_POSITION)
151 	{
152 		error("Don't know length of file", NULL_PARG);
153 		return;
154 	}
155 	pos = percent_pos(len, percent, fraction);
156 	if (pos >= len)
157 		pos = len-1;
158 
159 	jump_line_loc(pos, jump_sline);
160 }
161 
162 /*
163  * Jump to a specified position in the file.
164  * Like jump_loc, but the position need not be
165  * the first character in a line.
166  */
167 public void jump_line_loc(POSITION pos, int sline)
168 {
169 	int c;
170 
171 	if (ch_seek(pos) == 0)
172 	{
173 		/*
174 		 * Back up to the beginning of the line.
175 		 */
176 		while ((c = ch_back_get()) != '\n' && c != EOI)
177 			;
178 		if (c == '\n')
179 			(void) ch_forw_get();
180 		pos = ch_tell();
181 	}
182 	if (show_attn)
183 		set_attnpos(pos);
184 	jump_loc(pos, sline);
185 }
186 
187 /*
188  * Jump to a specified position in the file.
189  * The position must be the first character in a line.
190  * Place the target line on a specified line on the screen.
191  */
192 public void jump_loc(POSITION pos, int sline)
193 {
194 	int nline;
195 	int sindex;
196 	POSITION tpos;
197 	POSITION bpos;
198 
199 	/*
200 	 * Normalize sline.
201 	 */
202 	sindex = sindex_from_sline(sline);
203 
204 	if ((nline = onscreen(pos)) >= 0)
205 	{
206 		/*
207 		 * The line is currently displayed.
208 		 * Just scroll there.
209 		 */
210 		nline -= sindex;
211 		if (nline > 0)
212 			forw(nline, position(BOTTOM_PLUS_ONE), 1, 0, 0);
213 		else
214 			back(-nline, position(TOP), 1, 0);
215 #if HILITE_SEARCH
216 		if (show_attn)
217 			repaint_hilite(1);
218 #endif
219 		return;
220 	}
221 
222 	/*
223 	 * Line is not on screen.
224 	 * Seek to the desired location.
225 	 */
226 	if (ch_seek(pos))
227 	{
228 		error("Cannot seek to that file position", NULL_PARG);
229 		return;
230 	}
231 
232 	/*
233 	 * See if the desired line is before or after
234 	 * the currently displayed screen.
235 	 */
236 	tpos = position(TOP);
237 	bpos = position(BOTTOM_PLUS_ONE);
238 	if (tpos == NULL_POSITION || pos >= tpos)
239 	{
240 		/*
241 		 * The desired line is after the current screen.
242 		 * Move back in the file far enough so that we can
243 		 * call forw() and put the desired line at the
244 		 * sline-th line on the screen.
245 		 */
246 		for (nline = 0;  nline < sindex;  nline++)
247 		{
248 			if (bpos != NULL_POSITION && pos <= bpos)
249 			{
250 				/*
251 				 * Surprise!  The desired line is
252 				 * close enough to the current screen
253 				 * that we can just scroll there after all.
254 				 */
255 				forw(sc_height-sindex+nline-1, bpos, 1, 0, 0);
256 #if HILITE_SEARCH
257 				if (show_attn)
258 					repaint_hilite(1);
259 #endif
260 				return;
261 			}
262 			pos = back_line(pos);
263 			if (pos == NULL_POSITION)
264 			{
265 				/*
266 				 * Oops.  Ran into the beginning of the file.
267 				 * Exit the loop here and rely on forw()
268 				 * below to draw the required number of
269 				 * blank lines at the top of the screen.
270 				 */
271 				break;
272 			}
273 		}
274 		lastmark();
275 		squished = 0;
276 		screen_trashed = 0;
277 		forw(sc_height-1, pos, 1, 0, sindex-nline);
278 	} else
279 	{
280 		/*
281 		 * The desired line is before the current screen.
282 		 * Move forward in the file far enough so that we
283 		 * can call back() and put the desired line at the
284 		 * sindex-th line on the screen.
285 		 */
286 		for (nline = sindex;  nline < sc_height - 1;  nline++)
287 		{
288 			pos = forw_line(pos);
289 			if (pos == NULL_POSITION)
290 			{
291 				/*
292 				 * Ran into end of file.
293 				 * This shouldn't normally happen,
294 				 * but may if there is some kind of read error.
295 				 */
296 				break;
297 			}
298 #if HILITE_SEARCH
299 			pos = next_unfiltered(pos);
300 #endif
301 			if (pos >= tpos)
302 			{
303 				/*
304 				 * Surprise!  The desired line is
305 				 * close enough to the current screen
306 				 * that we can just scroll there after all.
307 				 */
308 				back(nline+1, tpos, 1, 0);
309 #if HILITE_SEARCH
310 				if (show_attn)
311 					repaint_hilite(1);
312 #endif
313 				return;
314 			}
315 		}
316 		lastmark();
317 		if (!top_scroll)
318 			clear();
319 		else
320 			home();
321 		screen_trashed = 0;
322 		add_back_pos(pos);
323 		back(sc_height-1, pos, 1, 0);
324 	}
325 }
326