Patrick Welche <prlw1@cam.ac.uk>

[netbsd-mini2440.git] / external / bsd / top / dist / display.c

/*
 * Copyright (c) 1984 through 2008, William LeFebvre
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 * 
 *     * Neither the name of William LeFebvre nor the names of other
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  Top users/processes display for Unix
 *  Version 3
 */

/*
 *  This file contains the routines that display information on the screen.
 *  Each section of the screen has two routines:  one for initially writing
 *  all constant and dynamic text, and one for only updating the text that
 *  changes.  The prefix "i_" is used on all the "initial" routines and the
 *  prefix "u_" is used for all the "updating" routines.
 *
 *  ASSUMPTIONS:
 *        None of the "i_" routines use any of the termcap capabilities.
 *        In this way, those routines can be safely used on terminals that
 *        have minimal (or nonexistant) terminal capabilities.
 *
 *        The routines should be called in this order:  *_loadave, *_uptime,
 *        i_timeofday, *_procstates, *_cpustates, *_memory, *_swap,
 *        *_message, *_header, *_process, *_endscreen.
 */

#include "os.h"
#include <ctype.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

#include "top.h"
#include "machine.h"
#include "screen.h"             /* interface to screen package */
#include "layout.h"             /* defines for screen position layout */
#include "display.h"
#include "boolean.h"
#include "utils.h"

#ifdef ENABLE_COLOR
#include "color.h"
#endif

#define CURSOR_COST 8

#define MESSAGE_DISPLAY_TIME 5

/* imported from screen.c */
extern int overstrike;

static int lmpid = -1;
static int display_width = MAX_COLS;
static int ncpu = 0;

/* cursor positions of key points on the screen are maintained here */
/* layout.h has static definitions, but we may change our minds on some
   of the positions as we make decisions about what needs to be displayed */

static int x_lastpid = X_LASTPID;
static int y_lastpid = Y_LASTPID;
static int x_loadave = X_LOADAVE;
static int y_loadave = Y_LOADAVE;
static int x_minibar = X_MINIBAR;
static int y_minibar = Y_MINIBAR;
static int x_uptime = X_UPTIME;
static int y_uptime = Y_UPTIME;
static int x_procstate = X_PROCSTATE;
static int y_procstate = Y_PROCSTATE;
static int x_cpustates = X_CPUSTATES;
static int y_cpustates = Y_CPUSTATES;
static int x_kernel = X_KERNEL;
static int y_kernel = Y_KERNEL;
static int x_mem = X_MEM;
static int y_mem = Y_MEM;
static int x_swap = X_SWAP;
static int y_swap = Y_SWAP;
static int y_message = Y_MESSAGE;
static int x_header = X_HEADER;
static int y_header = Y_HEADER;
static int x_idlecursor = X_IDLECURSOR;
static int y_idlecursor = Y_IDLECURSOR;
static int y_procs = Y_PROCS;

/* buffer and colormask that describes the content of the screen */
/* these are singly dimensioned arrays -- the row boundaries are
   determined on the fly.
*/
static char *screenbuf = NULL;
static char *colorbuf = NULL;
static char scratchbuf[MAX_COLS];
static int bufsize = 0;
static int multi = 0;

/* lineindex tells us where the beginning of a line is in the buffer */
#define lineindex(l) ((l)*MAX_COLS)

/* screen's cursor */
static int curr_x, curr_y;
static int curr_color;

/* virtual cursor */
static int virt_x, virt_y;

static const char **procstate_names;
static const char **cpustate_names;
static const char **memory_names;
static const char **swap_names;
static const char **kernel_names;

static int num_procstates;
static int num_cpustates;
static int num_memory;
static int num_swap;
static int num_kernel;

static int *lprocstates;
static int *lcpustates;

static int *cpustate_columns;
static int cpustate_total_length;

static int header_status = Yes;

/* pending messages are stored in a circular buffer, where message_first
   is the next one to display, and message_last is the last one
   in the buffer.  Counters wrap around at MAX_MESSAGES.  The buffer is
   empty when message_first == message_last and full when 
   message_last + 1 == message_first.  The pointer message_current holds
   the message currently being displayed, or "" if there is none.
*/
#define MAX_MESSAGES 16
static char *message_buf[MAX_MESSAGES];
static int message_first = 0;
static int message_last = 0;
static struct timeval message_time = {0, 0};
static char *message_current = NULL;
static int message_length = 0;
static int message_hold = 1;
static int message_barrier = No;

#ifdef ENABLE_COLOR
static int load_cidx[3];
static int header_cidx;
static int *cpustate_cidx;
static int *memory_cidx;
static int *swap_cidx;
static int *kernel_cidx;
#else
#define memory_cidx NULL
#define swap_cidx NULL
#define kernel_cidx NULL
#endif


/* internal support routines */

/*
 * static int string_count(char **pp)
 *
 * Pointer "pp" points to an array of string pointers, which is
 * terminated by a NULL.  Return the number of string pointers in
 * this array.
 */

static int
string_count(const char **pp)

{
    register int cnt = 0;

    if (pp != NULL)
    {
        while (*pp++ != NULL)
        {
            cnt++;
        }
    }
    return(cnt);
}

void
display_clear(void)

{
    dprintf("display_clear\n");
    screen_clear();
    memzero(screenbuf, bufsize);
    memzero(colorbuf, bufsize);
    curr_x = curr_y = 0;
}

/*
 * void display_move(int x, int y)
 *
 * Efficiently move the cursor to x, y.  This assumes the cursor is
 * currently located at curr_x, curr_y, and will only use cursor
 * addressing when it is less expensive than overstriking what's
 * already on the screen.
 */

