![[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 / less|
Return to line.c CVS log | Up to [local] / src / usr.bin / less |
1.1 ! etheisen 1: /*
! 2: * Copyright (c) 1984,1985,1989,1994,1995 Mark Nudelman
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice in the documentation and/or other materials provided with
! 12: * the distribution.
! 13: *
! 14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
! 15: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 17: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
! 18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 19: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
! 20: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
! 21: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
! 23: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
! 24: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 25: */
! 26:
! 27:
! 28: /*
! 29: * Routines to manipulate the "line buffer".
! 30: * The line buffer holds a line of output as it is being built
! 31: * in preparation for output to the screen.
! 32: */
! 33:
! 34: #include "less.h"
! 35:
! 36: public char linebuf[1024]; /* Buffer which holds the current output line */
! 37: public int size_linebuf = sizeof(linebuf);
! 38:
! 39: static char attr[1024]; /* Extension of linebuf to hold attributes */
! 40: static int curr; /* Index into linebuf */
! 41: static int column; /* Printable length, accounting for
! 42: backspaces, etc. */
! 43: static int lno_indent; /* Number of chars used for line number */
! 44: static int overstrike; /* Next char should overstrike previous char */
! 45: static int is_null_line; /* There is no current line */
! 46: static char pendc;
! 47: static POSITION pendpos;
! 48:
! 49: static int do_append();
! 50:
! 51: extern int bs_mode;
! 52: extern int tabstop;
! 53: extern int linenums;
! 54: extern int ctldisp;
! 55: extern int twiddle;
! 56: extern int binattr;
! 57: extern int auto_wrap, ignaw;
! 58: extern int bo_s_width, bo_e_width;
! 59: extern int ul_s_width, ul_e_width;
! 60: extern int bl_s_width, bl_e_width;
! 61: extern int so_s_width, so_e_width;
! 62: extern int sc_width, sc_height;
! 63:
! 64: /*
! 65: * Rewind the line buffer.
! 66: */
! 67: public void
! 68: prewind()
! 69: {
! 70: curr = 0;
! 71: column = 0;
! 72: overstrike = 0;
! 73: is_null_line = 0;
! 74: lno_indent = 0;
! 75: pendc = '\0';
! 76: }
! 77:
! 78: /*
! 79: * Insert the line number (of the given position) into the line buffer.
! 80: */
! 81: public void
! 82: plinenum(pos)
! 83: POSITION pos;
! 84: {
! 85: register int lno;
! 86: register int i;
! 87: register int n;
! 88:
! 89: /*
! 90: * We display the line number at the start of each line
! 91: * only if the -N option is set.
! 92: */
! 93: if (linenums != OPT_ONPLUS)
! 94: return;
! 95:
! 96: /*
! 97: * Get the line number and put it in the current line.
! 98: * {{ Note: since find_linenum calls forw_raw_line,
! 99: * it may seek in the input file, requiring the caller
! 100: * of plinenum to re-seek if necessary. }}
! 101: */
! 102: lno = find_linenum(pos);
! 103:
! 104: sprintf(&linebuf[curr], "%6d", lno);
! 105: n = strlen(&linebuf[curr]);
! 106: column += n;
! 107: for (i = 0; i < n; i++)
! 108: attr[curr++] = 0;
! 109:
! 110: /*
! 111: * Append enough spaces to bring us to the next tab stop.
! 112: * {{ We could avoid this at the cost of adding some
! 113: * complication to the tab stop logic in pappend(). }}
! 114: */
! 115: if (tabstop == 0)
! 116: tabstop = 1;
! 117: do
! 118: {
! 119: linebuf[curr] = ' ';
! 120: attr[curr++] = AT_NORMAL;
! 121: column++;
! 122: } while ((column % tabstop) != 0);
! 123: lno_indent = column;
! 124: }
! 125:
! 126: /*
! 127: * Return the printing width of the start (enter) sequence
! 128: * for a given character attribute.
! 129: */
! 130: int
! 131: attr_swidth(a)
! 132: int a;
! 133: {
! 134: switch (a)
! 135: {
! 136: case AT_BOLD: return (bo_s_width);
! 137: case AT_UNDERLINE: return (ul_s_width);
! 138: case AT_BLINK: return (bl_s_width);
! 139: case AT_STANDOUT: return (so_s_width);
! 140: }
! 141: return (0);
! 142: }
! 143:
! 144: /*
! 145: * Return the printing width of the end (exit) sequence
! 146: * for a given character attribute.
! 147: */
! 148: int
! 149: attr_ewidth(a)
! 150: int a;
! 151: {
! 152: switch (a)
! 153: {
! 154: case AT_BOLD: return (bo_e_width);
! 155: case AT_UNDERLINE: return (ul_e_width);
! 156: case AT_BLINK: return (bl_e_width);
! 157: case AT_STANDOUT: return (so_e_width);
! 158: }
! 159: return (0);
! 160: }
! 161:
! 162: /*
! 163: * Return the printing width of a given character and attribute,
! 164: * if the character were added to the current position in the line buffer.
! 165: * Adding a character with a given attribute may cause an enter or exit
! 166: * attribute sequence to be inserted, so this must be taken into account.
! 167: */
! 168: static int
! 169: pwidth(c, a)
! 170: int c;
! 171: int a;
! 172: {
! 173: register int w;
! 174:
! 175: if (c == '\b')
! 176: /*
! 177: * Backspace moves backwards one position.
! 178: */
! 179: return (-1);
! 180:
! 181: if (control_char(c))
! 182: /*
! 183: * Control characters do unpredicatable things,
! 184: * so we don't even try to guess; say it doesn't move.
! 185: * This can only happen if the -r flag is in effect.
! 186: */
! 187: return (0);
! 188:
! 189: /*
! 190: * Other characters take one space,
! 191: * plus the width of any attribute enter/exit sequence.
! 192: */
! 193: w = 1;
! 194: if (curr > 0 && attr[curr-1] != a)
! 195: w += attr_ewidth(attr[curr-1]);
! 196: if (a && (curr == 0 || attr[curr-1] != a))
! 197: w += attr_swidth(a);
! 198: return (w);
! 199: }
! 200:
! 201: /*
! 202: * Delete the previous character in the line buffer.
! 203: */
! 204: static void
! 205: backc()
! 206: {
! 207: curr--;
! 208: column -= pwidth(linebuf[curr], attr[curr]);
! 209: }
! 210:
! 211: /*
! 212: * Append a character and attribute to the line buffer.
! 213: */
! 214: static int
! 215: storec(c, a, pos)
! 216: int c;
! 217: int a;
! 218: POSITION pos;
! 219: {
! 220: register int w;
! 221:
! 222: #if HILITE_SEARCH
! 223: if (is_hilited(pos, pos+1, 0))
! 224: /*
! 225: * This character should be highlighted.
! 226: * Override the attribute passed in.
! 227: */
! 228: a = AT_STANDOUT;
! 229: #endif
! 230: w = pwidth(c, a);
! 231: if (ctldisp > 0 && column + w + attr_ewidth(a) > sc_width)
! 232: /*
! 233: * Won't fit on screen.
! 234: */
! 235: return (1);
! 236:
! 237: if (curr >= sizeof(linebuf)-2)
! 238: /*
! 239: * Won't fit in line buffer.
! 240: */
! 241: return (1);
! 242:
! 243: /*
! 244: * Special handling for "magic cookie" terminals.
! 245: * If an attribute enter/exit sequence has a printing width > 0,
! 246: * and the sequence is adjacent to a space, delete the space.
! 247: * We just mark the space as invisible, to avoid having too
! 248: * many spaces deleted.
! 249: * {{ Note that even if the attribute width is > 1, we
! 250: * delete only one space. It's not worth trying to do more.
! 251: * It's hardly worth doing this much. }}
! 252: */
! 253: if (curr > 0 && a != AT_NORMAL &&
! 254: linebuf[curr-1] == ' ' && attr[curr-1] == AT_NORMAL &&
! 255: attr_swidth(a) > 0)
! 256: {
! 257: /*
! 258: * We are about to append an enter-attribute sequence
! 259: * just after a space. Delete the space.
! 260: */
! 261: attr[curr-1] = AT_INVIS;
! 262: column--;
! 263: } else if (curr > 0 && attr[curr-1] != AT_NORMAL &&
! 264: attr[curr-1] != AT_INVIS && c == ' ' && a == AT_NORMAL &&
! 265: attr_ewidth(attr[curr-1]) > 0)
! 266: {
! 267: /*
! 268: * We are about to append a space just after an
! 269: * exit-attribute sequence. Delete the space.
! 270: */
! 271: a = AT_INVIS;
! 272: column--;
! 273: }
! 274: /* End of magic cookie handling. */
! 275:
! 276: linebuf[curr] = c;
! 277: attr[curr] = a;
! 278: column += w;
! 279: return (0);
! 280: }
! 281:
! 282: /*
! 283: * Append a character to the line buffer.
! 284: * Expand tabs into spaces, handle underlining, boldfacing, etc.
! 285: * Returns 0 if ok, 1 if couldn't fit in buffer.
! 286: */
! 287: public int
! 288: pappend(c, pos)
! 289: register int c;
! 290: POSITION pos;
! 291: {
! 292: if (pendc)
! 293: {
! 294: if (do_append(pendc, pendpos))
! 295: /*
! 296: * Oops. We've probably lost the char which
! 297: * was in pendc, since caller won't back up.
! 298: */
! 299: return (1);
! 300: pendc = '\0';
! 301: }
! 302:
! 303: if (c == '\r' && bs_mode == BS_SPECIAL)
! 304: {
! 305: /*
! 306: * Don't put the CR into the buffer until we see
! 307: * the next char. If the next char is a newline,
! 308: * discard the CR.
! 309: */
! 310: pendc = c;
! 311: pendpos = pos;
! 312: return (0);
! 313: }
! 314:
! 315: return (do_append(c, pos));
! 316: }
! 317:
! 318: static int
! 319: do_append(c, pos)
! 320: int c;
! 321: POSITION pos;
! 322: {
! 323: register char *s;
! 324: register int a;
! 325:
! 326: #define STOREC(c,a) \
! 327: if (storec((c),(a),pos)) return (1); else curr++
! 328:
! 329: if (overstrike)
! 330: {
! 331: /*
! 332: * Overstrike the character at the current position
! 333: * in the line buffer. This will cause either
! 334: * underline (if a "_" is overstruck),
! 335: * bold (if an identical character is overstruck),
! 336: * or just deletion of the character in the buffer.
! 337: */
! 338: overstrike = 0;
! 339: if ((char)c == linebuf[curr])
! 340: STOREC(linebuf[curr], AT_BOLD);
! 341: else if (c == '_')
! 342: STOREC(linebuf[curr], AT_UNDERLINE);
! 343: else if (linebuf[curr] == '_')
! 344: STOREC(c, AT_UNDERLINE);
! 345: else if (control_char(c))
! 346: goto do_control_char;
! 347: else
! 348: STOREC(c, AT_NORMAL);
! 349: } else if (c == '\b')
! 350: {
! 351: switch (bs_mode)
! 352: {
! 353: case BS_NORMAL:
! 354: STOREC(c, AT_NORMAL);
! 355: break;
! 356: case BS_CONTROL:
! 357: goto do_control_char;
! 358: case BS_SPECIAL:
! 359: if (curr == 0)
! 360: break;
! 361: backc();
! 362: overstrike = 1;
! 363: break;
! 364: }
! 365: } else if (c == '\t')
! 366: {
! 367: /*
! 368: * Expand a tab into spaces.
! 369: */
! 370: if (tabstop == 0)
! 371: tabstop = 1;
! 372: do
! 373: {
! 374: STOREC(' ', AT_NORMAL);
! 375: } while ((column % tabstop) != 0);
! 376: } else if (control_char(c))
! 377: {
! 378: do_control_char:
! 379: if (ctldisp == 0)
! 380: {
! 381: /*
! 382: * Output as a normal character.
! 383: */
! 384: STOREC(c, AT_NORMAL);
! 385: } else
! 386: {
! 387: /*
! 388: * Convert to printable representation.
! 389: */
! 390: s = prchar(c);
! 391: a = binattr;
! 392:
! 393: /*
! 394: * Make sure we can get the entire representation
! 395: * of the character on this line.
! 396: */
! 397: if (column + (int) strlen(s) +
! 398: attr_swidth(a) + attr_ewidth(a) > sc_width)
! 399: return (1);
! 400:
! 401: for ( ; *s != 0; s++)
! 402: STOREC(*s, a);
! 403: }
! 404: } else
! 405: {
! 406: STOREC(c, AT_NORMAL);
! 407: }
! 408:
! 409: return (0);
! 410: }
! 411:
! 412: /*
! 413: * Terminate the line in the line buffer.
! 414: */
! 415: public void
! 416: pdone(endline)
! 417: int endline;
! 418: {
! 419: if (pendc && (pendc != '\r' || !endline))
! 420: /*
! 421: * If we had a pending character, put it in the buffer.
! 422: * But discard a pending CR if we are at end of line
! 423: * (that is, discard the CR in a CR/LF sequence).
! 424: */
! 425: (void) do_append(pendc, pendpos);
! 426:
! 427: /*
! 428: * Add a newline if necessary,
! 429: * and append a '\0' to the end of the line.
! 430: */
! 431: if (column < sc_width || !auto_wrap || ignaw || ctldisp == 0)
! 432: {
! 433: linebuf[curr] = '\n';
! 434: attr[curr] = AT_NORMAL;
! 435: curr++;
! 436: }
! 437: linebuf[curr] = '\0';
! 438: attr[curr] = AT_NORMAL;
! 439: }
! 440:
! 441: /*
! 442: * Get a character from the current line.
! 443: * Return the character as the function return value,
! 444: * and the character attribute in *ap.
! 445: */
! 446: public int
! 447: gline(i, ap)
! 448: register int i;
! 449: register int *ap;
! 450: {
! 451: char *s;
! 452:
! 453: if (is_null_line)
! 454: {
! 455: /*
! 456: * If there is no current line, we pretend the line is
! 457: * either "~" or "", depending on the "twiddle" flag.
! 458: */
! 459: *ap = AT_NORMAL;
! 460: s = (twiddle) ? "~\n" : "\n";
! 461: return (s[i]);
! 462: }
! 463:
! 464: *ap = attr[i];
! 465: return (linebuf[i] & 0377);
! 466: }
! 467:
! 468: /*
! 469: * Indicate that there is no current line.
! 470: */
! 471: public void
! 472: null_line()
! 473: {
! 474: is_null_line = 1;
! 475: }
! 476:
! 477: #if 1
! 478: /*
! 479: * Analogous to forw_line(), but deals with "raw lines":
! 480: * lines which are not split for screen width.
! 481: * {{ This is supposed to be more efficient than forw_line(). }}
! 482: */
! 483: public POSITION
! 484: forw_raw_line(curr_pos, linep)
! 485: POSITION curr_pos;
! 486: char **linep;
! 487: {
! 488: register char *p;
! 489: register int c;
! 490: POSITION new_pos;
! 491:
! 492: if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
! 493: (c = ch_forw_get()) == EOI)
! 494: return (NULL_POSITION);
! 495:
! 496: p = linebuf;
! 497:
! 498: for (;;)
! 499: {
! 500: if (c == '\n' || c == EOI)
! 501: {
! 502: new_pos = ch_tell();
! 503: break;
! 504: }
! 505: if (p >= &linebuf[sizeof(linebuf)-1])
! 506: {
! 507: /*
! 508: * Overflowed the input buffer.
! 509: * Pretend the line ended here.
! 510: * {{ The line buffer is supposed to be big
! 511: * enough that this never happens. }}
! 512: */
! 513: new_pos = ch_tell() - 1;
! 514: break;
! 515: }
! 516: *p++ = c;
! 517: c = ch_forw_get();
! 518: }
! 519: *p = '\0';
! 520: if (linep != NULL)
! 521: *linep = linebuf;
! 522: return (new_pos);
! 523: }
! 524:
! 525: /*
! 526: * Analogous to back_line(), but deals with "raw lines".
! 527: * {{ This is supposed to be more efficient than back_line(). }}
! 528: */
! 529: public POSITION
! 530: back_raw_line(curr_pos, linep)
! 531: POSITION curr_pos;
! 532: char **linep;
! 533: {
! 534: register char *p;
! 535: register int c;
! 536: POSITION new_pos;
! 537:
! 538: if (curr_pos == NULL_POSITION || curr_pos <= ch_zero() ||
! 539: ch_seek(curr_pos-1))
! 540: return (NULL_POSITION);
! 541:
! 542: p = &linebuf[sizeof(linebuf)];
! 543: *--p = '\0';
! 544:
! 545: for (;;)
! 546: {
! 547: c = ch_back_get();
! 548: if (c == '\n')
! 549: {
! 550: /*
! 551: * This is the newline ending the previous line.
! 552: * We have hit the beginning of the line.
! 553: */
! 554: new_pos = ch_tell() + 1;
! 555: break;
! 556: }
! 557: if (c == EOI)
! 558: {
! 559: /*
! 560: * We have hit the beginning of the file.
! 561: * This must be the first line in the file.
! 562: * This must, of course, be the beginning of the line.
! 563: */
! 564: new_pos = ch_zero();
! 565: break;
! 566: }
! 567: if (p <= linebuf)
! 568: {
! 569: /*
! 570: * Overflowed the input buffer.
! 571: * Pretend the line ended here.
! 572: */
! 573: new_pos = ch_tell() + 1;
! 574: break;
! 575: }
! 576: *--p = c;
! 577: }
! 578: if (linep != NULL)
! 579: *linep = p;
! 580: return (new_pos);
! 581: }
! 582: #endif