less/dist/input.c

/*
 * Copyright (C) 1984-2017  Mark Nudelman
 *
 * You may distribute under the terms of either the GNU General Public
 * License or the Less License, as specified in the README file.
 *
 * For more information, see the README file.
 */

/*
 * High level routines dealing with getting lines of input 
 * from the file being viewed.
 *
 * When we speak of "lines" here, we mean PRINTABLE lines;
 * lines processed with respect to the screen width.
 * We use the term "raw line" to refer to lines simply
 * delimited by newlines; not processed with respect to screen width.
 */

#include "less.h"

extern int squeeze;
extern int chopline;
extern int hshift;
extern int quit_if_one_screen;
extern int sigs;
extern int ignore_eoi;
extern int status_col;
extern POSITION start_attnpos;
extern POSITION end_attnpos;
#if HILITE_SEARCH
extern int hilite_search;
extern int size_linebuf;
#endif

/*
 * Get the next line.
 * A "current" position is passed and a "new" position is returned.
 * The current position is the position of the first character of
 * a line.  The new position is the position of the first character
 * of the NEXT line.  The line obtained is the line starting at curr_pos.
 */
        public POSITION
forw_line(curr_pos)
        POSITION curr_pos;
{
        POSITION base_pos;
        POSITION new_pos;
        int c;
        int blankline;
        int endline;
        int chopped;
        int backchars;

get_forw_line:
        if (curr_pos == NULL_POSITION)
        {
                null_line();
                return (NULL_POSITION);
        }
#if HILITE_SEARCH
        if (hilite_search == OPT_ONPLUS || is_filtering() || status_col)
        {
                /*
                 * If we are ignoring EOI (command F), only prepare
                 * one line ahead, to avoid getting stuck waiting for
                 * slow data without displaying the data we already have.
                 * If we're not ignoring EOI, we *could* do the same, but
                 * for efficiency we prepare several lines ahead at once.
                 */
                prep_hilite(curr_pos, curr_pos + 3*size_linebuf, 
                                ignore_eoi ? 1 : -1);
                curr_pos = next_unfiltered(curr_pos);
        }
#endif
        if (ch_seek(curr_pos))
        {
                null_line();
                return (NULL_POSITION);
        }

        /*
         * Step back to the beginning of the line.
         */
        base_pos = curr_pos;
        for (;;)
        {
                if (ABORT_SIGS())
                {
                        null_line();
                        return (NULL_POSITION);
                }
                c = ch_back_get();
                if (c == EOI)
                        break;
                if (c == '\n')
                {
                        (void) ch_forw_get();
                        break;
                }
                --base_pos;
        }

        /*
         * Read forward again to the position we should start at.
         */
        prewind();
        plinenum(base_pos);
        (void) ch_seek(base_pos);
        new_pos = base_pos;
        while (new_pos < curr_pos)
        {
                if (ABORT_SIGS())
                {
                        null_line();
                        return (NULL_POSITION);
                }
                c = ch_forw_get();
                backchars = pappend(c, new_pos);
                new_pos++;
                if (backchars > 0)
                {
                        pshift_all();
                        new_pos -= backchars;
                        while (--backchars >= 0)
                                (void) ch_back_get();
                }
        }
        (void) pflushmbc();
        pshift_all();

        /*
         * Read the first character to display.
         */
        c = ch_forw_get();
        if (c == EOI)
        {
                null_line();
                return (NULL_POSITION);
        }
        blankline = (c == '\n' || c == '\r');

        /*
         * Read each character in the line and append to the line buffer.
         */
        chopped = FALSE;
        for (;;)
        {
                if (ABORT_SIGS())
                {
                        null_line();
                        return (NULL_POSITION);
                }
                if (c == '\n' || c == EOI)
                {
                        /*
                         * End of the line.
                         */
                        backchars = pflushmbc();
                        new_pos = ch_tell();
                        if (backchars > 0 && !chopline && hshift == 0)
                        {
                                new_pos -= backchars + 1;
                                endline = FALSE;
                        } else
                                endline = TRUE;
                        break;
                }
                if (c != '\r')
                        blankline = 0;

                /*
                 * Append the char to the line and get the next char.
                 */
                backchars = pappend(c, ch_tell()-1);
                if (backchars > 0)
                {
                        /*
                         * The char won't fit in the line; the line
                         * is too long to print in the screen width.
                         * End the line here.
                         */
                        if (chopline || hshift > 0)
                        {
                                do
                                {
                                        if (ABORT_SIGS())
                                        {
                                                null_line();
                                                return (NULL_POSITION);
                                        }
                                        c = ch_forw_get();
                                } while (c != '\n' && c != EOI);
                                new_pos = ch_tell();
                                endline = TRUE;
                                quit_if_one_screen = FALSE;
                                chopped = TRUE;
                        } else
                        {
                                new_pos = ch_tell() - backchars;
                                endline = FALSE;
                        }
                        break;
                }
                c = ch_forw_get();
        }

        pdone(endline, chopped, 1);

#if HILITE_SEARCH
        if (is_filtered(base_pos))
        {
                /*
                 * We don't want to display this line.
                 * Get the next line.
                 */
                curr_pos = new_pos;
                goto get_forw_line;
        }

        if (status_col && is_hilited(base_pos, ch_tell()-1, 1, NULL))
                set_status_col('*');
#endif

        if (squeeze && blankline)
        {
                /*
                 * This line is blank.
                 * Skip down to the last contiguous blank line
                 * and pretend it is the one which we are returning.
                 */
                while ((c = ch_forw_get()) == '\n' || c == '\r')
                        if (ABORT_SIGS())
                        {
                                null_line();
                                return (NULL_POSITION);
                        }
                if (c != EOI)
                        (void) ch_back_get();
                new_pos = ch_tell();
        }

        return (new_pos);
}

