contrib/less-381/line.c

   1 /*
   2  * Copyright (C) 1984-2002  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 about less, or for information on how to
   8  * contact the author, see the README file.
   9  */
  10
  11
  12 /*
  13  * Routines to manipulate the "line buffer".
  14  * The line buffer holds a line of output as it is being built
  15  * in preparation for output to the screen.
  16  */
  17
  18 #include "less.h"
  19
  20 #define IS_CONT(c)  (((c) & 0xC0) == 0x80)
  21
  22 public char *linebuf = NULL;    /* Buffer which holds the current output line */
  23 static char *attr = NULL;       /* Extension of linebuf to hold attributes */
  24 public int size_linebuf = 0;    /* Size of line buffer (and attr buffer) */
  25
  26 public int cshift;              /* Current left-shift of output line buffer */
  27 public int hshift;              /* Desired left-shift of output line buffer */
  28 public int tabstops[TABSTOP_MAX] = { 0 }; /* Custom tabstops */
  29 public int ntabstops = 1;       /* Number of tabstops */
  30 public int tabdefault = 8;      /* Default repeated tabstops */
  31
  32 static int curr;                /* Index into linebuf */
  33 static int column;              /* Printable length, accounting for
  34                                    backspaces, etc. */
  35 static int overstrike;          /* Next char should overstrike previous char */
  36 static int last_overstrike = AT_NORMAL;
  37 static int is_null_line;        /* There is no current line */
  38 static int lmargin;             /* Left margin */
  39 static int hilites;             /* Number of hilites in this line */
  40 static char pendc;
  41 static POSITION pendpos;
  42 static char *end_ansi_chars;
  43
  44 static int do_append();
  45
  46 extern int bs_mode;
  47 extern int linenums;
  48 extern int ctldisp;
  49 extern int twiddle;
  50 extern int binattr;
  51 extern int status_col;
  52 extern int auto_wrap, ignaw;
  53 extern int bo_s_width, bo_e_width;
  54 extern int ul_s_width, ul_e_width;
  55 extern int bl_s_width, bl_e_width;
  56 extern int so_s_width, so_e_width;
  57 extern int sc_width, sc_height;
  58 extern int utf_mode;
  59 extern POSITION start_attnpos;
  60 extern POSITION end_attnpos;
  61
  62 /*
  63  * Initialize from environment variables.
  64  */
  65         public void
  66 init_line()
  67 {
  68         end_ansi_chars = lgetenv("LESSANSIENDCHARS");
  69         if (end_ansi_chars == NULL || *end_ansi_chars == '\0')
  70                 end_ansi_chars = "m";
  71         linebuf = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
  72         attr = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
  73         size_linebuf = LINEBUF_SIZE;
  74 }
  75
  76 /*
  77  * Expand the line buffer.
  78  */
  79         static int
  80 expand_linebuf()
  81 {
  82         int new_size = size_linebuf + LINEBUF_SIZE;
  83         char *new_buf = (char *) calloc(new_size, sizeof(char));
  84         char *new_attr = (char *) calloc(new_size, sizeof(char));
  85         if (new_buf == NULL || new_attr == NULL)
  86         {
  87                 if (new_attr != NULL)
  88                         free(new_attr);
  89                 if (new_buf != NULL)
  90                         free(new_buf);
  91                 return 1;
  92         }
  93         memcpy(new_buf, linebuf, size_linebuf * sizeof(char));
  94         memcpy(new_attr, attr, size_linebuf * sizeof(char));
  95         free(attr);
  96         free(linebuf);
  97         linebuf = new_buf;
  98         attr = new_attr;
  99         size_linebuf = new_size;
 100         return 0;
 101 }
 102
 103 /*
 104  * Rewind the line buffer.
 105  */
 106         public void
 107 prewind()
 108 {
 109         curr = 0;
 110         column = 0;
 111         overstrike = 0;
 112         is_null_line = 0;
 113         pendc = '\0';
 114         lmargin = 0;
 115         if (status_col)
 116                 lmargin += 1;
 117 #if HILITE_SEARCH
 118         hilites = 0;
 119 #endif
 120 }
 121
 122 /*
 123  * Insert the line number (of the given position) into the line buffer.
 124  */
 125         public void
 126 plinenum(pos)
 127         POSITION pos;
 128 {
 129         register LINENUM linenum = 0;
 130         register int i;
 131
 132         if (linenums == OPT_ONPLUS)
 133         {
 134                 /*
 135                  * Get the line number and put it in the current line.
 136                  * {{ Note: since find_linenum calls forw_raw_line,
 137                  *    it may seek in the input file, requiring the caller
 138                  *    of plinenum to re-seek if necessary. }}
 139                  * {{ Since forw_raw_line modifies linebuf, we must
 140                  *    do this first, before storing anything in linebuf. }}
 141                  */
 142                 linenum = find_linenum(pos);
 143         }
 144
 145         /*
 146          * Display a status column if the -J option is set.
 147          */
 148         if (status_col)
 149         {
 150                 linebuf[curr] = ' ';
 151                 if (start_attnpos != NULL_POSITION &&
 152                     pos >= start_attnpos && pos < end_attnpos)
 153                         attr[curr] = AT_STANDOUT;
 154                 else
 155                         attr[curr] = 0;
 156                 curr++;
 157                 column++;
 158         }
 159         /*
 160          * Display the line number at the start of each line
 161          * if the -N option is set.
 162          */
 163         if (linenums == OPT_ONPLUS)
 164         {
 165                 char buf[INT_STRLEN_BOUND(pos) + 2];
 166                 int n;
 167
 168                 linenumtoa(linenum, buf);
 169                 n = strlen(buf);
 170                 if (n < MIN_LINENUM_WIDTH)
 171                         n = MIN_LINENUM_WIDTH;
 172                 sprintf(linebuf+curr, "%*s ", n, buf);
 173                 n++;  /* One space after the line number. */
 174                 for (i = 0; i < n; i++)
 175                         attr[curr+i] = AT_NORMAL;
 176                 curr += n;
 177                 column += n;
 178                 lmargin += n;
 179         }
 180
 181         /*
 182          * Append enough spaces to bring us to the lmargin.
 183          */
 184         while (column < lmargin)
 185         {
 186                 linebuf[curr] = ' ';
 187                 attr[curr++] = AT_NORMAL;
 188                 column++;
 189         }
 190 }
 191
 192 /*
 193  * Determine how many characters are required to shift N columns.
 194  */
 195         static int
 196 shift_chars(s, len)
 197         char *s;
 198         int len;
 199 {
 200         char *p = s;
 201
 202         /*
 203          * Each char counts for one column, except ANSI color escape
 204          * sequences use no columns since they don't move the cursor.
 205          */
 206         while (*p != '\0' && len > 0)
 207         {
 208                 if (*p++ != ESC)
 209                 {
 210                         len--;
 211                 } else
 212                 {
 213                         while (*p != '\0')
 214                         {
 215                                 if (is_ansi_end(*p++))
 216                                         break;
 217                         }
 218                 }
 219         }
 220         return (p - s);
 221 }
 222
 223 /*
 224  * Determine how many characters are required to shift N columns (UTF version).
 225  * {{ FIXME: what about color escape sequences in UTF mode? }}
 226  */
 227         static int
 228 utf_shift_chars(s, len)
 229         char *s;
 230         int len;
 231 {
 232         int ulen = 0;
 233
 234         while (*s != '\0' && len > 0)
 235         {
 236                 if (!IS_CONT(*s))
 237                         len--;
 238                 s++;
 239                 ulen++;
 240         }
 241         while (IS_CONT(*s))
 242         {
 243                 s++;
 244                 ulen++;
 245         }
 246         return (ulen);
 247 }
 248
 249 /*
 250  * Shift the input line left.
 251  * This means discarding N printable chars at the start of the buffer.
 252  */
 253         static void
 254 pshift(shift)
 255         int shift;
 256 {
 257         int i;
 258         int nchars;
 259
 260         if (shift > column - lmargin)
 261                 shift = column - lmargin;
 262         if (shift > curr - lmargin)
 263                 shift = curr - lmargin;
 264
 265         if (utf_mode)
 266                 nchars = utf_shift_chars(linebuf + lmargin, shift);
 267         else
 268                 nchars = shift_chars(linebuf + lmargin, shift);
 269         if (nchars > curr)
 270                 nchars = curr;
 271         for (i = 0;  i < curr - nchars;  i++)
 272         {
 273                 linebuf[lmargin + i] = linebuf[lmargin + i + nchars];
 274                 attr[lmargin + i] = attr[lmargin + i + nchars];
 275         }
 276         curr -= nchars;
 277         column -= shift;
 278         cshift += shift;
 279 }
 280
 281 /*
 282  * Return the printing width of the start (enter) sequence
 283  * for a given character attribute.
 284  */
 285         static int
 286 attr_swidth(a)
 287         int a;
 288 {
 289         switch (a)
 290         {
 291         case AT_BOLD:           return (bo_s_width);
 292         case AT_UNDERLINE:      return (ul_s_width);
 293         case AT_BLINK:          return (bl_s_width);
 294         case AT_STANDOUT:       return (so_s_width);
 295         }
 296         return (0);
 297 }
 298
 299 /*
 300  * Return the printing width of the end (exit) sequence
 301  * for a given character attribute.
 302  */
 303         static int
 304 attr_ewidth(a)
 305         int a;
 306 {
 307         switch (a)
 308         {
 309         case AT_BOLD:           return (bo_e_width);
 310         case AT_UNDERLINE:      return (ul_e_width);
 311         case AT_BLINK:          return (bl_e_width);
 312         case AT_STANDOUT:       return (so_e_width);
 313         }
 314         return (0);
 315 }
 316
 317 /*
 318  * Return the printing width of a given character and attribute,
 319  * if the character were added to the current position in the line buffer.
 320  * Adding a character with a given attribute may cause an enter or exit
 321  * attribute sequence to be inserted, so this must be taken into account.
 322  */
 323         static int
 324 pwidth(c, a)
 325         int c;
 326         int a;
 327 {
 328         register int w;
 329
 330         if (utf_mode && IS_CONT(c))
 331                 return (0);
 332
 333         if (c == '\b')
 334                 /*
 335                  * Backspace moves backwards one position.
 336                  */
 337                 return (-1);
 338
 339         if (control_char(c))
 340                 /*
 341                  * Control characters do unpredicatable things,
 342                  * so we don't even try to guess; say it doesn't move.
 343                  * This can only happen if the -r flag is in effect.
 344                  */
 345                 return (0);
 346
 347         /*
 348          * Other characters take one space,
 349          * plus the width of any attribute enter/exit sequence.
 350          */
 351         w = 1;
 352         if (curr > 0 && attr[curr-1] != a)
 353                 w += attr_ewidth(attr[curr-1]);
 354         if (a && (curr == 0 || attr[curr-1] != a))
 355                 w += attr_swidth(a);
 356         return (w);
 357 }
 358
 359 /*
 360  * Delete the previous character in the line buffer.
 361  */
 362         static void
 363 backc()
 364 {
 365         curr--;
 366         column -= pwidth(linebuf[curr], attr[curr]);
 367 }
 368
 369 /*
 370  * Are we currently within a recognized ANSI escape sequence?
 371  */
 372         static int
 373 in_ansi_esc_seq()
 374 {
 375         int i;
 376
 377         /*
 378          * Search backwards for either an ESC (which means we ARE in a seq);
 379          * or an end char (which means we're NOT in a seq).
 380          */
 381         for (i = curr-1;  i >= 0;  i--)
 382         {
 383                 if (linebuf[i] == ESC)
 384                         return (1);
 385                 if (is_ansi_end(linebuf[i]))
 386                         return (0);
 387         }
 388         return (0);
 389 }
 390
 391 /*
 392  * Is a character the end of an ANSI escape sequence?
 393  */
 394         public int
 395 is_ansi_end(c)
 396         char c;
 397 {
 398         return (strchr(end_ansi_chars, c) != NULL);
 399 }
 400
 401 /*
 402  * Append a character and attribute to the line buffer.
 403  */
 404 #define STORE_CHAR(c,a,pos) \
 405         do { if (store_char((c),(a),(pos))) return (1); else curr++; } while (0)
 406
 407         static int
 408 store_char(c, a, pos)
 409         int c;
 410         int a;
 411         POSITION pos;
 412 {
 413         register int w;
 414
 415         if (a != AT_NORMAL)
 416                 last_overstrike = a;
 417 #if HILITE_SEARCH
 418         if (is_hilited(pos, pos+1, 0))
 419         {
 420                 /*
 421                  * This character should be highlighted.
 422                  * Override the attribute passed in.
 423                  */
 424                 a = AT_STANDOUT;
 425                 hilites++;
 426         }
 427 #endif
 428         if (ctldisp == OPT_ONPLUS && in_ansi_esc_seq())
 429                 w = 0;
 430         else
 431                 w = pwidth(c, a);
 432         if (ctldisp != OPT_ON && column + w + attr_ewidth(a) > sc_width)
 433                 /*
 434                  * Won't fit on screen.
 435                  */
 436                 return (1);
 437
 438         if (curr >= size_linebuf-2)
 439         {
 440                 /*
 441                  * Won't fit in line buffer.
 442                  * Try to expand it.
 443                  */
 444                 if (expand_linebuf())
 445                         return (1);
 446         }
 447
 448         /*
 449          * Special handling for "magic cookie" terminals.
 450          * If an attribute enter/exit sequence has a printing width > 0,
 451          * and the sequence is adjacent to a space, delete the space.
 452          * We just mark the space as invisible, to avoid having too
 453          * many spaces deleted.
 454          * {{ Note that even if the attribute width is > 1, we
 455          *    delete only one space.  It's not worth trying to do more.
 456          *    It's hardly worth doing this much. }}
 457          */
 458         if (curr > 0 && a != AT_NORMAL &&
 459                 linebuf[curr-1] == ' ' && attr[curr-1] == AT_NORMAL &&
 460                 attr_swidth(a) > 0)
 461         {
 462                 /*
 463                  * We are about to append an enter-attribute sequence
 464                  * just after a space.  Delete the space.
 465                  */
 466                 attr[curr-1] = AT_INVIS;
 467                 column--;
 468         } else if (curr > 0 && attr[curr-1] != AT_NORMAL &&
 469                 attr[curr-1] != AT_INVIS && c == ' ' && a == AT_NORMAL &&
 470                 attr_ewidth(attr[curr-1]) > 0)
 471         {
 472                 /*
 473                  * We are about to append a space just after an
 474                  * exit-attribute sequence.  Delete the space.
 475                  */
 476                 a = AT_INVIS;
 477                 column--;
 478         }
 479         /* End of magic cookie handling. */
 480
 481         linebuf[curr] = c;
 482         attr[curr] = a;
 483         column += w;
 484         return (0);
 485 }
 486
 487 /*
 488  * Append a tab to the line buffer.
 489  * Store spaces to represent the tab.
 490  */
 491 #define STORE_TAB(a,pos) \
 492         do { if (store_tab((a),(pos))) return (1); } while (0)
 493
 494         static int
 495 store_tab(attr, pos)
 496         int attr;
 497         POSITION pos;
 498 {
 499         int to_tab = column + cshift - lmargin;
 500         int i;
 501
 502         if (ntabstops < 2 || to_tab >= tabstops[ntabstops-1])
 503                 to_tab = tabdefault -
 504                      ((to_tab - tabstops[ntabstops-1]) % tabdefault);
 505         else
 506         {
 507                 for (i = ntabstops - 2;  i >= 0;  i--)
 508                         if (to_tab >= tabstops[i])
 509                                 break;
 510                 to_tab = tabstops[i+1] - to_tab;
 511         }
 512
 513         do {
 514                 STORE_CHAR(' ', attr, pos);
 515         } while (--to_tab > 0);
 516         return 0;
 517 }
 518
 519 /*
 520  * Append a character to the line buffer.
 521  * Expand tabs into spaces, handle underlining, boldfacing, etc.
 522  * Returns 0 if ok, 1 if couldn't fit in buffer.
 523  */
 524         public int
 525 pappend(c, pos)
 526         register int c;
 527         POSITION pos;
 528 {
 529         int r;
 530
 531         if (pendc)
 532         {
 533                 if (do_append(pendc, pendpos))
 534                         /*
 535                          * Oops.  We've probably lost the char which
 536                          * was in pendc, since caller won't back up.
 537                          */
 538                         return (1);
 539                 pendc = '\0';
 540         }
 541
 542         if (c == '\r' && bs_mode == BS_SPECIAL)
 543         {
 544                 /*
 545                  * Don't put the CR into the buffer until we see
 546                  * the next char.  If the next char is a newline,
 547                  * discard the CR.
 548                  */
 549                 pendc = c;
 550                 pendpos = pos;
 551                 return (0);
 552         }
 553
 554         r = do_append(c, pos);
 555         /*
 556          * If we need to shift the line, do it.
 557          * But wait until we get to at least the middle of the screen,
 558          * so shifting it doesn't affect the chars we're currently
 559          * pappending.  (Bold & underline can get messed up otherwise.)
 560          */
 561         if (cshift < hshift && column > sc_width / 2)
 562         {
 563                 linebuf[curr] = '\0';
 564                 pshift(hshift - cshift);
 565         }
 566         return (r);
 567 }
 568
 569 #define IS_UTF8_4BYTE(c) ( ((c) & 0xf8) == 0xf0 )
 570 #define IS_UTF8_3BYTE(c) ( ((c) & 0xf0) == 0xe0 )
 571 #define IS_UTF8_2BYTE(c) ( ((c) & 0xe0) == 0xc0 )
 572 #define IS_UTF8_TRAIL(c) ( ((c) & 0xc0) == 0x80 )
 573
 574         static int
 575 do_append(c, pos)
 576         int c;
 577         POSITION pos;
 578 {
 579         register char *s;
 580         register int a;
 581
 582 #define STOREC(c,a) \
 583         if ((c) == '\t') STORE_TAB((a),pos); else STORE_CHAR((c),(a),pos)
 584
 585         if (c == '\b')
 586         {
 587                 switch (bs_mode)
 588                 {
 589                 case BS_NORMAL:
 590                         STORE_CHAR(c, AT_NORMAL, pos);
 591                         break;
 592                 case BS_CONTROL:
 593                         goto do_control_char;
 594                 case BS_SPECIAL:
 595                         if (curr == 0)
 596                                 break;
 597                         backc();
 598                         overstrike = 1;
 599                         break;
 600                 }
 601         } else if (overstrike)
 602         {
 603                 /*
 604                  * Overstrike the character at the current position
 605                  * in the line buffer.  This will cause either
 606                  * underline (if a "_" is overstruck),
 607                  * bold (if an identical character is overstruck),
 608                  * or just deletion of the character in the buffer.
 609                  */
 610                 overstrike--;
 611                 if (utf_mode && IS_UTF8_4BYTE(c) && curr > 2 && (char)c == linebuf[curr-3])
 612                 {
 613                         backc();
 614                         backc();
 615                         backc();
 616                         STORE_CHAR(linebuf[curr], AT_BOLD, pos);
 617                         overstrike = 3;
 618                 } else if (utf_mode && (IS_UTF8_3BYTE(c) || (overstrike==2 && IS_UTF8_TRAIL(c))) && curr > 1 && (char)c == linebuf[curr-2])
 619                 {
 620                         backc();
 621                         backc();
 622                         STORE_CHAR(linebuf[curr], AT_BOLD, pos);
 623                         overstrike = 2;
 624                 } else if (utf_mode && curr > 0 && (IS_UTF8_2BYTE(c) || (overstrike==1 && IS_UTF8_TRAIL(c))) && (char)c == linebuf[curr-1])
 625                 {
 626                         backc();
 627                         STORE_CHAR(linebuf[curr], AT_BOLD, pos);
 628                         overstrike = 1;
 629                 } else if (utf_mode && curr > 0 && IS_UTF8_TRAIL(c) && attr[curr-1] == AT_UNDERLINE)
 630                 {
 631                         STOREC(c, AT_UNDERLINE);
 632                 } else if ((char)c == linebuf[curr])
 633                 {
 634                         /*
 635                          * Overstriking a char with itself means make it bold.
 636                          * But overstriking an underscore with itself is
 637                          * ambiguous.  It could mean make it bold, or
 638                          * it could mean make it underlined.
 639                          * Use the previous overstrike to resolve it.
 640                          */
 641                         if (c == '_' && last_overstrike != AT_NORMAL)
 642                                 STOREC(c, last_overstrike);
 643                         else
 644                                 STOREC(c, AT_BOLD);
 645                 } else if (c == '_')
 646                 {
 647                         if (utf_mode)
 648                         {
 649                                 int i;
 650                                 for (i = 0;  i < 5;  i++)
 651                                 {
 652                                         if (curr <= i || !IS_CONT(linebuf[curr-i]))
 653                                                 break;
 654                                         attr[curr-i-1] = AT_UNDERLINE;
 655                                 }
 656                         }
 657                         STOREC(linebuf[curr], AT_UNDERLINE);
 658                 } else if (linebuf[curr] == '_')
 659                 {
 660                         if (utf_mode)
 661                         {
 662                                 if (IS_UTF8_2BYTE(c))
 663                                         overstrike = 1;
 664                                 else if (IS_UTF8_3BYTE(c))
 665                                         overstrike = 2;
 666                                 else if (IS_UTF8_4BYTE(c))
 667                                         overstrike = 3;
 668                         }
 669                         STOREC(c, AT_UNDERLINE);
 670                 } else if (control_char(c))
 671                         goto do_control_char;
 672                 else
 673                         STOREC(c, AT_NORMAL);
 674         } else if (c == '\t')
 675         {
 676                 /*
 677                  * Expand a tab into spaces.
 678                  */
 679                 switch (bs_mode)
 680                 {
 681                 case BS_CONTROL:
 682                         goto do_control_char;
 683                 case BS_NORMAL:
 684                 case BS_SPECIAL:
 685                         STORE_TAB(AT_NORMAL, pos);
 686                         break;
 687                 }
 688         } else if (control_char(c))
 689         {
 690         do_control_char:
 691                 if (ctldisp == OPT_ON || (ctldisp == OPT_ONPLUS && c == ESC))
 692                 {
 693                         /*
 694                          * Output as a normal character.
 695                          */
 696                         STORE_CHAR(c, AT_NORMAL, pos);
 697                 } else
 698                 {
 699                         /*
 700                          * Convert to printable representation.
 701                          */
 702                         s = prchar(c);
 703                         a = binattr;
 704
 705                         /*
 706                          * Make sure we can get the entire representation
 707                          * of the character on this line.
 708                          */
 709                         if (column + (int) strlen(s) +
 710                             attr_swidth(a) + attr_ewidth(a) > sc_width)
 711                                 return (1);
 712
 713                         for ( ;  *s != 0;  s++)
 714                                 STORE_CHAR(*s, a, pos);
 715                 }
 716         } else
 717         {
 718                 STOREC(c, AT_NORMAL);
 719         }
 720
 721         return (0);
 722 }
 723
 724 /*
 725  * Terminate the line in the line buffer.
 726  */
 727         public void
 728 pdone(endline)
 729         int endline;
 730 {
 731         if (pendc && (pendc != '\r' || !endline))
 732                 /*
 733                  * If we had a pending character, put it in the buffer.
 734                  * But discard a pending CR if we are at end of line
 735                  * (that is, discard the CR in a CR/LF sequence).
 736                  */
 737                 (void) do_append(pendc, pendpos);
 738
 739         /*
 740          * Make sure we've shifted the line, if we need to.
 741          */
 742         if (cshift < hshift)
 743                 pshift(hshift - cshift);
 744
 745         /*
 746          * Add a newline if necessary,
 747          * and append a '\0' to the end of the line.
 748          */
 749         if (column < sc_width || !auto_wrap || ignaw || ctldisp == OPT_ON)
 750         {
 751                 linebuf[curr] = '\n';
 752                 attr[curr] = AT_NORMAL;
 753                 curr++;
 754         }
 755         linebuf[curr] = '\0';
 756         attr[curr] = AT_NORMAL;
 757
 758 #if HILITE_SEARCH
 759         if (status_col && hilites > 0)
 760         {
 761                 linebuf[0] = '*';
 762                 attr[0] = AT_STANDOUT;
 763         }
 764 #endif
 765         /*
 766          * If we are done with this line, reset the current shift.
 767          */
 768         if (endline)
 769                 cshift = 0;
 770 }
 771
 772 /*
 773  * Get a character from the current line.
 774  * Return the character as the function return value,
 775  * and the character attribute in *ap.
 776  */
 777         public int
 778 gline(i, ap)
 779         register int i;
 780         register int *ap;
 781 {
 782         char *s;
 783
 784         if (is_null_line)
 785         {
 786                 /*
 787                  * If there is no current line, we pretend the line is
 788                  * either "~" or "", depending on the "twiddle" flag.
 789                  */
 790                 *ap = AT_BOLD;
 791                 s = (twiddle) ? "~\n" : "\n";
 792                 return (s[i]);
 793         }
 794
 795         *ap = attr[i];
 796         return (linebuf[i] & 0377);
 797 }
 798
 799 /*
 800  * Indicate that there is no current line.
 801  */
 802         public void
 803 null_line()
 804 {
 805         is_null_line = 1;
 806         cshift = 0;
 807 }
 808
 809 /*
 810  * Analogous to forw_line(), but deals with "raw lines":
 811  * lines which are not split for screen width.
 812  * {{ This is supposed to be more efficient than forw_line(). }}
 813  */
 814         public POSITION
 815 forw_raw_line(curr_pos, linep)
 816         POSITION curr_pos;
 817         char **linep;
 818 {
 819         register int n;
 820         register int c;
 821         POSITION new_pos;
 822
 823         if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
 824                 (c = ch_forw_get()) == EOI)
 825                 return (NULL_POSITION);
 826
 827         n = 0;
 828         for (;;)
 829         {
 830                 if (c == '\n' || c == EOI)
 831                 {
 832                         new_pos = ch_tell();
 833                         break;
 834                 }
 835                 if (n >= size_linebuf-1)
 836                 {
 837                         if (expand_linebuf())
 838                         {
 839                                 /*
 840                                  * Overflowed the input buffer.
 841                                  * Pretend the line ended here.
 842                                  */
 843                                 new_pos = ch_tell() - 1;
 844                                 break;
 845                         }
 846                 }
 847                 linebuf[n++] = c;
 848                 c = ch_forw_get();
 849         }
 850         linebuf[n] = '\0';
 851         if (linep != NULL)
 852                 *linep = linebuf;
 853         return (new_pos);
 854 }
 855
 856 /*
 857  * Analogous to back_line(), but deals with "raw lines".
 858  * {{ This is supposed to be more efficient than back_line(). }}
 859  */
 860         public POSITION
 861 back_raw_line(curr_pos, linep)
 862         POSITION curr_pos;
 863         char **linep;
 864 {
 865         register int n;
 866         register int c;
 867         POSITION new_pos;
 868
 869         if (curr_pos == NULL_POSITION || curr_pos <= ch_zero() ||
 870                 ch_seek(curr_pos-1))
 871                 return (NULL_POSITION);
 872
 873         n = size_linebuf;
 874         linebuf[--n] = '\0';
 875         for (;;)
 876         {
 877                 c = ch_back_get();
 878                 if (c == '\n')
 879                 {
 880                         /*
 881                          * This is the newline ending the previous line.
 882                          * We have hit the beginning of the line.
 883                          */
 884                         new_pos = ch_tell() + 1;
 885                         break;
 886                 }
 887                 if (c == EOI)
 888                 {
 889                         /*
 890                          * We have hit the beginning of the file.
 891                          * This must be the first line in the file.
 892                          * This must, of course, be the beginning of the line.
 893                          */
 894                         new_pos = ch_zero();
 895                         break;
 896                 }
 897                 if (n <= 0)
 898                 {
 899                         int old_size_linebuf = size_linebuf;
 900                         char *fm;
 901                         char *to;
 902                         if (expand_linebuf())
 903                         {
 904                                 /*
 905                                  * Overflowed the input buffer.
 906                                  * Pretend the line ended here.
 907                                  */
 908                                 new_pos = ch_tell() + 1;
 909                                 break;
 910                         }
 911                         /*
 912                          * Shift the data to the end of the new linebuf.
 913                          */
 914                         for (fm = linebuf + old_size_linebuf,
 915                               to = linebuf + size_linebuf;
 916                              fm >= linebuf;  fm--, to--)
 917                                 *to = *fm;
 918                         n = size_linebuf - old_size_linebuf;
 919                 }
 920                 linebuf[--n] = c;
 921         }
 922         if (linep != NULL)
 923                 *linep = &linebuf[n];
 924         return (new_pos);
 925 }