contrib/less/position.c

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