static void
display_move(int x, int y)

{
    char buff[128];
    char *p;
    char *bufp;
    char *colorp;
    int cnt = 0;
    int color = curr_color;

    dprintf("display_move(%d, %d): curr_x %d, curr_y %d\n", x, y, curr_x, curr_y);

    /* are we in a position to do this without cursor addressing? */
    if (curr_y < y || (curr_y == y && curr_x <= x))
    {
        /* start buffering up what it would take to move there by rewriting
           what's on the screen */
        cnt = CURSOR_COST;
        p = buff;

        /* one newline for every line */
        while (cnt > 0 && curr_y < y)
        {
#ifdef ENABLE_COLOR
            if (color != 0)
            {
                p = strcpyend(p, color_setstr(0));
                color = 0;
                cnt -= 5;
            }
#endif
            *p++ = '\n';
            curr_y++;
            curr_x = 0;
            cnt--;
        }

        /* write whats in the screenbuf */
        bufp = &screenbuf[lineindex(curr_y) + curr_x];
        colorp = &colorbuf[lineindex(curr_y) + curr_x];
        while (cnt > 0 && curr_x < x)
        {
#ifdef ENABLE_COLOR
            if (color != *colorp)
            {
                color = *colorp;
                p = strcpyend(p, color_setstr(color));
                cnt -= 5;
            }
#endif
            if ((*p = *bufp) == '\0')
            {
                /* somwhere on screen we haven't been before */
                *p = *bufp = ' ';
            }
            p++;
            bufp++;
            colorp++;
            curr_x++;
            cnt--;
        }
    }

    /* move the cursor */
    if (cnt > 0)
    {
        /* screen rewrite is cheaper */
        *p = '\0';
        fputs(buff, stdout);
        curr_color = color;
    }
    else
    {
        screen_move(x, y);
    }

    /* update our position */
    curr_x = x;
    curr_y = y;
}

/*
 * display_write(int x, int y, int newcolor, int eol, char *new)
 *
 * Optimized write to the display.  This writes characters to the
 * screen in a way that optimizes the number of characters actually
 * sent, by comparing what is being written to what is already on
 * the screen (according to screenbuf and colorbuf).  The string to
 * write is "new", the first character of "new" should appear at
 * screen position x, y.  If x is -1 then "new" begins wherever the
 * cursor is currently positioned.  The string is written with color
 * "newcolor".  If "eol" is true then the remainder of the line is
 * cleared.  It is expected that "new" will have no newlines and no
 * escape sequences.
 */

static void
display_write(int x, int y, int newcolor, int eol, const char *new)

{
    char *bufp;
    char *colorp;
    int ch;
    int diff;

    dprintf("display_write(%d, %d, %d, %d, \"%s\")\n",
            x, y, newcolor, eol, new);

    /* dumb terminal handling here */
    if (!smart_terminal)
    {
        if (x != -1)
        {
            /* make sure we are on the right line */
            while (curr_y < y)
            {
                putchar('\n');
                curr_y++;
                curr_x = 0;
            }

            /* make sure we are on the right column */
            while (curr_x < x)
            {
                putchar(' ');
                curr_x++;
            }
        }

        /* write */
        fputs(new, stdout);
        curr_x += strlen(new);

        return;
    }

    /* adjust for "here" */
    if (x == -1)
    {
        x = virt_x;
        y = virt_y;
    }
    else
    {
        virt_x = x;
        virt_y = y;
    }

    /* a pointer to where we start */
    bufp = &screenbuf[lineindex(y) + x];
    colorp = &colorbuf[lineindex(y) + x];

    /* main loop */
    while ((ch = *new++) != '\0')
    {
        /* if either character or color are different, an update is needed */
        /* but only when the screen is wide enough */
        if (x < display_width && (ch != *bufp || newcolor != *colorp))
        {
            /* check cursor */
            if (y != curr_y || x != curr_x)
            {
                /* have to move the cursor */
                display_move(x, y);
            }

            /* write character */
#ifdef ENABLE_COLOR
            if (curr_color != newcolor)
            {
                fputs(color_setstr(newcolor), stdout);
                curr_color = newcolor;
            }
#endif
            putchar(ch);
            *bufp = ch;
            *colorp = curr_color;
            curr_x++;
        }

        /* move */
        x++;
        virt_x++;
        bufp++;
        colorp++;
    }

    /* eol handling */
    if (eol && *bufp != '\0')
    {
        dprintf("display_write: clear-eol (bufp = \"%s\")\n", bufp);
        /* make sure we are color 0 */
#ifdef ENABLE_COLOR
        if (curr_color != 0)
        {
            fputs(color_setstr(0), stdout);
            curr_color = 0;
        }
#endif

        /* make sure we are at the end */
        if (x != curr_x || y != curr_y)
        {
            screen_move(x, y);
            curr_x = x;
            curr_y = y;
        }

        /* clear to end */
        screen_cleareol(strlen(bufp));

        /* clear out whats left of this line's buffer */
        diff = display_width - x;
        if (diff > 0)
        {
            memzero(bufp, diff);
            memzero(colorp, diff);
        }
    }
}

static void
display_fmt(int x, int y, int newcolor, int eol, const char *fmt, ...)

{
    va_list argp;

    va_start(argp, fmt);

    vsnprintf(scratchbuf, MAX_COLS, fmt, argp);
    display_write(x, y, newcolor, eol, scratchbuf);
}

static void
display_cte(void)

