contrib/less/output.c

   1 /*
   2  * Copyright (C) 1984-2000  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  * High level routines dealing with the output to the screen.
  14  */
  15
  16 #include "less.h"
  17 #if MSDOS_COMPILER==WIN32C
  18 #include "windows.h"
  19 #endif
  20
  21 public int errmsgs;     /* Count of messages displayed by error() */
  22 public int need_clr;
  23 public int final_attr;
  24
  25 extern int sigs;
  26 extern int sc_width;
  27 extern int so_s_width, so_e_width;
  28 extern int screen_trashed;
  29 extern int any_display;
  30 extern int is_tty;
  31
  32 /*
  33  * Display the line which is in the line buffer.
  34  */
  35         public void
  36 put_line()
  37 {
  38         register int c;
  39         register int i;
  40         int a;
  41         int curr_attr;
  42
  43         if (ABORT_SIGS())
  44         {
  45                 /*
  46                  * Don't output if a signal is pending.
  47                  */
  48                 screen_trashed = 1;
  49                 return;
  50         }
  51
  52         curr_attr = AT_NORMAL;
  53
  54         for (i = 0;  (c = gline(i, &a)) != '\0';  i++)
  55         {
  56                 if (a != curr_attr)
  57                 {
  58                         /*
  59                          * Changing attributes.
  60                          * Display the exit sequence for the old attribute
  61                          * and the enter sequence for the new one.
  62                          */
  63                         switch (curr_attr)
  64                         {
  65                         case AT_UNDERLINE:      ul_exit();      break;
  66                         case AT_BOLD:           bo_exit();      break;
  67                         case AT_BLINK:          bl_exit();      break;
  68                         case AT_STANDOUT:       so_exit();      break;
  69                         }
  70                         switch (a)
  71                         {
  72                         case AT_UNDERLINE:      ul_enter();     break;
  73                         case AT_BOLD:           bo_enter();     break;
  74                         case AT_BLINK:          bl_enter();     break;
  75                         case AT_STANDOUT:       so_enter();     break;
  76                         }
  77                         curr_attr = a;
  78                 }
  79                 if (curr_attr == AT_INVIS)
  80                         continue;
  81                 if (c == '\b')
  82                         putbs();
  83                 else
  84                         putchr(c);
  85         }
  86
  87         switch (curr_attr)
  88         {
  89         case AT_UNDERLINE:      ul_exit();      break;
  90         case AT_BOLD:           bo_exit();      break;
  91         case AT_BLINK:          bl_exit();      break;
  92         case AT_STANDOUT:       so_exit();      break;
  93         }
  94         final_attr = curr_attr;
  95 }
  96
  97 static char obuf[OUTBUF_SIZE];
  98 static char *ob = obuf;
  99
 100 /*
 101  * Flush buffered output.
 102  *
 103  * If we haven't displayed any file data yet,
 104  * output messages on error output (file descriptor 2),
 105  * otherwise output on standard output (file descriptor 1).
 106  *
 107  * This has the desirable effect of producing all
 108  * error messages on error output if standard output
 109  * is directed to a file.  It also does the same if
 110  * we never produce any real output; for example, if
 111  * the input file(s) cannot be opened.  If we do
 112  * eventually produce output, code in edit() makes
 113  * sure these messages can be seen before they are
 114  * overwritten or scrolled away.
 115  */
 116         public void
 117 flush()
 118 {
 119         register int n;
 120         register int fd;
 121
 122         n = ob - obuf;
 123         if (n == 0)
 124                 return;
 125 #if MSDOS_COMPILER==WIN32C
 126         if (is_tty && any_display)
 127         {
 128                 char *op;
 129                 DWORD nwritten = 0;
 130                 CONSOLE_SCREEN_BUFFER_INFO scr;
 131                 int row;
 132                 int col;
 133                 int olen;
 134                 extern HANDLE con_out;
 135
 136                 olen = ob - obuf;
 137                 /*
 138                  * There is a bug in Win32 WriteConsole() if we're
 139                  * writing in the last cell with a different color.
 140                  * To avoid color problems in the bottom line,
 141                  * we scroll the screen manually, before writing.
 142                  */
 143                 GetConsoleScreenBufferInfo(con_out, &scr);
 144                 col = scr.dwCursorPosition.X;
 145                 row = scr.dwCursorPosition.Y;
 146                 for (op = obuf;  op < obuf + olen;  op++)
 147                 {
 148                         if (*op == '\n')
 149                         {
 150                                 col = 0;
 151                                 row++;
 152                         } else
 153                         {
 154                                 col++;
 155                                 if (col >= sc_width)
 156                                 {
 157                                         col = 0;
 158                                         row++;
 159                                 }
 160                         }
 161                 }
 162                 if (row > scr.srWindow.Bottom)
 163                         win32_scroll_up(row - scr.srWindow.Bottom);
 164                 WriteConsole(con_out, obuf, olen, &nwritten, NULL);
 165                 ob = obuf;
 166                 return;
 167         }
 168 #else
 169 #if MSDOS_COMPILER==MSOFTC
 170         if (is_tty && any_display)
 171         {
 172                 *ob = '\0';
 173                 _outtext(obuf);
 174                 ob = obuf;
 175                 return;
 176         }
 177 #else
 178 #if MSDOS_COMPILER==BORLANDC || MSDOS_COMPILER==DJGPPC
 179         if (is_tty && any_display)
 180         {
 181                 *ob = '\0';
 182                 cputs(obuf);
 183                 ob = obuf;
 184                 return;
 185         }
 186 #endif
 187 #endif
 188 #endif
 189         fd = (any_display) ? 1 : 2;
 190         if (write(fd, obuf, n) != n)
 191                 screen_trashed = 1;
 192         ob = obuf;
 193 }
 194
 195 /*
 196  * Output a character.
 197  */
 198         public int
 199 putchr(c)
 200         int c;
 201 {
 202         if (need_clr)
 203         {
 204                 need_clr = 0;
 205                 clear_bot();
 206         }
 207 #if MSDOS_COMPILER
 208         if (c == '\n' && is_tty)
 209         {
 210                 /* remove_top(1); */
 211                 putchr('\r');
 212         }
 213 #else
 214 #ifdef _OSK
 215         if (c == '\n' && is_tty)  /* In OS-9, '\n' == 0x0D */
 216                 putchr(0x0A);
 217 #endif
 218 #endif
 219         /*
 220          * Some versions of flush() write to *ob, so we must flush
 221          * when we are still one char from the end of obuf.
 222          */
 223         if (ob >= &obuf[sizeof(obuf)-1])
 224                 flush();
 225         *ob++ = c;
 226         return (c);
 227 }
 228
 229 /*
 230  * Output a string.
 231  */
 232         public void
 233 putstr(s)
 234         register char *s;
 235 {
 236         while (*s != '\0')
 237                 putchr(*s++);
 238 }
 239
 240
 241 /*
 242  * Output an integer in a given radix.
 243  */
 244         static int
 245 iprintnum(num, radix)
 246         int num;
 247         int radix;
 248 {
 249         register char *s;
 250         int r;
 251         int neg;
 252         char buf[INT_STRLEN_BOUND(num)];
 253
 254         neg = (num < 0);
 255         if (neg)
 256                 num = -num;
 257
 258         s = buf;
 259         do
 260         {
 261                 *s++ = (num % radix) + '0';
 262         } while ((num /= radix) != 0);
 263
 264         if (neg)
 265                 *s++ = '-';
 266         r = s - buf;
 267
 268         while (s > buf)
 269                 putchr(*--s);
 270         return (r);
 271 }
 272
 273 /*
 274  * This function implements printf-like functionality
 275  * using a more portable argument list mechanism than printf's.
 276  */
 277         static int
 278 less_printf(fmt, parg)
 279         register char *fmt;
 280         PARG *parg;
 281 {
 282         register char *s;
 283         register int n;
 284         register int col;
 285
 286         col = 0;
 287         while (*fmt != '\0')
 288         {
 289                 if (*fmt != '%')
 290                 {
 291                         putchr(*fmt++);
 292                         col++;
 293                 } else
 294                 {
 295                         ++fmt;
 296                         switch (*fmt++) {
 297                         case 's':
 298                                 s = parg->p_string;
 299                                 parg++;
 300                                 while (*s != '\0')
 301                                 {
 302                                         putchr(*s++);
 303                                         col++;
 304                                 }
 305                                 break;
 306                         case 'd':
 307                                 n = parg->p_int;
 308                                 parg++;
 309                                 col += iprintnum(n, 10);
 310                                 break;
 311                         }
 312                 }
 313         }
 314         return (col);
 315 }
 316
 317 /*
 318  * Get a RETURN.
 319  * If some other non-trivial char is pressed, unget it, so it will
 320  * become the next command.
 321  */
 322         public void
 323 get_return()
 324 {
 325         int c;
 326
 327 #if ONLY_RETURN
 328         while ((c = getchr()) != '\n' && c != '\r')
 329                 bell();
 330 #else
 331         c = getchr();
 332         if (c != '\n' && c != '\r' && c != ' ' && c != READ_INTR)
 333                 ungetcc(c);
 334 #endif
 335 }
 336
 337 /*
 338  * Output a message in the lower left corner of the screen
 339  * and wait for carriage return.
 340  */
 341         public void
 342 error(fmt, parg)
 343         char *fmt;
 344         PARG *parg;
 345 {
 346         int col = 0;
 347         static char return_to_continue[] = "  (press RETURN)";
 348
 349         errmsgs++;
 350
 351         if (any_display && is_tty)
 352         {
 353                 clear_bot();
 354                 so_enter();
 355                 col += so_s_width;
 356         }
 357
 358         col += less_printf(fmt, parg);
 359
 360         if (!(any_display && is_tty))
 361         {
 362                 putchr('\n');
 363                 return;
 364         }
 365
 366         putstr(return_to_continue);
 367         so_exit();
 368         col += sizeof(return_to_continue) + so_e_width;
 369
 370         get_return();
 371         lower_left();
 372
 373         if (col >= sc_width)
 374                 /*
 375                  * Printing the message has probably scrolled the screen.
 376                  * {{ Unless the terminal doesn't have auto margins,
 377                  *    in which case we just hammered on the right margin. }}
 378                  */
 379                 screen_trashed = 1;
 380
 381         flush();
 382 }
 383
 384 static char intr_to_abort[] = "... (interrupt to abort)";
 385
 386 /*
 387  * Output a message in the lower left corner of the screen
 388  * and don't wait for carriage return.
 389  * Usually used to warn that we are beginning a potentially
 390  * time-consuming operation.
 391  */
 392         public void
 393 ierror(fmt, parg)
 394         char *fmt;
 395         PARG *parg;
 396 {
 397         clear_bot();
 398         so_enter();
 399         (void) less_printf(fmt, parg);
 400         putstr(intr_to_abort);
 401         so_exit();
 402         flush();
 403         need_clr = 1;
 404 }
 405
 406 /*
 407  * Output a message in the lower left corner of the screen
 408  * and return a single-character response.
 409  */
 410         public int
 411 query(fmt, parg)
 412         char *fmt;
 413         PARG *parg;
 414 {
 415         register int c;
 416         int col = 0;
 417
 418         if (any_display && is_tty)
 419                 clear_bot();
 420
 421         (void) less_printf(fmt, parg);
 422         c = getchr();
 423
 424         if (!(any_display && is_tty))
 425         {
 426                 putchr('\n');
 427                 return (c);
 428         }
 429
 430         lower_left();
 431         if (col >= sc_width)
 432                 screen_trashed = 1;
 433         flush();
 434
 435         return (c);
 436 }