contrib/less-381/input.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  * High level routines dealing with getting lines of input
  14  * from the file being viewed.
  15  *
  16  * When we speak of "lines" here, we mean PRINTABLE lines;
  17  * lines processed with respect to the screen width.
  18  * We use the term "raw line" to refer to lines simply
  19  * delimited by newlines; not processed with respect to screen width.
  20  */
  21
  22 #include "less.h"
  23
  24 extern int squeeze;
  25 extern int chopline;
  26 extern int hshift;
  27 extern int quit_if_one_screen;
  28 extern int sigs;
  29 extern int ignore_eoi;
  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 new_pos;
  49         register int c;
  50         int blankline;
  51         int endline;
  52
  53         if (curr_pos == NULL_POSITION)
  54         {
  55                 null_line();
  56                 return (NULL_POSITION);
  57         }
  58 #if HILITE_SEARCH
  59         if (hilite_search == OPT_ONPLUS)
  60                 /*
  61                  * If we are ignoring EOI (command F), only prepare
  62                  * one line ahead, to avoid getting stuck waiting for
  63                  * slow data without displaying the data we already have.
  64                  * If we're not ignoring EOI, we *could* do the same, but
  65                  * for efficiency we prepare several lines ahead at once.
  66                  */
  67                 prep_hilite(curr_pos, curr_pos + 3*size_linebuf,
  68                                 ignore_eoi ? 1 : -1);
  69 #endif
  70         if (ch_seek(curr_pos))
  71         {
  72                 null_line();
  73                 return (NULL_POSITION);
  74         }
  75
  76         prewind();
  77         plinenum(curr_pos);
  78         (void) ch_seek(curr_pos);
  79
  80         c = ch_forw_get();
  81         if (c == EOI)
  82         {
  83                 null_line();
  84                 return (NULL_POSITION);
  85         }
  86         blankline = (c == '\n' || c == '\r');
  87
  88         for (;;)
  89         {
  90                 if (ABORT_SIGS())
  91                 {
  92                         null_line();
  93                         return (NULL_POSITION);
  94                 }
  95                 if (c == '\n' || c == EOI)
  96                 {
  97                         /*
  98                          * End of the line.
  99                          */
 100                         new_pos = ch_tell();
 101                         endline = TRUE;
 102                         break;
 103                 }
 104
 105                 /*
 106                  * Append the char to the line and get the next char.
 107                  */
 108                 if (pappend(c, ch_tell()-1))
 109                 {
 110                         /*
 111                          * The char won't fit in the line; the line
 112                          * is too long to print in the screen width.
 113                          * End the line here.
 114                          */
 115                         if (chopline || hshift > 0)
 116                         {
 117                                 do
 118                                 {
 119                                         c = ch_forw_get();
 120                                 } while (c != '\n' && c != EOI);
 121                                 new_pos = ch_tell();
 122                                 endline = TRUE;
 123                                 quit_if_one_screen = FALSE;
 124                         } else
 125                         {
 126                                 new_pos = ch_tell() - 1;
 127                                 endline = FALSE;
 128                         }
 129                         break;
 130                 }
 131                 c = ch_forw_get();
 132         }
 133         pdone(endline);
 134
 135         if (squeeze && blankline)
 136         {
 137                 /*
 138                  * This line is blank.
 139                  * Skip down to the last contiguous blank line
 140                  * and pretend it is the one which we are returning.
 141                  */
 142                 while ((c = ch_forw_get()) == '\n' || c == '\r')
 143                         if (ABORT_SIGS())
 144                         {
 145                                 null_line();
 146                                 return (NULL_POSITION);
 147                         }
 148                 if (c != EOI)
 149                         (void) ch_back_get();
 150                 new_pos = ch_tell();
 151         }
 152
 153         return (new_pos);
 154 }
 155
 156 /*
 157  * Get the previous line.
 158  * A "current" position is passed and a "new" position is returned.
 159  * The current position is the position of the first character of
 160  * a line.  The new position is the position of the first character
 161  * of the PREVIOUS line.  The line obtained is the one starting at new_pos.
 162  */
 163         public POSITION
 164 back_line(curr_pos)
 165         POSITION curr_pos;
 166 {
 167         POSITION new_pos, begin_new_pos;
 168         int c;
 169         int endline;
 170
 171         if (curr_pos == NULL_POSITION || curr_pos <= ch_zero())
 172         {
 173                 null_line();
 174                 return (NULL_POSITION);
 175         }
 176 #if HILITE_SEARCH
 177         if (hilite_search == OPT_ONPLUS)
 178                 prep_hilite((curr_pos < 3*size_linebuf) ?
 179                                 0 : curr_pos - 3*size_linebuf, curr_pos, -1);
 180 #endif
 181         if (ch_seek(curr_pos-1))
 182         {
 183                 null_line();
 184                 return (NULL_POSITION);
 185         }
 186
 187         if (squeeze)
 188         {
 189                 /*
 190                  * Find out if the "current" line was blank.
 191                  */
 192                 (void) ch_forw_get();   /* Skip the newline */
 193                 c = ch_forw_get();      /* First char of "current" line */
 194                 (void) ch_back_get();   /* Restore our position */
 195                 (void) ch_back_get();
 196
 197                 if (c == '\n' || c == '\r')
 198                 {
 199                         /*
 200                          * The "current" line was blank.
 201                          * Skip over any preceding blank lines,
 202                          * since we skipped them in forw_line().
 203                          */
 204                         while ((c = ch_back_get()) == '\n' || c == '\r')
 205                                 if (ABORT_SIGS())
 206                                 {
 207                                         null_line();
 208                                         return (NULL_POSITION);
 209                                 }
 210                         if (c == EOI)
 211                         {
 212                                 null_line();
 213                                 return (NULL_POSITION);
 214                         }
 215                         (void) ch_forw_get();
 216                 }
 217         }
 218
 219         /*
 220          * Scan backwards until we hit the beginning of the line.
 221          */
 222         for (;;)
 223         {
 224                 if (ABORT_SIGS())
 225                 {
 226                         null_line();
 227                         return (NULL_POSITION);
 228                 }
 229                 c = ch_back_get();
 230                 if (c == '\n')
 231                 {
 232                         /*
 233                          * This is the newline ending the previous line.
 234                          * We have hit the beginning of the line.
 235                          */
 236                         new_pos = ch_tell() + 1;
 237                         break;
 238                 }
 239                 if (c == EOI)
 240                 {
 241                         /*
 242                          * We have hit the beginning of the file.
 243                          * This must be the first line in the file.
 244                          * This must, of course, be the beginning of the line.
 245                          */
 246                         new_pos = ch_tell();
 247                         break;
 248                 }
 249         }
 250
 251         /*
 252          * Now scan forwards from the beginning of this line.
 253          * We keep discarding "printable lines" (based on screen width)
 254          * until we reach the curr_pos.
 255          *
 256          * {{ This algorithm is pretty inefficient if the lines
 257          *    are much longer than the screen width,
 258          *    but I don't know of any better way. }}
 259          */
 260         if (ch_seek(new_pos))
 261         {
 262                 null_line();
 263                 return (NULL_POSITION);
 264         }
 265         endline = FALSE;
 266     loop:
 267         begin_new_pos = new_pos;
 268         prewind();
 269         plinenum(new_pos);
 270         (void) ch_seek(new_pos);
 271
 272         do
 273         {
 274                 c = ch_forw_get();
 275                 if (c == EOI || ABORT_SIGS())
 276                 {
 277                         null_line();
 278                         return (NULL_POSITION);
 279                 }
 280                 new_pos++;
 281                 if (c == '\n')
 282                 {
 283                         endline = TRUE;
 284                         break;
 285                 }
 286                 if (pappend(c, ch_tell()-1))
 287                 {
 288                         /*
 289                          * Got a full printable line, but we haven't
 290                          * reached our curr_pos yet.  Discard the line
 291                          * and start a new one.
 292                          */
 293                         if (chopline || hshift > 0)
 294                         {
 295                                 endline = TRUE;
 296                                 quit_if_one_screen = FALSE;
 297                                 break;
 298                         }
 299                         pdone(0);
 300                         (void) ch_back_get();
 301                         new_pos--;
 302                         goto loop;
 303                 }
 304         } while (new_pos < curr_pos);
 305
 306         pdone(endline);
 307
 308         return (begin_new_pos);
 309 }
 310
 311 /*
 312  * Set attnpos.
 313  */
 314         public void
 315 set_attnpos(pos)
 316         POSITION pos;
 317 {
 318         int c;
 319
 320         if (pos != NULL_POSITION)
 321         {
 322                 if (ch_seek(pos))
 323                         return;
 324                 for (;;)
 325                 {
 326                         c = ch_forw_get();
 327                         if (c == EOI)
 328                                 return;
 329                         if (c != '\n' && c != '\r')
 330                                 break;
 331                         pos++;
 332                 }
 333         }
 334         start_attnpos = pos;
 335         for (;;)
 336         {
 337                 c = ch_forw_get();
 338                 pos++;
 339                 if (c == EOI || c == '\n' || c == '\r')
 340                         break;
 341         }
 342         end_attnpos = pos;
 343 }