{
    int len;
    int y;
    char *p;
    int need_clear = 0;

    /* is there anything out there that needs to be cleared? */
    p = &screenbuf[lineindex(virt_y) + virt_x];
    if (*p != '\0')
    {
        need_clear = 1;
    }
    else
    {
        /* this line is clear, what about the rest? */
        y = virt_y;
        while (++y < screen_length)
        {
            if (screenbuf[lineindex(y)] != '\0')
            {
                need_clear = 1;
                break;
            }
        }
    }

    if (need_clear)
    {
        dprintf("display_cte: clearing\n");

        /* we will need this later */
        len = lineindex(virt_y) + virt_x;

        /* move to x and y, then clear to end */
        display_move(virt_x, virt_y);
        if (!screen_cte())
        {
            /* screen has no clear to end, so do it by hand */
            p = &screenbuf[len];
            len = strlen(p);
            if (len > 0)
            {
                screen_cleareol(len);
            }
            while (++virt_y < screen_length)
            {
                display_move(0, virt_y);
                p = &screenbuf[lineindex(virt_y)];
                len = strlen(p);
                if (len > 0)
                {
                    screen_cleareol(len);
                }
            }
        }

        /* clear the screenbuf */
        memzero(&screenbuf[len], bufsize - len);
        memzero(&colorbuf[len], bufsize - len);
    }
}

static void
summary_format(int x, int y, int *numbers, const char **names, int *cidx)

{
    register int num;
    register const char *thisname;
    register const char *lastname = NULL;
    register int color;

    /* format each number followed by its string */
    while ((thisname = *names++) != NULL)
    {
        /* get the number to format */
        num = *numbers++;
        color = 0;

        /* display only non-zero numbers */
        if (num != 0)
        {
            /* write the previous name */
            if (lastname != NULL)
            {
                display_write(-1, -1, 0, 0, lastname);
            }

#ifdef ENABLE_COLOR
            if (cidx != NULL)
            {
                /* choose a color */
                color = color_test(*cidx++, num);
            }
#endif

            /* write this number if positive */
            if (num > 0)
            {
                display_write(x, y, color, 0, itoa(num));
            }

            /* defer writing this name */
            lastname = thisname;

            /* next iteration will not start at x, y */
            x = y = -1;
        }
    }

    /* if the last string has a separator on the end, it has to be
       written with care */
    if (lastname != NULL)
    {
        if ((num = strlen(lastname)) > 1 &&
            lastname[num-2] == ',' && lastname[num-1] == ' ')
        {
            display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
        }
        else
        {
            display_write(-1, -1, 0, 1, lastname);
        }
    }
}

static void
summary_format_memory(int x, int y, long *numbers, const char **names, int *cidx)

{
    register long num;
    register int color;
    register const char *thisname;
    register const char *lastname = NULL;

    /* format each number followed by its string */
    while ((thisname = *names++) != NULL)
    {
        /* get the number to format */
        num = *numbers++;
        color = 0;

        /* display only non-zero numbers */
        if (num != 0)
        {
            /* write the previous name */
            if (lastname != NULL)
            {
                display_write(-1, -1, 0, 0, lastname);
            }

            /* defer writing this name */
            lastname = thisname;

#ifdef ENABLE_COLOR
            /* choose a color */
            color = color_test(*cidx++, num);
#endif

            /* is this number in kilobytes? */
            if (thisname[0] == 'K')
            {
                display_write(x, y, color, 0, format_k(num));
                lastname++;
            }
            else
            {
                display_write(x, y, color, 0, itoa((int)num));
            }

            /* next iteration will not start at x, y */
            x = y = -1;
        }
    }

    /* if the last string has a separator on the end, it has to be
       written with care */
    if (lastname != NULL)
    {
        if ((num = strlen(lastname)) > 1 &&
            lastname[num-2] == ',' && lastname[num-1] == ' ')
        {
            display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
        }
        else
        {
            display_write(-1, -1, 0, 1, lastname);
        }
    }
}

/*
 * int display_resize()
 *
 * Reallocate buffer space needed by the display package to accomodate
 * a new screen size.  Must be called whenever the screen's size has
 * changed.  Returns the number of lines available for displaying 
 * processes or -1 if there was a problem allocating space.
 */

int
display_resize()

{
    register int top_lines;
    register int newsize;

    /* calculate the current dimensions */
    /* if operating in "dumb" mode, we only need one line */
    top_lines = smart_terminal ? screen_length : 1;

    /* we don't want more than MAX_COLS columns, since the machine-dependent
       modules make static allocations based on MAX_COLS and we don't want
       to run off the end of their buffers */
    display_width = screen_width;
    if (display_width >= MAX_COLS)
    {
        display_width = MAX_COLS - 1;
    }

    /* see how much space we need */
    newsize = top_lines * (MAX_COLS + 1);

    /* reallocate only if we need more than we already have */
    if (newsize > bufsize)
    {
        /* deallocate any previous buffer that may have been there */
        if (screenbuf != NULL)
        {
            free(screenbuf);
        }
        if (colorbuf != NULL)
        {
            free(colorbuf);
        }

        /* allocate space for the screen and color buffers */
        bufsize = newsize;
        screenbuf = ecalloc(bufsize, sizeof(char));
        colorbuf = ecalloc(bufsize, sizeof(char));
        if (screenbuf == NULL || colorbuf == NULL)
        {
            /* oops! */
            return(-1);
        }
    }
    else
    {
        /* just clear them out */
        memzero(screenbuf, bufsize);
        memzero(colorbuf, bufsize);
    }

    /* for dumb terminals, pretend like we can show any amount */
    if (!smart_terminal)
        return Largest;

    /* adjust total lines on screen to lines available for procs */
    if (top_lines < y_procs)
        return -1;
    top_lines -= y_procs;

    /* return number of lines available */
    return top_lines;
}

