diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/miscellany/less-177/jump.c

   1 /*
   2  * Routines which jump to a new location in the file.
   3  */
   4
   5 #include "less.h"
   6 #include "position.h"
   7
   8 extern int hit_eof;
   9 extern int jump_sline;
  10 extern int squished;
  11 extern int screen_trashed;
  12 extern int sc_width, sc_height;
  13
  14 /*
  15  * Jump to the end of the file.
  16  */
  17         public void
  18 jump_forw()
  19 {
  20         POSITION pos;
  21
  22         if (ch_end_seek())
  23         {
  24                 error("Cannot seek to end of file", NULL_PARG);
  25                 return;
  26         }
  27         /*
  28          * Position the last line in the file at the last screen line.
  29          * Go back one line from the end of the file
  30          * to get to the beginning of the last line.
  31          */
  32         pos = back_line(ch_tell());
  33         if (pos == NULL_POSITION)
  34                 jump_loc((POSITION)0, sc_height-1);
  35         else
  36                 jump_loc(pos, sc_height-1);
  37 }
  38
  39 /*
  40  * Jump to line n in the file.
  41  */
  42         public void
  43 jump_back(n)
  44         int n;
  45 {
  46         POSITION pos;
  47         PARG parg;
  48
  49         /*
  50          * Find the position of the specified line.
  51          * If we can seek there, just jump to it.
  52          * If we can't seek, but we're trying to go to line number 1,
  53          * use ch_beg_seek() to get as close as we can.
  54          */
  55         pos = find_pos(n);
  56         if (pos != NULL_POSITION && ch_seek(pos) == 0)
  57         {
  58                 jump_loc(pos, jump_sline);
  59         } else if (n <= 1 && ch_beg_seek() == 0)
  60         {
  61                 jump_loc(ch_tell(), jump_sline);
  62                 error("Cannot seek to beginning of file", NULL_PARG);
  63         } else
  64         {
  65                 parg.p_int = n;
  66                 error("Cannot seek to line number %d", &parg);
  67         }
  68 }
  69
  70 /*
  71  * Repaint the screen.
  72  */
  73         public void
  74 repaint()
  75 {
  76         struct scrpos scrpos;
  77         /*
  78          * Start at the line currently at the top of the screen
  79          * and redisplay the screen.
  80          */
  81         get_scrpos(&scrpos);
  82         pos_clear();
  83         jump_loc(scrpos.pos, scrpos.ln);
  84 }
  85
  86 /*
  87  * Jump to a specified percentage into the file.
  88  */
  89         public void
  90 jump_percent(percent)
  91         int percent;
  92 {
  93         POSITION pos, len;
  94
  95         /*
  96          * Determine the position in the file
  97          * (the specified percentage of the file's length).
  98          */
  99         if ((len = ch_length()) == NULL_POSITION)
 100         {
 101                 error("Don't know length of file", NULL_PARG);
 102                 return;
 103         }
 104         /*
 105          * {{ This calculation may overflow! }}
 106          */
 107         pos = (percent * len) / 100;
 108         if (pos >= len)
 109                 pos = len-1;
 110
 111         jump_line_loc(pos, jump_sline);
 112 }
 113
 114 /*
 115  * Jump to a specified position in the file.
 116  * Like jump_loc, but the position need not be
 117  * the first character in a line.
 118  */
 119         public void
 120 jump_line_loc(pos, sline)
 121         POSITION pos;
 122         int sline;
 123 {
 124         int c;
 125
 126         if (ch_seek(pos) == 0)
 127         {
 128                 /*
 129                  * Back up to the beginning of the line.
 130                  */
 131                 while ((c = ch_back_get()) != '\n' && c != EOI)
 132                         ;
 133                 if (c == '\n')
 134                         (void) ch_forw_get();
 135                 pos = ch_tell();
 136         }
 137         jump_loc(pos, sline);
 138 }
 139
 140 /*
 141  * Jump to a specified position in the file.
 142  * The position must be the first character in a line.
 143  * Place the target line on a specified line on the screen.
 144  */
 145         public void
 146 jump_loc(pos, sline)
 147         POSITION pos;
 148         int sline;
 149 {
 150         register int nline;
 151         POSITION tpos;
 152         POSITION bpos;
 153
 154         /*
 155          * Normalize sline.
 156          */
 157         sline = adjsline(sline);
 158
 159         if ((nline = onscreen(pos)) >= 0)
 160         {
 161                 /*
 162                  * The line is currently displayed.
 163                  * Just scroll there.
 164                  */
 165                 nline -= sline;
 166                 if (nline > 0)
 167                         forw(nline, position(BOTTOM_PLUS_ONE), 1, 0, 0);
 168                 else
 169                         back(-nline, position(TOP), 1, 0);
 170                 return;
 171         }
 172
 173         /*
 174          * Line is not on screen.
 175          * Seek to the desired location.
 176          */
 177         if (ch_seek(pos))
 178         {
 179                 error("Cannot seek to that file position", NULL_PARG);
 180                 return;
 181         }
 182
 183         /*
 184          * See if the desired line is before or after
 185          * the currently displayed screen.
 186          */
 187         tpos = position(TOP);
 188         bpos = position(BOTTOM_PLUS_ONE);
 189         if (tpos == NULL_POSITION || pos >= tpos)
 190         {
 191                 /*
 192                  * The desired line is after the current screen.
 193                  * Move back in the file far enough so that we can
 194                  * call forw() and put the desired line at the
 195                  * sline-th line on the screen.
 196                  */
 197                 for (nline = 0;  nline < sline;  nline++)
 198                 {
 199                         if (bpos != NULL_POSITION && pos <= bpos)
 200                         {
 201                                 /*
 202                                  * Surprise!  The desired line is
 203                                  * close enough to the current screen
 204                                  * that we can just scroll there after all.
 205                                  */
 206                                 forw(sc_height-sline+nline-1, bpos, 1, 0, 0);
 207                                 return;
 208                         }
 209                         pos = back_line(pos);
 210                         if (pos == NULL_POSITION)
 211                         {
 212                                 /*
 213                                  * Oops.  Ran into the beginning of the file.
 214                                  * Exit the loop here and rely on forw()
 215                                  * below to draw the required number of
 216                                  * blank lines at the top of the screen.
 217                                  */
 218                                 break;
 219                         }
 220                 }
 221                 lastmark();
 222                 hit_eof = 0;
 223                 squished = 0;
 224                 screen_trashed = 0;
 225                 forw(sc_height-1, pos, 1, 0, sline-nline);
 226         } else
 227         {
 228                 /*
 229                  * The desired line is before the current screen.
 230                  * Move forward in the file far enough so that we
 231                  * can call back() and put the desired line at the
 232                  * sline-th line on the screen.
 233                  */
 234                 for (nline = sline;  nline < sc_height - 1;  nline++)
 235                 {
 236                         pos = forw_line(pos);
 237                         if (pos == NULL_POSITION)
 238                         {
 239                                 /* Cannot happen! */
 240                                 error("Program error: EOI in jump_loc (forw)",
 241                                         NULL_PARG);
 242                                 quit(1);
 243                         }
 244                         if (pos >= tpos)
 245                         {
 246                                 /*
 247                                  * Surprise!  The desired line is
 248                                  * close enough to the current screen
 249                                  * that we can just scroll there after all.
 250                                  */
 251                                 back(nline+1, tpos, 1, 0);
 252                                 return;
 253                         }
 254                 }
 255                 lastmark();
 256                 clear();
 257                 screen_trashed = 0;
 258                 add_back_pos(pos);
 259                 back(sc_height-1, pos, 1, 0);
 260         }
 261 }