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

   1 /*
   2  * High level routines dealing with the output to the screen.
   3  */
   4
   5 #include "less.h"
   6
   7 public int errmsgs;     /* Count of messages displayed by error() */
   8 public int need_clr;
   9
  10 extern int sigs;
  11 extern int sc_width;
  12 extern int so_s_width, so_e_width;
  13 extern int screen_trashed;
  14 extern int any_display;
  15 #if __MSDOS__
  16 extern int output_mode;
  17 #endif
  18
  19 /*
  20  * Display the line which is in the line buffer.
  21  */
  22         public void
  23 put_line()
  24 {
  25         register int c;
  26         register int i;
  27         int a;
  28         int curr_attr;
  29
  30         if (sigs)
  31         {
  32                 /*
  33                  * Don't output if a signal is pending.
  34                  */
  35                 screen_trashed = 1;
  36                 return;
  37         }
  38
  39         curr_attr = NORMAL;
  40
  41         for (i = 0;  (c = gline(i, &a)) != '\0';  i++)
  42         {
  43                 if (a != curr_attr)
  44                 {
  45                         /*
  46                          * Changing attributes.
  47                          * Display the exit sequence for the old attribute
  48                          * and the enter sequence for the new one.
  49                          */
  50                         switch (curr_attr)
  51                         {
  52                         case UNDERLINE: ul_exit();      break;
  53                         case BOLD:      bo_exit();      break;
  54                         case BLINK:     bl_exit();      break;
  55                         }
  56                         switch (a)
  57                         {
  58                         case UNDERLINE: ul_enter();     break;
  59                         case BOLD:      bo_enter();     break;
  60                         case BLINK:     bl_enter();     break;
  61                         }
  62                         curr_attr = a;
  63                 }
  64                 if (curr_attr == INVIS)
  65                         continue;
  66                 if (c == '\b')
  67                         putbs();
  68                 else
  69                         putchr(c);
  70         }
  71 }
  72
  73 static char obuf[1024];
  74 static char *ob = obuf;
  75
  76 /*
  77  * Flush buffered output.
  78  *
  79  * If we haven't displayed any file data yet,
  80  * output messages on error output (file descriptor 2),
  81  * otherwise output on standard output (file descriptor 1).
  82  *
  83  * This has the desirable effect of producing all
  84  * error messages on error output if standard output
  85  * is directed to a file.  It also does the same if
  86  * we never produce any real output; for example, if
  87  * the input file(s) cannot be opened.  If we do
  88  * eventually produce output, code in edit() makes
  89  * sure these messages can be seen before they are
  90  * overwritten or scrolled away.
  91  */
  92         public void
  93 flush()
  94 {
  95         register int n;
  96         register int fd;
  97
  98 #if __MSDOS__
  99         if (output_mode == 0)
 100         {
 101                 *ob = '\0';
 102                 cputs(obuf);
 103                 ob = obuf;
 104                 return;
 105         }
 106 #endif
 107         n = ob - obuf;
 108         if (n == 0)
 109                 return;
 110         fd = (any_display) ? 1 : 2;
 111         if (write(fd, obuf, n) != n)
 112                 screen_trashed = 1;
 113         ob = obuf;
 114 }
 115
 116 /*
 117  * Output a character.
 118  */
 119         public void
 120 putchr(c)
 121         int c;
 122 {
 123         if (ob >= &obuf[sizeof(obuf)])
 124                 flush();
 125         if (need_clr)
 126         {
 127                 need_clr = 0;
 128                 lower_left();
 129                 clear_eol();
 130         }
 131 #if __MSDOS__
 132         if (c == '\n')
 133                 *ob++ = '\r';
 134 #endif
 135         *ob++ = c;
 136 }
 137
 138 /*
 139  * Output a string.
 140  */
 141         public void
 142 putstr(s)
 143         register char *s;
 144 {
 145         while (*s != '\0')
 146                 putchr(*s++);
 147 }
 148
 149
 150 /*
 151  * Output an integer in a given radix.
 152  */
 153         static int
 154 iprintnum(num, radix)
 155         int num;
 156         int radix;
 157 {
 158         register char *s;
 159         int r;
 160         int neg;
 161         char buf[10];
 162
 163         if (neg = (num < 0))
 164                 num = -num;
 165
 166         s = buf;
 167         do
 168         {
 169                 *s++ = (num % radix) + '0';
 170         } while ((num /= radix) != 0);
 171
 172         if (neg)
 173                 *s++ = '-';
 174         r = s - buf;
 175
 176         while (s > buf)
 177                 putchr(*--s);
 178         return (r);
 179 }
 180
 181 /*
 182  * This function implements printf-like functionality
 183  * using a more portable argument list mechanism than printf's.
 184  */
 185         static int
 186 iprintf(fmt, parg)
 187         register char *fmt;
 188         PARG *parg;
 189 {
 190         register char *s;
 191         register int n;
 192         register int col;
 193
 194         col = 0;
 195         while (*fmt != '\0')
 196         {
 197                 if (*fmt != '%')
 198                 {
 199                         putchr(*fmt++);
 200                         col++;
 201                 } else
 202                 {
 203                         ++fmt;
 204                         switch (*fmt++) {
 205                         case 's':
 206                                 s = parg->p_string;
 207                                 parg++;
 208                                 while (*s != '\0')
 209                                 {
 210                                         putchr(*s++);
 211                                         col++;
 212                                 }
 213                                 break;
 214                         case 'd':
 215                                 n = parg->p_int;
 216                                 parg++;
 217                                 col += iprintnum(n, 10);
 218                                 break;
 219                         }
 220                 }
 221         }
 222         return (col);
 223 }
 224
 225 /*
 226  * Output a message in the lower left corner of the screen
 227  * and wait for carriage return.
 228  */
 229         public void
 230 error(fmt, parg)
 231         char *fmt;
 232         PARG *parg;
 233 {
 234         int c;
 235         int col = 0;
 236         static char return_to_continue[] = "  (press RETURN)";
 237
 238         errmsgs++;
 239
 240         if (any_display)
 241         {
 242                 lower_left();
 243                 clear_eol();
 244                 so_enter();
 245                 col += so_s_width;
 246         }
 247
 248         col += iprintf(fmt, parg);
 249
 250         if (!any_display)
 251         {
 252                 putchr('\n');
 253                 return;
 254         }
 255
 256         putstr(return_to_continue);
 257         so_exit();
 258         col += sizeof(return_to_continue) + so_e_width;
 259
 260 #if ONLY_RETURN
 261         while ((c = getchr()) != '\n' && c != '\r')
 262                 bell();
 263 #else
 264         c = getchr();
 265         if (c != '\n' && c != '\r' && c != ' ' && c != READ_INTR)
 266                 ungetcc(c);
 267 #endif
 268         lower_left();
 269
 270         if (col >= sc_width)
 271                 /*
 272                  * Printing the message has probably scrolled the screen.
 273                  * {{ Unless the terminal doesn't have auto margins,
 274                  *    in which case we just hammered on the right margin. }}
 275                  */
 276                 screen_trashed = 1;
 277
 278         flush();
 279 }
 280
 281 static char intr_to_abort[] = "... (interrupt to abort)";
 282
 283 /*
 284  * Output a message in the lower left corner of the screen
 285  * and don't wait for carriage return.
 286  * Usually used to warn that we are beginning a potentially
 287  * time-consuming operation.
 288  */
 289         public void
 290 ierror(fmt, parg)
 291         char *fmt;
 292         PARG *parg;
 293 {
 294         lower_left();
 295         clear_eol();
 296         so_enter();
 297         (void) iprintf(fmt, parg);
 298         putstr(intr_to_abort);
 299         so_exit();
 300         flush();
 301         need_clr = 1;
 302 }
 303
 304 /*
 305  * Output a message in the lower left corner of the screen
 306  * and return a single-character response.
 307  */
 308         public int
 309 query(fmt, parg)
 310         char *fmt;
 311         PARG *parg;
 312 {
 313         register int c;
 314         int col = 0;
 315
 316         if (any_display)
 317         {
 318                 lower_left();
 319                 clear_eol();
 320         }
 321
 322         (void) iprintf(fmt, parg);
 323         c = getchr();
 324
 325         if (!any_display)
 326         {
 327                 putchr('\n');
 328                 return (c);
 329         }
 330
 331         lower_left();
 332         if (col >= sc_width)
 333                 screen_trashed = 1;
 334         flush();
 335
 336         return (c);
 337 }