/*
 * Get the previous line.
 * A "current" position is passed and a "new" position is returned.
 * The current position is the position of the first character of
 * a line.  The new position is the position of the first character
 * of the PREVIOUS line.  The line obtained is the one starting at new_pos.
 */
        public POSITION
back_line(curr_pos)
        POSITION curr_pos;
{
        POSITION new_pos, begin_new_pos, base_pos;
        int c;
        int endline;
        int chopped;
        int backchars;

get_back_line:
        if (curr_pos == NULL_POSITION || curr_pos <= ch_zero())
        {
                null_line();
                return (NULL_POSITION);
        }
#if HILITE_SEARCH
        if (hilite_search == OPT_ONPLUS || is_filtering() || status_col)
                prep_hilite((curr_pos < 3*size_linebuf) ? 
                                0 : curr_pos - 3*size_linebuf, curr_pos, -1);
#endif
        if (ch_seek(curr_pos-1))
        {
                null_line();
                return (NULL_POSITION);
        }

        if (squeeze)
        {
                /*
                 * Find out if the "current" line was blank.
                 */
                (void) ch_forw_get();    /* Skip the newline */
                c = ch_forw_get();       /* First char of "current" line */
                (void) ch_back_get();    /* Restore our position */
                (void) ch_back_get();

                if (c == '\n' || c == '\r')
                {
                        /*
                         * The "current" line was blank.
                         * Skip over any preceding blank lines,
                         * since we skipped them in forw_line().
                         */
                        while ((c = ch_back_get()) == '\n' || c == '\r')
                                if (ABORT_SIGS())
                                {
                                        null_line();
                                        return (NULL_POSITION);
                                }
                        if (c == EOI)
                        {
                                null_line();
                                return (NULL_POSITION);
                        }
                        (void) ch_forw_get();
                }
        }

        /*
         * Scan backwards until we hit the beginning of the line.
         */
        for (;;)
        {
                if (ABORT_SIGS())
                {
                        null_line();
                        return (NULL_POSITION);
                }
                c = ch_back_get();
                if (c == '\n')
                {
                        /*
                         * This is the newline ending the previous line.
                         * We have hit the beginning of the line.
                         */
                        base_pos = ch_tell() + 1;
                        break;
                }
                if (c == EOI)
                {
                        /*
                         * We have hit the beginning of the file.
                         * This must be the first line in the file.
                         * This must, of course, be the beginning of the line.
                         */
                        base_pos = ch_tell();
                        break;
                }
        }

        /*
         * Now scan forwards from the beginning of this line.
         * We keep discarding "printable lines" (based on screen width)
         * until we reach the curr_pos.
         *
         * {{ This algorithm is pretty inefficient if the lines
         *    are much longer than the screen width, 
         *    but I don't know of any better way. }}
         */
        new_pos = base_pos;
        if (ch_seek(new_pos))
        {
                null_line();
                return (NULL_POSITION);
        }
        endline = FALSE;
        prewind();
        plinenum(new_pos);
    loop:
        begin_new_pos = new_pos;
        (void) ch_seek(new_pos);
        chopped = FALSE;

        do
        {
                c = ch_forw_get();
                if (c == EOI || ABORT_SIGS())
                {
                        null_line();
                        return (NULL_POSITION);
                }
                new_pos++;
                if (c == '\n')
                {
                        backchars = pflushmbc();
                        if (backchars > 0 && !chopline && hshift == 0)
                        {
                                backchars++;
                                goto shift;
                        }
                        endline = TRUE;
                        break;
                }
                backchars = pappend(c, ch_tell()-1);
                if (backchars > 0)
                {
                        /*
                         * Got a full printable line, but we haven't
                         * reached our curr_pos yet.  Discard the line
                         * and start a new one.
                         */
                        if (chopline || hshift > 0)
                        {
                                endline = TRUE;
                                chopped = TRUE;
                                quit_if_one_screen = FALSE;
                                break;
                        }
                shift:
                        pshift_all();
                        while (backchars-- > 0)
                        {
                                (void) ch_back_get();
                                new_pos--;
                        }
                        goto loop;
                }
        } while (new_pos < curr_pos);

        pdone(endline, chopped, 0);

#if HILITE_SEARCH
        if (is_filtered(base_pos))
        {
                /*
                 * We don't want to display this line.
                 * Get the previous line.
                 */
                curr_pos = begin_new_pos;
                goto get_back_line;
        }

        if (status_col && curr_pos > 0 && is_hilited(base_pos, curr_pos-1, 1, NULL))
                set_status_col('*');
#endif

        return (begin_new_pos);
}

