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