external/bsd/less/dist/position.c

   1 /*      $NetBSD: position.c,v 1.4 2013/09/04 19:44:21 tron Exp $        */
   2
   3 /*
   4  * Copyright (C) 1984-2012  Mark Nudelman
   5  *
   6  * You may distribute under the terms of either the GNU General Public
   7  * License or the Less License, as specified in the README file.
   8  *
   9  * For more information, see the README file.
  10  */
  11
  12
  13 /*
  14  * Routines dealing with the "position" table.
  15  * This is a table which tells the position (in the input file) of the
  16  * first char on each currently displayed line.
  17  *
  18  * {{ The position table is scrolled by moving all the entries.
  19  *    Would be better to have a circular table
  20  *    and just change a couple of pointers. }}
  21  */
  22
  23 #include "less.h"
  24 #include "position.h"
  25
  26 static POSITION *table = NULL;  /* The position table */
  27 static int table_size;
  28
  29 extern int sc_width, sc_height;
  30
  31 /*
  32  * Return the starting file position of a line displayed on the screen.
  33  * The line may be specified as a line number relative to the top
  34  * of the screen, but is usually one of these special cases:
  35  *      the top (first) line on the screen
  36  *      the second line on the screen
  37  *      the bottom line on the screen
  38  *      the line after the bottom line on the screen
  39  */
  40         public POSITION
  41 position(where)
  42         int where;
  43 {
  44         switch (where)
  45         {
  46         case BOTTOM:
  47                 where = sc_height - 2;
  48                 break;
  49         case BOTTOM_PLUS_ONE:
  50                 where = sc_height - 1;
  51                 break;
  52         case MIDDLE:
  53                 where = (sc_height - 1) / 2;
  54         }
  55         return (table[where]);
  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         register 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         register 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()
  97 {
  98         register 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()
 109 {
 110         struct scrpos scrpos;
 111         scrpos.pos = scrpos.ln = 0;     /* XXX: GCC */
 112
 113         if (sc_height <= table_size)
 114                 return;
 115         /*
 116          * If we already have a table, remember the first line in it
 117          * before we free it, so we can copy that line to the new table.
 118          */
 119         if (table != NULL)
 120         {
 121                 get_scrpos(&scrpos);
 122                 free((char*)table);
 123         } else
 124                 scrpos.pos = NULL_POSITION;
 125         table = (POSITION *) ecalloc(sc_height, sizeof(POSITION));
 126         table_size = sc_height;
 127         pos_clear();
 128         if (scrpos.pos != NULL_POSITION)
 129                 table[scrpos.ln-1] = scrpos.pos;
 130 }
 131
 132 /*
 133  * See if the byte at a specified position is currently on the screen.
 134  * Check the position table to see if the position falls within its range.
 135  * Return the position table entry if found, -1 if not.
 136  */
 137         public int
 138 onscreen(pos)
 139         POSITION pos;
 140 {
 141         register int i;
 142
 143         if (pos < table[0])
 144                 return (-1);
 145         for (i = 1;  i < sc_height;  i++)
 146                 if (pos < table[i])
 147                         return (i-1);
 148         return (-1);
 149 }
 150
 151 /*
 152  * See if the entire screen is empty.
 153  */
 154         public int
 155 empty_screen()
 156 {
 157         return (empty_lines(0, sc_height-1));
 158 }
 159
 160         public int
 161 empty_lines(s, e)
 162         int s;
 163         int e;
 164 {
 165         register int i;
 166
 167         for (i = s;  i <= e;  i++)
 168                 if (table[i] != NULL_POSITION && table[i] != 0)
 169                         return (0);
 170         return (1);
 171 }
 172
 173 /*
 174  * Get the current screen position.
 175  * The screen position consists of both a file position and
 176  * a screen line number where the file position is placed on the screen.
 177  * Normally the screen line number is 0, but if we are positioned
 178  * such that the top few lines are empty, we may have to set
 179  * the screen line to a number > 0.
 180  */
 181         public void
 182 get_scrpos(scrpos)
 183         struct scrpos *scrpos;
 184 {
 185         register int i;
 186
 187         /*
 188          * Find the first line on the screen which has something on it,
 189          * and return the screen line number and the file position.
 190          */
 191         for (i = 0; i < sc_height;  i++)
 192                 if (table[i] != NULL_POSITION)
 193                 {
 194                         scrpos->ln = i+1;
 195                         scrpos->pos = table[i];
 196                         return;
 197                 }
 198         /*
 199          * The screen is empty.
 200          */
 201         scrpos->pos = NULL_POSITION;
 202 }
 203
 204 /*
 205  * Adjust a screen line number to be a simple positive integer
 206  * in the range { 0 .. sc_height-2 }.
 207  * (The bottom line, sc_height-1, is reserved for prompts, etc.)
 208  * The given "sline" may be in the range { 1 .. sc_height-1 }
 209  * to refer to lines relative to the top of the screen (starting from 1),
 210  * or it may be in { -1 .. -(sc_height-1) } to refer to lines
 211  * relative to the bottom of the screen.
 212  */
 213         public int
 214 adjsline(sline)
 215         int sline;
 216 {
 217         /*
 218          * Negative screen line number means
 219          * relative to the bottom of the screen.
 220          */
 221         if (sline < 0)
 222                 sline += sc_height;
 223         /*
 224          * Can't be less than 1 or greater than sc_height-1.
 225          */
 226         if (sline <= 0)
 227                 sline = 1;
 228         if (sline >= sc_height)
 229                 sline = sc_height - 1;
 230         /*
 231          * Return zero-based line number, not one-based.
 232          */
 233         return (sline-1);
 234 }