1 /* 2 * Copyright (C) 1984-2020 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 * Routines to manipulate the "line buffer". 12 * The line buffer holds a line of output as it is being built 13 * in preparation for output to the screen. 14 */ 15 16 #include "less.h" 17 #include "charset.h" 18 #include "position.h" 19 20 #if MSDOS_COMPILER==WIN32C 21 #define WIN32_LEAN_AND_MEAN 22 #include <windows.h> 23 #endif 24 25 static char *linebuf = NULL; /* Buffer which holds the current output line */ 26 static char *attr = NULL; /* Extension of linebuf to hold attributes */ 27 public int size_linebuf = 0; /* Size of line buffer (and attr buffer) */ 28 29 static int cshift; /* Current left-shift of output line buffer */ 30 public int hshift; /* Desired left-shift of output line buffer */ 31 public int tabstops[TABSTOP_MAX] = { 0 }; /* Custom tabstops */ 32 public int ntabstops = 1; /* Number of tabstops */ 33 public int tabdefault = 8; /* Default repeated tabstops */ 34 public POSITION highest_hilite; /* Pos of last hilite in file found so far */ 35 36 static int curr; /* Index into linebuf */ 37 static int column; /* Printable length, accounting for 38 backspaces, etc. */ 39 static int right_curr; 40 static int right_column; 41 static int overstrike; /* Next char should overstrike previous char */ 42 static int last_overstrike = AT_NORMAL; 43 static int is_null_line; /* There is no current line */ 44 static int lmargin; /* Left margin */ 45 static LWCHAR pendc; 46 static POSITION pendpos; 47 static char *end_ansi_chars; 48 static char *mid_ansi_chars; 49 50 static int attr_swidth LESSPARAMS ((int a)); 51 static int attr_ewidth LESSPARAMS ((int a)); 52 static int do_append LESSPARAMS ((LWCHAR ch, char *rep, POSITION pos)); 53 54 extern int sigs; 55 extern int bs_mode; 56 extern int linenums; 57 extern int ctldisp; 58 extern int twiddle; 59 extern int binattr; 60 extern int status_col; 61 extern int auto_wrap, ignaw; 62 extern int bo_s_width, bo_e_width; 63 extern int ul_s_width, ul_e_width; 64 extern int bl_s_width, bl_e_width; 65 extern int so_s_width, so_e_width; 66 extern int sc_width, sc_height; 67 extern int utf_mode; 68 extern POSITION start_attnpos; 69 extern POSITION end_attnpos; 70 extern char rscroll_char; 71 extern int rscroll_attr; 72 73 static char mbc_buf[MAX_UTF_CHAR_LEN]; 74 static int mbc_buf_len = 0; 75 static int mbc_buf_index = 0; 76 static POSITION mbc_pos; 77 78 /* 79 * Initialize from environment variables. 80 */ 81 public void 82 init_line(VOID_PARAM) 83 { 84 end_ansi_chars = lgetenv("LESSANSIENDCHARS"); 85 if (isnullenv(end_ansi_chars)) 86 end_ansi_chars = "m"; 87 88 mid_ansi_chars = lgetenv("LESSANSIMIDCHARS"); 89 if (isnullenv(mid_ansi_chars)) 90 mid_ansi_chars = "0123456789:;[?!\"'#%()*+ "; 91 92 linebuf = (char *) ecalloc(LINEBUF_SIZE, sizeof(char)); 93 attr = (char *) ecalloc(LINEBUF_SIZE, sizeof(char)); 94 size_linebuf = LINEBUF_SIZE; 95 } 96 97 /* 98 * Expand the line buffer. 99 */ 100 static int 101 expand_linebuf(VOID_PARAM) 102 { 103 /* Double the size of the line buffer. */ 104 int new_size = size_linebuf * 2; 105 106 /* Just realloc to expand the buffer, if we can. */ 107 #if HAVE_REALLOC 108 char *new_buf = (char *) realloc(linebuf, new_size); 109 char *new_attr = (char *) realloc(attr, new_size); 110 #else 111 char *new_buf = (char *) calloc(new_size, sizeof(char)); 112 char *new_attr = (char *) calloc(new_size, sizeof(char)); 113 #endif 114 if (new_buf == NULL || new_attr == NULL) 115 { 116 if (new_attr != NULL) 117 free(new_attr); 118 if (new_buf != NULL) 119 free(new_buf); 120 return 1; 121 } 122 #if !HAVE_REALLOC 123 /* 124 * We just calloc'd the buffers; copy the old contents. 125 */ 126 memcpy(new_buf, linebuf, size_linebuf * sizeof(char)); 127 memcpy(new_attr, attr, size_linebuf * sizeof(char)); 128 free(attr); 129 free(linebuf); 130 #endif 131 linebuf = new_buf; 132 attr = new_attr; 133 size_linebuf = new_size; 134 return 0; 135 } 136 137 /* 138 * Is a character ASCII? 139 */ 140 public int 141 is_ascii_char(ch) 142 LWCHAR ch; 143 { 144 return (ch <= 0x7F); 145 } 146 147 /* 148 * Rewind the line buffer. 149 */ 150 public void 151 prewind(VOID_PARAM) 152 { 153 curr = 0; 154 column = 0; 155 right_curr = 0; 156 right_column = 0; 157 cshift = 0; 158 overstrike = 0; 159 last_overstrike = AT_NORMAL; 160 mbc_buf_len = 0; 161 is_null_line = 0; 162 pendc = '\0'; 163 lmargin = 0; 164 if (status_col) 165 lmargin += 2; 166 } 167 168 /* 169 * Set a character in the line buffer. 170 */ 171 static void 172 set_linebuf(n, ch, a) 173 int n; 174 char ch; 175 char a; 176 { 177 linebuf[n] = ch; 178 attr[n] = a; 179 } 180 181 /* 182 * Append a character to the line buffer. 183 */ 184 static void 185 add_linebuf(ch, a, w) 186 char ch; 187 char a; 188 int w; 189 { 190 set_linebuf(curr++, ch, a); 191 column += w; 192 } 193 194 /* 195 * Insert the line number (of the given position) into the line buffer. 196 */ 197 public void 198 plinenum(pos) 199 POSITION pos; 200 { 201 LINENUM linenum = 0; 202 int i; 203 204 if (linenums == OPT_ONPLUS) 205 { 206 /* 207 * Get the line number and put it in the current line. 208 * {{ Note: since find_linenum calls forw_raw_line, 209 * it may seek in the input file, requiring the caller 210 * of plinenum to re-seek if necessary. }} 211 * {{ Since forw_raw_line modifies linebuf, we must 212 * do this first, before storing anything in linebuf. }} 213 */ 214 linenum = find_linenum(pos); 215 } 216 217 /* 218 * Display a status column if the -J option is set. 219 */ 220 if (status_col) 221 { 222 int a = AT_NORMAL; 223 char c = posmark(pos); 224 if (c != 0) 225 a |= AT_HILITE; 226 else 227 { 228 c = ' '; 229 if (start_attnpos != NULL_POSITION && 230 pos >= start_attnpos && pos <= end_attnpos) 231 a |= AT_HILITE; 232 } 233 add_linebuf(c, a, 1); /* column 0: status */ 234 add_linebuf(' ', AT_NORMAL, 1); /* column 1: empty */ 235 } 236 237 /* 238 * Display the line number at the start of each line 239 * if the -N option is set. 240 */ 241 if (linenums == OPT_ONPLUS) 242 { 243 char buf[INT_STRLEN_BOUND(linenum) + 2]; 244 int pad = 0; 245 int n; 246 247 linenumtoa(linenum, buf); 248 n = (int) strlen(buf); 249 if (n < MIN_LINENUM_WIDTH) 250 pad = MIN_LINENUM_WIDTH - n; 251 for (i = 0; i < pad; i++) 252 add_linebuf(' ', AT_NORMAL, 1); 253 for (i = 0; i < n; i++) 254 add_linebuf(buf[i], AT_BOLD, 1); 255 add_linebuf(' ', AT_NORMAL, 1); 256 lmargin += n + pad + 1; 257 } 258 /* 259 * Append enough spaces to bring us to the lmargin. 260 */ 261 while (column < lmargin) 262 { 263 add_linebuf(' ', AT_NORMAL, 1); 264 } 265 } 266 267 /* 268 * Shift the input line left. 269 * This means discarding N printable chars at the start of the buffer. 270 */ 271 static void 272 pshift(shift) 273 int shift; 274 { 275 LWCHAR prev_ch = 0; 276 unsigned char c; 277 int shifted = 0; 278 int to; 279 int from; 280 int len; 281 int width; 282 int prev_attr; 283 int next_attr; 284 285 if (shift > column - lmargin) 286 shift = column - lmargin; 287 if (shift > curr - lmargin) 288 shift = curr - lmargin; 289 290 to = from = lmargin; 291 /* 292 * We keep on going when shifted == shift 293 * to get all combining chars. 294 */ 295 while (shifted <= shift && from < curr) 296 { 297 c = linebuf[from]; 298 if (ctldisp == OPT_ONPLUS && IS_CSI_START(c)) 299 { 300 /* Keep cumulative effect. */ 301 linebuf[to] = c; 302 attr[to++] = attr[from++]; 303 while (from < curr && linebuf[from]) 304 { 305 linebuf[to] = linebuf[from]; 306 attr[to++] = attr[from]; 307 if (!is_ansi_middle(linebuf[from++])) 308 break; 309 } 310 continue; 311 } 312 313 width = 0; 314 315 if (!IS_ASCII_OCTET(c) && utf_mode) 316 { 317 /* Assumes well-formedness validation already done. */ 318 LWCHAR ch; 319 320 len = utf_len(c); 321 if (from + len > curr) 322 break; 323 ch = get_wchar(linebuf + from); 324 if (!is_composing_char(ch) && !is_combining_char(prev_ch, ch)) 325 width = is_wide_char(ch) ? 2 : 1; 326 prev_ch = ch; 327 } else 328 { 329 len = 1; 330 if (c == '\b') 331 /* XXX - Incorrect if several '\b' in a row. */ 332 width = (utf_mode && is_wide_char(prev_ch)) ? -2 : -1; 333 else if (!control_char(c)) 334 width = 1; 335 prev_ch = 0; 336 } 337 338 if (width == 2 && shift - shifted == 1) { 339 /* Should never happen when called by pshift_all(). */ 340 attr[to] = attr[from]; 341 /* 342 * Assume a wide_char will never be the first half of a 343 * combining_char pair, so reset prev_ch in case we're 344 * followed by a '\b'. 345 */ 346 prev_ch = linebuf[to++] = ' '; 347 from += len; 348 shifted++; 349 continue; 350 } 351 352 /* Adjust width for magic cookies. */ 353 prev_attr = (to > 0) ? attr[to-1] : AT_NORMAL; 354 next_attr = (from + len < curr) ? attr[from + len] : prev_attr; 355 if (!is_at_equiv(attr[from], prev_attr) && 356 !is_at_equiv(attr[from], next_attr)) 357 { 358 width += attr_swidth(attr[from]); 359 if (from + len < curr) 360 width += attr_ewidth(attr[from]); 361 if (is_at_equiv(prev_attr, next_attr)) 362 { 363 width += attr_ewidth(prev_attr); 364 if (from + len < curr) 365 width += attr_swidth(next_attr); 366 } 367 } 368 369 if (shift - shifted < width) 370 break; 371 from += len; 372 shifted += width; 373 if (shifted < 0) 374 shifted = 0; 375 } 376 while (from < curr) 377 { 378 linebuf[to] = linebuf[from]; 379 attr[to++] = attr[from++]; 380 } 381 curr = to; 382 column -= shifted; 383 cshift += shifted; 384 } 385 386 /* 387 * 388 */ 389 public void 390 pshift_all(VOID_PARAM) 391 { 392 pshift(column); 393 } 394 395 /* 396 * Return the printing width of the start (enter) sequence 397 * for a given character attribute. 398 */ 399 static int 400 attr_swidth(a) 401 int a; 402 { 403 int w = 0; 404 405 a = apply_at_specials(a); 406 407 if (a & AT_UNDERLINE) 408 w += ul_s_width; 409 if (a & AT_BOLD) 410 w += bo_s_width; 411 if (a & AT_BLINK) 412 w += bl_s_width; 413 if (a & AT_STANDOUT) 414 w += so_s_width; 415 416 return w; 417 } 418 419 /* 420 * Return the printing width of the end (exit) sequence 421 * for a given character attribute. 422 */ 423 static int 424 attr_ewidth(a) 425 int a; 426 { 427 int w = 0; 428 429 a = apply_at_specials(a); 430 431 if (a & AT_UNDERLINE) 432 w += ul_e_width; 433 if (a & AT_BOLD) 434 w += bo_e_width; 435 if (a & AT_BLINK) 436 w += bl_e_width; 437 if (a & AT_STANDOUT) 438 w += so_e_width; 439 440 return w; 441 } 442 443 /* 444 * Return the printing width of a given character and attribute, 445 * if the character were added to the current position in the line buffer. 446 * Adding a character with a given attribute may cause an enter or exit 447 * attribute sequence to be inserted, so this must be taken into account. 448 */ 449 static int 450 pwidth(ch, a, prev_ch) 451 LWCHAR ch; 452 int a; 453 LWCHAR prev_ch; 454 { 455 int w; 456 457 if (ch == '\b') 458 /* 459 * Backspace moves backwards one or two positions. 460 * XXX - Incorrect if several '\b' in a row. 461 */ 462 return (utf_mode && is_wide_char(prev_ch)) ? -2 : -1; 463 464 if (!utf_mode || is_ascii_char(ch)) 465 { 466 if (control_char((char)ch)) 467 { 468 /* 469 * Control characters do unpredictable things, 470 * so we don't even try to guess; say it doesn't move. 471 * This can only happen if the -r flag is in effect. 472 */ 473 return (0); 474 } 475 } else 476 { 477 if (is_composing_char(ch) || is_combining_char(prev_ch, ch)) 478 { 479 /* 480 * Composing and combining chars take up no space. 481 * 482 * Some terminals, upon failure to compose a 483 * composing character with the character(s) that 484 * precede(s) it will actually take up one column 485 * for the composing character; there isn't much 486 * we could do short of testing the (complex) 487 * composition process ourselves and printing 488 * a binary representation when it fails. 489 */ 490 return (0); 491 } 492 } 493 494 /* 495 * Other characters take one or two columns, 496 * plus the width of any attribute enter/exit sequence. 497 */ 498 w = 1; 499 if (is_wide_char(ch)) 500 w++; 501 if (curr > 0 && !is_at_equiv(attr[curr-1], a)) 502 w += attr_ewidth(attr[curr-1]); 503 if ((apply_at_specials(a) != AT_NORMAL) && 504 (curr == 0 || !is_at_equiv(attr[curr-1], a))) 505 w += attr_swidth(a); 506 return (w); 507 } 508 509 /* 510 * Delete to the previous base character in the line buffer. 511 * Return 1 if one is found. 512 */ 513 static int 514 backc(VOID_PARAM) 515 { 516 LWCHAR prev_ch; 517 char *p = linebuf + curr; 518 LWCHAR ch = step_char(&p, -1, linebuf + lmargin); 519 int width; 520 521 /* This assumes that there is no '\b' in linebuf. */ 522 while ( curr > lmargin 523 && column > lmargin 524 && (!(attr[curr - 1] & (AT_ANSI|AT_BINARY)))) 525 { 526 curr = (int) (p - linebuf); 527 prev_ch = step_char(&p, -1, linebuf + lmargin); 528 width = pwidth(ch, attr[curr], prev_ch); 529 column -= width; 530 if (width > 0) 531 return 1; 532 ch = prev_ch; 533 } 534 535 return 0; 536 } 537 538 /* 539 * Are we currently within a recognized ANSI escape sequence? 540 */ 541 static int 542 in_ansi_esc_seq(VOID_PARAM) 543 { 544 char *p; 545 546 /* 547 * Search backwards for either an ESC (which means we ARE in a seq); 548 * or an end char (which means we're NOT in a seq). 549 */ 550 for (p = &linebuf[curr]; p > linebuf; ) 551 { 552 LWCHAR ch = step_char(&p, -1, linebuf); 553 if (IS_CSI_START(ch)) 554 return (1); 555 if (!is_ansi_middle(ch)) 556 return (0); 557 } 558 return (0); 559 } 560 561 /* 562 * Is a character the end of an ANSI escape sequence? 563 */ 564 public int 565 is_ansi_end(ch) 566 LWCHAR ch; 567 { 568 if (!is_ascii_char(ch)) 569 return (0); 570 return (strchr(end_ansi_chars, (char) ch) != NULL); 571 } 572 573 /* 574 * Can a char appear in an ANSI escape sequence, before the end char? 575 */ 576 public int 577 is_ansi_middle(ch) 578 LWCHAR ch; 579 { 580 if (!is_ascii_char(ch)) 581 return (0); 582 if (is_ansi_end(ch)) 583 return (0); 584 return (strchr(mid_ansi_chars, (char) ch) != NULL); 585 } 586 587 /* 588 * Skip past an ANSI escape sequence. 589 * pp is initially positioned just after the CSI_START char. 590 */ 591 public void 592 skip_ansi(pp, limit) 593 char **pp; 594 constant char *limit; 595 { 596 LWCHAR c; 597 do { 598 c = step_char(pp, +1, limit); 599 } while (*pp < limit && is_ansi_middle(c)); 600 /* Note that we discard final char, for which is_ansi_middle is false. */ 601 } 602 603 604 /* 605 * Append a character and attribute to the line buffer. 606 */ 607 #define STORE_CHAR(ch,a,rep,pos) \ 608 do { \ 609 if (store_char((ch),(a),(rep),(pos))) return (1); \ 610 } while (0) 611 612 static int 613 store_char(ch, a, rep, pos) 614 LWCHAR ch; 615 int a; 616 char *rep; 617 POSITION pos; 618 { 619 int w; 620 int replen; 621 char cs; 622 623 w = (a & (AT_UNDERLINE|AT_BOLD)); /* Pre-use w. */ 624 if (w != AT_NORMAL) 625 last_overstrike = w; 626 627 #if HILITE_SEARCH 628 { 629 int matches; 630 if (is_hilited(pos, pos+1, 0, &matches)) 631 { 632 /* 633 * This character should be highlighted. 634 * Override the attribute passed in. 635 */ 636 if (a != AT_ANSI) 637 { 638 if (highest_hilite != NULL_POSITION && 639 pos > highest_hilite) 640 highest_hilite = pos; 641 a |= AT_HILITE; 642 } 643 } 644 } 645 #endif 646 647 if (ctldisp == OPT_ONPLUS && in_ansi_esc_seq()) 648 { 649 if (!is_ansi_end(ch) && !is_ansi_middle(ch)) { 650 /* Remove whole unrecognized sequence. */ 651 char *p = &linebuf[curr]; 652 LWCHAR bch; 653 do { 654 bch = step_char(&p, -1, linebuf); 655 } while (p > linebuf && !IS_CSI_START(bch)); 656 curr = (int) (p - linebuf); 657 return 0; 658 } 659 a = AT_ANSI; /* Will force re-AT_'ing around it. */ 660 w = 0; 661 } 662 else if (ctldisp == OPT_ONPLUS && IS_CSI_START(ch)) 663 { 664 a = AT_ANSI; /* Will force re-AT_'ing around it. */ 665 w = 0; 666 } 667 else 668 { 669 char *p = &linebuf[curr]; 670 LWCHAR prev_ch = step_char(&p, -1, linebuf); 671 w = pwidth(ch, a, prev_ch); 672 } 673 674 if (ctldisp != OPT_ON && column + w + attr_ewidth(a) > sc_width) 675 /* 676 * Won't fit on screen. 677 */ 678 return (1); 679 680 if (rep == NULL) 681 { 682 cs = (char) ch; 683 rep = &cs; 684 replen = 1; 685 } else 686 { 687 replen = utf_len(rep[0]); 688 } 689 if (curr + replen >= size_linebuf-6) 690 { 691 /* 692 * Won't fit in line buffer. 693 * Try to expand it. 694 */ 695 if (expand_linebuf()) 696 return (1); 697 } 698 699 if (column > right_column && w > 0) 700 { 701 right_column = column; 702 right_curr = curr; 703 } 704 705 while (replen-- > 0) 706 { 707 add_linebuf(*rep++, a, 0); 708 } 709 column += w; 710 return (0); 711 } 712 713 /* 714 * Append a tab to the line buffer. 715 * Store spaces to represent the tab. 716 */ 717 #define STORE_TAB(a,pos) \ 718 do { if (store_tab((a),(pos))) return (1); } while (0) 719 720 static int 721 store_tab(attr, pos) 722 int attr; 723 POSITION pos; 724 { 725 int to_tab = column + cshift - lmargin; 726 int i; 727 728 if (ntabstops < 2 || to_tab >= tabstops[ntabstops-1]) 729 to_tab = tabdefault - 730 ((to_tab - tabstops[ntabstops-1]) % tabdefault); 731 else 732 { 733 for (i = ntabstops - 2; i >= 0; i--) 734 if (to_tab >= tabstops[i]) 735 break; 736 to_tab = tabstops[i+1] - to_tab; 737 } 738 739 if (column + to_tab - 1 + pwidth(' ', attr, 0) + attr_ewidth(attr) > sc_width) 740 return 1; 741 742 do { 743 STORE_CHAR(' ', attr, " ", pos); 744 } while (--to_tab > 0); 745 return 0; 746 } 747 748 #define STORE_PRCHAR(c, pos) \ 749 do { if (store_prchar((c), (pos))) return 1; } while (0) 750 751 static int 752 store_prchar(c, pos) 753 LWCHAR c; 754 POSITION pos; 755 { 756 char *s; 757 758 /* 759 * Convert to printable representation. 760 */ 761 s = prchar(c); 762 763 /* 764 * Make sure we can get the entire representation 765 * of the character on this line. 766 */ 767 if (column + (int) strlen(s) - 1 + 768 pwidth(' ', binattr, 0) + attr_ewidth(binattr) > sc_width) 769 return 1; 770 771 for ( ; *s != 0; s++) 772 STORE_CHAR(*s, AT_BINARY, NULL, pos); 773 774 return 0; 775 } 776 777 static int 778 flush_mbc_buf(pos) 779 POSITION pos; 780 { 781 int i; 782 783 for (i = 0; i < mbc_buf_index; i++) 784 if (store_prchar(mbc_buf[i], pos)) 785 return mbc_buf_index - i; 786 787 return 0; 788 } 789 790 /* 791 * Append a character to the line buffer. 792 * Expand tabs into spaces, handle underlining, boldfacing, etc. 793 * Returns 0 if ok, 1 if couldn't fit in buffer. 794 */ 795 public int 796 pappend(c, pos) 797 int c; 798 POSITION pos; 799 { 800 int r; 801 802 if (pendc) 803 { 804 if (c == '\r' && pendc == '\r') 805 return (0); 806 if (do_append(pendc, NULL, pendpos)) 807 /* 808 * Oops. We've probably lost the char which 809 * was in pendc, since caller won't back up. 810 */ 811 return (1); 812 pendc = '\0'; 813 } 814 815 if (c == '\r' && bs_mode == BS_SPECIAL) 816 { 817 if (mbc_buf_len > 0) /* utf_mode must be on. */ 818 { 819 /* Flush incomplete (truncated) sequence. */ 820 r = flush_mbc_buf(mbc_pos); 821 mbc_buf_index = r + 1; 822 mbc_buf_len = 0; 823 if (r) 824 return (mbc_buf_index); 825 } 826 827 /* 828 * Don't put the CR into the buffer until we see 829 * the next char. If the next char is a newline, 830 * discard the CR. 831 */ 832 pendc = c; 833 pendpos = pos; 834 return (0); 835 } 836 837 if (!utf_mode) 838 { 839 r = do_append(c, NULL, pos); 840 } else 841 { 842 /* Perform strict validation in all possible cases. */ 843 if (mbc_buf_len == 0) 844 { 845 retry: 846 mbc_buf_index = 1; 847 *mbc_buf = c; 848 if (IS_ASCII_OCTET(c)) 849 r = do_append(c, NULL, pos); 850 else if (IS_UTF8_LEAD(c)) 851 { 852 mbc_buf_len = utf_len(c); 853 mbc_pos = pos; 854 return (0); 855 } else 856 /* UTF8_INVALID or stray UTF8_TRAIL */ 857 r = flush_mbc_buf(pos); 858 } else if (IS_UTF8_TRAIL(c)) 859 { 860 mbc_buf[mbc_buf_index++] = c; 861 if (mbc_buf_index < mbc_buf_len) 862 return (0); 863 if (is_utf8_well_formed(mbc_buf, mbc_buf_index)) 864 r = do_append(get_wchar(mbc_buf), mbc_buf, mbc_pos); 865 else 866 /* Complete, but not shortest form, sequence. */ 867 mbc_buf_index = r = flush_mbc_buf(mbc_pos); 868 mbc_buf_len = 0; 869 } else 870 { 871 /* Flush incomplete (truncated) sequence. */ 872 r = flush_mbc_buf(mbc_pos); 873 mbc_buf_index = r + 1; 874 mbc_buf_len = 0; 875 /* Handle new char. */ 876 if (!r) 877 goto retry; 878 } 879 } 880 881 /* 882 * If we need to shift the line, do it. 883 * But wait until we get to at least the middle of the screen, 884 * so shifting it doesn't affect the chars we're currently 885 * pappending. (Bold & underline can get messed up otherwise.) 886 */ 887 if (cshift < hshift && column > sc_width / 2) 888 { 889 linebuf[curr] = '\0'; 890 pshift(hshift - cshift); 891 } 892 if (r) 893 { 894 /* How many chars should caller back up? */ 895 r = (!utf_mode) ? 1 : mbc_buf_index; 896 } 897 return (r); 898 } 899 900 static int 901 do_append(ch, rep, pos) 902 LWCHAR ch; 903 char *rep; 904 POSITION pos; 905 { 906 int a; 907 LWCHAR prev_ch; 908 909 a = AT_NORMAL; 910 911 if (ch == '\b') 912 { 913 if (bs_mode == BS_CONTROL) 914 goto do_control_char; 915 916 /* 917 * A better test is needed here so we don't 918 * backspace over part of the printed 919 * representation of a binary character. 920 */ 921 if ( curr <= lmargin 922 || column <= lmargin 923 || (attr[curr - 1] & (AT_ANSI|AT_BINARY))) 924 STORE_PRCHAR('\b', pos); 925 else if (bs_mode == BS_NORMAL) 926 STORE_CHAR(ch, AT_NORMAL, NULL, pos); 927 else if (bs_mode == BS_SPECIAL) 928 overstrike = backc(); 929 930 return 0; 931 } 932 933 if (overstrike > 0) 934 { 935 /* 936 * Overstrike the character at the current position 937 * in the line buffer. This will cause either 938 * underline (if a "_" is overstruck), 939 * bold (if an identical character is overstruck), 940 * or just deletion of the character in the buffer. 941 */ 942 overstrike = utf_mode ? -1 : 0; 943 if (utf_mode) 944 { 945 /* To be correct, this must be a base character. */ 946 prev_ch = get_wchar(linebuf + curr); 947 } else 948 { 949 prev_ch = (unsigned char) linebuf[curr]; 950 } 951 a = attr[curr]; 952 if (ch == prev_ch) 953 { 954 /* 955 * Overstriking a char with itself means make it bold. 956 * But overstriking an underscore with itself is 957 * ambiguous. It could mean make it bold, or 958 * it could mean make it underlined. 959 * Use the previous overstrike to resolve it. 960 */ 961 if (ch == '_') 962 { 963 if ((a & (AT_BOLD|AT_UNDERLINE)) != AT_NORMAL) 964 a |= (AT_BOLD|AT_UNDERLINE); 965 else if (last_overstrike != AT_NORMAL) 966 a |= last_overstrike; 967 else 968 a |= AT_BOLD; 969 } else 970 a |= AT_BOLD; 971 } else if (ch == '_') 972 { 973 a |= AT_UNDERLINE; 974 ch = prev_ch; 975 rep = linebuf + curr; 976 } else if (prev_ch == '_') 977 { 978 a |= AT_UNDERLINE; 979 } 980 /* Else we replace prev_ch, but we keep its attributes. */ 981 } else if (overstrike < 0) 982 { 983 if ( is_composing_char(ch) 984 || is_combining_char(get_wchar(linebuf + curr), ch)) 985 /* Continuation of the same overstrike. */ 986 a = last_overstrike; 987 else 988 overstrike = 0; 989 } 990 991 if (ch == '\t') 992 { 993 /* 994 * Expand a tab into spaces. 995 */ 996 switch (bs_mode) 997 { 998 case BS_CONTROL: 999 goto do_control_char; 1000 case BS_NORMAL: 1001 case BS_SPECIAL: 1002 STORE_TAB(a, pos); 1003 break; 1004 } 1005 } else if ((!utf_mode || is_ascii_char(ch)) && control_char((char)ch)) 1006 { 1007 do_control_char: 1008 if (ctldisp == OPT_ON || (ctldisp == OPT_ONPLUS && IS_CSI_START(ch))) 1009 { 1010 /* 1011 * Output as a normal character. 1012 */ 1013 STORE_CHAR(ch, AT_NORMAL, rep, pos); 1014 } else 1015 { 1016 STORE_PRCHAR((char) ch, pos); 1017 } 1018 } else if (utf_mode && ctldisp != OPT_ON && is_ubin_char(ch)) 1019 { 1020 char *s; 1021 1022 s = prutfchar(ch); 1023 1024 if (column + (int) strlen(s) - 1 + 1025 pwidth(' ', binattr, 0) + attr_ewidth(binattr) > sc_width) 1026 return (1); 1027 1028 for ( ; *s != 0; s++) 1029 STORE_CHAR(*s, AT_BINARY, NULL, pos); 1030 } else 1031 { 1032 STORE_CHAR(ch, a, rep, pos); 1033 } 1034 return (0); 1035 } 1036 1037 /* 1038 * 1039 */ 1040 public int 1041 pflushmbc(VOID_PARAM) 1042 { 1043 int r = 0; 1044 1045 if (mbc_buf_len > 0) 1046 { 1047 /* Flush incomplete (truncated) sequence. */ 1048 r = flush_mbc_buf(mbc_pos); 1049 mbc_buf_len = 0; 1050 } 1051 return r; 1052 } 1053 1054 /* 1055 * Switch to normal attribute at end of line. 1056 */ 1057 static void 1058 add_attr_normal(VOID_PARAM) 1059 { 1060 char *p = "\033[m"; 1061 1062 if (ctldisp != OPT_ONPLUS || !is_ansi_end('m')) 1063 return; 1064 for ( ; *p != '\0'; p++) 1065 add_linebuf(*p, AT_ANSI, 0); 1066 } 1067 1068 /* 1069 * Terminate the line in the line buffer. 1070 */ 1071 public void 1072 pdone(endline, chopped, forw) 1073 int endline; 1074 int chopped; 1075 int forw; 1076 { 1077 (void) pflushmbc(); 1078 1079 if (pendc && (pendc != '\r' || !endline)) 1080 /* 1081 * If we had a pending character, put it in the buffer. 1082 * But discard a pending CR if we are at end of line 1083 * (that is, discard the CR in a CR/LF sequence). 1084 */ 1085 (void) do_append(pendc, NULL, pendpos); 1086 1087 /* 1088 * Make sure we've shifted the line, if we need to. 1089 */ 1090 if (cshift < hshift) 1091 pshift(hshift - cshift); 1092 1093 if (chopped && rscroll_char) 1094 { 1095 /* 1096 * Display the right scrolling char. 1097 * If we've already filled the rightmost screen char 1098 * (in the buffer), overwrite it. 1099 */ 1100 if (column >= sc_width) 1101 { 1102 /* We've already written in the rightmost char. */ 1103 column = right_column; 1104 curr = right_curr; 1105 } 1106 add_attr_normal(); 1107 while (column < sc_width-1) 1108 { 1109 /* 1110 * Space to last (rightmost) char on screen. 1111 * This may be necessary if the char we overwrote 1112 * was double-width. 1113 */ 1114 add_linebuf(' ', AT_NORMAL, 1); 1115 } 1116 /* Print rscroll char. It must be single-width. */ 1117 add_linebuf(rscroll_char, rscroll_attr, 1); 1118 } else 1119 { 1120 add_attr_normal(); 1121 } 1122 1123 /* 1124 * Add a newline if necessary, 1125 * and append a '\0' to the end of the line. 1126 * We output a newline if we're not at the right edge of the screen, 1127 * or if the terminal doesn't auto wrap, 1128 * or if this is really the end of the line AND the terminal ignores 1129 * a newline at the right edge. 1130 * (In the last case we don't want to output a newline if the terminal 1131 * doesn't ignore it since that would produce an extra blank line. 1132 * But we do want to output a newline if the terminal ignores it in case 1133 * the next line is blank. In that case the single newline output for 1134 * that blank line would be ignored!) 1135 */ 1136 if (column < sc_width || !auto_wrap || (endline && ignaw) || ctldisp == OPT_ON) 1137 { 1138 add_linebuf('\n', AT_NORMAL, 0); 1139 } 1140 else if (ignaw && column >= sc_width && forw) 1141 { 1142 /* 1143 * Terminals with "ignaw" don't wrap until they *really* need 1144 * to, i.e. when the character *after* the last one to fit on a 1145 * line is output. But they are too hard to deal with when they 1146 * get in the state where a full screen width of characters 1147 * have been output but the cursor is sitting on the right edge 1148 * instead of at the start of the next line. 1149 * So we nudge them into wrapping by outputting a space 1150 * character plus a backspace. But do this only if moving 1151 * forward; if we're moving backward and drawing this line at 1152 * the top of the screen, the space would overwrite the first 1153 * char on the next line. We don't need to do this "nudge" 1154 * at the top of the screen anyway. 1155 */ 1156 add_linebuf(' ', AT_NORMAL, 1); 1157 add_linebuf('\b', AT_NORMAL, -1); 1158 } 1159 set_linebuf(curr, '\0', AT_NORMAL); 1160 } 1161 1162 /* 1163 * 1164 */ 1165 public void 1166 set_status_col(c) 1167 int c; 1168 { 1169 set_linebuf(0, c, AT_NORMAL|AT_HILITE); 1170 } 1171 1172 /* 1173 * Get a character from the current line. 1174 * Return the character as the function return value, 1175 * and the character attribute in *ap. 1176 */ 1177 public int 1178 gline(i, ap) 1179 int i; 1180 int *ap; 1181 { 1182 if (is_null_line) 1183 { 1184 /* 1185 * If there is no current line, we pretend the line is 1186 * either "~" or "", depending on the "twiddle" flag. 1187 */ 1188 if (twiddle) 1189 { 1190 if (i == 0) 1191 { 1192 *ap = AT_BOLD; 1193 return '~'; 1194 } 1195 --i; 1196 } 1197 /* Make sure we're back to AT_NORMAL before the '\n'. */ 1198 *ap = AT_NORMAL; 1199 return i ? '\0' : '\n'; 1200 } 1201 1202 *ap = attr[i]; 1203 return (linebuf[i] & 0xFF); 1204 } 1205 1206 /* 1207 * Indicate that there is no current line. 1208 */ 1209 public void 1210 null_line(VOID_PARAM) 1211 { 1212 is_null_line = 1; 1213 cshift = 0; 1214 } 1215 1216 /* 1217 * Analogous to forw_line(), but deals with "raw lines": 1218 * lines which are not split for screen width. 1219 * {{ This is supposed to be more efficient than forw_line(). }} 1220 */ 1221 public POSITION 1222 forw_raw_line(curr_pos, linep, line_lenp) 1223 POSITION curr_pos; 1224 char **linep; 1225 int *line_lenp; 1226 { 1227 int n; 1228 int c; 1229 POSITION new_pos; 1230 1231 if (curr_pos == NULL_POSITION || ch_seek(curr_pos) || 1232 (c = ch_forw_get()) == EOI) 1233 return (NULL_POSITION); 1234 1235 n = 0; 1236 for (;;) 1237 { 1238 if (c == '\n' || c == EOI || ABORT_SIGS()) 1239 { 1240 new_pos = ch_tell(); 1241 break; 1242 } 1243 if (n >= size_linebuf-1) 1244 { 1245 if (expand_linebuf()) 1246 { 1247 /* 1248 * Overflowed the input buffer. 1249 * Pretend the line ended here. 1250 */ 1251 new_pos = ch_tell() - 1; 1252 break; 1253 } 1254 } 1255 linebuf[n++] = c; 1256 c = ch_forw_get(); 1257 } 1258 linebuf[n] = '\0'; 1259 if (linep != NULL) 1260 *linep = linebuf; 1261 if (line_lenp != NULL) 1262 *line_lenp = n; 1263 return (new_pos); 1264 } 1265 1266 /* 1267 * Analogous to back_line(), but deals with "raw lines". 1268 * {{ This is supposed to be more efficient than back_line(). }} 1269 */ 1270 public POSITION 1271 back_raw_line(curr_pos, linep, line_lenp) 1272 POSITION curr_pos; 1273 char **linep; 1274 int *line_lenp; 1275 { 1276 int n; 1277 int c; 1278 POSITION new_pos; 1279 1280 if (curr_pos == NULL_POSITION || curr_pos <= ch_zero() || 1281 ch_seek(curr_pos-1)) 1282 return (NULL_POSITION); 1283 1284 n = size_linebuf; 1285 linebuf[--n] = '\0'; 1286 for (;;) 1287 { 1288 c = ch_back_get(); 1289 if (c == '\n' || ABORT_SIGS()) 1290 { 1291 /* 1292 * This is the newline ending the previous line. 1293 * We have hit the beginning of the line. 1294 */ 1295 new_pos = ch_tell() + 1; 1296 break; 1297 } 1298 if (c == EOI) 1299 { 1300 /* 1301 * We have hit the beginning of the file. 1302 * This must be the first line in the file. 1303 * This must, of course, be the beginning of the line. 1304 */ 1305 new_pos = ch_zero(); 1306 break; 1307 } 1308 if (n <= 0) 1309 { 1310 int old_size_linebuf = size_linebuf; 1311 char *fm; 1312 char *to; 1313 if (expand_linebuf()) 1314 { 1315 /* 1316 * Overflowed the input buffer. 1317 * Pretend the line ended here. 1318 */ 1319 new_pos = ch_tell() + 1; 1320 break; 1321 } 1322 /* 1323 * Shift the data to the end of the new linebuf. 1324 */ 1325 for (fm = linebuf + old_size_linebuf - 1, 1326 to = linebuf + size_linebuf - 1; 1327 fm >= linebuf; fm--, to--) 1328 *to = *fm; 1329 n = size_linebuf - old_size_linebuf; 1330 } 1331 linebuf[--n] = c; 1332 } 1333 if (linep != NULL) 1334 *linep = &linebuf[n]; 1335 if (line_lenp != NULL) 1336 *line_lenp = size_linebuf - 1 - n; 1337 return (new_pos); 1338 } 1339 1340 /* 1341 * Find the shift necessary to show the end of the longest displayed line. 1342 */ 1343 public int 1344 rrshift(VOID_PARAM) 1345 { 1346 POSITION pos; 1347 int save_width; 1348 int line; 1349 int longest = 0; 1350 1351 save_width = sc_width; 1352 sc_width = INT_MAX; 1353 hshift = 0; 1354 pos = position(TOP); 1355 for (line = 0; line < sc_height && pos != NULL_POSITION; line++) 1356 { 1357 pos = forw_line(pos); 1358 if (column > longest) 1359 longest = column; 1360 } 1361 sc_width = save_width; 1362 if (longest < sc_width) 1363 return 0; 1364 return longest - sc_width; 1365 } 1366