int
display_lines()

{
    return(smart_terminal ? screen_length : Largest);
}

int
display_columns()

{
    return(display_width);
}

/*
 * int display_init(struct statics *statics)
 *
 * Initialize the display system based on information in the statics
 * structure.  Returns the number of lines available for displaying
 * processes or -1 if there was an error.
 */

int
display_setmulti(int m)
{
    int i;
    if (m == multi)
        return 0;
    if ((multi = m) != 0) {
        for (i = 1; i < ncpu; i++)
        {
            /* adjust screen placements */
            y_kernel++;
            y_mem++;
            y_swap++;
            y_message++;
            y_header++;
            y_idlecursor++;
            y_procs++;
        }
        return -(ncpu - 1);
    } else {
        for (i = 1; i < ncpu; i++)
        {
            /* adjust screen placements */
            y_kernel--;
            y_mem--;
            y_swap--;
            y_message--;
            y_header--;
            y_idlecursor--;
            y_procs--;
        }
        return (ncpu - 1);
    }
}

int
display_init(struct statics *statics, int percpuinfo)

{
    register int top_lines;
    register const char **pp;
    register char *p;
    register int *ip;
    register int i;

    /* certain things may influence the screen layout,
       so look at those first */

    ncpu = statics->ncpu ? statics->ncpu : 1;
    /* a kernel line shifts parts of the display down */
    kernel_names = statics->kernel_names;
    if ((num_kernel = string_count(kernel_names)) > 0)
    {
        /* adjust screen placements */
        y_mem++;
        y_swap++;
        y_message++;
        y_header++;
        y_idlecursor++;
        y_procs++;
    }

    (void)display_setmulti(percpuinfo);

    /* a swap line shifts parts of the display down one */
    swap_names = statics->swap_names;
    if ((num_swap = string_count(swap_names)) > 0)
    {
        /* adjust screen placements */
        y_message++;
        y_header++;
        y_idlecursor++;
        y_procs++;
    }
    
    /* call resize to do the dirty work */
    top_lines = display_resize();

    /* only do the rest if we need to */
    if (top_lines > -1)
    {
        /* save pointers and allocate space for names */
        procstate_names = statics->procstate_names;
        num_procstates = string_count(procstate_names);
        lprocstates = ecalloc(num_procstates, sizeof(int));

        cpustate_names = statics->cpustate_names;
        num_cpustates = string_count(cpustate_names);
        lcpustates = ecalloc(num_cpustates, sizeof(int) * ncpu);
        cpustate_columns = ecalloc(num_cpustates, sizeof(int));
        memory_names = statics->memory_names;
        num_memory = string_count(memory_names);

        /* calculate starting columns where needed */
        cpustate_total_length = 0;
        pp = cpustate_names;
        ip = cpustate_columns;
        while (*pp != NULL)
        {
            *ip++ = cpustate_total_length;
            if ((i = strlen(*pp++)) > 0)
            {
                cpustate_total_length += i + 8;
            }
        }
    }

#ifdef ENABLE_COLOR
    /* set up color tags for loadavg */
    load_cidx[0] = color_tag("1min");
    load_cidx[1] = color_tag("5min");
    load_cidx[2] = color_tag("15min");

    /* find header color */
    header_cidx = color_tag("header");

    /* color tags for cpu states */
    cpustate_cidx = emalloc(num_cpustates * sizeof(int));
    i = 0;
    p = strcpyend(scratchbuf, "cpu.");
    while (i < num_cpustates)
    {
        strcpy(p, cpustate_names[i]);
        cpustate_cidx[i++] = color_tag(scratchbuf);
    }

    /* color tags for kernel */
    if (num_kernel > 0)
    {
        kernel_cidx = emalloc(num_kernel * sizeof(int));
        i = 0;
        p = strcpyend(scratchbuf, "kernel.");
        while (i < num_kernel)
        {
            strcpy(p, homogenize(kernel_names[i]+1));
            kernel_cidx[i++] = color_tag(scratchbuf);
        }
    }

    /* color tags for memory */
    memory_cidx = emalloc(num_memory * sizeof(int));
    i = 0;
    p = strcpyend(scratchbuf, "memory.");
    while (i < num_memory)
    {
        strcpy(p, homogenize(memory_names[i]+1));
        memory_cidx[i++] = color_tag(scratchbuf);
    }

    /* color tags for swap */
    if (num_swap > 0)
    {
        swap_cidx = emalloc(num_swap * sizeof(int));
        i = 0;
        p = strcpyend(scratchbuf, "swap.");
        while (i < num_swap)
        {
            strcpy(p, homogenize(swap_names[i]+1));
            swap_cidx[i++] = color_tag(scratchbuf);
        }
    }
#endif

    /* return number of lines available (or error) */
    return(top_lines);
}

static void
pr_loadavg(double avg, int i)

{
    int color = 0;

#ifdef ENABLE_COLOR
    color = color_test(load_cidx[i], (int)(avg * 100));
#endif
    display_fmt(x_loadave + X_LOADAVEWIDTH * i, y_loadave, color, 0,
                avg < 10.0 ? " %5.2f" : " %5.1f", avg);
    display_write(-1, -1, 0, 0, (i < 2 ? "," : ";"));
}

