mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-30 13:44:55 +00:00
20d6e5fe6e
of user keys (documentation pending). The only key whose semantics have changed is the capital 'N' key, which now performs a repeat-search in the opposite direction (just like in vi). This commit is a little bulkier than what I had originally planned. I'm not completely happy with the direction it went, but it's definately an improvement, and the alternative is to continue becoming irrelevant compared to GNU less. (Does anyone even _use_ /usr/bin/more these days?)
523 lines
13 KiB
C
523 lines
13 KiB
C
/*
|
|
* Copyright (c) 1988 Mark Nudleman
|
|
* Copyright (c) 1988, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)line.c 8.1 (Berkeley) 6/6/93";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif /* not lint */
|
|
|
|
/*
|
|
* Routines to manipulate the "line buffer".
|
|
* The line buffer holds a line of output as it is being built
|
|
* in preparation for output to the screen.
|
|
* We keep track of the PRINTABLE length of the line as it is being built.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include "less.h"
|
|
|
|
static char linebuf[8192]; /* Buffer to hold the current output line */
|
|
static char *curr; /* Pointer into linebuf */
|
|
static int column; /* Printable length, accounting for
|
|
backspaces, etc. */
|
|
/*
|
|
* A ridiculously complex state machine takes care of backspaces. The
|
|
* complexity arises from the attempt to deal with all cases, especially
|
|
* involving long lines with underlining, boldfacing or whatever. There
|
|
* are still some cases which will break it.
|
|
*
|
|
* There are four states:
|
|
* LN_NORMAL is the normal state (not in underline mode).
|
|
* LN_UNDERLINE means we are in underline mode. We expect to get
|
|
* either a sequence like "_\bX" or "X\b_" to continue
|
|
* underline mode, or anything else to end underline mode.
|
|
* LN_BOLDFACE means we are in boldface mode. We expect to get sequences
|
|
* like "X\bX\b...X\bX" to continue boldface mode, or anything
|
|
* else to end boldface mode.
|
|
* LN_UL_X means we are one character after LN_UNDERLINE
|
|
* (we have gotten the '_' in "_\bX" or the 'X' in "X\b_").
|
|
* LN_UL_XB means we are one character after LN_UL_X
|
|
* (we have gotten the backspace in "_\bX" or "X\b_";
|
|
* we expect one more ordinary character,
|
|
* which will put us back in state LN_UNDERLINE).
|
|
* LN_BO_X means we are one character after LN_BOLDFACE
|
|
* (we have gotten the 'X' in "X\bX").
|
|
* LN_BO_XB means we are one character after LN_BO_X
|
|
* (we have gotten the backspace in "X\bX";
|
|
* we expect one more 'X' which will put us back
|
|
* in LN_BOLDFACE).
|
|
*/
|
|
static int ln_state; /* Current normal/underline/bold/etc mode */
|
|
#define LN_NORMAL 0 /* Not in underline/boldface/whatever mode */
|
|
#define LN_UNDERLINE 1 /* In underline, need next char */
|
|
#define LN_UL_X 2 /* In underline, got char, need \b */
|
|
#define LN_UL_XB 3 /* In underline, got char & \b, need one more */
|
|
#define LN_BOLDFACE 4 /* In boldface, need next char */
|
|
#define LN_BO_X 5 /* In boldface, got char, need \b */
|
|
#define LN_BO_XB 6 /* In boldface, got char & \b, need same char */
|
|
|
|
char *line; /* Pointer to the current line.
|
|
Usually points to linebuf. */
|
|
|
|
extern int bs_mode;
|
|
extern int tabstop;
|
|
extern int bo_width, be_width;
|
|
extern int ul_width, ue_width;
|
|
extern int sc_width, sc_height;
|
|
extern int horiz_off;
|
|
|
|
/*
|
|
* Rewind the line buffer.
|
|
*/
|
|
prewind()
|
|
{
|
|
line = curr = linebuf;
|
|
ln_state = LN_NORMAL;
|
|
column = -horiz_off;
|
|
}
|
|
|
|
/*
|
|
* Append a character to the line buffer.
|
|
* Expand tabs into spaces, handle underlining, boldfacing, etc.
|
|
* Returns 0 if ok, 1 if couldn't fit in buffer. Characters before horiz_off
|
|
* will be added to the buffer but will not count against the line size.
|
|
*
|
|
* XXX This function sucks.
|
|
*/
|
|
#define NEW_COLUMN(addon) \
|
|
if (column + addon + (ln_state ? ue_width : 0) > sc_width) \
|
|
return(1); \
|
|
else \
|
|
column += addon
|
|
|
|
pappend(c)
|
|
int c;
|
|
{
|
|
if (c == '\0') {
|
|
/*
|
|
* Terminate any special modes, if necessary.
|
|
* Append a '\0' to the end of the line.
|
|
*/
|
|
switch (ln_state) {
|
|
case LN_UL_X:
|
|
curr[0] = curr[-1];
|
|
curr[-1] = UE_CHAR;
|
|
curr++;
|
|
break;
|
|
case LN_BO_X:
|
|
curr[0] = curr[-1];
|
|
curr[-1] = BE_CHAR;
|
|
curr++;
|
|
break;
|
|
case LN_UL_XB:
|
|
case LN_UNDERLINE:
|
|
*curr++ = UE_CHAR;
|
|
break;
|
|
case LN_BO_XB:
|
|
case LN_BOLDFACE:
|
|
*curr++ = BE_CHAR;
|
|
break;
|
|
}
|
|
ln_state = LN_NORMAL;
|
|
*curr = '\0';
|
|
return(0);
|
|
}
|
|
|
|
if (curr > linebuf + sizeof(linebuf) - 12)
|
|
/*
|
|
* Almost out of room in the line buffer.
|
|
* Don't take any chances.
|
|
* {{ Linebuf is supposed to be big enough that this
|
|
* will never happen, but may need to be made
|
|
* bigger for really long lines. }}
|
|
*/
|
|
return(1);
|
|
|
|
if (!bs_mode) {
|
|
/*
|
|
* Advance the state machine.
|
|
*/
|
|
switch (ln_state) {
|
|
case LN_NORMAL:
|
|
if (curr <= linebuf + 1
|
|
|| curr[-1] != '\b')
|
|
break;
|
|
if (c == ((unsigned char)curr[-2]))
|
|
goto enter_boldface;
|
|
if (c == '_' || curr[-2] == '_')
|
|
goto enter_underline;
|
|
curr -= 2;
|
|
break;
|
|
|
|
enter_boldface:
|
|
/*
|
|
* We have "X\bX" (including the current char).
|
|
* Switch into boldface mode.
|
|
*/
|
|
column--;
|
|
if (column + bo_width + be_width >= sc_width)
|
|
/*
|
|
* Not enough room left on the screen to
|
|
* enter and exit boldface mode.
|
|
*/
|
|
return (1);
|
|
|
|
if (bo_width > 0 && curr > linebuf + 2
|
|
&& curr[-3] == ' ') {
|
|
/*
|
|
* Special case for magic cookie terminals:
|
|
* if the previous char was a space, replace
|
|
* it with the "enter boldface" sequence.
|
|
*/
|
|
curr[-3] = BO_CHAR;
|
|
column += bo_width-1;
|
|
} else {
|
|
curr[-1] = curr[-2];
|
|
curr[-2] = BO_CHAR;
|
|
column += bo_width;
|
|
curr++;
|
|
}
|
|
goto ln_bo_xb_case;
|
|
|
|
enter_underline:
|
|
/*
|
|
* We have either "_\bX" or "X\b_" (including
|
|
* the current char). Switch into underline mode.
|
|
*/
|
|
column--;
|
|
if (column + ul_width + ue_width >= sc_width)
|
|
/*
|
|
* Not enough room left on the screen to
|
|
* enter and exit underline mode.
|
|
*/
|
|
return (1);
|
|
|
|
if (ul_width > 0 &&
|
|
curr > linebuf + 2 && curr[-3] == ' ')
|
|
{
|
|
/*
|
|
* Special case for magic cookie terminals:
|
|
* if the previous char was a space, replace
|
|
* it with the "enter underline" sequence.
|
|
*/
|
|
curr[-3] = UL_CHAR;
|
|
column += ul_width-1;
|
|
} else
|
|
{
|
|
curr[-1] = curr[-2];
|
|
curr[-2] = UL_CHAR;
|
|
column += ul_width;
|
|
curr++;
|
|
}
|
|
goto ln_ul_xb_case;
|
|
/*NOTREACHED*/
|
|
case LN_UL_XB:
|
|
/*
|
|
* Termination of a sequence "_\bX" or "X\b_".
|
|
*/
|
|
if (c != '_' && curr[-2] != '_' && c == ((unsigned char)curr[-2]))
|
|
{
|
|
/*
|
|
* We seem to have run on from underlining
|
|
* into boldfacing - this is a nasty fix, but
|
|
* until this whole routine is rewritten as a
|
|
* real DFA, ... well ...
|
|
*/
|
|
curr[0] = curr[-2];
|
|
curr[-2] = UE_CHAR;
|
|
curr[-1] = BO_CHAR;
|
|
curr += 2; /* char & non-existent backspace */
|
|
ln_state = LN_BO_XB;
|
|
goto ln_bo_xb_case;
|
|
}
|
|
ln_ul_xb_case:
|
|
if (c == '_')
|
|
c = (unsigned char)curr[-2];
|
|
curr -= 2;
|
|
ln_state = LN_UNDERLINE;
|
|
break;
|
|
case LN_BO_XB:
|
|
/*
|
|
* Termination of a sequnce "X\bX".
|
|
*/
|
|
if (c != ((unsigned char)curr[-2]) && (c == '_' || curr[-2] == '_'))
|
|
{
|
|
/*
|
|
* We seem to have run on from
|
|
* boldfacing into underlining.
|
|
*/
|
|
curr[0] = curr[-2];
|
|
curr[-2] = BE_CHAR;
|
|
curr[-1] = UL_CHAR;
|
|
curr += 2; /* char & non-existent backspace */
|
|
ln_state = LN_UL_XB;
|
|
goto ln_ul_xb_case;
|
|
}
|
|
ln_bo_xb_case:
|
|
curr -= 2;
|
|
ln_state = LN_BOLDFACE;
|
|
break;
|
|
case LN_UNDERLINE:
|
|
if (column + ue_width + bo_width + be_width >= sc_width)
|
|
/*
|
|
* We have just barely enough room to
|
|
* exit underline mode and handle a possible
|
|
* underline/boldface run on mixup.
|
|
*/
|
|
return (1);
|
|
ln_state = LN_UL_X;
|
|
break;
|
|
case LN_BOLDFACE:
|
|
if (c == '\b')
|
|
{
|
|
ln_state = LN_BO_XB;
|
|
break;
|
|
}
|
|
if (column + be_width + ul_width + ue_width >= sc_width)
|
|
/*
|
|
* We have just barely enough room to
|
|
* exit underline mode and handle a possible
|
|
* underline/boldface run on mixup.
|
|
*/
|
|
return (1);
|
|
ln_state = LN_BO_X;
|
|
break;
|
|
case LN_UL_X:
|
|
if (c == '\b')
|
|
ln_state = LN_UL_XB;
|
|
else
|
|
{
|
|
/*
|
|
* Exit underline mode.
|
|
* We have to shuffle the chars a bit
|
|
* to make this work.
|
|
*/
|
|
curr[0] = curr[-1];
|
|
curr[-1] = UE_CHAR;
|
|
column += ue_width;
|
|
if (ue_width > 0 && curr[0] == ' ')
|
|
/*
|
|
* Another special case for magic
|
|
* cookie terminals: if the next
|
|
* char is a space, replace it
|
|
* with the "exit underline" sequence.
|
|
*/
|
|
column--;
|
|
else
|
|
curr++;
|
|
ln_state = LN_NORMAL;
|
|
}
|
|
break;
|
|
case LN_BO_X:
|
|
if (c == '\b')
|
|
ln_state = LN_BO_XB;
|
|
else
|
|
{
|
|
/*
|
|
* Exit boldface mode.
|
|
* We have to shuffle the chars a bit
|
|
* to make this work.
|
|
*/
|
|
curr[0] = curr[-1];
|
|
curr[-1] = BE_CHAR;
|
|
column += be_width;
|
|
if (be_width > 0 && curr[0] == ' ')
|
|
/*
|
|
* Another special case for magic
|
|
* cookie terminals: if the next
|
|
* char is a space, replace it
|
|
* with the "exit boldface" sequence.
|
|
*/
|
|
column--;
|
|
else
|
|
curr++;
|
|
ln_state = LN_NORMAL;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (c == '\t') {
|
|
/*
|
|
* Expand a tab into spaces.
|
|
*/
|
|
do {
|
|
NEW_COLUMN(1);
|
|
} while (((column + horiz_off) % tabstop) != 0);
|
|
*curr++ = '\t';
|
|
return (0);
|
|
}
|
|
|
|
if (c == '\b') {
|
|
if (ln_state == LN_NORMAL)
|
|
NEW_COLUMN(0);
|
|
else
|
|
column--;
|
|
*curr++ = c;
|
|
return(0);
|
|
}
|
|
|
|
switch ((char)c) {
|
|
case UL_CHAR:
|
|
case UE_CHAR:
|
|
case BO_CHAR:
|
|
case BE_CHAR:
|
|
c &= ~0200;
|
|
/* fall through */
|
|
case '\200':
|
|
NEW_COLUMN(2);
|
|
break;
|
|
default:
|
|
if (CONTROL_CHAR(c))
|
|
NEW_COLUMN(2);
|
|
else
|
|
NEW_COLUMN(1);
|
|
break;
|
|
}
|
|
|
|
*curr++ = c;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Analogous to forw_line(), but deals with "raw lines":
|
|
* lines which are not split for screen width.
|
|
* {{ This is supposed to be more efficient than forw_line(). }}
|
|
*/
|
|
off_t
|
|
forw_raw_line(curr_pos)
|
|
off_t curr_pos;
|
|
{
|
|
register char *p;
|
|
register int c;
|
|
off_t new_pos, ch_tell();
|
|
|
|
if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
|
|
(c = ch_forw_get()) == EOI)
|
|
return (NULL_POSITION);
|
|
|
|
p = linebuf;
|
|
|
|
for (;;)
|
|
{
|
|
if (c == '\n' || c == EOI)
|
|
{
|
|
new_pos = ch_tell();
|
|
break;
|
|
}
|
|
if (p >= &linebuf[sizeof(linebuf)-1])
|
|
{
|
|
/*
|
|
* Overflowed the input buffer.
|
|
* Pretend the line ended here.
|
|
* {{ The line buffer is supposed to be big
|
|
* enough that this never happens, but it's
|
|
* statically allocated, so that's really just
|
|
* a pipe dream. This causes no end of trouble.
|
|
* The line.c needs to be rewritten. }}
|
|
*/
|
|
new_pos = ch_tell() - 1;
|
|
break;
|
|
}
|
|
*p++ = c;
|
|
c = ch_forw_get();
|
|
}
|
|
*p = '\0';
|
|
line = linebuf;
|
|
return (new_pos);
|
|
}
|
|
|
|
/*
|
|
* Analogous to back_line(), but deals with "raw lines".
|
|
* {{ This is supposed to be more efficient than back_line(). }}
|
|
*/
|
|
off_t
|
|
back_raw_line(curr_pos)
|
|
off_t curr_pos;
|
|
{
|
|
register char *p;
|
|
register int c;
|
|
off_t new_pos, ch_tell();
|
|
|
|
if (curr_pos == NULL_POSITION || curr_pos <= (off_t)0 ||
|
|
ch_seek(curr_pos-1))
|
|
return (NULL_POSITION);
|
|
|
|
p = &linebuf[sizeof(linebuf)];
|
|
*--p = '\0';
|
|
|
|
for (;;)
|
|
{
|
|
c = ch_back_get();
|
|
if (c == '\n')
|
|
{
|
|
/*
|
|
* This is the newline ending the previous line.
|
|
* We have hit the beginning of the line.
|
|
*/
|
|
new_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.
|
|
*/
|
|
new_pos = (off_t)0;
|
|
break;
|
|
}
|
|
if (p <= linebuf)
|
|
{
|
|
/*
|
|
* Overflowed the input buffer.
|
|
* Pretend the line ended here.
|
|
*/
|
|
new_pos = ch_tell() + 1;
|
|
break;
|
|
}
|
|
*--p = c;
|
|
}
|
|
line = p;
|
|
return (new_pos);
|
|
}
|