/*
 * Set attnpos.
 */
        public void
set_attnpos(pos)
        POSITION pos;
{
        int c;

        if (pos != NULL_POSITION)
        {
                if (ch_seek(pos))
                        return;
                for (;;)
                {
                        c = ch_forw_get();
                        if (c == EOI)
                                break;
                        if (c == '\n' || c == '\r')
                        {
                                (void) ch_back_get();
                                break;
                        }
                        pos++;
                }
                end_attnpos = pos;
                for (;;)
                {
                        c = ch_back_get();
                        if (c == EOI || c == '\n' || c == '\r')
                                break;
                        pos--;
                }
        }
        start_attnpos = pos;
}
Revision:	11360
Committed:	Fri Jul 6 12:43:09 2018 UTC (5 years, 9 months ago) by laffer1
Content type:	text/plain
File size:	9036 byte(s)
Log Message:	less 530
#	Content
1	/*
2	* Copyright (C) 1984-2017 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	* High level routines dealing with getting lines of input
12	* from the file being viewed.
13	*
14	* When we speak of "lines" here, we mean PRINTABLE lines;
15	* lines processed with respect to the screen width.
16	* We use the term "raw line" to refer to lines simply
17	* delimited by newlines; not processed with respect to screen width.
18	*/
19
20	#include "less.h"
21
22	extern int squeeze;
23	extern int chopline;
24	extern int hshift;
25	extern int quit_if_one_screen;
26	extern int sigs;
27	extern int ignore_eoi;
28	extern int status_col;
29	extern POSITION start_attnpos;
30	extern POSITION end_attnpos;
31	#if HILITE_SEARCH
32	extern int hilite_search;
33	extern int size_linebuf;
34	#endif
35
36	/*
37	* Get the next line.
38	* A "current" position is passed and a "new" position is returned.
39	* The current position is the position of the first character of
40	* a line. The new position is the position of the first character
41	* of the NEXT line. The line obtained is the line starting at curr_pos.
42	*/
43	public POSITION
44	forw_line(curr_pos)
45	POSITION curr_pos;
46	{
47	POSITION base_pos;
48	POSITION new_pos;
49	int c;
50	int blankline;
51	int endline;
52	int chopped;
53	int backchars;
54
55	get_forw_line:
56	if (curr_pos == NULL_POSITION)
57	{
58	null_line();
59	return (NULL_POSITION);
60	}
61	#if HILITE_SEARCH
62	if (hilite_search == OPT_ONPLUS \|\| is_filtering() \|\| status_col)
63	{
64	/*
65	* If we are ignoring EOI (command F), only prepare
66	* one line ahead, to avoid getting stuck waiting for
67	* slow data without displaying the data we already have.
68	* If we're not ignoring EOI, we could do the same, but
69	* for efficiency we prepare several lines ahead at once.
70	*/
71	prep_hilite(curr_pos, curr_pos + 3*size_linebuf,
72	ignore_eoi ? 1 : -1);
73	curr_pos = next_unfiltered(curr_pos);
74	}
75	#endif
76	if (ch_seek(curr_pos))
77	{
78	null_line();
79	return (NULL_POSITION);
80	}
81
82	/*
83	* Step back to the beginning of the line.
84	*/
85	base_pos = curr_pos;
86	for (;;)
87	{
88	if (ABORT_SIGS())
89	{
90	null_line();
91	return (NULL_POSITION);
92	}
93	c = ch_back_get();
94	if (c == EOI)
95	break;
96	if (c == '\n')
97	{
98	(void) ch_forw_get();
99	break;
100	}
101	--base_pos;
102	}
103
104	/*
105	* Read forward again to the position we should start at.
106	*/
107	prewind();
108	plinenum(base_pos);
109	(void) ch_seek(base_pos);
110	new_pos = base_pos;
111	while (new_pos < curr_pos)
112	{
113	if (ABORT_SIGS())
114	{
115	null_line();
116	return (NULL_POSITION);
117	}
118	c = ch_forw_get();
119	backchars = pappend(c, new_pos);
120	new_pos++;
121	if (backchars > 0)
122	{
123	pshift_all();
124	new_pos -= backchars;
125	while (--backchars >= 0)
126	(void) ch_back_get();
127	}
128	}
129	(void) pflushmbc();
130	pshift_all();
131
132	/*
133	* Read the first character to display.
134	*/
135	c = ch_forw_get();
136	if (c == EOI)
137	{
138	null_line();
139	return (NULL_POSITION);
140	}
141	blankline = (c == '\n' \|\| c == '\r');
142
143	/*
144	* Read each character in the line and append to the line buffer.
145	*/
146	chopped = FALSE;
147	for (;;)
148	{
149	if (ABORT_SIGS())
150	{
151	null_line();
152	return (NULL_POSITION);
153	}
154	if (c == '\n' \|\| c == EOI)
155	{
156	/*
157	* End of the line.
158	*/
159	backchars = pflushmbc();
160	new_pos = ch_tell();
161	if (backchars > 0 && !chopline && hshift == 0)
162	{
163	new_pos -= backchars + 1;
164	endline = FALSE;
165	} else
166	endline = TRUE;
167	break;
168	}
169	if (c != '\r')
170	blankline = 0;
171
172	/*
173	* Append the char to the line and get the next char.
174	*/
175	backchars = pappend(c, ch_tell()-1);
176	if (backchars > 0)
177	{
178	/*
179	* The char won't fit in the line; the line
180	* is too long to print in the screen width.
181	* End the line here.
182	*/
183	if (chopline \|\| hshift > 0)
184	{
185	do
186	{
187	if (ABORT_SIGS())
188	{
189	null_line();
190	return (NULL_POSITION);
191	}
192	c = ch_forw_get();
193	} while (c != '\n' && c != EOI);
194	new_pos = ch_tell();
195	endline = TRUE;
196	quit_if_one_screen = FALSE;
197	chopped = TRUE;
198	} else
199	{
200	new_pos = ch_tell() - backchars;
201	endline = FALSE;
202	}
203	break;
204	}
205	c = ch_forw_get();
206	}
207
208	pdone(endline, chopped, 1);
209
210	#if HILITE_SEARCH
211	if (is_filtered(base_pos))
212	{
213	/*
214	* We don't want to display this line.
215	* Get the next line.
216	*/
217	curr_pos = new_pos;
218	goto get_forw_line;
219	}
220
221	if (status_col && is_hilited(base_pos, ch_tell()-1, 1, NULL))
222	set_status_col('*');
223	#endif
224
225	if (squeeze && blankline)
226	{
227	/*
228	* This line is blank.
229	* Skip down to the last contiguous blank line
230	* and pretend it is the one which we are returning.
231	*/
232	while ((c = ch_forw_get()) == '\n' \|\| c == '\r')
233	if (ABORT_SIGS())
234	{
235	null_line();
236	return (NULL_POSITION);
237	}
238	if (c != EOI)
239	(void) ch_back_get();
240	new_pos = ch_tell();
241	}
242
243	return (new_pos);
244	}
245
246	/*
247	* Get the previous line.
248	* A "current" position is passed and a "new" position is returned.
249	* The current position is the position of the first character of
250	* a line. The new position is the position of the first character
251	* of the PREVIOUS line. The line obtained is the one starting at new_pos.
252	*/
253	public POSITION
254	back_line(curr_pos)
255	POSITION curr_pos;
256	{
257	POSITION new_pos, begin_new_pos, base_pos;
258	int c;
259	int endline;
260	int chopped;
261	int backchars;
262
263	get_back_line:
264	if (curr_pos == NULL_POSITION \|\| curr_pos <= ch_zero())
265	{
266	null_line();
267	return (NULL_POSITION);
268	}
269	#if HILITE_SEARCH
270	if (hilite_search == OPT_ONPLUS \|\| is_filtering() \|\| status_col)
271	prep_hilite((curr_pos < 3*size_linebuf) ?
272	0 : curr_pos - 3*size_linebuf, curr_pos, -1);
273	#endif
274	if (ch_seek(curr_pos-1))
275	{
276	null_line();
277	return (NULL_POSITION);
278	}
279
280	if (squeeze)
281	{
282	/*
283	* Find out if the "current" line was blank.
284	*/
285	(void) ch_forw_get(); /* Skip the newline */
286	c = ch_forw_get(); /* First char of "current" line */
287	(void) ch_back_get(); /* Restore our position */
288	(void) ch_back_get();
289
290	if (c == '\n' \|\| c == '\r')
291	{
292	/*
293	* The "current" line was blank.
294	* Skip over any preceding blank lines,
295	* since we skipped them in forw_line().
296	*/
297	while ((c = ch_back_get()) == '\n' \|\| c == '\r')
298	if (ABORT_SIGS())
299	{
300	null_line();
301	return (NULL_POSITION);
302	}
303	if (c == EOI)
304	{
305	null_line();
306	return (NULL_POSITION);
307	}
308	(void) ch_forw_get();
309	}
310	}
311
312	/*
313	* Scan backwards until we hit the beginning of the line.
314	*/
315	for (;;)
316	{
317	if (ABORT_SIGS())
318	{
319	null_line();
320	return (NULL_POSITION);
321	}
322	c = ch_back_get();
323	if (c == '\n')
324	{
325	/*
326	* This is the newline ending the previous line.
327	* We have hit the beginning of the line.
328	*/
329	base_pos = ch_tell() + 1;
330	break;
331	}
332	if (c == EOI)
333	{
334	/*
335	* We have hit the beginning of the file.
336	* This must be the first line in the file.
337	* This must, of course, be the beginning of the line.
338	*/
339	base_pos = ch_tell();
340	break;
341	}
342	}
343
344	/*
345	* Now scan forwards from the beginning of this line.
346	* We keep discarding "printable lines" (based on screen width)
347	* until we reach the curr_pos.
348	*
349	* {{ This algorithm is pretty inefficient if the lines
350	* are much longer than the screen width,
351	* but I don't know of any better way. }}
352	*/
353	new_pos = base_pos;
354	if (ch_seek(new_pos))
355	{
356	null_line();
357	return (NULL_POSITION);
358	}
359	endline = FALSE;
360	prewind();
361	plinenum(new_pos);
362	loop:
363	begin_new_pos = new_pos;
364	(void) ch_seek(new_pos);
365	chopped = FALSE;
366
367	do
368	{
369	c = ch_forw_get();
370	if (c == EOI \|\| ABORT_SIGS())
371	{
372	null_line();
373	return (NULL_POSITION);
374	}
375	new_pos++;
376	if (c == '\n')
377	{
378	backchars = pflushmbc();
379	if (backchars > 0 && !chopline && hshift == 0)
380	{
381	backchars++;
382	goto shift;
383	}
384	endline = TRUE;
385	break;
386	}
387	backchars = pappend(c, ch_tell()-1);
388	if (backchars > 0)
389	{
390	/*
391	* Got a full printable line, but we haven't
392	* reached our curr_pos yet. Discard the line
393	* and start a new one.
394	*/
395	if (chopline \|\| hshift > 0)
396	{
397	endline = TRUE;
398	chopped = TRUE;
399	quit_if_one_screen = FALSE;
400	break;
401	}
402	shift:
403	pshift_all();
404	while (backchars-- > 0)
405	{
406	(void) ch_back_get();
407	new_pos--;
408	}
409	goto loop;
410	}
411	} while (new_pos < curr_pos);
412
413	pdone(endline, chopped, 0);
414
415	#if HILITE_SEARCH
416	if (is_filtered(base_pos))
417	{
418	/*
419	* We don't want to display this line.
420	* Get the previous line.
421	*/
422	curr_pos = begin_new_pos;
423	goto get_back_line;
424	}
425
426	if (status_col && curr_pos > 0 && is_hilited(base_pos, curr_pos-1, 1, NULL))
427	set_status_col('*');
428	#endif
429
430	return (begin_new_pos);
431	}
432
433	/*
434	* Set attnpos.
435	*/
436	public void
437	set_attnpos(pos)
438	POSITION pos;
439	{
440	int c;
441
442	if (pos != NULL_POSITION)
443	{
444	if (ch_seek(pos))
445	return;
446	for (;;)
447	{
448	c = ch_forw_get();
449	if (c == EOI)
450	break;
451	if (c == '\n' \|\| c == '\r')
452	{
453	(void) ch_back_get();
454	break;
455	}
456	pos++;
457	}
458	end_attnpos = pos;
459	for (;;)
460	{
461	c = ch_back_get();
462	if (c == EOI \|\| c == '\n' \|\| c == '\r')
463	break;
464	pos--;
465	}
466	}
467	start_attnpos = pos;
468	}