void
i_loadave(int mpid, double *avenrun)

{
    register int i;

    /* mpid == -1 implies this system doesn't have an _mpid */
    if (mpid != -1)
    {
        display_fmt(0, 0, 0, 0,
                    "last pid: %5d;  load avg:", mpid);
        x_loadave = X_LOADAVE;
    }
    else
    {
        display_write(0, 0, 0, 0, "load averages:");
        x_loadave = X_LOADAVE - X_LASTPIDWIDTH;
    }
    for (i = 0; i < 3; i++)
    {
        pr_loadavg(avenrun[i], i);
    }

    lmpid = mpid;
}

void
u_loadave(int mpid, double *avenrun)

{
    register int i;

    if (mpid != -1)
    {
        /* change screen only when value has really changed */
        if (mpid != lmpid)
        {
            display_fmt(x_lastpid, y_lastpid, 0, 0,
                        "%5d", mpid);
            lmpid = mpid;
        }
    }

    /* display new load averages */
    for (i = 0; i < 3; i++)
    {
        pr_loadavg(avenrun[i], i);
    }
}

static char minibar_buffer[64];
#define MINIBAR_WIDTH 20

void
i_minibar(int (*formatter)(char *, int))
{
    (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));

    display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
}

void
u_minibar(int (*formatter)(char *, int))
{
    (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));

    display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
}

static int uptime_days;
static int uptime_hours;
static int uptime_mins;
static int uptime_secs;

void
i_uptime(time_t *bt, time_t *tod)

{
    time_t uptime;

    if (*bt != -1)
    {
        uptime = *tod - *bt;
        uptime += 30;
        uptime_days = uptime / 86400;
        uptime %= 86400;
        uptime_hours = uptime / 3600;
        uptime %= 3600;
        uptime_mins = uptime / 60;
        uptime_secs = uptime % 60;

        /*
         *  Display the uptime.
         */

        display_fmt(x_uptime, y_uptime, 0, 0,
                    "  up %d+%02d:%02d:%02d",
                    uptime_days, uptime_hours, uptime_mins, uptime_secs);
    }
}

void
u_uptime(time_t *bt, time_t *tod)

{
    i_uptime(bt, tod);
}


void
i_timeofday(time_t *tod)

{
    /*
     *  Display the current time.
     *  "ctime" always returns a string that looks like this:
     *  
     *  Sun Sep 16 01:03:52 1973
     *  012345678901234567890123
     *            1         2
     *
     *  We want indices 11 thru 18 (length 8).
     */

    int x;

    /* where on the screen do we start? */
    x = (smart_terminal ? screen_width : 79) - 8;

    /* but don't bump in to uptime */
    if (x < x_uptime + 19)
    {
        x = x_uptime + 19;
    }

    /* display it */
    display_fmt(x, 0, 0, 1, "%-8.8s", &(ctime(tod)[11]));
}

static int ltotal = 0;
static int lthreads = 0;

/*
 *  *_procstates(total, brkdn, names) - print the process summary line
 */


void
i_procstates(int total, int *brkdn, int threads)

{
    /* write current number of processes and remember the value */
    display_fmt(0, y_procstate, 0, 0,
                "%d %s: ", total, threads ? "threads" : "processes");
    ltotal = total;

    /* remember where the summary starts */
    x_procstate = virt_x;

    if (total > 0)
    {
        /* format and print the process state summary */
        summary_format(-1, -1, brkdn, procstate_names, NULL);

        /* save the numbers for next time */
        memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
        lthreads = threads;
    }
}

void
u_procstates(int total, int *brkdn, int threads)

{
    /* if threads state has changed, do a full update */
    if (lthreads != threads)
    {
        i_procstates(total, brkdn, threads);
        return;
    }

    /* update number of processes only if it has changed */
    if (ltotal != total)
    {
        display_fmt(0, y_procstate, 0, 0,
                    "%d", total);

        /* if number of digits differs, rewrite the label */
        if (digits(total) != digits(ltotal))
        {
            display_fmt(-1, -1, 0, 0, " %s: ", threads ? "threads" : "processes");
            x_procstate = virt_x;
        }

        /* save new total */
        ltotal = total;
    }

    /* see if any of the state numbers has changed */
    if (total > 0 && memcmp(lprocstates, brkdn, num_procstates * sizeof(int)) != 0)
    {
        /* format and update the line */
        summary_format(x_procstate, y_procstate, brkdn, procstate_names, NULL);
        memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
    }
}

/*
 *  *_cpustates(states, names) - print the cpu state percentages
 */

/* cpustates_tag() calculates the correct tag to use to label the line */

static char *
cpustates_tag(int c)

{
    register const char *use;

    static char fmttag[100];

    const char *short_tag = ncpu > 1 && multi ? "CPU%d: " : "CPU: ";
    const char *long_tag = ncpu > 1 && multi ? "CPU%d states: " : "CPU states: ";

    /* if length + strlen(long_tag) >= screen_width, then we have to
       use the shorter tag (we subtract 2 to account for ": ") */
    if (cpustate_total_length + (int)strlen(long_tag) - 2 - ((ncpu > 1) ? 1 : 0)
        >= screen_width)
    {
        use = short_tag;
    }
    else
    {
        use = long_tag;
    }

    snprintf(fmttag, sizeof(fmttag), use, c);

    /* set x_cpustates accordingly then return result */
    x_cpustates = strlen(fmttag);
    return(fmttag);
}

void
i_cpustates(int *states)

