2330ca422ec363dd9e0d58fb06ce487cfee2120c
[dragonfly.git] / contrib / top / display.c
1 /*
2  * Copyright (c) 1984 through 2008, William LeFebvre
3  * All rights reserved.
4  * 
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  * 
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  * 
16  *     * Neither the name of William LeFebvre nor the names of other
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  * 
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 /*
34  *  Top users/processes display for Unix
35  *  Version 3
36  */
37
38 /*
39  *  This file contains the routines that display information on the screen.
40  *  Each section of the screen has two routines:  one for initially writing
41  *  all constant and dynamic text, and one for only updating the text that
42  *  changes.  The prefix "i_" is used on all the "initial" routines and the
43  *  prefix "u_" is used for all the "updating" routines.
44  *
45  *  ASSUMPTIONS:
46  *        None of the "i_" routines use any of the termcap capabilities.
47  *        In this way, those routines can be safely used on terminals that
48  *        have minimal (or nonexistant) terminal capabilities.
49  *
50  *        The routines should be called in this order:  *_loadave, *_uptime,
51  *        i_timeofday, *_procstates, *_cpustates, *_memory, *_swap,
52  *        *_message, *_header, *_process, *_endscreen.
53  */
54
55 #include "os.h"
56 #include <ctype.h>
57 #include <stdarg.h>
58 #include <sys/types.h>
59 #include <sys/uio.h>
60 #include <unistd.h>
61
62 #include "top.h"
63 #include "machine.h"
64 #include "screen.h"             /* interface to screen package */
65 #include "layout.h"             /* defines for screen position layout */
66 #include "display.h"
67 #include "boolean.h"
68 #include "utils.h"
69
70 #ifdef ENABLE_COLOR
71 #include "color.h"
72 #endif
73
74 #define CURSOR_COST 8
75
76 #define MESSAGE_DISPLAY_TIME 5
77
78 /* imported from screen.c */
79 extern int overstrike;
80
81 static int lmpid = -1;
82 static int display_width = MAX_COLS;
83
84 /* cursor positions of key points on the screen are maintained here */
85 /* layout.h has static definitions, but we may change our minds on some
86    of the positions as we make decisions about what needs to be displayed */
87
88 static int x_lastpid = X_LASTPID;
89 static int y_lastpid = Y_LASTPID;
90 static int x_loadave = X_LOADAVE;
91 static int y_loadave = Y_LOADAVE;
92 static int x_minibar = X_MINIBAR;
93 static int y_minibar = Y_MINIBAR;
94 static int x_uptime = X_UPTIME;
95 static int y_uptime = Y_UPTIME;
96 static int x_procstate = X_PROCSTATE;
97 static int y_procstate = Y_PROCSTATE;
98 static int x_cpustates = X_CPUSTATES;
99 static int y_cpustates = Y_CPUSTATES;
100 static int x_kernel = X_KERNEL;
101 static int y_kernel = Y_KERNEL;
102 static int x_mem = X_MEM;
103 static int y_mem = Y_MEM;
104 static int x_swap = X_SWAP;
105 static int y_swap = Y_SWAP;
106 static int y_message = Y_MESSAGE;
107 static int x_header = X_HEADER;
108 static int y_header = Y_HEADER;
109 static int x_idlecursor = X_IDLECURSOR;
110 static int y_idlecursor = Y_IDLECURSOR;
111 static int y_procs = Y_PROCS;
112
113 /* buffer and colormask that describes the content of the screen */
114 /* these are singly dimensioned arrays -- the row boundaries are
115    determined on the fly.
116 */
117 static char *screenbuf = NULL;
118 static char *colorbuf = NULL;
119 static char scratchbuf[MAX_COLS];
120 static int bufsize = 0;
121
122 /* lineindex tells us where the beginning of a line is in the buffer */
123 #define lineindex(l) ((l)*MAX_COLS)
124
125 /* screen's cursor */
126 static int curr_x, curr_y;
127 static int curr_color;
128
129 /* virtual cursor */
130 static int virt_x, virt_y;
131
132 static char **procstate_names;
133 static char **cpustate_names;
134 static char **memory_names;
135 static char **swap_names;
136 static char **kernel_names;
137
138 static int num_procstates;
139 static int num_cpustates;
140 static int num_memory;
141 static int num_swap;
142 static int num_kernel;
143
144 static int *lprocstates;
145 static int *lcpustates;
146
147 static int *cpustate_columns;
148 static int cpustate_total_length;
149
150 static int header_status = Yes;
151
152 /* pending messages are stored in a circular buffer, where message_first
153    is the next one to display, and message_last is the last one
154    in the buffer.  Counters wrap around at MAX_MESSAGES.  The buffer is
155    empty when message_first == message_last and full when 
156    message_last + 1 == message_first.  The pointer message_current holds
157    the message currently being displayed, or "" if there is none.
158 */
159 #define MAX_MESSAGES 16
160 static char *message_buf[MAX_MESSAGES];
161 static int message_first = 0;
162 static int message_last = 0;
163 static struct timeval message_time = {0, 0};
164 static char *message_current = NULL;
165 static int message_length = 0;
166 static int message_hold = 1;
167 static int message_barrier = No;
168
169 #ifdef ENABLE_COLOR
170 static int load_cidx[3];
171 static int header_cidx;
172 static int *cpustate_cidx;
173 static int *memory_cidx;
174 static int *swap_cidx;
175 static int *kernel_cidx;
176 #else
177 #define memory_cidx NULL
178 #define swap_cidx NULL
179 #define kernel_cidx NULL
180 #endif
181
182
183 /* internal support routines */
184
185 /*
186  * static int string_count(char **pp)
187  *
188  * Pointer "pp" points to an array of string pointers, which is
189  * terminated by a NULL.  Return the number of string pointers in
190  * this array.
191  */
192
193 static int
194 string_count(char **pp)
195
196 {
197     register int cnt = 0;
198
199     if (pp != NULL)
200     {
201         while (*pp++ != NULL)
202         {
203             cnt++;
204         }
205     }
206     return(cnt);
207 }
208
209 void
210 display_clear()
211
212 {
213     dprintf("display_clear\n");
214     screen_clear();
215     memzero(screenbuf, bufsize);
216     memzero(colorbuf, bufsize);
217     curr_x = curr_y = 0;
218 }
219
220 /*
221  * void display_move(int x, int y)
222  *
223  * Efficiently move the cursor to x, y.  This assumes the cursor is
224  * currently located at curr_x, curr_y, and will only use cursor
225  * addressing when it is less expensive than overstriking what's
226  * already on the screen.
227  */
228
229 void
230 display_move(int x, int y)
231
232 {
233     char buff[128];
234     char *p;
235     char *bufp;
236     char *colorp;
237     int cnt = 0;
238     int color = curr_color;
239
240     dprintf("display_move(%d, %d): curr_x %d, curr_y %d\n", x, y, curr_x, curr_y);
241
242     /* are we in a position to do this without cursor addressing? */
243     if (curr_y < y || (curr_y == y && curr_x <= x))
244     {
245         /* start buffering up what it would take to move there by rewriting
246            what's on the screen */
247         cnt = CURSOR_COST;
248         p = buff;
249
250         /* one newline for every line */
251         while (cnt > 0 && curr_y < y)
252         {
253 #ifdef ENABLE_COLOR
254             if (color != 0)
255             {
256                 p = strcpyend(p, color_setstr(0));
257                 color = 0;
258                 cnt -= 5;
259             }
260 #endif
261             *p++ = '\n';
262             curr_y++;
263             curr_x = 0;
264             cnt--;
265         }
266
267         /* write whats in the screenbuf */
268         bufp = &screenbuf[lineindex(curr_y) + curr_x];
269         colorp = &colorbuf[lineindex(curr_y) + curr_x];
270         while (cnt > 0 && curr_x < x)
271         {
272 #ifdef ENABLE_COLOR
273             if (color != *colorp)
274             {
275                 color = *colorp;
276                 p = strcpyend(p, color_setstr(color));
277                 cnt -= 5;
278             }
279 #endif
280             if ((*p = *bufp) == '\0')
281             {
282                 /* somwhere on screen we haven't been before */
283                 *p = *bufp = ' ';
284             }
285             p++;
286             bufp++;
287             colorp++;
288             curr_x++;
289             cnt--;
290         }
291     }
292
293     /* move the cursor */
294     if (cnt > 0)
295     {
296         /* screen rewrite is cheaper */
297         *p = '\0';
298         fputs(buff, stdout);
299         curr_color = color;
300     }
301     else
302     {
303         screen_move(x, y);
304     }
305
306     /* update our position */
307     curr_x = x;
308     curr_y = y;
309 }
310
311 /*
312  * display_write(int x, int y, int newcolor, int eol, char *new)
313  *
314  * Optimized write to the display.  This writes characters to the
315  * screen in a way that optimizes the number of characters actually
316  * sent, by comparing what is being written to what is already on
317  * the screen (according to screenbuf and colorbuf).  The string to
318  * write is "new", the first character of "new" should appear at
319  * screen position x, y.  If x is -1 then "new" begins wherever the
320  * cursor is currently positioned.  The string is written with color
321  * "newcolor".  If "eol" is true then the remainder of the line is
322  * cleared.  It is expected that "new" will have no newlines and no
323  * escape sequences.
324  */
325
326 void
327 display_write(int x, int y, int newcolor, int eol, char *new)
328
329 {
330     char *bufp;
331     char *colorp;
332     int ch;
333     int diff;
334
335     dprintf("display_write(%d, %d, %d, %d, \"%s\")\n",
336             x, y, newcolor, eol, new);
337
338     /* dumb terminal handling here */
339     if (!smart_terminal)
340     {
341         if (x != -1)
342         {
343             /* make sure we are on the right line */
344             while (curr_y < y)
345             {
346                 putchar('\n');
347                 curr_y++;
348                 curr_x = 0;
349             }
350
351             /* make sure we are on the right column */
352             while (curr_x < x)
353             {
354                 putchar(' ');
355                 curr_x++;
356             }
357         }
358
359         /* write */
360         fputs(new, stdout);
361         curr_x += strlen(new);
362
363         return;
364     }
365
366     /* adjust for "here" */
367     if (x == -1)
368     {
369         x = virt_x;
370         y = virt_y;
371     }
372     else
373     {
374         virt_x = x;
375         virt_y = y;
376     }
377
378     /* a pointer to where we start */
379     bufp = &screenbuf[lineindex(y) + x];
380     colorp = &colorbuf[lineindex(y) + x];
381
382     /* main loop */
383     while ((ch = *new++) != '\0')
384     {
385         /* if either character or color are different, an update is needed */
386         /* but only when the screen is wide enough */
387         if (x < display_width && (ch != *bufp || newcolor != *colorp))
388         {
389             /* check cursor */
390             if (y != curr_y || x != curr_x)
391             {
392                 /* have to move the cursor */
393                 display_move(x, y);
394             }
395
396             /* write character */
397 #ifdef ENABLE_COLOR
398             if (curr_color != newcolor)
399             {
400                 fputs(color_setstr(newcolor), stdout);
401                 curr_color = newcolor;
402             }
403 #endif
404             putchar(ch);
405             *bufp = ch;
406             *colorp = curr_color;
407             curr_x++;
408         }
409
410         /* move */
411         x++;
412         virt_x++;
413         bufp++;
414         colorp++;
415     }
416
417     /* eol handling */
418     if (eol && *bufp != '\0')
419     {
420         dprintf("display_write: clear-eol (bufp = \"%s\")\n", bufp);
421         /* make sure we are color 0 */
422 #ifdef ENABLE_COLOR
423         if (curr_color != 0)
424         {
425             fputs(color_setstr(0), stdout);
426             curr_color = 0;
427         }
428 #endif
429
430         /* make sure we are at the end */
431         if (x != curr_x || y != curr_y)
432         {
433             screen_move(x, y);
434             curr_x = x;
435             curr_y = y;
436         }
437
438         /* clear to end */
439         screen_cleareol(strlen(bufp));
440
441         /* clear out whats left of this line's buffer */
442         diff = display_width - x;
443         if (diff > 0)
444         {
445             memzero(bufp, diff);
446             memzero(colorp, diff);
447         }
448     }
449 }
450
451 void
452 display_fmt(int x, int y, int newcolor, int eol, char *fmt, ...)
453
454 {
455     va_list argp;
456
457     va_start(argp, fmt);
458
459     vsnprintf(scratchbuf, MAX_COLS, fmt, argp);
460     display_write(x, y, newcolor, eol, scratchbuf);
461 }
462
463 void
464 display_cte()
465
466 {
467     int len;
468     int y;
469     char *p;
470     int need_clear = 0;
471
472     /* is there anything out there that needs to be cleared? */
473     p = &screenbuf[lineindex(virt_y) + virt_x];
474     if (*p != '\0')
475     {
476         need_clear = 1;
477     }
478     else
479     {
480         /* this line is clear, what about the rest? */
481         y = virt_y;
482         while (++y < screen_length)
483         {
484             if (screenbuf[lineindex(y)] != '\0')
485             {
486                 need_clear = 1;
487                 break;
488             }
489         }
490     }
491
492     if (need_clear)
493     {
494         dprintf("display_cte: clearing\n");
495
496         /* we will need this later */
497         len = lineindex(virt_y) + virt_x;
498
499         /* move to x and y, then clear to end */
500         display_move(virt_x, virt_y);
501         if (!screen_cte())
502         {
503             /* screen has no clear to end, so do it by hand */
504             p = &screenbuf[len];
505             len = strlen(p);
506             if (len > 0)
507             {
508                 screen_cleareol(len);
509             }
510             while (++virt_y < screen_length)
511             {
512                 display_move(0, virt_y);
513                 p = &screenbuf[lineindex(virt_y)];
514                 len = strlen(p);
515                 if (len > 0)
516                 {
517                     screen_cleareol(len);
518                 }
519             }
520         }
521
522         /* clear the screenbuf */
523         memzero(&screenbuf[len], bufsize - len);
524         memzero(&colorbuf[len], bufsize - len);
525     }
526 }
527
528 static void
529 summary_format(int x, int y, int *numbers, char **names, int *cidx)
530
531 {
532     register int num;
533     register char *thisname;
534     register char *lastname = NULL;
535     register int color;
536
537     /* format each number followed by its string */
538     while ((thisname = *names++) != NULL)
539     {
540         /* get the number to format */
541         num = *numbers++;
542         color = 0;
543
544         /* display only non-zero numbers */
545         if (num != 0)
546         {
547             /* write the previous name */
548             if (lastname != NULL)
549             {
550                 display_write(-1, -1, 0, 0, lastname);
551             }
552
553 #ifdef ENABLE_COLOR
554             if (cidx != NULL)
555             {
556                 /* choose a color */
557                 color = color_test(*cidx++, num);
558             }
559 #endif
560
561             /* write this number if positive */
562             if (num > 0)
563             {
564                 display_write(x, y, color, 0, itoa(num));
565             }
566
567             /* defer writing this name */
568             lastname = thisname;
569
570             /* next iteration will not start at x, y */
571             x = y = -1;
572         }
573     }
574
575     /* if the last string has a separator on the end, it has to be
576        written with care */
577     if (lastname != NULL)
578     {
579         if ((num = strlen(lastname)) > 1 &&
580             lastname[num-2] == ',' && lastname[num-1] == ' ')
581         {
582             display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
583         }
584         else
585         {
586             display_write(-1, -1, 0, 1, lastname);
587         }
588     }
589 }
590
591 static void
592 summary_format_memory(int x, int y, long *numbers, char **names, int *cidx)
593
594 {
595     register long num;
596     register int color;
597     register char *thisname;
598     register char *lastname = NULL;
599
600     /* format each number followed by its string */
601     while ((thisname = *names++) != NULL)
602     {
603         /* get the number to format */
604         num = *numbers++;
605         color = 0;
606
607         /* display only non-zero numbers */
608         if (num != 0)
609         {
610             /* write the previous name */
611             if (lastname != NULL)
612             {
613                 display_write(-1, -1, 0, 0, lastname);
614             }
615
616             /* defer writing this name */
617             lastname = thisname;
618
619 #ifdef ENABLE_COLOR
620             /* choose a color */
621             color = color_test(*cidx++, num);
622 #endif
623
624             /* is this number in kilobytes? */
625             if (thisname[0] == 'K')
626             {
627                 display_write(x, y, color, 0, format_k(num));
628                 lastname++;
629             }
630             else
631             {
632                 display_write(x, y, color, 0, itoa((int)num));
633             }
634
635             /* next iteration will not start at x, y */
636             x = y = -1;
637         }
638     }
639
640     /* if the last string has a separator on the end, it has to be
641        written with care */
642     if (lastname != NULL)
643     {
644         if ((num = strlen(lastname)) > 1 &&
645             lastname[num-2] == ',' && lastname[num-1] == ' ')
646         {
647             display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
648         }
649         else
650         {
651             display_write(-1, -1, 0, 1, lastname);
652         }
653     }
654 }
655
656 /*
657  * int display_resize()
658  *
659  * Reallocate buffer space needed by the display package to accomodate
660  * a new screen size.  Must be called whenever the screen's size has
661  * changed.  Returns the number of lines available for displaying 
662  * processes or -1 if there was a problem allocating space.
663  */
664
665 int
666 display_resize()
667
668 {
669     register int top_lines;
670     register int newsize;
671
672     /* calculate the current dimensions */
673     /* if operating in "dumb" mode, we only need one line */
674     top_lines = smart_terminal ? screen_length : 1;
675
676     /* we don't want more than MAX_COLS columns, since the machine-dependent
677        modules make static allocations based on MAX_COLS and we don't want
678        to run off the end of their buffers */
679     display_width = screen_width;
680     if (display_width >= MAX_COLS)
681     {
682         display_width = MAX_COLS - 1;
683     }
684
685     /* see how much space we need */
686     newsize = top_lines * (MAX_COLS + 1);
687
688     /* reallocate only if we need more than we already have */
689     if (newsize > bufsize)
690     {
691         /* deallocate any previous buffer that may have been there */
692         if (screenbuf != NULL)
693         {
694             free(screenbuf);
695         }
696         if (colorbuf != NULL)
697         {
698             free(colorbuf);
699         }
700
701         /* allocate space for the screen and color buffers */
702         bufsize = newsize;
703         screenbuf = (char *)calloc(bufsize, sizeof(char));
704         colorbuf = (char *)calloc(bufsize, sizeof(char));
705         if (screenbuf == NULL || colorbuf == NULL)
706         {
707             /* oops! */
708             return(-1);
709         }
710     }
711     else
712     {
713         /* just clear them out */
714         memzero(screenbuf, bufsize);
715         memzero(colorbuf, bufsize);
716     }
717
718     /* adjust total lines on screen to lines available for procs */
719     top_lines -= y_procs;
720
721     /* return number of lines available */
722     /* for dumb terminals, pretend like we can show any amount */
723     return(smart_terminal ? top_lines : Largest);
724 }
725
726 int
727 display_lines()
728
729 {
730     return(smart_terminal ? screen_length : Largest);
731 }
732
733 int
734 display_columns()
735
736 {
737     return(display_width);
738 }
739
740 /*
741  * int display_init(struct statics *statics)
742  *
743  * Initialize the display system based on information in the statics
744  * structure.  Returns the number of lines available for displaying
745  * processes or -1 if there was an error.
746  */
747
748 int
749 display_init(struct statics *statics)
750
751 {
752     register int top_lines;
753     register char **pp;
754     register char *p;
755     register int *ip;
756     register int i;
757
758     /* certain things may influence the screen layout,
759        so look at those first */
760
761     /* a kernel line shifts parts of the display down */
762     kernel_names = statics->kernel_names;
763     if ((num_kernel = string_count(kernel_names)) > 0)
764     {
765         /* adjust screen placements */
766         y_mem++;
767         y_swap++;
768         y_message++;
769         y_header++;
770         y_idlecursor++;
771         y_procs++;
772     }
773
774     /* a swap line shifts parts of the display down one */
775     swap_names = statics->swap_names;
776     if ((num_swap = string_count(swap_names)) > 0)
777     {
778         /* adjust screen placements */
779         y_message++;
780         y_header++;
781         y_idlecursor++;
782         y_procs++;
783     }
784     
785     /* call resize to do the dirty work */
786     top_lines = display_resize();
787
788     /* only do the rest if we need to */
789     if (top_lines > -1)
790     {
791         /* save pointers and allocate space for names */
792         procstate_names = statics->procstate_names;
793         num_procstates = string_count(procstate_names);
794         lprocstates = (int *)calloc(num_procstates, sizeof(int));
795
796         cpustate_names = statics->cpustate_names;
797         num_cpustates = string_count(cpustate_names);
798         lcpustates = (int *)calloc(num_cpustates, sizeof(int));
799         cpustate_columns = (int *)calloc(num_cpustates, sizeof(int));
800         memory_names = statics->memory_names;
801         num_memory = string_count(memory_names);
802
803         /* calculate starting columns where needed */
804         cpustate_total_length = 0;
805         pp = cpustate_names;
806         ip = cpustate_columns;
807         while (*pp != NULL)
808         {
809             *ip++ = cpustate_total_length;
810             if ((i = strlen(*pp++)) > 0)
811             {
812                 cpustate_total_length += i + 8;
813             }
814         }
815     }
816
817 #ifdef ENABLE_COLOR
818     /* set up color tags for loadavg */
819     load_cidx[0] = color_tag("1min");
820     load_cidx[1] = color_tag("5min");
821     load_cidx[2] = color_tag("15min");
822
823     /* find header color */
824     header_cidx = color_tag("header");
825
826     /* color tags for cpu states */
827     cpustate_cidx = (int *)malloc(num_cpustates * sizeof(int));
828     i = 0;
829     p = strcpyend(scratchbuf, "cpu.");
830     while (i < num_cpustates)
831     {
832         strcpy(p, cpustate_names[i]);
833         cpustate_cidx[i++] = color_tag(scratchbuf);
834     }
835
836     /* color tags for kernel */
837     if (num_kernel > 0)
838     {
839         kernel_cidx = (int *)malloc(num_kernel * sizeof(int));
840         i = 0;
841         p = strcpyend(scratchbuf, "kernel.");
842         while (i < num_kernel)
843         {
844             strcpy(p, homogenize(kernel_names[i]+1));
845             kernel_cidx[i++] = color_tag(scratchbuf);
846         }
847     }
848
849     /* color tags for memory */
850     memory_cidx = (int *)malloc(num_memory * sizeof(int));
851     i = 0;
852     p = strcpyend(scratchbuf, "memory.");
853     while (i < num_memory)
854     {
855         strcpy(p, homogenize(memory_names[i]+1));
856         memory_cidx[i++] = color_tag(scratchbuf);
857     }
858
859     /* color tags for swap */
860     if (num_swap > 0)
861     {
862         swap_cidx = (int *)malloc(num_swap * sizeof(int));
863         i = 0;
864         p = strcpyend(scratchbuf, "swap.");
865         while (i < num_swap)
866         {
867             strcpy(p, homogenize(swap_names[i]+1));
868             swap_cidx[i++] = color_tag(scratchbuf);
869         }
870     }
871 #endif
872
873     /* return number of lines available (or error) */
874     return(top_lines);
875 }
876
877 static void
878 pr_loadavg(double avg, int i)
879
880 {
881     int color = 0;
882
883 #ifdef ENABLE_COLOR
884     color = color_test(load_cidx[i], (int)(avg * 100));
885 #endif
886     display_fmt(x_loadave + X_LOADAVEWIDTH * i, y_loadave, color, 0,
887                 avg < 10.0 ? " %5.2f" : " %5.1f", avg);
888     display_write(-1, -1, 0, 0, (i < 2 ? "," : ";"));
889 }
890
891 void
892 i_loadave(int mpid, double *avenrun)
893
894 {
895     register int i;
896
897     /* mpid == -1 implies this system doesn't have an _mpid */
898     if (mpid != -1)
899     {
900         display_fmt(0, 0, 0, 0,
901                     "last pid: %5d;  load avg:", mpid);
902         x_loadave = X_LOADAVE;
903     }
904     else
905     {
906         display_write(0, 0, 0, 0, "load averages:");
907         x_loadave = X_LOADAVE - X_LASTPIDWIDTH;
908     }
909     for (i = 0; i < 3; i++)
910     {
911         pr_loadavg(avenrun[i], i);
912     }
913
914     lmpid = mpid;
915 }
916
917 void
918 u_loadave(int mpid, double *avenrun)
919
920 {
921     register int i;
922
923     if (mpid != -1)
924     {
925         /* change screen only when value has really changed */
926         if (mpid != lmpid)
927         {
928             display_fmt(x_lastpid, y_lastpid, 0, 0,
929                         "%5d", mpid);
930             lmpid = mpid;
931         }
932     }
933
934     /* display new load averages */
935     for (i = 0; i < 3; i++)
936     {
937         pr_loadavg(avenrun[i], i);
938     }
939 }
940
941 static char minibar_buffer[64];
942 #define MINIBAR_WIDTH 20
943
944 void
945 i_minibar(int (*formatter)(char *, int))
946 {
947     (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));
948
949     display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
950 }
951
952 void
953 u_minibar(int (*formatter)(char *, int))
954 {
955     (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));
956
957     display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
958 }
959
960 static int uptime_days;
961 static int uptime_hours;
962 static int uptime_mins;
963 static int uptime_secs;
964
965 void
966 i_uptime(time_t *bt, time_t *tod)
967
968 {
969     time_t uptime;
970
971     if (*bt != -1)
972     {
973         uptime = *tod - *bt;
974         uptime += 30;
975         uptime_days = uptime / 86400;
976         uptime %= 86400;
977         uptime_hours = uptime / 3600;
978         uptime %= 3600;
979         uptime_mins = uptime / 60;
980         uptime_secs = uptime % 60;
981
982         /*
983          *  Display the uptime.
984          */
985
986         display_fmt(x_uptime, y_uptime, 0, 0,
987                     "  up %d+%02d:%02d:%02d",
988                     uptime_days, uptime_hours, uptime_mins, uptime_secs);
989     }
990 }
991
992 void
993 u_uptime(time_t *bt, time_t *tod)
994
995 {
996     i_uptime(bt, tod);
997 }
998
999
1000 void
1001 i_timeofday(time_t *tod)
1002
1003 {
1004     /*
1005      *  Display the current time.
1006      *  "ctime" always returns a string that looks like this:
1007      *  
1008      *  Sun Sep 16 01:03:52 1973
1009      *  012345678901234567890123
1010      *            1         2
1011      *
1012      *  We want indices 11 thru 18 (length 8).
1013      */
1014
1015     int x;
1016
1017     /* where on the screen do we start? */
1018     x = (smart_terminal ? screen_width : 79) - 8;
1019
1020     /* but don't bump in to uptime */
1021     if (x < x_uptime + 19)
1022     {
1023         x = x_uptime + 19;
1024     }
1025
1026     /* display it */
1027     display_fmt(x, 0, 0, 1, "%-8.8s", &(ctime(tod)[11]));
1028 }
1029
1030 static int ltotal = 0;
1031 static int lthreads = 0;
1032
1033 /*
1034  *  *_procstates(total, brkdn, names) - print the process summary line
1035  */
1036
1037
1038 void
1039 i_procstates(int total, int *brkdn, int threads)
1040
1041 {
1042     /* write current number of processes and remember the value */
1043     display_fmt(0, y_procstate, 0, 0,
1044                 "%d %s: ", total, threads ? "threads" : "processes");
1045     ltotal = total;
1046
1047     /* remember where the summary starts */
1048     x_procstate = virt_x;
1049
1050     if (total > 0)
1051     {
1052         /* format and print the process state summary */
1053         summary_format(-1, -1, brkdn, procstate_names, NULL);
1054
1055         /* save the numbers for next time */
1056         memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
1057         lthreads = threads;
1058     }
1059 }
1060
1061 void
1062 u_procstates(int total, int *brkdn, int threads)
1063
1064 {
1065     /* if threads state has changed, do a full update */
1066     if (lthreads != threads)
1067     {
1068         i_procstates(total, brkdn, threads);
1069         return;
1070     }
1071
1072     /* update number of processes only if it has changed */
1073     if (ltotal != total)
1074     {
1075         display_fmt(0, y_procstate, 0, 0,
1076                     "%d", total);
1077
1078         /* if number of digits differs, rewrite the label */
1079         if (digits(total) != digits(ltotal))
1080         {
1081             display_fmt(-1, -1, 0, 0, " %s: ", threads ? "threads" : "processes");
1082             x_procstate = virt_x;
1083         }
1084
1085         /* save new total */
1086         ltotal = total;
1087     }
1088
1089     /* see if any of the state numbers has changed */
1090     if (total > 0 && memcmp(lprocstates, brkdn, num_procstates * sizeof(int)) != 0)
1091     {
1092         /* format and update the line */
1093         summary_format(x_procstate, y_procstate, brkdn, procstate_names, NULL);
1094         memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
1095     }
1096 }
1097
1098 /*
1099  *  *_cpustates(states, names) - print the cpu state percentages
1100  */
1101
1102 /* cpustates_tag() calculates the correct tag to use to label the line */
1103
1104 char *
1105 cpustates_tag()
1106
1107 {
1108     register char *use;
1109
1110     static char *short_tag = "CPU: ";
1111     static char *long_tag = "CPU states: ";
1112
1113     /* if length + strlen(long_tag) >= screen_width, then we have to
1114        use the shorter tag (we subtract 2 to account for ": ") */
1115     if (cpustate_total_length + (int)strlen(long_tag) - 2 >= screen_width)
1116     {
1117         use = short_tag;
1118     }
1119     else
1120     {
1121         use = long_tag;
1122     }
1123
1124     /* set x_cpustates accordingly then return result */
1125     x_cpustates = strlen(use);
1126     return(use);
1127 }
1128
1129 void
1130 i_cpustates(int *states)
1131
1132 {
1133     int value;
1134     char **names;
1135     char *thisname;
1136     int *colp;
1137     int color = 0;
1138 #ifdef ENABLE_COLOR
1139     int *cidx = cpustate_cidx;
1140 #endif
1141
1142     /* initialize */
1143     names = cpustate_names;
1144     colp = cpustate_columns;
1145
1146     /* print tag */
1147     display_write(0, y_cpustates, 0, 0, cpustates_tag());
1148
1149     /* now walk thru the names and print the line */
1150     while ((thisname = *names++) != NULL)
1151     {
1152         if (*thisname != '\0')
1153         {
1154             /* retrieve the value and remember it */
1155             value = *states;
1156
1157 #ifdef ENABLE_COLOR
1158             /* determine color number to use */
1159             color = color_test(*cidx++, value/10);
1160 #endif
1161
1162             /* if percentage is >= 1000, print it as 100% */
1163             display_fmt(x_cpustates + *colp, y_cpustates,
1164                         color, 0,
1165                         (value >= 1000 ? "%4.0f%% %s%s" : "%4.1f%% %s%s"),
1166                         ((float)value)/10.,
1167                         thisname,
1168                         *names != NULL ? ", " : "");
1169
1170         }
1171         /* increment */
1172         colp++;
1173         states++;
1174     }
1175
1176     /* copy over values into "last" array */
1177     memcpy(lcpustates, states, num_cpustates * sizeof(int));
1178 }
1179
1180 void
1181 u_cpustates(int *states)
1182
1183 {
1184     int value;
1185     char **names = cpustate_names;
1186     char *thisname;
1187     int *lp;
1188     int *colp;
1189     int color = 0;
1190 #ifdef ENABLE_COLOR
1191     int *cidx = cpustate_cidx;
1192 #endif
1193
1194     lp = lcpustates;
1195     colp = cpustate_columns;
1196
1197     /* we could be much more optimal about this */
1198     while ((thisname = *names++) != NULL)
1199     {
1200         if (*thisname != '\0')
1201         {
1202             /* did the value change since last time? */
1203             if (*lp != *states)
1204             {
1205                 /* yes, change it */
1206                 /* retrieve value and remember it */
1207                 value = *states;
1208
1209 #ifdef ENABLE_COLOR
1210                 /* determine color number to use */
1211                 color = color_test(*cidx, value/10);
1212 #endif
1213
1214                 /* if percentage is >= 1000, print it as 100% */
1215                 display_fmt(x_cpustates + *colp, y_cpustates, color, 0,
1216                             (value >= 1000 ? "%4.0f" : "%4.1f"),
1217                             ((double)value)/10.);
1218
1219                 /* remember it for next time */
1220                 *lp = value;
1221             }
1222 #ifdef ENABLE_COLOR
1223             cidx++;
1224 #endif
1225         }
1226
1227         /* increment and move on */
1228         lp++;
1229         states++;
1230         colp++;
1231     }
1232 }
1233
1234 void
1235 z_cpustates()
1236
1237 {
1238     register int i = 0;
1239     register char **names = cpustate_names;
1240     register char *thisname;
1241     register int *lp;
1242
1243     /* print tag */
1244     display_write(0, y_cpustates, 0, 0, cpustates_tag());
1245
1246     while ((thisname = *names++) != NULL)
1247     {
1248         if (*thisname != '\0')
1249         {
1250             display_fmt(-1, -1, 0, 0, "%s    %% %s", i++ == 0 ? "" : ", ",
1251                         thisname);
1252         }
1253     }
1254
1255     /* fill the "last" array with all -1s, to insure correct updating */
1256     lp = lcpustates;
1257     i = num_cpustates;
1258     while (--i >= 0)
1259     {
1260         *lp++ = -1;
1261     }
1262 }
1263
1264 /*
1265  *  *_kernel(stats) - print "Kernel: " followed by the kernel summary string
1266  *
1267  *  Assumptions:  cursor is on "lastline", the previous line
1268  */
1269
1270 void
1271 i_kernel(int *stats)
1272
1273 {
1274     if (num_kernel > 0)
1275     {
1276         display_write(0, y_kernel, 0, 0, "Kernel: ");
1277
1278         /* format and print the kernel summary */
1279         summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
1280     }
1281 }
1282
1283 void
1284 u_kernel(int *stats)
1285
1286 {
1287     if (num_kernel > 0)
1288     {
1289         /* format the new line */
1290         summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
1291     }
1292 }
1293
1294 /*
1295  *  *_memory(stats) - print "Memory: " followed by the memory summary string
1296  *
1297  *  Assumptions:  cursor is on "lastline", the previous line
1298  */
1299
1300 void
1301 i_memory(long *stats)
1302
1303 {
1304     display_write(0, y_mem, 0, 0, "Memory: ");
1305
1306     /* format and print the memory summary */
1307     summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
1308 }
1309
1310 void
1311 u_memory(long *stats)
1312
1313 {
1314     /* format the new line */
1315     summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
1316 }
1317
1318 /*
1319  *  *_swap(stats) - print "Swap: " followed by the swap summary string
1320  *
1321  *  Assumptions:  cursor is on "lastline", the previous line
1322  *
1323  *  These functions only print something when num_swap > 0
1324  */
1325
1326 void
1327 i_swap(long *stats)
1328
1329 {
1330     if (num_swap > 0)
1331     {
1332         /* print the tag */
1333         display_write(0, y_swap, 0, 0, "Swap: ");
1334
1335         /* format and print the swap summary */
1336         summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
1337     }
1338 }
1339
1340 void
1341 u_swap(long *stats)
1342
1343 {
1344     if (num_swap > 0)
1345     {
1346         /* format the new line */
1347         summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
1348     }
1349 }
1350
1351 /*
1352  *  *_message() - print the next pending message line, or erase the one
1353  *                that is there.
1354  *
1355  *  Note that u_message is (currently) the same as i_message.
1356  *
1357  *  Assumptions:  lastline is consistent
1358  */
1359
1360 /*
1361  *  i_message is funny because it gets its message asynchronously (with
1362  *      respect to screen updates).  Messages are taken out of the
1363  *      circular message_buf and displayed one at a time.
1364  */
1365
1366 void
1367 i_message(struct timeval *now)
1368
1369 {
1370     struct timeval my_now;
1371     int i = 0;
1372
1373     dprintf("i_message(%08x)\n", now);
1374
1375     /* if now is NULL we have to get it ourselves */
1376     if (now == NULL)
1377     {
1378         time_get(&my_now);
1379         now = &my_now;
1380     }
1381
1382     /* now that we have been called, messages no longer need to be held */
1383     message_hold = 0;
1384
1385     dprintf("i_message: now %d, message_time %d\n",
1386             now->tv_sec, message_time.tv_sec);
1387
1388     if (smart_terminal)
1389     {
1390         /* is it time to change the message? */
1391         if (timercmp(now, &message_time, > ))
1392         {
1393             /* yes, free the current message */
1394             dprintf("i_message: timer expired\n");
1395             if (message_current != NULL)
1396             {
1397                 free(message_current);
1398                 message_current = NULL;
1399             }
1400
1401             /* is there a new message to be displayed? */
1402             if (message_first != message_last)
1403             {
1404                 /* move index to next message */
1405                 if (++message_first == MAX_MESSAGES) message_first = 0;
1406
1407                 /* make the next message the current one */
1408                 message_current = message_buf[message_first];
1409
1410                 /* show it */
1411                 dprintf("i_message: showing \"%s\"\n", message_current);
1412                 display_move(0, y_message);
1413                 screen_standout(message_current);
1414                 i = strlen(message_current);
1415
1416                 /* set the expiration timer */
1417                 message_time = *now;
1418                 message_time.tv_sec += MESSAGE_DISPLAY_TIME;
1419
1420                 /* clear the rest of the line */
1421                 screen_cleareol(message_length - i);
1422                 putchar('\r');
1423                 message_length = i;
1424             }
1425             else
1426             {
1427                 /* just clear what was there before, if anything */
1428                 if (message_length > 0)
1429                 {
1430                     display_move(0, y_message);
1431                     screen_cleareol(message_length);
1432                     putchar('\r');
1433                     message_length = 0;
1434                 }
1435             }
1436         }
1437     }
1438 }
1439
1440 void
1441 u_message(struct timeval *now)
1442
1443 {
1444     i_message(now);
1445 }
1446
1447 static int header_length;
1448
1449 /*
1450  *  *_header(text) - print the header for the process area
1451  *
1452  *  Assumptions:  cursor is on the previous line and lastline is consistent
1453  */
1454
1455 void
1456 i_header(char *text)
1457
1458 {
1459     int header_color = 0;
1460
1461 #ifdef ENABLE_COLOR
1462     header_color = color_test(header_cidx, 0);
1463 #endif
1464     header_length = strlen(text);
1465     if (header_status)
1466     {
1467         display_write(x_header, y_header, header_color, 1, text);
1468     }
1469 }
1470
1471 /*ARGSUSED*/
1472 void
1473 u_header(char *text)
1474
1475 {
1476     int header_color = 0;
1477
1478 #ifdef ENABLE_COLOR
1479     header_color = color_test(header_cidx, 0);
1480 #endif
1481     display_write(x_header, y_header, header_color, 1,
1482                   header_status ? text : "");
1483 }
1484
1485 /*
1486  *  *_process(line, thisline) - print one process line
1487  *
1488  *  Assumptions:  lastline is consistent
1489  */
1490
1491 void
1492 i_process(int line, char *thisline)
1493
1494 {
1495     /* truncate the line to conform to our current screen width */
1496     thisline[display_width] = '\0';
1497
1498     /* write the line out */
1499     display_write(0, y_procs + line, 0, 1, thisline);
1500 }
1501
1502 void
1503 u_process(int line, char *new_line)
1504
1505 {
1506     i_process(line, new_line);
1507 }
1508
1509 void
1510 i_endscreen()
1511
1512 {
1513     if (smart_terminal)
1514     {
1515         /* move the cursor to a pleasant place */
1516         display_move(x_idlecursor, y_idlecursor);
1517     }
1518     else
1519     {
1520         /* separate this display from the next with some vertical room */
1521         fputs("\n\n", stdout);
1522     }
1523     fflush(stdout);
1524 }
1525
1526 void
1527 u_endscreen()
1528
1529 {
1530     if (smart_terminal)
1531     {
1532         /* clear-to-end the display */
1533         display_cte();
1534
1535         /* move the cursor to a pleasant place */
1536         display_move(x_idlecursor, y_idlecursor);
1537         fflush(stdout);
1538     }
1539     else
1540     {
1541         /* separate this display from the next with some vertical room */
1542         fputs("\n\n", stdout);
1543     }
1544 }
1545
1546 void
1547 display_header(int t)
1548
1549 {
1550     header_status = t != 0;
1551 }
1552
1553 void
1554 message_mark()
1555
1556 {
1557     message_barrier = Yes;
1558 }
1559
1560 void
1561 message_expire()
1562
1563 {
1564     message_time.tv_sec = 0;
1565     message_time.tv_usec = 0;
1566 }
1567
1568 void
1569 message_flush()
1570
1571 {
1572     message_first = message_last;
1573     message_time.tv_sec = 0;
1574     message_time.tv_usec = 0;
1575 }
1576
1577 /*
1578  * void new_message_v(char *msgfmt, va_list ap)
1579  *
1580  * Display a message in the message area.  This function takes a va_list for
1581  * the arguments.  Safe to call before display_init.  This function only
1582  * queues a message for display, and allowed for multiple messages to be
1583  * queued.  The i_message function drains the queue and actually writes the
1584  * messages on the display.
1585  */
1586
1587
1588 void
1589 new_message_v(char *msgfmt, va_list ap)
1590
1591 {
1592     int i;
1593     int empty;
1594     char msg[MAX_COLS];
1595
1596     /* if message_barrier is active, remove all pending messages */
1597     if (message_barrier)
1598     {
1599         message_flush();
1600         message_barrier = No;
1601     }
1602
1603     /* first, format the message */
1604     (void) vsnprintf(msg, sizeof(msg), msgfmt, ap);
1605
1606     /* where in the buffer will it go? */
1607     i = message_last + 1;
1608     if (i >= MAX_MESSAGES) i = 0;
1609
1610     /* make sure the buffer is not full */
1611     if (i != message_first)
1612     {
1613         /* insert it in to message_buf */
1614         message_buf[i] = strdup(msg);
1615         dprintf("new_message_v: new message inserted in slot %d\n", i);
1616
1617         /* remember if the buffer is empty and set the index */
1618         empty = message_last == message_first;
1619         message_last = i;
1620
1621         /* is message_buf otherwise empty and have we started displaying? */
1622         if (empty && !message_hold)
1623         {
1624             /* we can display the message now */
1625             i_message(NULL);
1626         }
1627     }
1628 }
1629
1630 /*
1631  * void new_message(int type, char *msgfmt, ...)
1632  *
1633  * Display a message in the message area.  It is safe to call this function
1634  * before display_init.  Messages logged before the display is drawn will be
1635  * held and displayed later.
1636  */
1637
1638 void
1639 new_message(char *msgfmt, ...)
1640
1641 {
1642     va_list ap;
1643
1644     va_start(ap, msgfmt);
1645     new_message_v(msgfmt, ap);
1646     va_end(ap);
1647 }
1648
1649 /*
1650  * void message_error(char *msgfmt, ...)
1651  *
1652  * Put an error message in the message area.  It is safe to call this function
1653  * before display_init.  Messages logged before the display is drawn will be
1654  * held and displayed later.
1655  */
1656
1657 void
1658 message_error(char *msgfmt, ...)
1659
1660 {
1661     va_list ap;
1662
1663     va_start(ap, msgfmt);
1664     new_message_v(msgfmt, ap);
1665     fflush(stdout);
1666     va_end(ap);
1667 }
1668
1669 /*
1670  * void message_clear()
1671  *
1672  * Clear message area and flush all pending messages.
1673  */
1674
1675 void
1676 message_clear()
1677
1678 {
1679     /* remove any existing message */
1680     if (message_current != NULL)
1681     {
1682         display_move(0, y_message);
1683         screen_cleareol(message_length);
1684         free(message_current);
1685         message_current = 0;
1686     }
1687
1688     /* flush all pending messages */
1689     message_flush();
1690 }
1691
1692 /*
1693  * void message_prompt_v(int so, char *msgfmt, va_list ap)
1694  *
1695  * Place a prompt in the message area.  A prompt is different from a 
1696  * message as follows: it is displayed immediately, overwriting any
1697  * message that may already be there, it may be highlighted in standout
1698  * mode (if "so" is true), the cursor is left to rest at the end of the
1699  * prompt.  This call causes all pending messages to be flushed.
1700  */
1701
1702 void
1703 message_prompt_v(int so, char *msgfmt, va_list ap)
1704
1705 {
1706     char msg[MAX_COLS];
1707     int i;
1708
1709     /* clear out the message buffer */
1710     message_flush();
1711
1712     /* format the message */
1713     i = vsnprintf(msg, sizeof(msg), msgfmt, ap);
1714
1715     /* this goes over any existing message */
1716     display_move(0, y_message);
1717
1718     /* clear the entire line */
1719     screen_cleareol(message_length);
1720
1721     /* show the prompt */
1722     if (so)
1723     {
1724         screen_standout(msg);
1725     }
1726     else
1727     {
1728         fputs(msg, stdout);
1729     }
1730
1731     /* make it all visible */
1732     fflush(stdout);
1733
1734     /* even though we dont keep a copy of the prompt, track its length */
1735     message_length = i < MAX_COLS ? i : MAX_COLS;
1736 }
1737
1738 /*
1739  * void message_prompt(char *msgfmt, ...)
1740  *
1741  * Place a prompt in the message area (see message_prompt_v).
1742  */
1743
1744 void
1745 message_prompt(char *msgfmt, ...)
1746
1747 {
1748     va_list ap;
1749
1750     va_start(ap, msgfmt);
1751     message_prompt_v(Yes, msgfmt, ap);
1752     va_end(ap);
1753 }
1754
1755 void
1756 message_prompt_plain(char *msgfmt, ...)
1757
1758 {
1759     va_list ap;
1760
1761     va_start(ap, msgfmt);
1762     message_prompt_v(No, msgfmt, ap);
1763     va_end(ap);
1764 }
1765
1766 /*
1767  * int readline(char *buffer, int size, int numeric)
1768  *
1769  * Read a line of input from the terminal.  The line is placed in
1770  * "buffer" not to exceed "size".  If "numeric" is true then the input
1771  * can only consist of digits.  This routine handles all character
1772  * editing while keeping the terminal in cbreak mode.  If "numeric"
1773  * is true then the number entered is returned.  Otherwise the number
1774  * of character read in to "buffer" is returned.
1775  */
1776
1777 int
1778 readline(char *buffer, int size, int numeric)
1779
1780 {
1781     register char *ptr = buffer;
1782     register char ch;
1783     register char cnt = 0;
1784
1785     /* allow room for null terminator */
1786     size -= 1;
1787
1788     /* read loop */
1789     while ((fflush(stdout), read(0, ptr, 1) > 0))
1790     {
1791         /* newline or return means we are done */
1792         if ((ch = *ptr) == '\n' || ch == '\r')
1793         {
1794             break;
1795         }
1796
1797         /* handle special editing characters */
1798         if (ch == ch_kill)
1799         {
1800             /* return null string */
1801             *buffer = '\0';
1802             putchar('\r');
1803             return(-1);
1804         }
1805         else if (ch == ch_werase)
1806         {
1807             /* erase previous word */
1808             if (cnt <= 0)
1809             {
1810                 /* none to erase! */
1811                 putchar('\7');
1812             }
1813             else
1814             {
1815                 /*
1816                  * First: remove all spaces till the first-non-space 
1817                  * Second: remove all non-spaces till the first-space
1818                  */
1819                 while(cnt > 0 && ptr[-1] == ' ')
1820                 {
1821                     fputs("\b \b", stdout);
1822                     ptr--;
1823                     cnt--;
1824                 }
1825                 while(cnt > 0 && ptr[-1] != ' ')
1826                 {
1827                     fputs("\b \b", stdout);
1828                     ptr--;
1829                     cnt--;
1830                 }
1831             }
1832         }
1833         else if (ch == ch_erase)
1834         {
1835             /* erase previous character */
1836             if (cnt <= 0)
1837             {
1838                 /* none to erase! */
1839                 putchar('\7');
1840             }
1841             else
1842             {
1843                 fputs("\b \b", stdout);
1844                 ptr--;
1845                 cnt--;
1846             }
1847         }
1848         /* check for character validity and buffer overflow */
1849         else if (cnt == size || (numeric && !isdigit((int)ch)) ||
1850                 !isprint((int)ch))
1851         {
1852             /* not legal */
1853             putchar('\7');
1854         }
1855         else
1856         {
1857             /* echo it and store it in the buffer */
1858             putchar(ch);
1859             ptr++;
1860             cnt++;
1861         }
1862     }
1863
1864     /* all done -- null terminate the string */
1865     *ptr = '\0';
1866
1867     /* add response length to message_length */
1868     message_length += cnt;
1869
1870     /* return either inputted number or string length */
1871     putchar('\r');
1872     return(cnt == 0 ? -1 : numeric ? atoi(buffer) : cnt);
1873 }
1874
1875 void
1876 display_pagerstart()
1877
1878 {
1879     display_clear();
1880 }
1881
1882 void
1883 display_pagerend()
1884
1885 {
1886     char ch;
1887
1888     screen_standout("Hit any key to continue: ");
1889     fflush(stdout);
1890     (void) read(0, &ch, 1);
1891 }
1892
1893 void
1894 display_pager(char *fmt, ...)
1895
1896 {
1897     va_list ap;
1898
1899     int ch;
1900     char readch;
1901     char buffer[MAX_COLS];
1902     char *data;
1903
1904     /* format into buffer */
1905     va_start(ap, fmt);
1906     (void) vsnprintf(buffer, MAX_COLS, fmt, ap);
1907     va_end(ap);
1908     data = buffer;
1909
1910     while ((ch = *data++) != '\0')
1911     {
1912         putchar(ch);
1913         if (ch == '\n')
1914         {
1915             if (++curr_y >= screen_length - 1)
1916             {
1917                 screen_standout("...More...");
1918                 fflush(stdout);
1919                 (void) read(0, &readch, 1);
1920                 putchar('\r');
1921                 switch(readch)
1922                 {
1923                 case '\r':
1924                 case '\n':
1925                     curr_y--;
1926                     break;
1927
1928                 case 'q':
1929                     return;
1930
1931                 default:
1932                     curr_y = 0;
1933                 }
1934             }
1935         }
1936     }
1937 }