contrib/less/input.c

   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  * High level routines dealing with getting lines of input
  12  * from the file being viewed.
  13  *
  14  * When we speak of "lines" here, we mean PRINTABLE lines;
  15  * lines processed with respect to the screen width.
  16  * We use the term "raw line" to refer to lines simply
  17  * delimited by newlines; not processed with respect to screen width.
  18  */
  19
  20 #include "less.h"
  21
  22 extern int squeeze;
  23 extern int chopline;
  24 extern int hshift;
  25 extern int quit_if_one_screen;
  26 extern int sigs;
  27 extern int ignore_eoi;
  28 extern int status_col;
  29 extern POSITION start_attnpos;
  30 extern POSITION end_attnpos;
  31 #if HILITE_SEARCH
  32 extern int hilite_search;
  33 extern int size_linebuf;
  34 #endif
  35
  36 /*
  37  * Get the next line.
  38  * A "current" position is passed and a "new" position is returned.
  39  * The current position is the position of the first character of
  40  * a line.  The new position is the position of the first character
  41  * of the NEXT line.  The line obtained is the line starting at curr_pos.
  42  */
  43         public POSITION
  44 forw_line(curr_pos)
  45         POSITION curr_pos;
  46 {
  47         POSITION base_pos;
  48         POSITION new_pos;
  49         int c;
  50         int blankline;
  51         int endline;
  52         int chopped;
  53         int backchars;
  54
  55 get_forw_line:
  56         if (curr_pos == NULL_POSITION)
  57         {
  58                 null_line();
  59                 return (NULL_POSITION);
  60         }
  61 #if HILITE_SEARCH
  62         if (hilite_search == OPT_ONPLUS || is_filtering() || status_col)
  63         {
  64                 /*
  65                  * If we are ignoring EOI (command F), only prepare
  66                  * one line ahead, to avoid getting stuck waiting for
  67                  * slow data without displaying the data we already have.
  68                  * If we're not ignoring EOI, we *could* do the same, but
  69                  * for efficiency we prepare several lines ahead at once.
  70                  */
  71                 prep_hilite(curr_pos, curr_pos + 3*size_linebuf,
  72                                 ignore_eoi ? 1 : -1);
  73                 curr_pos = next_unfiltered(curr_pos);
  74         }
  75 #endif
  76         if (ch_seek(curr_pos))
  77         {
  78                 null_line();
  79                 return (NULL_POSITION);
  80         }
  81
  82         /*
  83          * Step back to the beginning of the line.
  84          */
  85         base_pos = curr_pos;
  86         for (;;)
  87         {
  88                 if (ABORT_SIGS())
  89                 {
  90                         null_line();
  91                         return (NULL_POSITION);
  92                 }
  93                 c = ch_back_get();
  94                 if (c == EOI)
  95                         break;
  96                 if (c == '\n')
  97                 {
  98                         (void) ch_forw_get();
  99                         break;
 100                 }
 101                 --base_pos;
 102         }
 103
 104         /*
 105          * Read forward again to the position we should start at.
 106          */
 107         prewind();
 108         plinenum(base_pos);
 109         (void) ch_seek(base_pos);
 110         new_pos = base_pos;
 111         while (new_pos < curr_pos)
 112         {
 113                 if (ABORT_SIGS())
 114                 {
 115                         null_line();
 116                         return (NULL_POSITION);
 117                 }
 118                 c = ch_forw_get();
 119                 backchars = pappend(c, new_pos);
 120                 new_pos++;
 121                 if (backchars > 0)
 122                 {
 123                         pshift_all();
 124                         new_pos -= backchars;
 125                         while (--backchars >= 0)
 126                                 (void) ch_back_get();
 127                 }
 128         }
 129         (void) pflushmbc();
 130         pshift_all();
 131
 132         /*
 133          * Read the first character to display.
 134          */
 135         c = ch_forw_get();
 136         if (c == EOI)
 137         {
 138                 null_line();
 139                 return (NULL_POSITION);
 140         }
 141         blankline = (c == '\n' || c == '\r');
 142
 143         /*
 144          * Read each character in the line and append to the line buffer.
 145          */
 146         chopped = FALSE;
 147         for (;;)
 148         {
 149                 if (ABORT_SIGS())
 150                 {
 151                         null_line();
 152                         return (NULL_POSITION);
 153                 }
 154                 if (c == '\n' || c == EOI)
 155                 {
 156                         /*
 157                          * End of the line.
 158                          */
 159                         backchars = pflushmbc();
 160                         new_pos = ch_tell();
 161                         if (backchars > 0 && !chopline && hshift == 0)
 162                         {
 163                                 new_pos -= backchars + 1;
 164                                 endline = FALSE;
 165                         } else
 166                                 endline = TRUE;
 167                         break;
 168                 }
 169                 if (c != '\r')
 170                         blankline = 0;
 171
 172                 /*
 173                  * Append the char to the line and get the next char.
 174                  */
 175                 backchars = pappend(c, ch_tell()-1);
 176                 if (backchars > 0)
 177                 {
 178                         /*
 179                          * The char won't fit in the line; the line
 180                          * is too long to print in the screen width.
 181                          * End the line here.
 182                          */
 183                         if (chopline || hshift > 0)
 184                         {
 185                                 do
 186                                 {
 187                                         if (ABORT_SIGS())
 188                                         {
 189                                                 null_line();
 190                                                 return (NULL_POSITION);
 191                                         }
 192                                         c = ch_forw_get();
 193                                 } while (c != '\n' && c != EOI);
 194                                 new_pos = ch_tell();
 195                                 endline = TRUE;
 196                                 quit_if_one_screen = FALSE;
 197                                 chopped = TRUE;
 198                         } else
 199                         {
 200                                 new_pos = ch_tell() - backchars;
 201                                 endline = FALSE;
 202                         }
 203                         break;
 204                 }
 205                 c = ch_forw_get();
 206         }
 207
 208         pdone(endline, chopped, 1);
 209
 210 #if HILITE_SEARCH
 211         if (is_filtered(base_pos))
 212         {
 213                 /*
 214                  * We don't want to display this line.
 215                  * Get the next line.
 216                  */
 217                 curr_pos = new_pos;
 218                 goto get_forw_line;
 219         }
 220
 221         if (status_col && is_hilited(base_pos, ch_tell()-1, 1, NULL))
 222                 set_status_col('*');
 223 #endif
 224
 225         if (squeeze && blankline)
 226         {
 227                 /*
 228                  * This line is blank.
 229                  * Skip down to the last contiguous blank line
 230                  * and pretend it is the one which we are returning.
 231                  */
 232                 while ((c = ch_forw_get()) == '\n' || c == '\r')
 233                         if (ABORT_SIGS())
 234                         {
 235                                 null_line();
 236                                 return (NULL_POSITION);
 237                         }
 238                 if (c != EOI)
 239                         (void) ch_back_get();
 240                 new_pos = ch_tell();
 241         }
 242
 243         return (new_pos);
 244 }
 245
 246 /*
 247  * Get the previous line.
 248  * A "current" position is passed and a "new" position is returned.
 249  * The current position is the position of the first character of
 250  * a line.  The new position is the position of the first character
 251  * of the PREVIOUS line.  The line obtained is the one starting at new_pos.
 252  */
 253         public POSITION
 254 back_line(curr_pos)
 255         POSITION curr_pos;
 256 {
 257         POSITION new_pos, begin_new_pos, base_pos;
 258         int c;
 259         int endline;
 260         int chopped;
 261         int backchars;
 262
 263 get_back_line:
 264         if (curr_pos == NULL_POSITION || curr_pos <= ch_zero())
 265         {
 266                 null_line();
 267                 return (NULL_POSITION);
 268         }
 269 #if HILITE_SEARCH
 270         if (hilite_search == OPT_ONPLUS || is_filtering() || status_col)
 271                 prep_hilite((curr_pos < 3*size_linebuf) ?
 272                                 0 : curr_pos - 3*size_linebuf, curr_pos, -1);
 273 #endif
 274         if (ch_seek(curr_pos-1))
 275         {
 276                 null_line();
 277                 return (NULL_POSITION);
 278         }
 279
 280         if (squeeze)
 281         {
 282                 /*
 283                  * Find out if the "current" line was blank.
 284                  */
 285                 (void) ch_forw_get();    /* Skip the newline */
 286                 c = ch_forw_get();       /* First char of "current" line */
 287                 (void) ch_back_get();    /* Restore our position */
 288                 (void) ch_back_get();
 289
 290                 if (c == '\n' || c == '\r')
 291                 {
 292                         /*
 293                          * The "current" line was blank.
 294                          * Skip over any preceding blank lines,
 295                          * since we skipped them in forw_line().
 296                          */
 297                         while ((c = ch_back_get()) == '\n' || c == '\r')
 298                                 if (ABORT_SIGS())
 299                                 {
 300                                         null_line();
 301                                         return (NULL_POSITION);
 302                                 }
 303                         if (c == EOI)
 304                         {
 305                                 null_line();
 306                                 return (NULL_POSITION);
 307                         }
 308                         (void) ch_forw_get();
 309                 }
 310         }
 311
 312         /*
 313          * Scan backwards until we hit the beginning of the line.
 314          */
 315         for (;;)
 316         {
 317                 if (ABORT_SIGS())
 318                 {
 319                         null_line();
 320                         return (NULL_POSITION);
 321                 }
 322                 c = ch_back_get();
 323                 if (c == '\n')
 324                 {
 325                         /*
 326                          * This is the newline ending the previous line.
 327                          * We have hit the beginning of the line.
 328                          */
 329                         base_pos = ch_tell() + 1;
 330                         break;
 331                 }
 332                 if (c == EOI)
 333                 {
 334                         /*
 335                          * We have hit the beginning of the file.
 336                          * This must be the first line in the file.
 337                          * This must, of course, be the beginning of the line.
 338                          */
 339                         base_pos = ch_tell();
 340                         break;
 341                 }
 342         }
 343
 344         /*
 345          * Now scan forwards from the beginning of this line.
 346          * We keep discarding "printable lines" (based on screen width)
 347          * until we reach the curr_pos.
 348          *
 349          * {{ This algorithm is pretty inefficient if the lines
 350          *    are much longer than the screen width,
 351          *    but I don't know of any better way. }}
 352          */
 353         new_pos = base_pos;
 354         if (ch_seek(new_pos))
 355         {
 356                 null_line();
 357                 return (NULL_POSITION);
 358         }
 359         endline = FALSE;
 360         prewind();
 361         plinenum(new_pos);
 362     loop:
 363         begin_new_pos = new_pos;
 364         (void) ch_seek(new_pos);
 365         chopped = FALSE;
 366
 367         do
 368         {
 369                 c = ch_forw_get();
 370                 if (c == EOI || ABORT_SIGS())
 371                 {
 372                         null_line();
 373                         return (NULL_POSITION);
 374                 }
 375                 new_pos++;
 376                 if (c == '\n')
 377                 {
 378                         backchars = pflushmbc();
 379                         if (backchars > 0 && !chopline && hshift == 0)
 380                         {
 381                                 backchars++;
 382                                 goto shift;
 383                         }
 384                         endline = TRUE;
 385                         break;
 386                 }
 387                 backchars = pappend(c, ch_tell()-1);
 388                 if (backchars > 0)
 389                 {
 390                         /*
 391                          * Got a full printable line, but we haven't
 392                          * reached our curr_pos yet.  Discard the line
 393                          * and start a new one.
 394                          */
 395                         if (chopline || hshift > 0)
 396                         {
 397                                 endline = TRUE;
 398                                 chopped = TRUE;
 399                                 quit_if_one_screen = FALSE;
 400                                 break;
 401                         }
 402                 shift:
 403                         pshift_all();
 404                         while (backchars-- > 0)
 405                         {
 406                                 (void) ch_back_get();
 407                                 new_pos--;
 408                         }
 409                         goto loop;
 410                 }
 411         } while (new_pos < curr_pos);
 412
 413         pdone(endline, chopped, 0);
 414
 415 #if HILITE_SEARCH
 416         if (is_filtered(base_pos))
 417         {
 418                 /*
 419                  * We don't want to display this line.
 420                  * Get the previous line.
 421                  */
 422                 curr_pos = begin_new_pos;
 423                 goto get_back_line;
 424         }
 425
 426         if (status_col && curr_pos > 0 && is_hilited(base_pos, curr_pos-1, 1, NULL))
 427                 set_status_col('*');
 428 #endif
 429
 430         return (begin_new_pos);
 431 }
 432
 433 /*
 434  * Set attnpos.
 435  */
 436         public void
 437 set_attnpos(pos)
 438         POSITION pos;
 439 {
 440         int c;
 441
 442         if (pos != NULL_POSITION)
 443         {
 444                 if (ch_seek(pos))
 445                         return;
 446                 for (;;)
 447                 {
 448                         c = ch_forw_get();
 449                         if (c == EOI)
 450                                 break;
 451                         if (c == '\n' || c == '\r')
 452                         {
 453                                 (void) ch_back_get();
 454                                 break;
 455                         }
 456                         pos++;
 457                 }
 458                 end_attnpos = pos;
 459                 for (;;)
 460                 {
 461                         c = ch_back_get();
 462                         if (c == EOI || c == '\n' || c == '\r')
 463                                 break;
 464                         pos--;
 465                 }
 466         }
 467         start_attnpos = pos;
 468 }