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