{
    int value;
    const char **names;
    const char *thisname;
    int *colp;
    int color = 0;
#ifdef ENABLE_COLOR
    int *cidx;
#endif
    int c, i;

    if (multi == 0 && ncpu > 1)
    {
        for (c = 1; c < ncpu; c++)
            for (i = 0; i < num_cpustates; i++)
                states[i] += states[c * num_cpustates + i];
        for (i = 0; i < num_cpustates; i++)
            states[i] /= ncpu;
    }

    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
#ifdef ENABLE_COLOR
        cidx = cpustate_cidx;
#endif

        /* print tag */
        display_write(0, y_cpustates + c, 0, 0, cpustates_tag(c));
        colp = cpustate_columns;

        /* now walk thru the names and print the line */
        for (i = 0, names = cpustate_names; ((thisname = *names++) != NULL);)
        {
            if (*thisname != '\0')
            {
                /* retrieve the value and remember it */
                value = *states;

#ifdef ENABLE_COLOR
                /* determine color number to use */
                color = color_test(*cidx++, value/10);
#endif

                /* if percentage is >= 1000, print it as 100% */
                display_fmt(x_cpustates + *colp, y_cpustates + c,
                            color, 0,
                            (value >= 1000 ? "%4.0f%% %s%s" : "%4.1f%% %s%s"),
                            ((float)value)/10.,
                            thisname,
                            *names != NULL ? ", " : "");

            }
            /* increment */
            colp++;
            states++;
        }
    }

    /* copy over values into "last" array */
    memcpy(lcpustates, states, num_cpustates * sizeof(int) * ncpu);
}

void
u_cpustates(int *states)

{
    int value;
    const char **names;
    const char *thisname;
    int *lp;
    int *colp;
    int color = 0;
#ifdef ENABLE_COLOR
    int *cidx;
#endif
    int c, i;

    lp = lcpustates;

    if (multi == 0 && ncpu > 1)
    {
        for (c = 1; c < ncpu; c++)
            for (i = 0; i < num_cpustates; i++)
                states[i] += states[c * num_cpustates + i];
        for (i = 0; i < num_cpustates; i++)
            states[i] /= ncpu;
    }

    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
#ifdef ENABLE_COLOR
        cidx = cpustate_cidx;
#endif
        colp = cpustate_columns;
        /* we could be much more optimal about this */
        for (names = cpustate_names; (thisname = *names++) != NULL;)
        {
            if (*thisname != '\0')
            {
                /* did the value change since last time? */
                if (*lp != *states)
                {
                    /* yes, change it */
                    /* retrieve value and remember it */
                    value = *states;

#ifdef ENABLE_COLOR
                    /* determine color number to use */
                    color = color_test(*cidx, value/10);
#endif

                    /* if percentage is >= 1000, print it as 100% */
                    display_fmt(x_cpustates + *colp, y_cpustates + c, color, 0,
                                (value >= 1000 ? "%4.0f" : "%4.1f"),
                                ((double)value)/10.);

                    /* remember it for next time */
                    *lp = value;
                }
#ifdef ENABLE_COLOR
                cidx++;
#endif
            }

            /* increment and move on */
            lp++;
            states++;
            colp++;
        }
    }
}

void
z_cpustates()

{
    register int i, c;
    register const char **names = cpustate_names;
    register const char *thisname;
    register int *lp;

    /* print tag */
    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
        display_write(0, y_cpustates + c, 0, 0, cpustates_tag(c));

        for (i = 0, names = cpustate_names; (thisname = *names++) != NULL;)
        {
            if (*thisname != '\0')
            {
                display_fmt(-1, -1, 0, 0, "%s    %% %s", i++ == 0 ? "" : ", ",
                            thisname);
            }
        }
    }

    /* fill the "last" array with all -1s, to insure correct updating */
    lp = lcpustates;
    i = num_cpustates * ncpu;
    while (--i >= 0)
    {
        *lp++ = -1;
    }
}

/*
 *  *_kernel(stats) - print "Kernel: " followed by the kernel summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 */

void
i_kernel(int *stats)

{
    if (num_kernel > 0)
    {
        display_write(0, y_kernel, 0, 0, "Kernel: ");

        /* format and print the kernel summary */
        summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
    }
}

void
u_kernel(int *stats)

{
    if (num_kernel > 0)
    {
        /* format the new line */
        summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
    }
}

/*
 *  *_memory(stats) - print "Memory: " followed by the memory summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 */

void
i_memory(long *stats)

{
    display_write(0, y_mem, 0, 0, "Memory: ");

    /* format and print the memory summary */
    summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
}

void
u_memory(long *stats)

{
    /* format the new line */
    summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
}

/*
 *  *_swap(stats) - print "Swap: " followed by the swap summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 *
 *  These functions only print something when num_swap > 0
 */

void
i_swap(long *stats)

{
    if (num_swap > 0)
    {
        /* print the tag */
        display_write(0, y_swap, 0, 0, "Swap: ");

        /* format and print the swap summary */
        summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
    }
}

void
u_swap(long *stats)

{
    if (num_swap > 0)
    {
        /* format the new line */
        summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
    }
}

/*
 *  *_message() - print the next pending message line, or erase the one
 *                that is there.
 *
 *  Note that u_message is (currently) the same as i_message.
 *
 *  Assumptions:  lastline is consistent
 */

/*
 *  i_message is funny because it gets its message asynchronously (with
 *      respect to screen updates).  Messages are taken out of the
 *      circular message_buf and displayed one at a time.
 */

void
i_message(struct timeval *now)

