position.c

   1 /*
   2  * Copyright (C) 1984-2022  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 header_lines;
  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
  40 position(sindex)
  41         int sindex;
  42 {
  43         switch (sindex)
  44         {
  45         case BOTTOM:
  46                 sindex = sc_height - 2;
  47                 break;
  48         case BOTTOM_PLUS_ONE:
  49                 sindex = sc_height - 1;
  50                 break;
  51         case MIDDLE:
  52                 sindex = (sc_height - 1) / 2;
  53                 break;
  54         }
  55         return (table[sindex]);
  56 }
  57
  58 /*
  59  * Add a new file position to the bottom of the position table.
  60  */
  61         public void
  62 add_forw_pos(pos)
  63         POSITION pos;
  64 {
  65         int i;
  66
  67         /*
  68          * Scroll the position table up.
  69          */
  70         for (i = 1;  i < sc_height;  i++)
  71                 table[i-1] = table[i];
  72         table[sc_height - 1] = pos;
  73 }
  74
  75 /*
  76  * Add a new file position to the top of the position table.
  77  */
  78         public void
  79 add_back_pos(pos)
  80         POSITION pos;
  81 {
  82         int i;
  83
  84         /*
  85          * Scroll the position table down.
  86          */
  87         for (i = sc_height - 1;  i > 0;  i--)
  88                 table[i] = table[i-1];
  89         table[0] = pos;
  90 }
  91
  92 /*
  93  * Initialize the position table, done whenever we clear the screen.
  94  */
  95         public void
  96 pos_clear(VOID_PARAM)
  97 {
  98         int i;
  99
 100         for (i = 0;  i < sc_height;  i++)
 101                 table[i] = NULL_POSITION;
 102 }
 103
 104 /*
 105  * Allocate or reallocate the position table.
 106  */
 107         public void
 108 pos_init(VOID_PARAM)
 109 {
 110         struct scrpos scrpos;
 111
 112         if (sc_height <= table_size)
 113                 return;
 114         /*
 115          * If we already have a table, remember the first line in it
 116          * before we free it, so we can copy that line to the new table.
 117          */
 118         if (table != NULL)
 119         {
 120                 get_scrpos(&scrpos, TOP);
 121                 free((char*)table);
 122         } else
 123                 scrpos.pos = NULL_POSITION;
 124         table = (POSITION *) ecalloc(sc_height, sizeof(POSITION));
 125         table_size = sc_height;
 126         pos_clear();
 127         if (scrpos.pos != NULL_POSITION)
 128                 table[scrpos.ln-1] = scrpos.pos;
 129 }
 130
 131 /*
 132  * See if the byte at a specified position is currently on the screen.
 133  * Check the position table to see if the position falls within its range.
 134  * Return the position table entry if found, -1 if not.
 135  */
 136         public int
 137 onscreen(pos)
 138         POSITION pos;
 139 {
 140         int i;
 141
 142         if (pos < table[0])
 143                 return (-1);
 144         for (i = 1;  i < sc_height;  i++)
 145                 if (pos < table[i])
 146                         return (i-1);
 147         return (-1);
 148 }
 149
 150 /*
 151  * See if the entire screen is empty.
 152  */
 153         public int
 154 empty_screen(VOID_PARAM)
 155 {
 156         return (empty_lines(0, sc_height-1));
 157 }
 158
 159         public int
 160 empty_lines(s, e)
 161         int s;
 162         int e;
 163 {
 164         int i;
 165
 166         for (i = s;  i <= e;  i++)
 167                 if (table[i] != NULL_POSITION && table[i] != 0)
 168                         return (0);
 169         return (1);
 170 }
 171
 172 /*
 173  * Get the current screen position.
 174  * The screen position consists of both a file position and
 175  * a screen line number where the file position is placed on the screen.
 176  * Normally the screen line number is 0, but if we are positioned
 177  * such that the top few lines are empty, we may have to set
 178  * the screen line to a number > 0.
 179  */
 180         public void
 181 get_scrpos(scrpos, where)
 182         struct scrpos *scrpos;
 183         int where;
 184 {
 185         int i;
 186         int dir;
 187         int last;
 188
 189         switch (where)
 190         {
 191         case TOP:
 192                 i = 0; dir = +1; last = sc_height-2;
 193                 break;
 194         case BOTTOM: case BOTTOM_PLUS_ONE:
 195                 i = sc_height-2; dir = -1; last = 0;
 196                 break;
 197         default:
 198                 i = where;
 199                 if (table[i] == NULL_POSITION) {
 200                         scrpos->pos = NULL_POSITION;
 201                         return;
 202                 }
 203                 /* Values of dir and last don't matter after this. */
 204                 break;
 205         }
 206
 207         /*
 208          * Find the first line on the screen which has something on it,
 209          * and return the screen line number and the file position.
 210          */
 211         for (;; i += dir)
 212         {
 213                 if (table[i] != NULL_POSITION)
 214                 {
 215                         scrpos->ln = i+1;
 216                         scrpos->pos = table[i];
 217                         return;
 218                 }
 219                 if (i == last) break;
 220         }
 221         /*
 222          * The screen is empty.
 223          */
 224         scrpos->pos = NULL_POSITION;
 225 }
 226
 227 /*
 228  * Adjust a screen line number to be a simple positive integer
 229  * in the range { 0 .. sc_height-2 }.
 230  * (The bottom line, sc_height-1, is reserved for prompts, etc.)
 231  * The given "sline" may be in the range { 1 .. sc_height-1 }
 232  * to refer to lines relative to the top of the screen (starting from 1),
 233  * or it may be in { -1 .. -(sc_height-1) } to refer to lines
 234  * relative to the bottom of the screen.
 235  */
 236         public int
 237 sindex_from_sline(sline)
 238         int sline;
 239 {
 240         /*
 241          * Negative screen line number means
 242          * relative to the bottom of the screen.
 243          */
 244         if (sline < 0)
 245                 sline += sc_height;
 246         /*
 247          * Can't be less than 1 or greater than sc_height.
 248          */
 249         if (sline <= 0)
 250                 sline = 1;
 251         if (sline > sc_height)
 252                 sline = sc_height;
 253         /*
 254          * Return zero-based line number, not one-based.
 255          */
 256         return (sline-1);
 257 }