/* $NetBSD: line.c,v 1.5 2003/10/13 14:34:25 agc Exp $ */ /* * Copyright (c) 1988 Mark Nudelman * 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. 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. */ #include <sys/cdefs.h> #ifndef lint #if 0 static char sccsid[] = "@(#)line.c 8.1 (Berkeley) 6/6/93"; #else __RCSID("$NetBSD: line.c,v 1.5 2003/10/13 14:34:25 agc Exp $"); #endif #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" #include "extern.h" static char linebuf[1024]; /* Buffer which holds 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; /* Currently in normal/underline/bold/etc mode? */ #define LN_NORMAL 0 /* Not in underline, boldface or 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. */ /* * Rewind the line buffer. */ void prewind() { line = curr = linebuf; ln_state = LN_NORMAL; column = 0; } /* * 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. */ #define NEW_COLUMN(addon) \ if (column + addon + (ln_state ? ue_width : 0) > sc_width) \ return(1); \ else \ column += addon int 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 wide screens or lots of backspaces. }} */ return(1); if (!bs_mode) { /* * Advance the state machine. */ switch (ln_state) { case LN_NORMAL: if (curr <= linebuf + 1 || curr[-1] != (char)('H' | 0200)) break; column -= 2; if (c == 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 + 1 >= 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 + 1 >= 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 == 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 = curr[-2]; curr -= 2; ln_state = LN_UNDERLINE; break; case LN_BO_XB: /* * Termination of a sequnce "X\bX". */ if (c != 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 + 1 + 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 + 1 + 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 % tabstop) != 0); *curr++ = '\t'; return (0); } if (c == '\b') { if (ln_state == LN_NORMAL) NEW_COLUMN(2); else column--; *curr++ = ('H' | 0200); return(0); } if (CONTROL_CHAR(c)) { /* * Put a "^X" into the buffer. The 0200 bit is used to tell * put_line() to prefix the char with a ^. We don't actually * put the ^ in the buffer because we sometimes need to move * chars around, and such movement might separate the ^ from * its following character. */ NEW_COLUMN(2); *curr++ = (CARAT_CHAR(c) | 0200); return(0); } /* * Ordinary character. Just put it in the buffer. */ NEW_COLUMN(1); *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; { char *p; int c; off_t new_pos; 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. }} */ 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; { char *p; int c; off_t new_pos; 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); }