contrib/less/position.c

   1 /*
   2  * Copyright (C) 1984-2015  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;
  26
  27 extern int sc_width, sc_height;
  28
  29 /*
  30  * Return the starting file position of a line displayed on the screen.
  31  * The line may be specified as a line number relative to the top
  32  * of the screen, but is usually one of these special cases:
  33  *      the top (first) line on the screen
  34  *      the second line on the screen
  35  *      the bottom line on the screen
  36  *      the line after the bottom line on the screen
  37  */
  38         public POSITION
  39 position(int where)
  40 {
  41         switch (where)
  42         {
  43         case BOTTOM:
  44                 where = sc_height - 2;
  45                 break;
  46         case BOTTOM_PLUS_ONE:
  47                 where = sc_height - 1;
  48                 break;
  49         case MIDDLE:
  50                 where = (sc_height - 1) / 2;
  51         }
  52         return (table[where]);
  53 }
  54
  55 /*
  56  * Add a new file position to the bottom of the position table.
  57  */
  58         public void
  59 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
  75 add_back_pos(POSITION pos)
  76 {
  77         int i;
  78
  79         /*
  80          * Scroll the position table down.
  81          */
  82         for (i = sc_height - 1;  i > 0;  i--)
  83                 table[i] = table[i-1];
  84         table[0] = pos;
  85 }
  86
  87 /*
  88  * Initialize the position table, done whenever we clear the screen.
  89  */
  90         public void
  91 pos_clear(void)
  92 {
  93         int i;
  94
  95         for (i = 0;  i < sc_height;  i++)
  96                 table[i] = NULL_POSITION;
  97 }
  98
  99 /*
 100  * Allocate or reallocate the position table.
 101  */
 102         public void
 103 pos_init(void)
 104 {
 105         struct scrpos scrpos;
 106
 107         if (sc_height <= table_size)
 108                 return;
 109         /*
 110          * If we already have a table, remember the first line in it
 111          * before we free it, so we can copy that line to the new table.
 112          */
 113         if (table != NULL)
 114         {
 115                 get_scrpos(&scrpos);
 116                 free((char*)table);
 117         } else
 118                 scrpos.pos = NULL_POSITION;
 119         table = (POSITION *) ecalloc(sc_height, sizeof(POSITION));
 120         table_size = sc_height;
 121         pos_clear();
 122         if (scrpos.pos != NULL_POSITION)
 123                 table[scrpos.ln-1] = scrpos.pos;
 124 }
 125
 126 /*
 127  * See if the byte at a specified position is currently on the screen.
 128  * Check the position table to see if the position falls within its range.
 129  * Return the position table entry if found, -1 if not.
 130  */
 131         public int
 132 onscreen(POSITION pos)
 133 {
 134         int i;
 135
 136         if (pos < table[0])
 137                 return (-1);
 138         for (i = 1;  i < sc_height;  i++)
 139                 if (pos < table[i])
 140                         return (i-1);
 141         return (-1);
 142 }
 143
 144 /*
 145  * See if the entire screen is empty.
 146  */
 147         public int
 148 empty_screen(void)
 149 {
 150         return (empty_lines(0, sc_height-1));
 151 }
 152
 153         public int
 154 empty_lines(int s, int e)
 155 {
 156         int i;
 157
 158         for (i = s;  i <= e;  i++)
 159                 if (table[i] != NULL_POSITION && table[i] != 0)
 160                         return (0);
 161         return (1);
 162 }
 163
 164 /*
 165  * Get the current screen position.
 166  * The screen position consists of both a file position and
 167  * a screen line number where the file position is placed on the screen.
 168  * Normally the screen line number is 0, but if we are positioned
 169  * such that the top few lines are empty, we may have to set
 170  * the screen line to a number > 0.
 171  */
 172         public void
 173 get_scrpos(struct scrpos *scrpos)
 174 {
 175         int i;
 176
 177         /*
 178          * Find the first line on the screen which has something on it,
 179          * and return the screen line number and the file position.
 180          */
 181         for (i = 0; i < sc_height;  i++)
 182                 if (table[i] != NULL_POSITION)
 183                 {
 184                         scrpos->ln = i+1;
 185                         scrpos->pos = table[i];
 186                         return;
 187                 }
 188         /*
 189          * The screen is empty.
 190          */
 191         scrpos->pos = NULL_POSITION;
 192 }
 193
 194 /*
 195  * Adjust a screen line number to be a simple positive integer
 196  * in the range { 0 .. sc_height-2 }.
 197  * (The bottom line, sc_height-1, is reserved for prompts, etc.)
 198  * The given "sline" may be in the range { 1 .. sc_height-1 }
 199  * to refer to lines relative to the top of the screen (starting from 1),
 200  * or it may be in { -1 .. -(sc_height-1) } to refer to lines
 201  * relative to the bottom of the screen.
 202  */
 203         public int
 204 adjsline(int sline)
 205 {
 206         /*
 207          * Negative screen line number means
 208          * relative to the bottom of the screen.
 209          */
 210         if (sline < 0)
 211                 sline += sc_height;
 212         /*
 213          * Can't be less than 1 or greater than sc_height-1.
 214          */
 215         if (sline <= 0)
 216                 sline = 1;
 217         if (sline >= sc_height)
 218                 sline = sc_height - 1;
 219         /*
 220          * Return zero-based line number, not one-based.
 221          */
 222         return (sline-1);
 223 }