{
    struct timeval my_now;
    int i = 0;

    dprintf("i_message(%08x)\n", now);

    /* if now is NULL we have to get it ourselves */
    if (now == NULL)
    {
        time_get(&my_now);
        now = &my_now;
    }

    /* now that we have been called, messages no longer need to be held */
    message_hold = 0;

    dprintf("i_message: now %d, message_time %d\n",
            now->tv_sec, message_time.tv_sec);

    if (smart_terminal)
    {
        /* is it time to change the message? */
        if (timercmp(now, &message_time, > ))
        {
            /* yes, free the current message */
            dprintf("i_message: timer expired\n");
            if (message_current != NULL)
            {
                free(message_current);
                message_current = NULL;
            }

            /* is there a new message to be displayed? */
            if (message_first != message_last)
            {
                /* move index to next message */
                if (++message_first == MAX_MESSAGES) message_first = 0;

                /* make the next message the current one */
                message_current = message_buf[message_first];

                /* show it */
                dprintf("i_message: showing \"%s\"\n", message_current);
                display_move(0, y_message);
                screen_standout(message_current);
                i = strlen(message_current);

                /* set the expiration timer */
                message_time = *now;
                message_time.tv_sec += MESSAGE_DISPLAY_TIME;

                /* clear the rest of the line */
                screen_cleareol(message_length - i);
                putchar('\r');
                message_length = i;
            }
            else
            {
                /* just clear what was there before, if anything */
                if (message_length > 0)
                {
                    display_move(0, y_message);
                    screen_cleareol(message_length);
                    putchar('\r');
                    message_length = 0;
                }
            }
        }
    }
}

void
u_message(struct timeval *now)

{
    i_message(now);
}

static int header_length;

/*
 *  *_header(text) - print the header for the process area
 *
 *  Assumptions:  cursor is on the previous line and lastline is consistent
 */

void
i_header(char *text)

{
    int header_color = 0;

#ifdef ENABLE_COLOR
    header_color = color_test(header_cidx, 0);
#endif
    header_length = strlen(text);
    if (header_status)
    {
        display_write(x_header, y_header, header_color, 1, text);
    }
}

/*ARGSUSED*/
void
u_header(char *text)

{
    int header_color = 0;

#ifdef ENABLE_COLOR
    header_color = color_test(header_cidx, 0);
#endif
    display_write(x_header, y_header, header_color, 1,
                  header_status ? text : "");
}

/*
 *  *_process(line, thisline) - print one process line
 *
 *  Assumptions:  lastline is consistent
 */

void
i_process(int line, char *thisline)

{
    /* truncate the line to conform to our current screen width */
    thisline[display_width] = '\0';

    /* write the line out */
    display_write(0, y_procs + line, 0, 1, thisline);
}

void
u_process(int line, char *new_line)

{
    i_process(line, new_line);
}

void
i_endscreen()

{
    if (smart_terminal)
    {
        /* move the cursor to a pleasant place */
        display_move(x_idlecursor, y_idlecursor);
    }
    else
    {
        /* separate this display from the next with some vertical room */
        fputs("\n\n", stdout);
    }
    fflush(stdout);
}

void
u_endscreen()

{
    if (smart_terminal)
    {
        /* clear-to-end the display */
        display_cte();

        /* move the cursor to a pleasant place */
        display_move(x_idlecursor, y_idlecursor);
        fflush(stdout);
    }
    else
    {
        /* separate this display from the next with some vertical room */
        fputs("\n\n", stdout);
    }
}

void
display_header(int t)

{
    header_status = t != 0;
}

void
message_mark(void)

{
    message_barrier = Yes;
}

void
message_expire(void)

{
    message_time.tv_sec = 0;
    message_time.tv_usec = 0;
}

static void
message_flush(void)

{
    message_first = message_last;
    message_time.tv_sec = 0;
    message_time.tv_usec = 0;
}

/*
 * void new_message_v(char *msgfmt, va_list ap)
 *
 * Display a message in the message area.  This function takes a va_list for
 * the arguments.  Safe to call before display_init.  This function only
 * queues a message for display, and allowed for multiple messages to be
 * queued.  The i_message function drains the queue and actually writes the
 * messages on the display.
 */


static void
new_message_v(const char *msgfmt, va_list ap)

{
    int i;
    int empty;
    char msg[MAX_COLS];

    /* if message_barrier is active, remove all pending messages */
    if (message_barrier)
    {
        message_flush();
        message_barrier = No;
    }

    /* first, format the message */
    (void) vsnprintf(msg, sizeof(msg), msgfmt, ap);

    /* where in the buffer will it go? */
    i = message_last + 1;
    if (i >= MAX_MESSAGES) i = 0;

    /* make sure the buffer is not full */
    if (i != message_first)
    {
        /* insert it in to message_buf */
        message_buf[i] = estrdup(msg);
        dprintf("new_message_v: new message inserted in slot %d\n", i);

        /* remember if the buffer is empty and set the index */
        empty = message_last == message_first;
        message_last = i;

        /* is message_buf otherwise empty and have we started displaying? */
        if (empty && !message_hold)
        {
            /* we can display the message now */
            i_message(NULL);
        }
    }
}

/*
 * void new_message(int type, char *msgfmt, ...)
 *
 * Display a message in the message area.  It is safe to call this function
 * before display_init.  Messages logged before the display is drawn will be
 * held and displayed later.
 */

void
new_message(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    new_message_v(msgfmt, ap);
    va_end(ap);
}

