contrib/less/position.c

   1 /*
   2  * Copyright (C) 1984-2024  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  * Routines dealing with the "position" table.
  13  * This is a table which tells the position (in the input file) of the
  14  * first char on each currently displayed line.
  15  *
  16  * {{ The position table is scrolled by moving all the entries.
  17  *    Would be better to have a circular table
  18  *    and just change a couple of pointers. }}
  19  */
  20
  21 #include "less.h"
  22 #include "position.h"
  23
  24 static POSITION *table = NULL;  /* The position table */
  25 static int table_size = 0;
  26
  27 extern int sc_width, sc_height;
  28 extern int hshift;
  29
  30 /*
  31  * Return the starting file position of a line displayed on the screen.
  32  * The line may be specified as a line number relative to the top
  33  * of the screen, but is usually one of these special cases:
  34  *      the top (first) line on the screen
  35  *      the second line on the screen
  36  *      the bottom line on the screen
  37  *      the line after the bottom line on the screen
  38  */
  39 public POSITION position(int sindex)
  40 {
  41         switch (sindex)
  42         {
  43         case BOTTOM:
  44                 sindex = sc_height - 2;
  45                 break;
  46         case BOTTOM_PLUS_ONE:
  47                 sindex = sc_height - 1;
  48                 break;
  49         case MIDDLE:
  50                 sindex = (sc_height - 1) / 2;
  51                 break;
  52         }
  53         return (table[sindex]);
  54 }
  55
  56 /*
  57  * Add a new file position to the bottom of the position table.
  58  */
  59 public void add_forw_pos(POSITION pos)
  60 {
  61         int i;
  62
  63         /*
  64          * Scroll the position table up.
  65          */
  66         for (i = 1;  i < sc_height;  i++)
  67                 table[i-1] = table[i];
  68         table[sc_height - 1] = pos;
  69 }
  70
  71 /*
  72  * Add a new file position to the top of the position table.
  73  */
  74 public void add_back_pos(POSITION pos)
  75 {
  76         int i;
  77
  78         /*
  79          * Scroll the position table down.
  80          */
  81         for (i = sc_height - 1;  i > 0;  i--)
  82                 table[i] = table[i-1];
  83         table[0] = pos;
  84 }
  85
  86 /*
  87  * Initialize the position table, done whenever we clear the screen.
  88  */
  89 public void pos_clear(void)
  90 {
  91         int i;
  92
  93         for (i = 0;  i < sc_height;  i++)
  94                 table[i] = NULL_POSITION;
  95 }
  96
  97 /*
  98  * Allocate or reallocate the position table.
  99  */
 100 public void pos_init(void)
 101 {
 102         struct scrpos scrpos;
 103
 104         if (sc_height <= table_size)
 105                 return;
 106         /*
 107          * If we already have a table, remember the first line in it
 108          * before we free it, so we can copy that line to the new table.
 109          */
 110         if (table != NULL)
 111         {
 112                 get_scrpos(&scrpos, TOP);
 113                 free((char*)table);
 114         } else
 115                 scrpos.pos = NULL_POSITION;
 116         table = (POSITION *) ecalloc((size_t) sc_height, sizeof(POSITION)); /*{{type-issue}}*/
 117         table_size = sc_height;
 118         pos_clear();
 119         if (scrpos.pos != NULL_POSITION)
 120                 table[scrpos.ln-1] = scrpos.pos;
 121 }
 122
 123 /*
 124  * See if the byte at a specified position is currently on the screen.
 125  * Check the position table to see if the position falls within its range.
 126  * Return the position table entry if found, -1 if not.
 127  */
 128 public int onscreen(POSITION pos)
 129 {
 130         int i;
 131
 132         if (pos < table[0])
 133                 return (-1);
 134         for (i = 1;  i < sc_height;  i++)
 135                 if (pos < table[i])
 136                         return (i-1);
 137         return (-1);
 138 }
 139
 140 /*
 141  * See if the entire screen is empty.
 142  */
 143 public int empty_screen(void)
 144 {
 145         return (empty_lines(0, sc_height-1));
 146 }
 147
 148 public int empty_lines(int s, int e)
 149 {
 150         int i;
 151
 152         for (i = s;  i <= e;  i++)
 153                 if (table[i] != NULL_POSITION && table[i] != 0)
 154                         return (0);
 155         return (1);
 156 }
 157
 158 /*
 159  * Get the current screen position.
 160  * The screen position consists of both a file position and
 161  * a screen line number where the file position is placed on the screen.
 162  * Normally the screen line number is 0, but if we are positioned
 163  * such that the top few lines are empty, we may have to set
 164  * the screen line to a number > 0.
 165  */
 166 public void get_scrpos(struct scrpos *scrpos, int where)
 167 {
 168         int i;
 169         int dir;
 170         int last;
 171
 172         switch (where)
 173         {
 174         case TOP:
 175                 i = 0; dir = +1; last = sc_height-2;
 176                 break;
 177         case BOTTOM: case BOTTOM_PLUS_ONE:
 178                 i = sc_height-2; dir = -1; last = 0;
 179                 break;
 180         default:
 181                 i = where;
 182                 if (table[i] == NULL_POSITION) {
 183                         scrpos->pos = NULL_POSITION;
 184                         return;
 185                 }
 186                 /* Values of dir and last don't matter after this. */
 187                 break;
 188         }
 189
 190         /*
 191          * Find the first line on the screen which has something on it,
 192          * and return the screen line number and the file position.
 193          */
 194         for (;; i += dir)
 195         {
 196                 if (table[i] != NULL_POSITION)
 197                 {
 198                         scrpos->ln = i+1;
 199                         scrpos->pos = table[i];
 200                         return;
 201                 }
 202                 if (i == last) break;
 203         }
 204         /*
 205          * The screen is empty.
 206          */
 207         scrpos->pos = NULL_POSITION;
 208 }
 209
 210 /*
 211  * Adjust a screen line number to be a simple positive integer
 212  * in the range { 0 .. sc_height-2 }.
 213  * (The bottom line, sc_height-1, is reserved for prompts, etc.)
 214  * The given "sline" may be in the range { 1 .. sc_height-1 }
 215  * to refer to lines relative to the top of the screen (starting from 1),
 216  * or it may be in { -1 .. -(sc_height-1) } to refer to lines
 217  * relative to the bottom of the screen.
 218  */
 219 public int sindex_from_sline(int sline)
 220 {
 221         /*
 222          * Negative screen line number means
 223          * relative to the bottom of the screen.
 224          */
 225         if (sline < 0)
 226                 sline += sc_height;
 227         /*
 228          * Can't be less than 1 or greater than sc_height.
 229          */
 230         if (sline <= 0)
 231                 sline = 1;
 232         if (sline > sc_height)
 233                 sline = sc_height;
 234         /*
 235          * Return zero-based line number, not one-based.
 236          */
 237         return (sline-1);
 238 }
 239
 240 /*
 241  * Given a line that starts at linepos,
 242  * and the character at byte offset choff into that line,
 243  * return the number of characters (not bytes) between the
 244  * beginning of the line and the first byte of the choff character.
 245  */
 246 static int pos_shift(POSITION linepos, size_t choff)
 247 {
 248         constant char *line;
 249         size_t line_len;
 250         POSITION pos;
 251         int cvt_ops;
 252         char *cline;
 253
 254         pos = forw_raw_line_len(linepos, choff, &line, &line_len);
 255         if (pos == NULL_POSITION || line_len != choff)
 256                 return -1;
 257         cvt_ops = get_cvt_ops(0); /* {{ Passing 0 ignores SRCH_NO_REGEX; does it matter? }} */
 258         /* {{ It would be nice to be able to call cvt_text with dst=NULL, to avoid need to alloc a useless cline. }} */
 259         cline = (char *) ecalloc(1, line_len+1);
 260         cvt_text(cline, line, NULL, &line_len, cvt_ops);
 261         free(cline);
 262         return (int) line_len;  /*{{type-issue}}*/
 263 }
 264
 265 /*
 266  * Return the position of the first char of the line containing tpos.
 267  * Thus if tpos is the first char of its line, just return tpos.
 268  */
 269 static POSITION beginning_of_line(POSITION tpos)
 270 {
 271         ch_seek(tpos);
 272         while (ch_tell() != ch_zero())
 273         {
 274                 int ch = ch_back_get();
 275                 if (ch == '\n')
 276                 {
 277                         (void) ch_forw_get();
 278                         break;
 279                 }
 280         }
 281         return ch_tell();
 282 }
 283
 284 /*
 285  * When viewing long lines, it may be that the first char in the top screen
 286  * line is not the first char in its (file) line (the table is "beheaded").
 287  * This function sets that entry to the position of the first char in the line,
 288  * and sets hshift so that the first char in the first line is unchanged.
 289  */
 290 public void pos_rehead(void)
 291 {
 292         POSITION linepos;
 293         POSITION tpos = table[TOP];
 294         if (tpos == NULL_POSITION)
 295                 return;
 296         linepos = beginning_of_line(tpos);
 297         if (linepos == tpos)
 298                 return;
 299         table[TOP] = linepos;
 300         hshift = pos_shift(linepos, (size_t) (tpos - linepos));
 301         screen_trashed();
 302 }