![[BACK]](/icons/back.gif){kind=icon}
Return to line.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / more|
Return to line.c CVS log | Up to [local] / src / usr.bin / more |
1.1 ! deraadt 1: /*
! 2: * Copyright (c) 1988 Mark Nudleman
! 3: * Copyright (c) 1988 Regents of the University of California.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. All advertising materials mentioning features or use of this software
! 15: * must display the following acknowledgement:
! 16: * This product includes software developed by the University of
! 17: * California, Berkeley and its contributors.
! 18: * 4. Neither the name of the University nor the names of its contributors
! 19: * may be used to endorse or promote products derived from this software
! 20: * without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 32: * SUCH DAMAGE.
! 33: */
! 34:
! 35: #ifndef lint
! 36: /* from: static char sccsid[] = "@(#)line.c 5.5 (Berkeley) 7/24/91"; */
! 37: static char *rcsid = "$Id: line.c,v 1.2 1993/11/09 05:09:49 cgd Exp $";
! 38: #endif /* not lint */
! 39:
! 40: /*
! 41: * Routines to manipulate the "line buffer".
! 42: * The line buffer holds a line of output as it is being built
! 43: * in preparation for output to the screen.
! 44: * We keep track of the PRINTABLE length of the line as it is being built.
! 45: */
! 46:
! 47: #include <sys/types.h>
! 48: #include <ctype.h>
! 49: #include <less.h>
! 50:
! 51: static char linebuf[1024]; /* Buffer which holds the current output line */
! 52: static char *curr; /* Pointer into linebuf */
! 53: static int column; /* Printable length, accounting for
! 54: backspaces, etc. */
! 55: /*
! 56: * A ridiculously complex state machine takes care of backspaces. The
! 57: * complexity arises from the attempt to deal with all cases, especially
! 58: * involving long lines with underlining, boldfacing or whatever. There
! 59: * are still some cases which will break it.
! 60: *
! 61: * There are four states:
! 62: * LN_NORMAL is the normal state (not in underline mode).
! 63: * LN_UNDERLINE means we are in underline mode. We expect to get
! 64: * either a sequence like "_\bX" or "X\b_" to continue
! 65: * underline mode, or anything else to end underline mode.
! 66: * LN_BOLDFACE means we are in boldface mode. We expect to get sequences
! 67: * like "X\bX\b...X\bX" to continue boldface mode, or anything
! 68: * else to end boldface mode.
! 69: * LN_UL_X means we are one character after LN_UNDERLINE
! 70: * (we have gotten the '_' in "_\bX" or the 'X' in "X\b_").
! 71: * LN_UL_XB means we are one character after LN_UL_X
! 72: * (we have gotten the backspace in "_\bX" or "X\b_";
! 73: * we expect one more ordinary character,
! 74: * which will put us back in state LN_UNDERLINE).
! 75: * LN_BO_X means we are one character after LN_BOLDFACE
! 76: * (we have gotten the 'X' in "X\bX").
! 77: * LN_BO_XB means we are one character after LN_BO_X
! 78: * (we have gotten the backspace in "X\bX";
! 79: * we expect one more 'X' which will put us back
! 80: * in LN_BOLDFACE).
! 81: */
! 82: static int ln_state; /* Currently in normal/underline/bold/etc mode? */
! 83: #define LN_NORMAL 0 /* Not in underline, boldface or whatever mode */
! 84: #define LN_UNDERLINE 1 /* In underline, need next char */
! 85: #define LN_UL_X 2 /* In underline, got char, need \b */
! 86: #define LN_UL_XB 3 /* In underline, got char & \b, need one more */
! 87: #define LN_BOLDFACE 4 /* In boldface, need next char */
! 88: #define LN_BO_X 5 /* In boldface, got char, need \b */
! 89: #define LN_BO_XB 6 /* In boldface, got char & \b, need same char */
! 90:
! 91: char *line; /* Pointer to the current line.
! 92: Usually points to linebuf. */
! 93:
! 94: extern int bs_mode;
! 95: extern int tabstop;
! 96: extern int bo_width, be_width;
! 97: extern int ul_width, ue_width;
! 98: extern int sc_width, sc_height;
! 99:
! 100: /*
! 101: * Rewind the line buffer.
! 102: */
! 103: prewind()
! 104: {
! 105: line = curr = linebuf;
! 106: ln_state = LN_NORMAL;
! 107: column = 0;
! 108: }
! 109:
! 110: /*
! 111: * Append a character to the line buffer.
! 112: * Expand tabs into spaces, handle underlining, boldfacing, etc.
! 113: * Returns 0 if ok, 1 if couldn't fit in buffer.
! 114: */
! 115: #define NEW_COLUMN(addon) \
! 116: if (column + addon + (ln_state ? ue_width : 0) > sc_width) \
! 117: return(1); \
! 118: else \
! 119: column += addon
! 120:
! 121: pappend(c)
! 122: int c;
! 123: {
! 124: if (c == '\0') {
! 125: /*
! 126: * Terminate any special modes, if necessary.
! 127: * Append a '\0' to the end of the line.
! 128: */
! 129: switch (ln_state) {
! 130: case LN_UL_X:
! 131: curr[0] = curr[-1];
! 132: curr[-1] = UE_CHAR;
! 133: curr++;
! 134: break;
! 135: case LN_BO_X:
! 136: curr[0] = curr[-1];
! 137: curr[-1] = BE_CHAR;
! 138: curr++;
! 139: break;
! 140: case LN_UL_XB:
! 141: case LN_UNDERLINE:
! 142: *curr++ = UE_CHAR;
! 143: break;
! 144: case LN_BO_XB:
! 145: case LN_BOLDFACE:
! 146: *curr++ = BE_CHAR;
! 147: break;
! 148: }
! 149: ln_state = LN_NORMAL;
! 150: *curr = '\0';
! 151: return(0);
! 152: }
! 153:
! 154: if (curr > linebuf + sizeof(linebuf) - 12)
! 155: /*
! 156: * Almost out of room in the line buffer.
! 157: * Don't take any chances.
! 158: * {{ Linebuf is supposed to be big enough that this
! 159: * will never happen, but may need to be made
! 160: * bigger for wide screens or lots of backspaces. }}
! 161: */
! 162: return(1);
! 163:
! 164: if (!bs_mode) {
! 165: /*
! 166: * Advance the state machine.
! 167: */
! 168: switch (ln_state) {
! 169: case LN_NORMAL:
! 170: if (curr <= linebuf + 1
! 171: || curr[-1] != (char)('H' | 0200))
! 172: break;
! 173: column -= 2;
! 174: if (c == curr[-2])
! 175: goto enter_boldface;
! 176: if (c == '_' || curr[-2] == '_')
! 177: goto enter_underline;
! 178: curr -= 2;
! 179: break;
! 180:
! 181: enter_boldface:
! 182: /*
! 183: * We have "X\bX" (including the current char).
! 184: * Switch into boldface mode.
! 185: */
! 186: column--;
! 187: if (column + bo_width + be_width + 1 >= sc_width)
! 188: /*
! 189: * Not enough room left on the screen to
! 190: * enter and exit boldface mode.
! 191: */
! 192: return (1);
! 193:
! 194: if (bo_width > 0 && curr > linebuf + 2
! 195: && curr[-3] == ' ') {
! 196: /*
! 197: * Special case for magic cookie terminals:
! 198: * if the previous char was a space, replace
! 199: * it with the "enter boldface" sequence.
! 200: */
! 201: curr[-3] = BO_CHAR;
! 202: column += bo_width-1;
! 203: } else {
! 204: curr[-1] = curr[-2];
! 205: curr[-2] = BO_CHAR;
! 206: column += bo_width;
! 207: curr++;
! 208: }
! 209: goto ln_bo_xb_case;
! 210:
! 211: enter_underline:
! 212: /*
! 213: * We have either "_\bX" or "X\b_" (including
! 214: * the current char). Switch into underline mode.
! 215: */
! 216: column--;
! 217: if (column + ul_width + ue_width + 1 >= sc_width)
! 218: /*
! 219: * Not enough room left on the screen to
! 220: * enter and exit underline mode.
! 221: */
! 222: return (1);
! 223:
! 224: if (ul_width > 0 &&
! 225: curr > linebuf + 2 && curr[-3] == ' ')
! 226: {
! 227: /*
! 228: * Special case for magic cookie terminals:
! 229: * if the previous char was a space, replace
! 230: * it with the "enter underline" sequence.
! 231: */
! 232: curr[-3] = UL_CHAR;
! 233: column += ul_width-1;
! 234: } else
! 235: {
! 236: curr[-1] = curr[-2];
! 237: curr[-2] = UL_CHAR;
! 238: column += ul_width;
! 239: curr++;
! 240: }
! 241: goto ln_ul_xb_case;
! 242: /*NOTREACHED*/
! 243: case LN_UL_XB:
! 244: /*
! 245: * Termination of a sequence "_\bX" or "X\b_".
! 246: */
! 247: if (c != '_' && curr[-2] != '_' && c == curr[-2])
! 248: {
! 249: /*
! 250: * We seem to have run on from underlining
! 251: * into boldfacing - this is a nasty fix, but
! 252: * until this whole routine is rewritten as a
! 253: * real DFA, ... well ...
! 254: */
! 255: curr[0] = curr[-2];
! 256: curr[-2] = UE_CHAR;
! 257: curr[-1] = BO_CHAR;
! 258: curr += 2; /* char & non-existent backspace */
! 259: ln_state = LN_BO_XB;
! 260: goto ln_bo_xb_case;
! 261: }
! 262: ln_ul_xb_case:
! 263: if (c == '_')
! 264: c = curr[-2];
! 265: curr -= 2;
! 266: ln_state = LN_UNDERLINE;
! 267: break;
! 268: case LN_BO_XB:
! 269: /*
! 270: * Termination of a sequnce "X\bX".
! 271: */
! 272: if (c != curr[-2] && (c == '_' || curr[-2] == '_'))
! 273: {
! 274: /*
! 275: * We seem to have run on from
! 276: * boldfacing into underlining.
! 277: */
! 278: curr[0] = curr[-2];
! 279: curr[-2] = BE_CHAR;
! 280: curr[-1] = UL_CHAR;
! 281: curr += 2; /* char & non-existent backspace */
! 282: ln_state = LN_UL_XB;
! 283: goto ln_ul_xb_case;
! 284: }
! 285: ln_bo_xb_case:
! 286: curr -= 2;
! 287: ln_state = LN_BOLDFACE;
! 288: break;
! 289: case LN_UNDERLINE:
! 290: if (column + ue_width + bo_width + 1 + be_width >= sc_width)
! 291: /*
! 292: * We have just barely enough room to
! 293: * exit underline mode and handle a possible
! 294: * underline/boldface run on mixup.
! 295: */
! 296: return (1);
! 297: ln_state = LN_UL_X;
! 298: break;
! 299: case LN_BOLDFACE:
! 300: if (c == '\b')
! 301: {
! 302: ln_state = LN_BO_XB;
! 303: break;
! 304: }
! 305: if (column + be_width + ul_width + 1 + ue_width >= sc_width)
! 306: /*
! 307: * We have just barely enough room to
! 308: * exit underline mode and handle a possible
! 309: * underline/boldface run on mixup.
! 310: */
! 311: return (1);
! 312: ln_state = LN_BO_X;
! 313: break;
! 314: case LN_UL_X:
! 315: if (c == '\b')
! 316: ln_state = LN_UL_XB;
! 317: else
! 318: {
! 319: /*
! 320: * Exit underline mode.
! 321: * We have to shuffle the chars a bit
! 322: * to make this work.
! 323: */
! 324: curr[0] = curr[-1];
! 325: curr[-1] = UE_CHAR;
! 326: column += ue_width;
! 327: if (ue_width > 0 && curr[0] == ' ')
! 328: /*
! 329: * Another special case for magic
! 330: * cookie terminals: if the next
! 331: * char is a space, replace it
! 332: * with the "exit underline" sequence.
! 333: */
! 334: column--;
! 335: else
! 336: curr++;
! 337: ln_state = LN_NORMAL;
! 338: }
! 339: break;
! 340: case LN_BO_X:
! 341: if (c == '\b')
! 342: ln_state = LN_BO_XB;
! 343: else
! 344: {
! 345: /*
! 346: * Exit boldface mode.
! 347: * We have to shuffle the chars a bit
! 348: * to make this work.
! 349: */
! 350: curr[0] = curr[-1];
! 351: curr[-1] = BE_CHAR;
! 352: column += be_width;
! 353: if (be_width > 0 && curr[0] == ' ')
! 354: /*
! 355: * Another special case for magic
! 356: * cookie terminals: if the next
! 357: * char is a space, replace it
! 358: * with the "exit boldface" sequence.
! 359: */
! 360: column--;
! 361: else
! 362: curr++;
! 363: ln_state = LN_NORMAL;
! 364: }
! 365: break;
! 366: }
! 367: }
! 368:
! 369: if (c == '\t') {
! 370: /*
! 371: * Expand a tab into spaces.
! 372: */
! 373: do {
! 374: NEW_COLUMN(1);
! 375: } while ((column % tabstop) != 0);
! 376: *curr++ = '\t';
! 377: return (0);
! 378: }
! 379:
! 380: if (c == '\b') {
! 381: if (ln_state == LN_NORMAL)
! 382: NEW_COLUMN(2);
! 383: else
! 384: column--;
! 385: *curr++ = ('H' | 0200);
! 386: return(0);
! 387: }
! 388:
! 389: if (CONTROL_CHAR(c)) {
! 390: /*
! 391: * Put a "^X" into the buffer. The 0200 bit is used to tell
! 392: * put_line() to prefix the char with a ^. We don't actually
! 393: * put the ^ in the buffer because we sometimes need to move
! 394: * chars around, and such movement might separate the ^ from
! 395: * its following character.
! 396: */
! 397: NEW_COLUMN(2);
! 398: *curr++ = (CARAT_CHAR(c) | 0200);
! 399: return(0);
! 400: }
! 401:
! 402: /*
! 403: * Ordinary character. Just put it in the buffer.
! 404: */
! 405: NEW_COLUMN(1);
! 406: *curr++ = c;
! 407: return (0);
! 408: }
! 409:
! 410: /*
! 411: * Analogous to forw_line(), but deals with "raw lines":
! 412: * lines which are not split for screen width.
! 413: * {{ This is supposed to be more efficient than forw_line(). }}
! 414: */
! 415: off_t
! 416: forw_raw_line(curr_pos)
! 417: off_t curr_pos;
! 418: {
! 419: register char *p;
! 420: register int c;
! 421: off_t new_pos, ch_tell();
! 422:
! 423: if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
! 424: (c = ch_forw_get()) == EOI)
! 425: return (NULL_POSITION);
! 426:
! 427: p = linebuf;
! 428:
! 429: for (;;)
! 430: {
! 431: if (c == '\n' || c == EOI)
! 432: {
! 433: new_pos = ch_tell();
! 434: break;
! 435: }
! 436: if (p >= &linebuf[sizeof(linebuf)-1])
! 437: {
! 438: /*
! 439: * Overflowed the input buffer.
! 440: * Pretend the line ended here.
! 441: * {{ The line buffer is supposed to be big
! 442: * enough that this never happens. }}
! 443: */
! 444: new_pos = ch_tell() - 1;
! 445: break;
! 446: }
! 447: *p++ = c;
! 448: c = ch_forw_get();
! 449: }
! 450: *p = '\0';
! 451: line = linebuf;
! 452: return (new_pos);
! 453: }
! 454:
! 455: /*
! 456: * Analogous to back_line(), but deals with "raw lines".
! 457: * {{ This is supposed to be more efficient than back_line(). }}
! 458: */
! 459: off_t
! 460: back_raw_line(curr_pos)
! 461: off_t curr_pos;
! 462: {
! 463: register char *p;
! 464: register int c;
! 465: off_t new_pos, ch_tell();
! 466:
! 467: if (curr_pos == NULL_POSITION || curr_pos <= (off_t)0 ||
! 468: ch_seek(curr_pos-1))
! 469: return (NULL_POSITION);
! 470:
! 471: p = &linebuf[sizeof(linebuf)];
! 472: *--p = '\0';
! 473:
! 474: for (;;)
! 475: {
! 476: c = ch_back_get();
! 477: if (c == '\n')
! 478: {
! 479: /*
! 480: * This is the newline ending the previous line.
! 481: * We have hit the beginning of the line.
! 482: */
! 483: new_pos = ch_tell() + 1;
! 484: break;
! 485: }
! 486: if (c == EOI)
! 487: {
! 488: /*
! 489: * We have hit the beginning of the file.
! 490: * This must be the first line in the file.
! 491: * This must, of course, be the beginning of the line.
! 492: */
! 493: new_pos = (off_t)0;
! 494: break;
! 495: }
! 496: if (p <= linebuf)
! 497: {
! 498: /*
! 499: * Overflowed the input buffer.
! 500: * Pretend the line ended here.
! 501: */
! 502: new_pos = ch_tell() + 1;
! 503: break;
! 504: }
! 505: *--p = c;
! 506: }
! 507: line = p;
! 508: return (new_pos);
! 509: }