git.marmaro.de Git - mmh/blob - docs/historical/mh-6.8.5/miscellany/less-177/prompt.c

   1 /*
   2  * Prompting and other messages.
   3  * There are three flavors of prompts, SHORT, MEDIUM and LONG,
   4  * selected by the -m/-M options.
   5  * There is also the "equals message", printed by the = command.
   6  * A prompt is a message composed of various pieces, such as the
   7  * name of the file being viewed, the percentage into the file, etc.
   8  */
   9
  10 #include "less.h"
  11 #include "position.h"
  12
  13 extern int pr_type;
  14 extern int hit_eof;
  15 extern int new_file;
  16 extern int sc_width;
  17 extern int so_s_width, so_e_width;
  18 extern int linenums;
  19 extern int sc_height;
  20 extern int jump_sline;
  21 extern IFILE curr_ifile;
  22 #if EDITOR
  23 extern char *editor;
  24 #endif
  25
  26 /*
  27  * Prototypes for the three flavors of prompts.
  28  * These strings are expanded by pr_expand().
  29  */
  30 static char s_proto[] =
  31   "?n?f%f .?m(file %i of %m) ..?e(END) ?x- Next\\: %x..%t";
  32 static char m_proto[] =
  33   "?n?f%f .?m(file %i of %m) ..?e(END) ?x- Next\\: %x.:?pB%pB\\%:byte %bB?s/%s...%t";
  34 static char M_proto[] =
  35   "?f%f .?n?m(file %i of %m) ..?ltline %lt?L/%L. :byte %bB?s/%s. .?e(END) ?x- Next\\: %x.:?pB%pB\\%..%t";
  36 static char e_proto[] =
  37   "?f%f .?m(file %i of %m) .?ltline %lt?L/%L. .byte %bB?s/%s. ?e(END) :?pB%pB\\%..%t";
  38
  39 public char *prproto[3];
  40 public char *eqproto = e_proto;
  41
  42 static char message[250];
  43 static char *mp;
  44
  45 /*
  46  * Initialize the prompt prototype strings.
  47  */
  48         public void
  49 init_prompt()
  50 {
  51         prproto[0] = save(s_proto);
  52         prproto[1] = save(m_proto);
  53         prproto[2] = save(M_proto);
  54         eqproto = save(e_proto);
  55 }
  56
  57 /*
  58  * Set the message pointer to the end of the message string.
  59  */
  60         static void
  61 setmp()
  62 {
  63         while (*mp != '\0')
  64                 mp++;
  65 }
  66
  67 /*
  68  * Append a POSITION (as a decimal integer) to the end of the message.
  69  */
  70         static void
  71 ap_pos(pos)
  72         POSITION pos;
  73 {
  74         sprintf(mp, "%ld", (long)pos);
  75         setmp();
  76 }
  77
  78 /*
  79  * Append an integer to the end of the message.
  80  */
  81         static void
  82 ap_int(n)
  83         int n;
  84 {
  85         sprintf(mp, "%d", n);
  86         setmp();
  87 }
  88
  89 /*
  90  * Append a string to the end of the message.
  91  */
  92         static void
  93 ap_str(s)
  94         char *s;
  95 {
  96         strtcpy(mp, s, (unsigned int)(&message[sizeof(message)] - mp));
  97         setmp();
  98 }
  99
 100 /*
 101  * Append a question mark to the end of the message.
 102  */
 103         static void
 104 ap_quest()
 105 {
 106         *mp++ = '?';
 107 }
 108
 109 /*
 110  * Return the "current" byte offset in the file.
 111  */
 112         static POSITION
 113 curr_byte(where)
 114         int where;
 115 {
 116         POSITION pos;
 117
 118         pos = position(where);
 119         while (pos == NULL_POSITION && where >= 0 && where < sc_height)
 120                 pos = position(++where);
 121         if (pos == NULL_POSITION)
 122                 pos = ch_length();
 123         return (pos);
 124 }
 125
 126 /*
 127  * Return the value of a prototype conditional.
 128  * A prototype string may include conditionals which consist of a
 129  * question mark followed by a single letter.
 130  * Here we decode that letter and return the appropriate boolean value.
 131  */
 132         static int
 133 cond(c, where)
 134         char c;
 135         int where;
 136 {
 137         switch (c)
 138         {
 139         case 'a':       /* Anything in the message yet? */
 140                 return (mp > message);
 141         case 'b':       /* Current byte offset known? */
 142                 return (curr_byte(where) != NULL_POSITION);
 143         case 'e':       /* At end of file? */
 144                 return (hit_eof);
 145         case 'f':       /* Filename known? */
 146                 return (strcmp(get_filename(curr_ifile), "-") != 0);
 147         case 'l':       /* Line number known? */
 148                 return (linenums);
 149         case 'L':       /* Final line number known? */
 150                 return (linenums && ch_length() != NULL_POSITION);
 151         case 'm':       /* More than one file? */
 152                 return (nifile() > 1);
 153         case 'n':       /* First prompt in a new file? */
 154                 return (new_file);
 155         case 'p':       /* Percent into file known? */
 156                 return (curr_byte(where) != NULL_POSITION &&
 157                                 ch_length() > 0);
 158         case 's':       /* Size of file known? */
 159         case 'B':
 160                 return (ch_length() != NULL_POSITION);
 161         case 'x':       /* Is there a "next" file? */
 162                 return (next_ifile(curr_ifile) != NULL_IFILE);
 163         }
 164         return (0);
 165 }
 166
 167 /*
 168  * Decode a "percent" prototype character.
 169  * A prototype string may include various "percent" escapes;
 170  * that is, a percent sign followed by a single letter.
 171  * Here we decode that letter and take the appropriate action,
 172  * usually by appending something to the message being built.
 173  */
 174         static void
 175 protochar(c, where)
 176         int c;
 177         int where;
 178 {
 179         POSITION pos;
 180         POSITION len;
 181         int n;
 182         IFILE h;
 183
 184         switch (c)
 185         {
 186         case 'b':       /* Current byte offset */
 187                 pos = curr_byte(where);
 188                 if (pos != NULL_POSITION)
 189                         ap_pos(pos);
 190                 else
 191                         ap_quest();
 192                 break;
 193 #if EDITOR
 194         case 'E':       /* Editor name */
 195                 ap_str(editor);
 196                 break;
 197 #endif
 198         case 'f':       /* File name */
 199                 ap_str(get_filename(curr_ifile));
 200                 break;
 201         case 'i':       /* Index into list of files */
 202                 ap_int(get_index(curr_ifile));
 203                 break;
 204         case 'l':       /* Current line number */
 205                 n = currline(where);
 206                 if (n != 0)
 207                         ap_int(n);
 208                 else
 209                         ap_quest();
 210                 break;
 211         case 'L':       /* Final line number */
 212                 len = ch_length();
 213                 if (len == NULL_POSITION || len == ch_zero() ||
 214                     (n = find_linenum(len)) <= 0)
 215                         ap_quest();
 216                 else
 217                         ap_int(n-1);
 218                 break;
 219         case 'm':       /* Number of files */
 220                 ap_int(nifile());
 221                 break;
 222         case 'p':       /* Percent into file */
 223                 pos = curr_byte(where);
 224                 len = ch_length();
 225                 if (pos != NULL_POSITION && len > 0)
 226                         /*
 227                          * {{ This calculation may overflow! }}
 228                          */
 229                         ap_int((int)(100*pos / len));
 230                 else
 231                         ap_quest();
 232                 break;
 233         case 's':       /* Size of file */
 234         case 'B':
 235                 len = ch_length();
 236                 if (len != NULL_POSITION)
 237                         ap_pos(len);
 238                 else
 239                         ap_quest();
 240                 break;
 241         case 't':       /* Truncate trailing spaces in the message */
 242                 while (mp > message && mp[-1] == ' ')
 243                         mp--;
 244                 break;
 245         case 'x':       /* Name of next file */
 246                 h = next_ifile(curr_ifile);
 247                 if (h != NULL_IFILE)
 248                         ap_str(get_filename(h));
 249                 else
 250                         ap_quest();
 251                 break;
 252         }
 253 }
 254
 255 /*
 256  * Skip a false conditional.
 257  * When a false condition is found (either a false IF or the ELSE part
 258  * of a true IF), this routine scans the prototype string to decide
 259  * where to resume parsing the string.
 260  * We must keep track of nested IFs and skip them properly.
 261  */
 262         static char *
 263 skipcond(p)
 264         register char *p;
 265 {
 266         register int iflevel;
 267
 268         /*
 269          * We came in here after processing a ? or :,
 270          * so we start nested one level deep.
 271          */
 272         iflevel = 1;
 273
 274         for (;;) switch (*++p)
 275         {
 276         case '?':
 277                 /*
 278                  * Start of a nested IF.
 279                  */
 280                 iflevel++;
 281                 break;
 282         case ':':
 283                 /*
 284                  * Else.
 285                  * If this matches the IF we came in here with,
 286                  * then we're done.
 287                  */
 288                 if (iflevel == 1)
 289                         return (p);
 290                 break;
 291         case '.':
 292                 /*
 293                  * Endif.
 294                  * If this matches the IF we came in here with,
 295                  * then we're done.
 296                  */
 297                 if (--iflevel == 0)
 298                         return (p);
 299                 break;
 300         case '\\':
 301                 /*
 302                  * Backslash escapes the next character.
 303                  */
 304                 ++p;
 305                 break;
 306         case '\0':
 307                 /*
 308                  * Whoops.  Hit end of string.
 309                  * This is a malformed conditional, but just treat it
 310                  * as if all active conditionals ends here.
 311                  */
 312                 return (p-1);
 313         }
 314         /*NOTREACHED*/
 315 }
 316
 317         static char *
 318 wherechar(p, wp)
 319         char *p;
 320         int *wp;
 321 {
 322         switch (*p)
 323         {
 324         case 'b': case 'l': case 'p':
 325                 switch (*++p)
 326                 {
 327                 case 't':   *wp = TOP;                  break;
 328                 case 'm':   *wp = MIDDLE;               break;
 329                 case 'b':   *wp = BOTTOM;               break;
 330                 case 'B':   *wp = BOTTOM_PLUS_ONE;      break;
 331                 case 'j':   *wp = adjsline(jump_sline); break;
 332                 default:    *wp = TOP;  p--;            break;
 333                 }
 334         }
 335         return (p);
 336 }
 337
 338 /*
 339  * Construct a message based on a prototype string.
 340  */
 341         public char *
 342 pr_expand(proto, maxwidth)
 343         char *proto;
 344         int maxwidth;
 345 {
 346         register char *p;
 347         register int c;
 348         int where;
 349
 350         mp = message;
 351
 352         if (*proto == '\0')
 353                 return ("");
 354
 355         for (p = proto;  *p != '\0';  p++)
 356         {
 357                 switch (*p)
 358                 {
 359                 default:        /* Just put the character in the message */
 360                         *mp++ = *p;
 361                         break;
 362                 case '\\':      /* Backslash escapes the next character */
 363                         p++;
 364                         *mp++ = *p;
 365                         break;
 366                 case '?':       /* Conditional (IF) */
 367                         if ((c = *++p) == '\0')
 368                                 --p;
 369                         else
 370                         {
 371                                 p = wherechar(p, &where);
 372                                 if (!cond(c, where))
 373                                         p = skipcond(p);
 374                         }
 375                         break;
 376                 case ':':       /* ELSE */
 377                         p = skipcond(p);
 378                         break;
 379                 case '.':       /* ENDIF */
 380                         break;
 381                 case '%':       /* Percent escape */
 382                         if ((c = *++p) == '\0')
 383                                 --p;
 384                         else
 385                         {
 386                                 p = wherechar(p, &where);
 387                                 protochar(c, where);
 388                         }
 389                         break;
 390                 }
 391         }
 392
 393         new_file = 0;
 394         if (mp == message)
 395                 return (NULL);
 396         *mp = '\0';
 397         if (maxwidth > 0 && mp >= message + maxwidth)
 398         {
 399                 /*
 400                  * Message is too long.
 401                  * Return just the final portion of it.
 402                  */
 403                 return (mp - maxwidth);
 404         }
 405         return (message);
 406 }
 407
 408 /*
 409  * Return a message suitable for printing by the "=" command.
 410  */
 411         public char *
 412 eq_message()
 413 {
 414         return (pr_expand(eqproto, 0));
 415 }
 416
 417 /*
 418  * Return a prompt.
 419  * This depends on the prompt type (SHORT, MEDIUM, LONG), etc.
 420  * If we can't come up with an appropriate prompt, return NULL
 421  * and the caller will prompt with a colon.
 422  */
 423         public char *
 424 pr_string()
 425 {
 426         return (pr_expand(prproto[pr_type], sc_width-so_s_width-so_e_width-2));
 427 }