home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d0xx / d034 / less.lha / Less / output.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-09-03  |  2.8 KB  |  205 lines
  1. /*
  2.  * High level routines dealing with the output to the screen.
  3.  */
  4.  
  5. #include "less.h"
  6.  
  7. extern int sigs;
  8. extern int sc_width, sc_height;
  9. extern int ul_width, ue_width;
  10. extern int so_width, se_width;
  11. extern int tabstop;
  12. extern int twiddle;
  13. extern char *line;
  14. extern char *first_cmd;
  15.  
  16. /*
  17.  * Display the line which is in the line buffer.
  18.  */
  19.     public void
  20. put_line()
  21. {
  22.     register char *p;
  23.     register int c;
  24.     register int column;
  25.     extern int auto_wrap, ignaw;
  26.  
  27.     if (sigs)
  28.         /*
  29.          * Don't output if a signal is pending.
  30.          */
  31.         return;
  32.  
  33.     if (line == NULL)
  34.         line = (twiddle) ? "~" : "";
  35.  
  36.     column = 0;
  37.     for (p = line;  *p != '\0';  p++)
  38.     {
  39.         switch (c = *p)
  40.         {
  41.         case UL_CHAR:
  42.             ul_enter();
  43.             column += ul_width;
  44.             break;
  45.         case UE_CHAR:
  46.             ul_exit();
  47.             column += ue_width;
  48.             break;
  49.         case '\t':
  50.             do
  51.             {
  52.                 putc(' ');
  53.                 column++;
  54.             } while ((column % tabstop) != 0);
  55.             break;
  56.         case '\b':
  57.             putbs();
  58.             column--;
  59.             break;
  60.         default:
  61.             if (c & 0200)
  62.             {
  63.                 putc('^');
  64.                 putc(c & 0177);
  65.                 column += 2;
  66.             } else
  67.             {
  68.                 putc(c);
  69.                 column++;
  70.             }
  71.         }
  72.     }
  73.     if (column < sc_width || !auto_wrap || ignaw)
  74.         putc('\n');
  75. }
  76.  
  77. /*
  78.  * Is a given character a "control" character?
  79.  * {{ ASCII DEPENDENT }}
  80.  */
  81.     public int
  82. control_char(c)
  83.     int c;
  84. {
  85.     return (c < ' ' || c == '\177');
  86. }
  87.  
  88. /*
  89.  * Return the printable character used to identify a control character
  90.  * (printed after a carat; e.g. '\3' => "^C").
  91.  * {{ ASCII DEPENDENT }}
  92.  */
  93.     public int
  94. carat_char(c)
  95.     int c;
  96. {
  97.     return ((c == '\177') ? '?' : (c | 0100));
  98. }
  99.  
  100.  
  101. static char obuf[1024];
  102. static char *ob = obuf;
  103.  
  104. /*
  105.  * Flush buffered output.
  106.  */
  107. public void
  108. flush()
  109. {
  110. #ifdef amiga
  111.     extern struct FileHandle *tty;
  112.     extern nrow;
  113.  
  114.     if (nrow == 0)
  115.         ttopen();
  116.  
  117.     ttflush();
  118.     Write(tty, obuf, (long) ob-obuf);
  119. #else
  120.     write(1, obuf, ob-obuf);
  121. #endif
  122.     ob = obuf;
  123. }
  124.  
  125. /*
  126.  * Discard buffered output.
  127.  */
  128.     public void
  129. dropout()
  130. {
  131.     ob = obuf;
  132. }
  133.  
  134. /*
  135.  * Output a character.
  136.  */
  137.     public void
  138. putc(c)
  139.     int c;
  140. {
  141.     if (ob >= &obuf[sizeof(obuf)])
  142.         flush();
  143.  
  144.     *ob++ = c;
  145. }
  146.  
  147. /*
  148.  * Output a string.
  149.  */
  150.     public void
  151. puts(s)
  152.     register char *s;
  153. {
  154.     while (*s != '\0')
  155.         putc(*s++);
  156. }
  157.  
  158. /*
  159.  * Output a message in the lower left corner of the screen
  160.  * and wait for carriage return.
  161.  */
  162.  
  163. static char return_to_continue[] = "  (press RETURN)";
  164.  
  165. public void
  166. error(s)
  167.     char *s;
  168. {
  169.     register int c;
  170.     static char buf[2];
  171.  
  172.     lower_left();
  173.     clear_eol();
  174.     so_enter();
  175.     puts(s);
  176.     puts(return_to_continue);
  177.     so_exit();
  178.  
  179. #if ONLY_RETURN
  180.     while ((c = getc()) != '\n' && c != '\r')
  181.         bell();
  182. #else
  183.     c = getc();
  184.     if (c != '\n' && c != '\r' && c != ' ')
  185.     {
  186.         buf[0] = c;
  187.         first_cmd = buf;
  188.     }
  189. #endif
  190.  
  191.     if (strlen(s) > sc_width)
  192.         repaint();
  193. }
  194.  
  195.     public int
  196. error_width()
  197. {
  198.     /*
  199.      * Don't use the last position, because some terminals
  200.      * will scroll if you write in the last char of the last line.
  201.      */
  202.     return (sc_width - 
  203.         (sizeof(return_to_continue) + so_width + se_width + 1));
  204. }
  205.