input.c

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