diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/miscellany/less-177/line.c

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