/*
 * void message_error(char *msgfmt, ...)
 *
 * Put an error message in the message area.  It is safe to call this function
 * before display_init.  Messages logged before the display is drawn will be
 * held and displayed later.
 */

void
message_error(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    new_message_v(msgfmt, ap);
    fflush(stdout);
    va_end(ap);
}

/*
 * void message_clear()
 *
 * Clear message area and flush all pending messages.
 */

void
message_clear()

{
    /* remove any existing message */
    if (message_current != NULL)
    {
        display_move(0, y_message);
        screen_cleareol(message_length);
        free(message_current);
        message_current = 0;
    }

    /* flush all pending messages */
    message_flush();
}

/*
 * void message_prompt_v(int so, char *msgfmt, va_list ap)
 *
 * Place a prompt in the message area.  A prompt is different from a 
 * message as follows: it is displayed immediately, overwriting any
 * message that may already be there, it may be highlighted in standout
 * mode (if "so" is true), the cursor is left to rest at the end of the
 * prompt.  This call causes all pending messages to be flushed.
 */

static void
message_prompt_v(int so, const char *msgfmt, va_list ap)

{
    char msg[MAX_COLS];
    int i;

    /* clear out the message buffer */
    message_flush();

    /* format the message */
    i = vsnprintf(msg, sizeof(msg), msgfmt, ap);

    /* this goes over any existing message */
    display_move(0, y_message);

    /* clear the entire line */
    screen_cleareol(message_length);

    /* show the prompt */
    if (so)
    {
        screen_standout(msg);
    }
    else
    {
        fputs(msg, stdout);
    }

    /* make it all visible */
    fflush(stdout);

    /* even though we dont keep a copy of the prompt, track its length */
    message_length = i < MAX_COLS ? i : MAX_COLS;
}

/*
 * void message_prompt(char *msgfmt, ...)
 *
 * Place a prompt in the message area (see message_prompt_v).
 */

void
message_prompt(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    message_prompt_v(Yes, msgfmt, ap);
    va_end(ap);
}

void
message_prompt_plain(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    message_prompt_v(No, msgfmt, ap);
    va_end(ap);
}

/*
 * int readline(char *buffer, int size, int numeric)
 *
 * Read a line of input from the terminal.  The line is placed in
 * "buffer" not to exceed "size".  If "numeric" is true then the input
 * can only consist of digits.  This routine handles all character
 * editing while keeping the terminal in cbreak mode.  If "numeric"
 * is true then the number entered is returned.  Otherwise the number
 * of character read in to "buffer" is returned.
 */

int
readline(char *buffer, int size, int numeric)

{
    register char *ptr = buffer;
    register char ch;
    register char cnt = 0;

    /* allow room for null terminator */
    size -= 1;

    /* read loop */
    while ((fflush(stdout), read(0, ptr, 1) > 0))
    {
        /* newline or return means we are done */
        if ((ch = *ptr) == '\n' || ch == '\r')
        {
            break;
        }

        /* handle special editing characters */
        if (ch == ch_kill)
        {
            /* return null string */
            *buffer = '\0';
            putchar('\r');
            return(-1);
        }
        else if (ch == ch_werase)
        {
            /* erase previous word */
            if (cnt <= 0)
            {
                /* none to erase! */
                putchar('\7');
            }
            else
            {
                /*
                 * First: remove all spaces till the first-non-space 
                 * Second: remove all non-spaces till the first-space
                 */
                while(cnt > 0 && ptr[-1] == ' ')
                {
                    fputs("\b \b", stdout);
                    ptr--;
                    cnt--;
                }
                while(cnt > 0 && ptr[-1] != ' ')
                {
                    fputs("\b \b", stdout);
                    ptr--;
                    cnt--;
                }
            }
        }
        else if (ch == ch_erase)
        {
            /* erase previous character */
            if (cnt <= 0)
            {
                /* none to erase! */
                putchar('\7');
            }
            else
            {
                fputs("\b \b", stdout);
                ptr--;
                cnt--;
            }
        }
        /* check for character validity and buffer overflow */
        else if (cnt == size || (numeric && !isdigit((int)ch)) ||
                !isprint((int)ch))
        {
            /* not legal */
            putchar('\7');
        }
        else
        {
            /* echo it and store it in the buffer */
            putchar(ch);
            ptr++;
            cnt++;
        }
    }

    /* all done -- null terminate the string */
    *ptr = '\0';

    /* add response length to message_length */
    message_length += cnt;

    /* return either inputted number or string length */
    putchar('\r');
    return(cnt == 0 ? -1 : numeric ? atoi(buffer) : cnt);
}

void
display_pagerstart()

{
    display_clear();
}

void
display_pagerend()

{
    char ch;

    screen_standout("Hit any key to continue: ");
    fflush(stdout);
    (void) read(0, &ch, 1);
}

void
display_pager(const char *fmt, ...)

{
    va_list ap;

    int ch;
    char readch;
    char buffer[MAX_COLS];
    char *data;

    /* format into buffer */
    va_start(ap, fmt);
    (void) vsnprintf(buffer, MAX_COLS, fmt, ap);
    va_end(ap);
    data = buffer;

    while ((ch = *data++) != '\0')
    {
        putchar(ch);
        if (ch == '\n')
        {
            if (++curr_y >= screen_length - 1)
            {
                screen_standout("...More...");
                fflush(stdout);
                (void) read(0, &readch, 1);
                putchar('\r');
                switch(readch)
                {
                case '\r':
                case '\n':
                    curr_y--;
                    break;

                case 'q':
                    return;

                default:
                    curr_y = 0;
                }
            }
        }
    }
}