panel.c

/* PANEL.C      (c) Copyright Roger Bowler, 1999-2012                */
/*              (c) Copyright TurboHercules, SAS 2010-2011           */
/*              Hercules Control Panel Commands                      */
/*                                                                   */
/*   Released under "The Q Public License Version 1"                 */
/*   (http://www.hercules-390.org/herclic.html) as modifications to  */
/*   Hercules.                                                       */

/* z/Architecture support - (c) Copyright Jan Jaeger, 1999-2012      */

/*              Modified for New Panel Display =NP=                  */
/*-------------------------------------------------------------------*/
/* This module is the control panel for the ESA/390 emulator.        */
/* It provides a command interface into hercules, and it displays    */
/* messages that are issued by various hercules components.          */
/*-------------------------------------------------------------------*/

/*-------------------------------------------------------------------*/
/* Additional credits:                                               */
/*      breakpoint command contributed by Dan Horak                  */
/*      devinit command contributed by Jay Maynard                   */
/*      New Panel Display contributed by Dutch Owen                  */
/*      HMC system console commands contributed by Jan Jaeger        */
/*      Set/reset bad frame indicator command by Jan Jaeger          */
/*      attach/detach/define commands by Jan Jaeger                  */
/*      Panel refresh rate triva by Reed H. Petty                    */
/*      64-bit address support by Roger Bowler                       */
/*      Display subchannel command by Nobumichi Kozawa               */
/*      External GUI logic contributed by "Fish" (David B. Trout)    */
/*      Socket Devices originally designed by Malcolm Beattie;       */
/*      actual implementation by "Fish" (David B. Trout).            */
/*-------------------------------------------------------------------*/

#include "hstdinc.h"

#define _PANEL_C_
#define _HENGINE_DLL_

#include "hercules.h"
#include "devtype.h"
#include "opcode.h"
#include "history.h"
// #include "inline.h"
#include "fillfnam.h"
#include "hconsole.h"

#define PANEL_MAX_ROWS  (256)
#define PANEL_MAX_COLS  (256)

int     redraw_msgs;                    /* 1=Redraw message area     */
int     redraw_cmd;                     /* 1=Redraw command line     */
int     redraw_status;                  /* 1=Redraw status line      */

/*=NP================================================================*/
/* Global data for new panel display                                 */
/*   (Note: all NPD mods are identified by the string =NP=           */
/*===================================================================*/

static int    NPDup = 0;               /* 1 = new panel is up       */
static int    NPDinit = 0;             /* 1 = new panel initialized */
static int    NPhelpup = 0;            /* 1 = help panel showing    */
static int    NPhelppaint = 1;         /* 1 = help pnl s/b painted  */
static int    NPhelpdown = 0;          /* 1 = help pnl coming down  */
static int    NPregdisp = 0;           /* which regs are displayed: */
                                       /* 0=gpr, 1=cr, 2=ar, 3=fpr  */
static int    NPcmd = 0;               /* 1 = NP in command mode    */
static int    NPdataentry = 0;         /* 1 = NP in data-entry mode */
static int    NPdevsel = 0;            /* 1 = device being selected */
static char   NPpending;               /* pending data entry cmd    */
static char   NPentered[256];          /* Data which was entered    */
static char   NPprompt1[40];           /* Left bottom screen prompt */
static char   NPoldprompt1[40];        /* Left bottom screen prompt */
static char   NPprompt2[40];           /* Right bottom screen prompt*/
static char   NPoldprompt2[40];        /* Right bottom screen prompt*/
static char   NPsel2;                  /* dev sel part 2 cmd letter */
static char   NPdevice;                /* Which device is selected  */
static int    NPasgn;                  /* Index to dev being init'ed*/
static int    NPlastdev;               /* Number of devices         */
static int    NPcpugraph_ncpu;         /* Number of CPUs to display */

static char  *NPregnum[]   = {" 0"," 1"," 2"," 3"," 4"," 5"," 6"," 7",
                              " 8"," 9","10","11","12","13","14","15"
                             };
static char  *NPregnum64[] = {"0", "1", "2", "3", "4", "5", "6", "7",
                              "8", "9", "A", "B", "C", "D", "E", "F"
                             };

/* Boolean fields; redraw the corresponding data field if false */
static int    NPcpunum_valid,
              NPcpupct_valid,
              NPpsw_valid,
              NPpswstate_valid,
              NPregs_valid,
              NPaddr_valid,
              NPdata_valid,
#ifdef OPTION_MIPS_COUNTING
              NPmips_valid,
              NPsios_valid,
#endif // OPTION_MIPS_COUNTING
              NPdevices_valid,
              NPcpugraph_valid;

/* Current CPU states */
//static U16    NPcpunum;
//static int    NPcpupct;
static int    NPpswmode;
static int    NPpswzhost;
static QWORD  NPpsw;
static char   NPpswstate[16];
static int    NPregmode;
static int    NPregzhost;
static U64    NPregs64[16];
static U32    NPregs[16];
static U32    NPaddress;
static U32    NPdata;
#ifdef OPTION_MIPS_COUNTING
static U32    NPmips;
static U32    NPsios;
#else
static U64    NPinstcount;
#endif // OPTION_MIPS_COUNTING
static int    NPcpugraph;
static int    NPcpugraphpct[MAX_CPU_ENGINES];

/* Current device states */
#define       NP_MAX_DEVICES (PANEL_MAX_ROWS - 3)
static int    NPonline[NP_MAX_DEVICES];
static U16    NPdevnum[NP_MAX_DEVICES];
static int    NPbusy[NP_MAX_DEVICES];
static U16    NPdevtype[NP_MAX_DEVICES];
static int    NPopen[NP_MAX_DEVICES];
static char   NPdevnam[NP_MAX_DEVICES][128];

static short  NPcurrow, NPcurcol;
static int    NPcolorSwitch;
static short  NPcolorFore;
static short  NPcolorBack;
static int    NPdatalen;

static char   *NPhelp[] = {
/*                   1         2         3         4         5         6         7         8 */
/* Line     ....+....0....+....0....+....0....+....0....+....0....+....0....+....0....+....0 */
/*    1 */ "All commands consist of one character keypresses. The various commands are",
/*    2 */ "highlighted onscreen by bright white versus the gray of other lettering.",
/*    3 */ "Disabled buttons, commands and areas are not shown when operating without",
/*    4 */ "defined CPUs (device server only mode).",
/*    5 */ " ",
/*    6 */ "Press the escape key to terminate the control panel and go to command mode.",
/*    7 */ " ",
/*    8 */ "Display Controls:   G - General purpose regs    C - Control regs",
/*    9 */ "                    A - Access registers        F - Floating Point regs",
/*   10 */ "                    I - Display main memory at ADDRESS",
/*   11 */ "CPU controls:       L - IPL                     S - Start CPU",
/*   12 */ "                    E - External interrupt      P - Stop CPU",
/*   13 */ "                    W - Exit Hercules           T - Restart interrupt",
/*   14 */ "Storage update:     R - Enter ADDRESS to be updated",
/*   15 */ "                    D - Enter DATA to be updated at ADDRESS",
/*   16 */ "                    O - place DATA value at ADDRESS",
/*   17 */ " ",
/*   18 */ "Peripherals:        N - enter a new name for the device file assignment",
/*   19 */ "                    U - send an I/O attention interrupt",
/*   20 */ " ",
/*   21 */ "In the display of the first 26 devices, a green device letter means the device",
/*   22 */ "is online, a highlighted device address means the device is busy, and a green",
/*   23 */ "model number means the attached file is open to the device.",
/*   24 */ " ",
/*   25 */ "               Press Escape to return to control panel operations",
"" };

///////////////////////////////////////////////////////////////////////

#define MSG_SIZE     PANEL_MAX_COLS     /* Size of one message       */
#define MAX_MSGS     2048                /* Number of slots in buffer */
//#define MAX_MSGS     300                /* (for testing scrolling)   */
#define MSG_LINES    (cons_rows - 2)    /* #lines in message area    */
#define SCROLL_LINES (MSG_LINES - numkept) /* #of scrollable lines   */
#define CMD_SIZE     256                /* cmdline buffer size       */

#define DEV_LINE        3               /* Line to start devices   */
#define PSW_LINE        2               /* Line to place PSW       */
#define REGS_LINE       5               /* Line to place REGS      */
#define ADDR_LINE       15              /* Line to place Addr/data */
#define BUTTONS_LINE    17              /* Line to place Buttons   */
#define CPU_GRAPH_LINE 20               /* Line to start CPU Graph */

///////////////////////////////////////////////////////////////////////

static int   cons_rows = 0;             /* console height in lines   */
static int   cons_cols = 0;             /* console width in chars    */
static short cur_cons_row = 0;          /* current console row       */
static short cur_cons_col = 0;          /* current console column    */
static char *cons_term = NULL;          /* TERM env value            */
static char  cmdins  = 1;               /* 1==insert mode, 0==overlay*/

static char  cmdline[CMD_SIZE+1];       /* Command line buffer       */
static int   cmdlen  = 0;               /* cmdline data len in bytes */
static int   cmdoff  = 0;               /* cmdline buffer cursor pos */

static int   cursor_on_cmdline = 1;     /* bool: cursor on cmdline   */
static char  saved_cmdline[CMD_SIZE+1]; /* Saved command             */
static int   saved_cmdlen   = 0;        /* Saved cmdline data len    */
static int   saved_cmdoff   = 0;        /* Saved cmdline buffer pos  */
static short saved_cons_row = 0;        /* Saved console row         */
static short saved_cons_col = 0;        /* Saved console column      */

static int   cmdcols = 0;               /* visible cmdline width cols*/
static int   cmdcol  = 0;               /* cols cmdline scrolled righ*/
static FILE *confp   = NULL;            /* Console file pointer      */

///////////////////////////////////////////////////////////////////////

#define CMD_PREFIX_HERC     "herc =====> "
#define CMD_PREFIX_LEN      (strlen(CMD_PREFIX_HERC))
#define CMDLINE_ROW         ((short)(cons_rows-1))
#define CMDLINE_COL         ((short)(CMD_PREFIX_LEN+1))

///////////////////////////////////////////////////////////////////////

#define ADJ_SCREEN_SIZE() \
    do { \
        int rows, cols; \
        get_dim (&rows, &cols); \
        if (rows != cons_rows || cols != cons_cols) { \
            cons_rows = rows; \
            cons_cols = cols; \
            cmdcols = cons_cols - CMDLINE_COL; \
            redraw_msgs = redraw_cmd = redraw_status = 1; \
            NPDinit = 0; \
            clr_screen(); \
        } \
    } while (0)

#define ADJ_CMDCOL() /* (called after modifying cmdoff) */ \
    do { \
        if (cmdoff-cmdcol > cmdcols) { /* past right edge of screen */ \
            cmdcol = cmdoff-cmdcols; \
        } else if (cmdoff < cmdcol) { /* past left edge of screen */ \
            cmdcol = cmdoff; \
        } \
    } while (0)

#define PUTC_CMDLINE() \
    do { \
        ASSERT(cmdcol <= cmdlen); \
        for (i=0; cmdcol+i < cmdlen && i < cmdcols; i++) \
            draw_char (cmdline[cmdcol+i]); \
    } while (0)

///////////////////////////////////////////////////////////////////////

typedef struct _PANMSG      /* Panel message control block structure */
{
    struct _PANMSG*     next;           /* --> next entry in chain   */
    struct _PANMSG*     prev;           /* --> prev entry in chain   */
    int                 msgnum;         /* msgbuf 0-relative entry#  */
    char                msg[MSG_SIZE];  /* text of panel message     */
}
PANMSG;                     /* Panel message control block structure */

static PANMSG*  msgbuf = NULL;          /* Circular message buffer   */
static PANMSG*  topmsg = NULL;          /* message at top of screen  */
static PANMSG*  curmsg = NULL;          /* newest message            */
static int      wrapped = 0;            /* wrapped-around flag       */
static int      numkept = 0;            /* count of kept messages    */
static int      npquiet = 0;            /* screen updating flag      */

///////////////////////////////////////////////////////////////////////

static char *lmsbuf = NULL;             /* xxx                       */
static int   lmsndx = 0;                /* xxx                       */
static int   lmsnum = -1;               /* xxx                       */
static int   lmscnt = -1;               /* xxx                       */
static int   lmsmax = LOG_DEFSIZE/2;    /* xxx                       */
static int   keybfd = -1;               /* Keyboard file descriptor  */

static REGS  copyregs, copysieregs;     /* Copied regs               */

/*-------------------------------------------------------------------*/
/* Screen manipulation primitives                                    */
/*-------------------------------------------------------------------*/

static void beep()
{
    console_beep( confp );
}

static PANMSG* oldest_msg()
{
    return (wrapped) ? curmsg->next : msgbuf;
}

static PANMSG* newest_msg()
{
    return curmsg;
}

static int lines_scrolled()
{
    /* return # of lines 'up' from current line that we're scrolled. */
    if (topmsg->msgnum <= curmsg->msgnum)
        return curmsg->msgnum - topmsg->msgnum;
    return MAX_MSGS - (topmsg->msgnum - curmsg->msgnum);
}

static int visible_lines()
{
    return (lines_scrolled() + 1);
}

static int is_currline_visible()
{
    return (visible_lines() <= SCROLL_LINES);
}

static int lines_remaining()
{
    return (SCROLL_LINES - visible_lines());
}

static void scroll_up_lines( int numlines )
{
    int i;

    for (i=0; i < numlines && topmsg != oldest_msg(); i++)
        topmsg = topmsg->prev;
}

static void scroll_down_lines( int numlines )
{
    int i;

    for (i=0; i < numlines && topmsg != newest_msg(); i++)
    {
        if (topmsg != newest_msg())
            topmsg = topmsg->next;
    }
}

static void page_up()
{
    scroll_up_lines( SCROLL_LINES - 1 );
}
static void page_down()
{
    scroll_down_lines( SCROLL_LINES - 1 );
}

static void scroll_to_top_line()
{
    topmsg = oldest_msg();
}

static void scroll_to_bottom_line()
{
    while (topmsg != newest_msg())
        scroll_down_lines( 1 );
}

static void scroll_to_bottom_screen()
{
    scroll_to_bottom_line();
    page_up();
}

static void do_panel_command( void* cmd )
{
    char *cmdsep;
    if (!is_currline_visible())
        scroll_to_bottom_screen();
    if (cmd != (void*)cmdline)
        strlcpy( cmdline, cmd, sizeof(cmdline) );
    if ( sysblk.cmdsep != NULL &&
         strlen(sysblk.cmdsep) == 1 &&
         strstr(cmdline, sysblk.cmdsep) != NULL )
    {
        char *command;
        char *strtok_str = NULL;

        command = strdup(cmdline);

        cmdsep = strtok_r(cmdline, sysblk.cmdsep, &strtok_str);
        while ( cmdsep != NULL )
        {
            panel_command( cmdsep );
            cmdsep = strtok_r(NULL, sysblk.cmdsep, &strtok_str);
        }

        history_add( command );
        free(command);
    }
    else
        panel_command( cmdline );
    cmdline[0] = '\0';
    cmdlen = 0;
    cmdoff = 0;
    ADJ_CMDCOL();
}

static void do_prev_history()
{
    if (history_prev() != -1)
    {
        strlcpy(cmdline, historyCmdLine, sizeof(cmdline) );
        cmdlen = (int)strlen(cmdline);
        cmdoff = cmdlen < cmdcols ? cmdlen : 0;
        ADJ_CMDCOL();
    }
}

static void do_next_history()
{
    if (history_next() != -1)
    {
        strlcpy(cmdline, historyCmdLine, sizeof(cmdline) );
        cmdlen = (int)strlen(cmdline);
        cmdoff = cmdlen < cmdcols ? cmdlen : 0;
        ADJ_CMDCOL();
    }
}

static void clr_screen ()
{
    clear_screen (confp);
}

static void get_dim (int *y, int *x)
{
    get_console_dim( confp, y, x);
    if (*y > PANEL_MAX_ROWS)
        *y = PANEL_MAX_ROWS;
    if (*x > PANEL_MAX_COLS)
        *x = PANEL_MAX_COLS;
#if defined(WIN32) && !defined( _MSVC_ )
   /* If running from a cygwin command prompt we do
     * better with one less row.
     */
    if (!cons_term || strcmp(cons_term, "xterm"))
        (*y)--;
#endif // defined(WIN32) && !defined( _MSVC_ )
}

static void set_color (short fg, short bg)
{
    set_screen_color (confp, fg, bg);
}

static void set_pos (short y, short x)
{
    cur_cons_row = y;
    cur_cons_col = x;
    y = y < 1 ? 1 : y > cons_rows ? cons_rows : y;
    x = x < 1 ? 1 : x > cons_cols ? cons_cols : x;
    set_screen_pos (confp, y, x);
}

static int is_cursor_on_cmdline()
{
#if defined(OPTION_EXTCURS)
    get_cursor_pos( keybfd, confp, &cur_cons_row, &cur_cons_col );
    cursor_on_cmdline =
    (1
        && cur_cons_row == CMDLINE_ROW
        && cur_cons_col >= CMDLINE_COL
        && cur_cons_col <= CMDLINE_COL + cmdcols
    );
#else // !defined(OPTION_EXTCURS)
    cursor_on_cmdline = 1;
#endif // defined(OPTION_EXTCURS)
    return cursor_on_cmdline;
}

static void cursor_cmdline_home()
{
    cmdoff = 0;
    ADJ_CMDCOL();
    set_pos( CMDLINE_ROW, CMDLINE_COL );
}

static void cursor_cmdline_end()
{
    cmdoff = cmdlen;
    ADJ_CMDCOL();
    set_pos( CMDLINE_ROW, CMDLINE_COL + cmdoff - cmdcol );
}

static void save_command_line()
{
    memcpy( saved_cmdline, cmdline, sizeof(saved_cmdline) );
    saved_cmdlen = cmdlen;
    saved_cmdoff = cmdoff;
    saved_cons_row = cur_cons_row;
    saved_cons_col = cur_cons_col;
}

static void restore_command_line()
{
    memcpy( cmdline, saved_cmdline, sizeof(cmdline) );
    cmdlen = saved_cmdlen;
    cmdoff = saved_cmdoff;
    cur_cons_row = saved_cons_row;
    cur_cons_col = saved_cons_col;
}

static void draw_text (char *text)
{
    int   len;
    char *short_text;

    if (cur_cons_row < 1 || cur_cons_row > cons_rows
     || cur_cons_col < 1 || cur_cons_col > cons_cols)
        return;
    len = (int)strlen(text);
    if ((cur_cons_col + len - 1) <= cons_cols)
        fprintf (confp, "%s", text);
    else
    {
        len = cons_cols - cur_cons_col + 1;
        if ((short_text = strdup(text)) == NULL)
            return;
        short_text[len] = '\0';
        fprintf (confp, "%s", short_text);
        free (short_text);
    }
    cur_cons_col += len;
}

static void write_text (char *text, int size)
{
    if (cur_cons_row < 1 || cur_cons_row > cons_rows
     || cur_cons_col < 1 || cur_cons_col > cons_cols)
        return;
    if (cons_cols - cur_cons_col + 1 < size)
        size = cons_cols - cur_cons_col + 1;
    fwrite (text, size, 1, confp);
    cur_cons_col += size;
}

static void draw_char (int c)
{
    if (cur_cons_row < 1 || cur_cons_row > cons_rows
     || cur_cons_col < 1 || cur_cons_col > cons_cols)
        return;
    fputc (c, confp);
    cur_cons_col++;
}

static void draw_fw (U32 fw)
{
    char buf[9];
    snprintf (buf, sizeof(buf), "%8.8X", fw);
    draw_text (buf);
}

static void draw_dw (U64 dw)
{
    char buf[17];
    snprintf (buf, sizeof(buf), "%16.16"PRIX64, dw);
    draw_text (buf);
}

static void fill_text (char c, short x)
{
    char buf[PANEL_MAX_COLS+1];
    int  len;

    if (x > PANEL_MAX_COLS) x = PANEL_MAX_COLS;
    len = x + 1 - cur_cons_col;
    if (len <= 0) return;
    memset( buf, c, len );
    buf[len] = '\0';
    draw_text (buf);
}

static void draw_button (short bg, short fg, short hfg, char *left, char *mid, char *right)
{
    set_color (fg, bg);
    draw_text (left);
    set_color (hfg, bg);
    draw_text (mid);
    set_color (fg, bg);
    draw_text (right);
}

void set_console_title ( char *status )
{
    char    title[256];

    if ( sysblk.daemon_mode ) return;

    redraw_status = 1;

    if ( !sysblk.pantitle && ( !status || strlen(status) == 0 ) ) return;

    if ( !sysblk.pantitle )
    {
        char msgbuf[256];
        char sysname[16] = { 0 };
        char sysplex[16] = { 0 };
        char systype[16] = { 0 };
        char lparnam[16] = { 0 };

        memset( msgbuf, 0, sizeof(msgbuf) );

        strlcat(systype,str_systype(),sizeof(systype));
        strlcat(sysname,str_sysname(),sizeof(sysname));
        strlcat(sysplex,str_sysplex(),sizeof(sysplex));
        strlcat(lparnam,str_lparname(),sizeof(lparnam));

        if ( strlen(lparnam)+strlen(systype)+strlen(sysname)+strlen(sysplex) > 0 )
        {
            if ( strlen(lparnam) > 0 )
            {
                strlcat(msgbuf, lparnam, sizeof(msgbuf));
                if ( strlen(systype)+strlen(sysname)+strlen(sysplex) > 0 )
                    strlcat(msgbuf, " - ", sizeof(msgbuf));
            }
            if ( strlen(systype) > 0 )
            {
                strlcat(msgbuf, systype, sizeof(msgbuf));
                if ( strlen(sysname)+strlen(sysplex) > 0 )
                    strlcat(msgbuf, " * ", sizeof(msgbuf));
            }
            if ( strlen(sysname) > 0 )
            {
                strlcat(msgbuf, sysname, sizeof(msgbuf));
                if ( strlen(sysplex) > 0 )
                    strlcat(msgbuf, " * ", sizeof(msgbuf));
            }
            if ( strlen(sysplex) > 0 )
            {
                strlcat(msgbuf, sysplex, sizeof(msgbuf));
            }

            MSGBUF( title, "%s - System Status: %s", msgbuf, status );
        }
        else
        {
            MSGBUF( title, "System Status: %s", status );
        }
    }
    else
    {
        if ( !status || strlen(status) == 0 )
            MSGBUF( title, "%s", sysblk.pantitle );
        else
            MSGBUF( title, "%s - System Status: %s", sysblk.pantitle, status );
    }

  #if defined( _MSVC_ )
    w32_set_console_title( title );
  #else /*!defined(_MSVC_) */
    /* For Unix systems we set the window title by sending a special
       escape sequence (depends on terminal type) to the console.
       See http://www.faqs.org/docs/Linux-mini/Xterm-Title.html */
    if (!cons_term) return;
    if (strcmp(cons_term,"xterm")==0
     || strcmp(cons_term,"rxvt")==0
     || strcmp(cons_term,"dtterm")==0
     || strcmp(cons_term,"screen")==0)
    {
        fprintf( confp, "%c]0;%s%c", '\033', title, '\007' );
    }
  #endif /*!defined(_MSVC_) */
}

/*=NP================================================================*/
/*  Initialize the NP data                                           */
/*===================================================================*/

static void NP_init()
{
    NPdataentry = 0;
    strlcpy(NPprompt1, "", sizeof(NPprompt1));
    strlcpy(NPprompt2, "", sizeof(NPprompt2));
}

/*=NP================================================================*/
/*  This draws the initial screen template                           */
/*===================================================================*/

static void NP_screen_redraw (REGS *regs)
{
    int  i, line;
    char buf[1024];

    /* Force all data to be redrawn */
    NPcpunum_valid   = NPcpupct_valid   = NPpsw_valid  =
    NPpswstate_valid = NPregs_valid     = NPaddr_valid =
    NPdata_valid     =
    NPdevices_valid  = NPcpugraph_valid = 0;
#if defined(OPTION_MIPS_COUNTING)
    NPmips_valid     = NPsios_valid     = 0;
#endif /*defined(OPTION_MIPS_COUNTING)*/

#if defined(_FEATURE_SIE)
    if(regs->sie_active)
        regs = regs->guestregs;
#endif /*defined(_FEATURE_SIE)*/

    /*
     * Draw the static parts of the NP screen
     */
    set_color (COLOR_LIGHT_GREY, COLOR_BLACK );
    clr_screen ();

    /* Line 1 - title line */
    set_color (COLOR_WHITE, COLOR_BLUE );
    set_pos   (1, 1);
    draw_text ("  Hercules");
    if (sysblk.hicpu)
    {
        fill_text (' ', 16);
        draw_text ("CPU:    %");
        fill_text (' ', 30);
        draw_text ((char *)get_arch_mode_string(NULL));
    }

    set_color (COLOR_LIGHT_GREY, COLOR_BLUE);
    fill_text (' ', 38);
    draw_text ("| ");
    set_color (COLOR_WHITE, COLOR_BLUE);

#if defined(OPTION_SHARED_DEVICES)

    /* Center "Peripherals" on the right-hand-side */
    i = 40 + snprintf(buf, sizeof(buf),
                      "Peripherals [Shared Port %u]",
                      sysblk.shrdport);
    if ((cons_cols < i) || !sysblk.shrdport)
        i = 52, buf[11] = 0;            /* Truncate string */
    if (cons_cols > i)                  /* Center string   */
        fill_text (' ', 40 + ((cons_cols - i) / 2));
    draw_text (buf);
    fill_text (' ', (short)cons_cols);

#endif // defined(OPTION_SHARED_DEVICES)

    /* Line 2 - peripheral headings */
    set_pos (2, 41);
    set_color (COLOR_WHITE, COLOR_BLACK);
    draw_char ('U');
    set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
    draw_text(" Addr Modl Type Assig");
    set_color (COLOR_WHITE, COLOR_BLACK);
    draw_char ('n');
    set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
    draw_text("ment");

    if (sysblk.hicpu)
    {
        /* PSW_LINE = PSW */
        NPpswmode = (regs->arch_mode == ARCH_900);
        NPpswzhost =
#if defined(_FEATURE_SIE)
                     !NPpswmode && SIE_MODE(regs) && regs->hostregs->arch_mode == ARCH_900;
#else
                     0;
#endif /*defined(_FEATURE_SIE)*/
        set_pos (PSW_LINE+1, NPpswmode || NPpswzhost ? 19 : 10);
        draw_text ("PSW");

        /* Register area */
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        NPregmode = (regs->arch_mode == ARCH_900 && (NPregdisp == 0 || NPregdisp == 1));
        NPregzhost =
#if defined(_FEATURE_SIE)
                     (regs->arch_mode != ARCH_900
                   && SIE_MODE(regs) && regs->hostregs->arch_mode == ARCH_900
                   && (NPregdisp == 0 || NPregdisp == 1));
#else
                     0;
#endif /*defined(_FEATURE_SIE)*/
        if (NPregmode == 1 || NPregzhost)
        {
            for (i = 0; i < 8; i++)
            {
                set_pos (REGS_LINE+i, 1);
                draw_text (NPregnum64[i*2]);
                set_pos (REGS_LINE+i, 20);
                draw_text (NPregnum64[i*2+1]);
            }
        }
        else
        {
            for (i = 0; i < 4; i++)
            {
                set_pos (i*2+(REGS_LINE+1),9);
                draw_text (NPregnum[i*4]);
                set_pos (i*2+(REGS_LINE+1),18);
                draw_text (NPregnum[i*4+1]);
                set_pos (i*2+(REGS_LINE+1),27);
                draw_text (NPregnum[i*4+2]);
                set_pos (i*2+(REGS_LINE+1),36);
                draw_text (NPregnum[i*4+3]);
            }
        }

        /* Register selection */
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        set_pos ((REGS_LINE+8), 6);
        draw_text ("GPR");
        set_pos ((REGS_LINE+8), 14);
        draw_text ("CR");
        set_pos ((REGS_LINE+8), 22);
        draw_text ("AR");
        set_pos ((REGS_LINE+8), 30);
        draw_text ("FPR");

        /* Address and data */
        set_pos (ADDR_LINE, 2);
        draw_text ("ADD");
        set_color (COLOR_WHITE, COLOR_BLACK);
        draw_char ('R');
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        draw_text ("ESS:");
        set_pos (ADDR_LINE, 22);
        set_color (COLOR_WHITE, COLOR_BLACK);
        draw_char ('D');
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        draw_text ("ATA:");
    }
    else
    {
        set_pos (8, 12);
        set_color (COLOR_LIGHT_RED, COLOR_BLACK);
        draw_text ("No CPUs defined");
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
    }

    /* separator */
    set_pos (ADDR_LINE+1, 1);
    fill_text ('-', 38);

    /* Buttons */

    if (sysblk.hicpu)
    {
        set_pos (BUTTONS_LINE, 16);
        draw_button(COLOR_BLUE,  COLOR_LIGHT_GREY, COLOR_WHITE,  " ST", "O", " "  );
        set_pos (BUTTONS_LINE, 24);
        draw_button(COLOR_BLUE,  COLOR_LIGHT_GREY, COLOR_WHITE,  " D",  "I", "S " );
        set_pos (BUTTONS_LINE, 32);
        draw_button(COLOR_BLUE,  COLOR_LIGHT_GREY, COLOR_WHITE,  " RS", "T", " "  );
    }

#if defined(OPTION_MIPS_COUNTING)
    if (sysblk.hicpu)
    {
        set_pos ((BUTTONS_LINE+1), 3);
        set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        draw_text ("MIPS");
    }

    if (0
        || sysblk.hicpu
#if defined(OPTION_SHARED_DEVICES)
        || sysblk.shrdport
#endif // defined(OPTION_SHARED_DEVICES)
    )
    {
        set_pos ((BUTTONS_LINE+1), 10);
        draw_text ("IO/s");
    }
#endif /*defined(OPTION_MIPS_COUNTING)*/

    if (sysblk.hicpu)
    {
        set_pos ((BUTTONS_LINE+2), 2);
        draw_button(COLOR_GREEN, COLOR_LIGHT_GREY, COLOR_WHITE,  " ",   "S", "TR ");
        set_pos ((BUTTONS_LINE+2), 9);
        draw_button(COLOR_RED,   COLOR_LIGHT_GREY, COLOR_WHITE,  " ST", "P", " "  );
        set_pos ((BUTTONS_LINE+2), 16);
        draw_button(COLOR_BLUE,  COLOR_LIGHT_GREY, COLOR_WHITE,  " ",   "E", "XT ");
        set_pos ((BUTTONS_LINE+2), 24);
        draw_button(COLOR_BLUE,  COLOR_LIGHT_GREY, COLOR_WHITE,  " IP", "L", " "  );
    }

    set_pos ((BUTTONS_LINE+2), 32);
    draw_button(COLOR_RED,   COLOR_LIGHT_GREY, COLOR_WHITE,  " P",  "W", "R " );

    set_color (COLOR_LIGHT_GREY, COLOR_BLACK);

    /* CPU busy graph */
    line = CPU_GRAPH_LINE;                          // this is where the dashes start
    NPcpugraph_ncpu = MIN(cons_rows - line - 1, sysblk.hicpu);
    set_pos (line++, 1);
    fill_text ('-', 38);
    if (sysblk.hicpu)
    {
        NPcpugraph = 1;
        NPcpugraph_valid = 0;
        for (i = 0; i < NPcpugraph_ncpu; i++)
        {
            snprintf (buf, sizeof(buf), "%s%02X ", PTYPSTR(i), i);
            set_pos (line++, 1);
            draw_text (buf);
        }
    }
    else
        NPcpugraph = 0;

    /* Vertical separators */
    for (i = 2; i <= cons_rows; i++)
    {
        set_pos (i , 39);
        draw_char ('|');
    }

    /* Last line : horizontal separator */
    if (cons_rows >= 24)
    {
        set_pos (cons_rows, 1);
        fill_text ('-', 38);
        draw_char ('|');
        fill_text ('-', cons_cols);
    }

    /* positions the cursor */
    set_pos (cons_rows, cons_cols);
}

static char *format_int(uint64_t ic)
{
    static char     obfr[32];   /* Enough for displaying 2^64-1 */
    char            grps[7][4]; /* 7 groups of 3 digits */
    int             maxg=0;
    int             i;

    strlcpy(grps[0],"0",sizeof(grps[0]) );
    while(ic>0)
    {
        int grp;
        grp=ic%1000;
        ic/=1000;
        if(ic==0)
        {
            snprintf(grps[maxg],sizeof(grps[maxg]),"%u",grp);
            grps[maxg][sizeof(grps[maxg])-1] = '\0';
        }
        else
        {
            snprintf(grps[maxg],sizeof(grps[maxg]),"%3.3u",grp);
            grps[maxg][sizeof(grps[maxg])-1] = '\0';
        }
        maxg++;
    }
    if(maxg) maxg--;
    obfr[0]=0;
    for(i=maxg;i>=0;i--)
    {
        strlcat(obfr,grps[i],sizeof(obfr));
        if(i)
        {
            strlcat(obfr,",",sizeof(obfr));
        }
    }
    return obfr;
}

/*=NP================================================================*/
/*  This refreshes the screen with new data every cycle              */
/*===================================================================*/

static void NP_update(REGS *regs)
{
    int     i, n;
    int     mode, zhost;
    int     cpupct_total;
    QWORD   curpsw;
    U32     addr, aaddr;
    DEVBLK *dev;
    int     online, busy, open;
    char   *devclass;
    char    devnam[MAX_PATH];
    char    buf[1024];

    if (NPhelpup == 1)
    {
        if (NPhelpdown == 1)
        {
             NP_init();
             NP_screen_redraw(regs);
             NPhelpup = 0;
             NPhelpdown = 0;
             NPhelppaint = 1;
        }
        else
        {
            if (NPhelppaint)
            {
                set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
                clr_screen ();
                for (i = 0; *NPhelp[i]; i++)
                {
                    set_pos (i+1, 1);
                    draw_text (NPhelp[i]);
                }
                NPhelppaint = 0;
            }
            return;
        }
    }

#if defined(_FEATURE_SIE)
    if(SIE_MODE(regs))
        regs = regs->hostregs;
#endif /*defined(_FEATURE_SIE)*/

#if defined(OPTION_MIPS_COUNTING)
    /* percent CPU busy */
    if (sysblk.hicpu)
    {
        cpupct_total = 0;
        n = 0;
        for ( i = 0; i < sysblk.maxcpu; i++ )
            if ( IS_CPU_ONLINE(i) )
                if ( sysblk.regs[i]->cpustate == CPUSTATE_STARTED )
                {
                    n++;
                    cpupct_total += sysblk.regs[i]->cpupct;
                }
        set_color (COLOR_WHITE, COLOR_BLUE);
        set_pos (1, 22);
        snprintf(buf, sizeof(buf), "%3d", (n > 0 ? cpupct_total/n : 0));
        draw_text (buf);
    }
#else // !defined(OPTION_MIPS_COUNTING)
    if (!NPcpupct_valid)
    {
        set_color (COLOR_WHITE, COLOR_BLUE);
        set_pos (1, 21);
        draw_text ("     ");
        NPcpupct_valid = 1;
    }
#endif /*defined(OPTION_MIPS_COUNTING)*/

    if (sysblk.hicpu)
    {
#if defined(_FEATURE_SIE)
        if(regs->sie_active)
            regs = regs->guestregs;
#endif /*defined(_FEATURE_SIE)*/

        mode = (regs->arch_mode == ARCH_900);
        zhost =
#if defined(_FEATURE_SIE)
                !mode && SIE_MODE(regs) && regs->hostregs->arch_mode == ARCH_900;
#else // !defined(_FEATURE_SIE)
                0;
#endif // defined(_FEATURE_SIE)

        /* Redraw the psw template if the mode changed */
        if (NPpswmode != mode || NPpswzhost != zhost)
        {
            NPpswmode = mode;
            NPpswzhost = zhost;
            NPpsw_valid = NPpswstate_valid = 0;
            set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
            set_pos (PSW_LINE, 1);
            fill_text (' ',38);
            set_pos (PSW_LINE+1, 1);
            fill_text (' ', 38);
            set_pos (PSW_LINE+1, NPpswmode || NPpswzhost ? 19 : 10);
            draw_text ("PSW");
        }

        /* Display the psw */
        memset(curpsw, 0, sizeof(QWORD));
        copy_psw (regs, curpsw);
        if (!NPpsw_valid || memcmp(NPpsw, curpsw, sizeof(QWORD)))
        {
            set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
            set_pos (PSW_LINE, 3);
            if (mode)
            {
                draw_dw (fetch_dw(curpsw));
                set_pos (PSW_LINE, 22);
                draw_dw (fetch_dw(curpsw+8));
            }
            else if (zhost)
            {
                draw_fw (fetch_fw(curpsw));
//              draw_fw (0);
                draw_fw (fetch_fw(curpsw+4)); /* *JJ */
                set_pos (PSW_LINE, 22);
//              draw_fw (fetch_fw(curpsw+4) & 0x80000000 ? 0x80000000 : 0);
//              draw_fw (fetch_fw(curpsw+4) & 0x7fffffff);
                draw_text("----------------"); /* *JJ */
            }
            else
            {
                draw_fw (fetch_fw(curpsw));
                set_pos (PSW_LINE, 12);
                draw_fw (fetch_fw(curpsw+4));
            }
            NPpsw_valid = 1;
            memcpy (NPpsw, curpsw, sizeof(QWORD));
        }

        /* Display psw state */
        snprintf (buf, sizeof(buf), "%2d%c%c%c%c%c%c%c%c",
                      regs->psw.amode64                  ? 64  :
                      regs->psw.amode                    ? 31  : 24,
                      regs->cpustate == CPUSTATE_STOPPED ? 'M' : '.',
                      sysblk.inststep                    ? 'T' : '.',
                      WAITSTATE (&regs->psw)             ? 'W' : '.',
                      regs->loadstate                    ? 'L' : '.',
                      regs->checkstop                    ? 'C' : '.',
                      PROBSTATE(&regs->psw)              ? 'P' : '.',
                      SIE_MODE(regs)                     ? 'S' : '.',
                      mode                               ? 'Z' : '.');
        if (!NPpswstate_valid || strcmp(NPpswstate, buf))
        {
            set_color( COLOR_LIGHT_YELLOW, COLOR_BLACK );
            set_pos( mode || zhost ? (PSW_LINE+1) : PSW_LINE, 28 );
            draw_text( buf );
            NPpswstate_valid = 1;
            strlcpy( NPpswstate, buf, sizeof(NPpswstate) );
        }

        /* Redraw the register template if the regmode switched */
        mode = (regs->arch_mode == ARCH_900 && (NPregdisp == 0 || NPregdisp == 1));
        zhost =
#if defined(_FEATURE_SIE)
                (regs->arch_mode != ARCH_900
              && SIE_MODE(regs) && regs->hostregs->arch_mode == ARCH_900
              && (NPregdisp == 0 || NPregdisp == 1));
#else // !defined(_FEATURE_SIE)
                     0;
#endif /*defined(_FEATURE_SIE)*/
        if (NPregmode != mode || NPregzhost != zhost)
        {
            NPregmode = mode;
            NPregzhost = zhost;
            NPregs_valid = 0;
            set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
            if (NPregmode || NPregzhost)
            {
                /* 64 bit registers */
                for (i = 0; i < 8; i++)
                {
                    set_pos (REGS_LINE+i, 1);
                    fill_text (' ', 38);
                    set_pos (REGS_LINE+i, 1);
                    draw_text (NPregnum64[i*2]);
                    set_pos (REGS_LINE+i, 20);
                    draw_text (NPregnum64[i*2+1]);
                }
            }
            else
            {
                /* 32 bit registers */
                for (i = 0; i < 4; i++)
                {
                    set_pos (i*2+REGS_LINE,1);
                    fill_text (' ', 38);
                    set_pos (i*2+(REGS_LINE+1),1);
                    fill_text (' ', 38);
                    set_pos (i*2+(REGS_LINE+1),9);
                    draw_text (NPregnum[i*4]);
                    set_pos (i*2+(REGS_LINE+1),18);
                    draw_text (NPregnum[i*4+1]);
                    set_pos (i*2+(REGS_LINE+1),27);
                    draw_text (NPregnum[i*4+2]);
                    set_pos (i*2+(REGS_LINE+1),36);
                    draw_text (NPregnum[i*4+3]);
                }
            }
        }

        /* Display register values */
        set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK );
        if (NPregmode)
        {
            /* 64 bit registers */
            for (i = 0; i < 16; i++)
            {
                switch (NPregdisp) {
                case 0:
                    if (!NPregs_valid || NPregs64[i] != regs->GR_G(i))
                    {
                        set_pos (REGS_LINE + i/2, 3 + (i%2)*19);
                        draw_dw (regs->GR_G(i));
                        NPregs64[i] = regs->GR_G(i);
                    }
                    break;
                case 1:
                    if (!NPregs_valid || NPregs64[i] != regs->CR_G(i))
                    {
                        set_pos (REGS_LINE + i/2, 3 + (i%2)*19);
                        draw_dw (regs->CR_G(i));
                        NPregs64[i] = regs->CR_G(i);
                    }
                    break;
                }
            }
        }
        else if (NPregzhost)
        {
            /* 32 bit registers on 64 bit template */
            for (i = 0; i < 16; i++)
            {
                switch (NPregdisp) {
                case 0:
                    if (!NPregs_valid || NPregs[i] != regs->GR_L(i))
                    {
                        set_pos (REGS_LINE + i/2, 3 + (i%2)*19);
//                      draw_fw (0);
                        draw_text("--------");
                        draw_fw (regs->GR_L(i));
                        NPregs[i] = regs->GR_L(i);
                    }
                    break;
                case 1:
                    if (!NPregs_valid || NPregs[i] != regs->CR_L(i))
                    {
                        set_pos (REGS_LINE + i/2, 3 + (i%2)*19);
//                      draw_fw (0);
                        draw_text("--------");
                        draw_fw (regs->CR_L(i));
                        NPregs[i] = regs->CR_L(i);
                    }
                    break;
                }
            }
        }
        else
        {
            /* 32 bit registers */
            addr = NPaddress;
            for (i = 0; i < 16; i++)
            {
                switch (NPregdisp) {
                default:
                case 0:
                    if (!NPregs_valid || NPregs[i] != regs->GR_L(i))
                    {
                        set_pos (REGS_LINE + (i/4)*2, 3 + (i%4)*9);
                        draw_fw (regs->GR_L(i));
                        NPregs[i] = regs->GR_L(i);
                    }
                    break;
                case 1:
                    if (!NPregs_valid || NPregs[i] != regs->CR_L(i))
                    {
                        set_pos (REGS_LINE + (i/4)*2, 3 + (i%4)*9);
                        draw_fw (regs->CR_L(i));
                        NPregs[i] = regs->CR_L(i);
                    }
                    break;
                case 2:
                    if (!NPregs_valid || NPregs[i] != regs->AR(i))
                    {
                        set_pos (REGS_LINE + (i/4)*2, 3 + (i%4)*9);
                        draw_fw (regs->AR(i));
                        NPregs[i] = regs->AR(i);
                    }
                    break;
                case 3:
                    if (!NPregs_valid || NPregs[i] != regs->fpr[i])
                    {
                        set_pos (REGS_LINE + (i/4)*2, 3 + (i%4)*9);
                        draw_fw (regs->fpr[i]);
                        NPregs[i] = regs->fpr[i];
                    }
                    break;
                case 4:
                    aaddr = APPLY_PREFIXING (addr, regs->PX);
                    addr += 4;
                    if (aaddr + 3 > regs->mainlim)
                        break;
                    if (!NPregs_valid || NPregs[i] != fetch_fw(regs->mainstor + aaddr))
                    {
                        set_pos (REGS_LINE + (i/4)*2, 3 + (i%4)*9);
                        draw_fw (fetch_fw(regs->mainstor + aaddr));
                        NPregs[i] = fetch_fw(regs->mainstor + aaddr);
                    }
                    break;
                }
            }
        }

        /* Update register selection indicator */
        if (!NPregs_valid)
        {
            set_pos ((REGS_LINE+8), 6);
            set_color (NPregdisp == 0 ? COLOR_LIGHT_YELLOW : COLOR_WHITE, COLOR_BLACK);
            draw_char ('G');

            set_pos ((REGS_LINE+8), 14);
            set_color (NPregdisp == 1 ? COLOR_LIGHT_YELLOW : COLOR_WHITE, COLOR_BLACK);
            draw_char ('C');

            set_pos ((REGS_LINE+8), 22);
            set_color (NPregdisp == 2 ? COLOR_LIGHT_YELLOW : COLOR_WHITE, COLOR_BLACK);
            draw_char ('A');

            set_pos ((REGS_LINE+8), 30);
            set_color (NPregdisp == 3 ? COLOR_LIGHT_YELLOW : COLOR_WHITE, COLOR_BLACK);
            draw_char ('F');
        }

        NPregs_valid = 1;

        /* Address & Data */
        if (!NPaddr_valid)
        {
            set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
            set_pos (ADDR_LINE, 12);
            draw_fw (NPaddress);
            NPaddr_valid = 1;
        }
        if (!NPdata_valid)
        {
            set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
            set_pos (ADDR_LINE, 30);
            draw_fw (NPdata);
            NPdata_valid = 1;
        }
    }

    /* Rates */
#ifdef OPTION_MIPS_COUNTING
    if ((!NPmips_valid || sysblk.mipsrate != NPmips) && sysblk.hicpu)
    {
        set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
        set_pos (BUTTONS_LINE, 1);
        if((sysblk.mipsrate / 1000000) > 999)
          snprintf(buf, sizeof(buf), "%2d,%03d", sysblk.mipsrate / 1000000000, sysblk.mipsrate % 1000000000 / 1000000);
        else if((sysblk.mipsrate / 1000000) > 99)
          snprintf(buf, sizeof(buf), "%4d.%01d", sysblk.mipsrate / 1000000, sysblk.mipsrate % 1000000 / 100000);
        else if((sysblk.mipsrate / 1000000) > 9)
          snprintf(buf, sizeof(buf), "%3d.%02d", sysblk.mipsrate / 1000000, sysblk.mipsrate % 1000000 / 10000);
        else
          snprintf(buf, sizeof(buf), "%2d.%03d", sysblk.mipsrate / 1000000, sysblk.mipsrate % 1000000 / 1000);
        draw_text (buf);
        NPmips = sysblk.mipsrate;
        NPmips_valid = 1;
    }

    if (0
        || (sysblk.hicpu && (!NPsios_valid || NPsios != sysblk.siosrate))
#if defined(OPTION_SHARED_DEVICES)
        || sysblk.shrdport
#endif // defined(OPTION_SHARED_DEVICES)
    )
    {
        set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
        set_pos (BUTTONS_LINE, 8);
        snprintf(buf, sizeof(buf), "%6.6s", format_int(sysblk.siosrate));
        draw_text (buf);
        NPsios = sysblk.siosrate;
        NPsios_valid = 1;
    }
#endif /* OPTION_MIPS_COUNTING */

    /* Optional cpu graph */
    if (NPcpugraph)
    {
        for (i = 0; i < NPcpugraph_ncpu; i++)
        {
            if (!IS_CPU_ONLINE(i))
            {
                if (!NPcpugraph_valid || NPcpugraphpct[i] != -2.0)
                {
                    set_color (COLOR_RED, COLOR_BLACK);
                    set_pos (CPU_GRAPH_LINE+1+i, 6);
                    draw_text ("OFFLINE");
                    fill_text (' ', 38);
                    NPcpugraphpct[i] = -2.0;
                }
            }
            else if (sysblk.regs[i]->cpustate != CPUSTATE_STARTED)
            {
                if (!NPcpugraph_valid || NPcpugraphpct[i] != -1.0)
                {
                    set_color (COLOR_LIGHT_YELLOW, COLOR_BLACK);
                    set_pos (CPU_GRAPH_LINE+1+i, 6);
                    draw_text ("STOPPED");
                    fill_text (' ', 38);
                    NPcpugraphpct[i] = -1.0;
                }
            }
            else if (!NPcpugraph_valid || NPcpugraphpct[i] != sysblk.regs[i]->cpupct)
            {
                n = (34 * sysblk.regs[i]->cpupct) / 100;
                if (n == 0 && sysblk.regs[i]->cpupct > 0)
                    n = 1;
                else if (n > 34)
                    n = 34;
                set_color (n > 17 ? COLOR_WHITE : COLOR_LIGHT_GREY, COLOR_BLACK);
                set_pos (CPU_GRAPH_LINE+1+i, 6);
                fill_text ('*', n+3);
                fill_text (' ', 38);
                NPcpugraphpct[i] = sysblk.regs[i]->cpupct;
            }

            if(sysblk.capvalue)
            {
              if(sysblk.ptyp[i] == SCCB_PTYP_CP)
              {
                if(sysblk.ptyp[i] == SCCB_PTYP_CP && sysblk.caplocked[i])
                  set_color(COLOR_LIGHT_RED, COLOR_BLACK);
                else
                  set_color(COLOR_LIGHT_GREY, COLOR_BLACK);
                set_pos(CPU_GRAPH_LINE + i + 1, 1);
                snprintf(buf, sizeof(buf), "%s%02X", PTYPSTR(i), i);
                draw_text(buf);
              }
            }

            set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
        }
        NPcpugraph_valid = 1;
    }

    /* Process devices */
    for (i = 0, dev = sysblk.firstdev; dev != NULL; i++, dev = dev->nextdev)
    {
        if (i >= cons_rows - 3) break;
        if (!dev->allocated) continue;

        online = (dev->console && dev->connected) || strlen(dev->filename) > 0;
        busy   = dev->busy != 0 || IOPENDING(dev) != 0;
        open   = dev->fd > 2;

        /* device identifier */
        if (!NPdevices_valid || online != NPonline[i])
        {
            set_pos (DEV_LINE+i, 41);
            set_color (online ? COLOR_LIGHT_GREEN : COLOR_LIGHT_GREY, COLOR_BLACK);
            draw_char (i < 26 ? 'A' + i : '.');
            NPonline[i] = online;
        }

        /* device number */
        if (!NPdevices_valid || dev->devnum != NPdevnum[i] || NPbusy[i] != busy)
        {
            set_pos (DEV_LINE+i, 43);
            set_color (busy ? COLOR_LIGHT_YELLOW : COLOR_LIGHT_GREY, COLOR_BLACK);
            snprintf (buf, sizeof(buf), "%4.4X", dev->devnum);
            draw_text (buf);
            NPdevnum[i] = dev->devnum;
            NPbusy[i] = busy;
        }

        /* device type */
        if (!NPdevices_valid || dev->devtype != NPdevtype[i] || open != NPopen[i])
        {
            set_pos (DEV_LINE+i, 48);
            set_color (open ? COLOR_LIGHT_GREEN : COLOR_LIGHT_GREY, COLOR_BLACK);
            snprintf (buf, sizeof(buf), "%4.4X", dev->devtype);
            draw_text (buf);
            NPdevtype[i] = dev->devtype;
            NPopen[i] = open;
        }

        /* device class and name */
        (dev->hnd->query)(dev, &devclass, sizeof(devnam), devnam);
        if (!NPdevices_valid || strcmp(NPdevnam[i], devnam))
        {
            set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
            set_pos (DEV_LINE+i, 53);
            snprintf (buf, sizeof(buf), "%-4.4s", devclass);
            draw_text (buf);
            /* Draw device name only if they're NOT assigning a new one */
            if (0
                || NPdataentry != 1
                || NPpending != 'n'
                || NPasgn != i
            )
            {
                /* locate first nonprintable and truncate */
                int l, p;

                l = (int)strlen(devnam);
                for ( p = 0; p < l; p++ )
                {
                    if ( !isprint(devnam[p]) )
                    {
                        devnam[p] = '\0';
                        break;
                    }
                }
                set_pos (DEV_LINE+i, 58);
                draw_text (devnam);
                fill_text (' ', PANEL_MAX_COLS);
            }
        }
    }

    /* Complete the device state table */
    if (!NPdevices_valid)
    {
        NPlastdev = i > 26 ? 26 : i - 1;
        for ( ; i < NP_MAX_DEVICES; i++)
        {
            NPonline[i] = NPdevnum[i] = NPbusy[i] = NPdevtype[i] = NPopen[i] = 0;
            strlcpy( NPdevnam[i], "", sizeof(NPdevnam[i]) );
        }
        NPdevices_valid = 1;
    }

    /* Prompt 1 */
    if (strcmp(NPprompt1, NPoldprompt1))
    {
        strlcpy(NPoldprompt1, NPprompt1, sizeof(NPoldprompt1) );
        if (strlen(NPprompt1) > 0)
        {
            set_color (COLOR_WHITE, COLOR_BLUE);
            set_pos (cons_rows, (40 - (short)strlen(NPprompt1)) / 2);
            draw_text (NPprompt1);
        }
        else if (cons_rows >= 24)
        {
            set_color (COLOR_LIGHT_GREY, COLOR_BLACK);
            set_pos (cons_rows, 1);
            fill_text ('-', 38);
        }
    }

    /* Prompt 2 */
    if (strcmp(NPprompt2, NPoldprompt2))
    {
        strlcpy(NPoldprompt2, NPprompt2, sizeof(NPoldprompt2) );
        if (strlen(NPprompt2) > 0)
        {
            set_color(COLOR_WHITE, COLOR_BLUE);
            set_pos(cons_rows, 41);
            draw_text(NPprompt2);
        }
        else if (cons_rows >= 24)
        {
            set_color( COLOR_LIGHT_GREY, COLOR_BLACK );
            set_pos( cons_rows, 41) ;
            fill_text( '-', cons_cols );
        }
    }

    /* Data entry field */
    if (NPdataentry && redraw_cmd)
    {
        set_pos (NPcurrow, NPcurcol);
        if (NPcolorSwitch)
            set_color (NPcolorFore, NPcolorBack);
        fill_text (' ', NPcurcol + NPdatalen - 1);
        set_pos (NPcurrow, NPcurcol);
        PUTC_CMDLINE();
        redraw_cmd = 0;
    }
    else
        /* Position the cursor to the bottom right */
        set_pos(cons_rows, cons_cols);
}

/* ==============   End of the main NP block of code    =============*/

static void panel_cleanup(void *unused);    // (forward reference)

#ifdef OPTION_MIPS_COUNTING

///////////////////////////////////////////////////////////////////////
// "maxrates" command support...

#define  DEF_MAXRATES_RPT_INTVL   (  1440  )

DLL_EXPORT U32    curr_high_mips_rate = 0;  // (high water mark for current interval)
DLL_EXPORT U32    curr_high_sios_rate = 0;  // (high water mark for current interval)

DLL_EXPORT U32    prev_high_mips_rate = 0;  // (saved high water mark for previous interval)
DLL_EXPORT U32    prev_high_sios_rate = 0;  // (saved high water mark for previous interval)

DLL_EXPORT time_t curr_int_start_time = 0;  // (start time of current interval)
DLL_EXPORT time_t prev_int_start_time = 0;  // (start time of previous interval)

DLL_EXPORT U32    maxrates_rpt_intvl  = DEF_MAXRATES_RPT_INTVL;

DLL_EXPORT void update_maxrates_hwm()       // (update high-water-mark values)
{
    time_t  current_time = 0;
    U32     elapsed_secs = 0;

    if (curr_high_mips_rate < sysblk.mipsrate)
        curr_high_mips_rate = sysblk.mipsrate;

    if (curr_high_sios_rate < sysblk.siosrate)
        curr_high_sios_rate = sysblk.siosrate;

    // Save high water marks for current interval...

    time( &current_time );

    elapsed_secs = current_time - curr_int_start_time;

    if ( elapsed_secs >= ( maxrates_rpt_intvl * 60 ) )
    {
#if 0
        // I'll ask if I want to know, please.
        if (sysblk.panel_init)
            panel_command( "maxrates" );
#endif

        prev_high_mips_rate = curr_high_mips_rate;
        prev_high_sios_rate = curr_high_sios_rate;

        curr_high_mips_rate = 0;
        curr_high_sios_rate = 0;

        prev_int_start_time = curr_int_start_time;
        curr_int_start_time = current_time;
    }
}
#endif // OPTION_MIPS_COUNTING
///////////////////////////////////////////////////////////////////////

REGS *copy_regs(int cpu)
{
    REGS *regs;

    if (cpu < 0 || cpu >= sysblk.maxcpu)
        cpu = 0;

    obtain_lock (&sysblk.cpulock[cpu]);

    if ((regs = sysblk.regs[cpu]) == NULL)
    {
        release_lock(&sysblk.cpulock[cpu]);
        return &sysblk.dummyregs;
    }

    memcpy (&copyregs, regs, sysblk.regs_copy_len);

    if (copyregs.hostregs == NULL)
    {
        release_lock(&sysblk.cpulock[cpu]);
        return &sysblk.dummyregs;
    }

#if defined(_FEATURE_SIE)
    if (regs->sie_active)
    {
        memcpy (&copysieregs, regs->guestregs, sysblk.regs_copy_len);
        copyregs.guestregs = &copysieregs;
        copysieregs.hostregs = &copyregs;
        regs = &copysieregs;
    }
    else
#endif // defined(_FEATURE_SIE)
        regs = &copyregs;

    SET_PSW_IA(regs);

    release_lock(&sysblk.cpulock[cpu]);
    return regs;
}


/*-------------------------------------------------------------------*/
/* Panel display thread                                              */
/*                                                                   */
/* This function runs on the main thread.  It receives messages      */
/* from the log task and displays them on the screen.  It accepts    */
/* panel commands from the keyboard and executes them.  It samples   */
/* the PSW periodically and displays it on the screen status line.   */
/*-------------------------------------------------------------------*/

#if defined(OPTION_DYNAMIC_LOAD)
void panel_display_r (void)
#else
void panel_display (void)
#endif // defined(OPTION_DYNAMIC_LOAD)
{
#ifndef _MSVC_
  int     rc;                           /* Return code                */
  int     maxfd;                        /* Highest file descriptor    */
  fd_set  readset;                      /* Select file descriptors    */
  struct  timeval tv;                   /* Select timeout structure   */
#endif // _MSVC_
int     i;                              /* Array subscripts           */
int     len;                            /* Length                     */
REGS   *regs;                           /* -> CPU register context    */
QWORD   curpsw;                         /* Current PSW                */
QWORD   prvpsw;                         /* Previous PSW               */
BYTE    prvstate = 0xFF;                /* Previous stopped state     */
U64     prvicount = 0;                  /* Previous instruction count */
#if defined(OPTION_MIPS_COUNTING)
U64     prvtcount = 0;                  /* Previous total count       */
U64     totalcount = 0;                 /* sum of all instruction cnt */
U32     numcpu = 0;                     /* Online CPU count           */
#endif /*defined(OPTION_MIPS_COUNTING)*/
int     prvcpupct = 0;                  /* Previous cpu percentage    */
#if defined(OPTION_SHARED_DEVICES)
U32     prvscount = 0;                  /* Previous shrdcount         */
#endif // defined(OPTION_SHARED_DEVICES)
int     prvpcpu = 0;                    /* Previous pcpu              */
int     prvparch = 0;                   /* Previous primary arch.     */
char    readbuf[MSG_SIZE];              /* Message read buffer        */
int     readoff = 0;                    /* Number of bytes in readbuf */
BYTE    c;                              /* Character work area        */
size_t  kbbufsize = CMD_SIZE;           /* Size of keyboard buffer    */
char   *kbbuf = NULL;                   /* Keyboard input buffer      */
int     kblen;                          /* Number of chars in kbbuf   */
U32     aaddr;                          /* Absolute address for STO   */
char    buf[1024];                      /* Buffer workarea            */
size_t  loopcount;                    /* Number of iterations done   */

    SET_THREAD_NAME("panel_display");

    set_thread_priority(0,0);     /* (don't actually change priority) */

    /* Display thread started message on control panel */
    WRMSG (HHC00100, "I", thread_id(), get_thread_priority(0), "Control panel");

    hdl_adsc("panel_cleanup",panel_cleanup, NULL);

    history_init();

#if defined( ENABLE_BUILTIN_SYMBOLS )
    /* Set Some Function Key Defaults */
    {
        set_symbol("PF01", "SUBST IMMED help &0");
        set_symbol("PF11", "IMMED devlist TAPE");
        set_symbol("PF10", "SUBST DELAY devinit &*");
    }
#endif  /* #if defined( ENABLE_BUILTIN_SYMBOLS ) */

    /* Set up the input file descriptors */
    confp = stderr;
    keybfd = STDIN_FILENO;

    /* Initialize screen dimensions */
    cons_term = getenv ("TERM");
    get_dim (&cons_rows, &cons_cols);

    /* Clear the command-line buffer */
    memset(cmdline, 0, sizeof(cmdline));
    cmdcols = cons_cols - CMDLINE_COL;

    /* Obtain storage for the keyboard buffer */
    if (!(kbbuf = malloc (kbbufsize)))
    {
        char buf[40];
        MSGBUF(buf, "malloc(%d)", (int)kbbufsize);
        WRMSG(HHC00075, "E", buf, strerror(errno));
        return;
    }

    /* Obtain storage for the circular message buffer */
    msgbuf = malloc (MAX_MSGS * sizeof(PANMSG));
    if (msgbuf == NULL)
    {
        char buf[40];
        MSGBUF(buf, "malloc(%d)", (int)(MAX_MSGS * (int)sizeof(PANMSG)));
        fprintf (stderr,
                MSG(HHC00075, "E", buf, strerror(errno)));
        return;
    }

    /* Initialize circular message buffer */
    for (curmsg = msgbuf, i=0; i < MAX_MSGS; curmsg++, i++)
    {
        curmsg->next = curmsg + 1;
        curmsg->prev = curmsg - 1;
        curmsg->msgnum = i;
        memset(curmsg->msg,SPACE,MSG_SIZE);
    }

    /* Complete the circle */
    msgbuf->prev = msgbuf + MAX_MSGS - 1;
    msgbuf->prev->next = msgbuf;

    /* Indicate "first-time" state */
    curmsg = topmsg = NULL;
    wrapped = 0;
    numkept = 0;

    /* Set screen output stream to NON-buffered */
    setvbuf (confp, NULL, _IONBF, 0);

    /* Put the terminal into cbreak mode */
    set_or_reset_console_mode( keybfd, 1 );

    /* Set console title */
    set_console_title(NULL);

    /* Clear the screen */
    set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
    clr_screen ();
    redraw_msgs = redraw_cmd = redraw_status = 1;

    /* Notify logger_thread we're in control */
    sysblk.panel_init = 1;

#ifdef OPTION_MIPS_COUNTING
    /* Initialize "maxrates" command reporting intervals */
    if ( maxrates_rpt_intvl == 1440 )
    {
        time_t      current_time;
        struct tm  *current_tm;
        time_t      since_midnight = 0;
        current_time = time( NULL );
        current_tm   = localtime( &current_time );
        since_midnight = (time_t)( ( ( current_tm->tm_hour  * 60 ) +
                                       current_tm->tm_min ) * 60   +
                                       current_tm->tm_sec );
        curr_int_start_time = current_time - since_midnight;
    }
    else
        curr_int_start_time = time( NULL );

    prev_int_start_time = curr_int_start_time;
#endif

    /* Process messages and commands */
    for (loopcount = 0; ; loopcount++)
    {
#if defined( _MSVC_ )
        /* Wait for keyboard input */
#define WAIT_FOR_KEYBOARD_INPUT_SLEEP_MILLISECS  (20)
        for (i=
#if defined(PANEL_REFRESH_RATE)
               sysblk.panrate
#else
               500
#endif
                             /WAIT_FOR_KEYBOARD_INPUT_SLEEP_MILLISECS; i && !kbhit(); i--)
            Sleep(WAIT_FOR_KEYBOARD_INPUT_SLEEP_MILLISECS);

        ADJ_SCREEN_SIZE();

        /* If keyboard input has [finally] arrived, then process it */
        if ( kbhit() )
        {
            /* Read character(s) from the keyboard */
            kbbuf[0] = getch();
            kbbuf[kblen=1] = '\0';
            translate_keystroke( kbbuf, &kblen );

#else // !defined( _MSVC_ )

        /* Set the file descriptors for select */
        FD_ZERO (&readset);
        FD_SET (keybfd, &readset);
        FD_SET (logger_syslogfd[LOG_READ], &readset);
        FD_SET (0, &readset);
        if(keybfd > logger_syslogfd[LOG_READ])
          maxfd = keybfd;
        else
          maxfd = logger_syslogfd[LOG_READ];

        /* Wait for a message to arrive, a key to be pressed,
           or the inactivity interval to expire */
        tv.tv_sec =
#if defined(PANEL_REFRESH_RATE)
                    sysblk.panrate
#else
                    500
#endif
                                   / 1000;
        tv.tv_usec = (
#if defined(PANEL_REFRESH_RATE)
                      sysblk.panrate
#else
                      500
#endif
                                     * 1000) % 1000000;
        rc = select (maxfd + 1, &readset, NULL, NULL, &tv);
        if (rc < 0 )
        {
            if (errno == EINTR) continue;
            // "select: %s"
            fprintf (stderr, MSG(HHC00014, "E", strerror(errno) ) );
            break;
        }

        ADJ_SCREEN_SIZE();

        /* If keyboard input has arrived then process it */
        if (loopcount && FD_ISSET(keybfd, &readset))
        {
            /* Read character(s) from the keyboard */
            kblen = read (keybfd, kbbuf, kbbufsize-1);

            if (kblen < 0)
            {
                // "keyboard read: %s"
                fprintf (stderr, MSG(HHC00015, "E", strerror(errno) ) );
                break;
            }
            if (!kblen)
            {
                panel_command("quit");             /* Force shutdown */
                break;                /* EOF on input.  Don't loop   */
            }

            kbbuf[kblen] = '\0';

#endif // defined( _MSVC_ )

            /* =NP= : Intercept NP commands & process */
            if (NPDup == 1)
            {
                if (NPdevsel == 1)
                {
                    NPdevsel = 0;
                    NPdevice = kbbuf[0];  /* save the device selected */
                    kbbuf[0] = NPsel2;    /* setup for 2nd part of rtn */
                }
                if (NPdataentry == 0 && kblen == 1)
                {   /* We are in command mode */
                    if (NPhelpup == 1)
                    {
                        if (kbbuf[0] == 0x1b)
                            NPhelpdown = 1;
                        kbbuf[0] = '\0';
                        redraw_status = 1;
                    }
                    cmdline[0] = '\0';
                    cmdlen = 0;
                    cmdoff = 0;
                    ADJ_CMDCOL();
                    switch(kbbuf[0]) {
                        case 0x1B:                  /* ESC */
                            NPDup = 0;
                            restore_command_line();
                            ADJ_CMDCOL();
                            redraw_msgs = redraw_cmd = redraw_status = 1;
                            npquiet = 0; // (forced for one paint cycle)
                            break;
                        case '?':
                            NPhelpup = 1;
                            redraw_status = 1;
                            break;
                        case 'S':                   /* START */
                        case 's':
                            if (!sysblk.hicpu)
                              break;
                            do_panel_command( "startall" );
                            break;
                        case 'P':                   /* STOP */
                        case 'p':
                            if (!sysblk.hicpu)
                              break;
                            do_panel_command( "stopall" );
                            break;
                        case 'O':                   /* Store */
                        case 'o':
                            if (!sysblk.hicpu)
                              break;
                            regs = copy_regs(sysblk.pcpu);
                            aaddr = APPLY_PREFIXING (NPaddress, regs->PX);
                            if (aaddr > regs->mainlim)
                                break;
                            store_fw (regs->mainstor + aaddr, NPdata);
                            redraw_status = 1;
                            break;
                        case 'I':                   /* Display */
                        case 'i':
                            if (!sysblk.hicpu)
                              break;
                            NPregdisp = 4;
                            NPregs_valid = 0;
                            redraw_status = 1;
                            break;
                        case 'g':                   /* display GPR */
                        case 'G':
                            if (!sysblk.hicpu)
                              break;
                            NPregdisp = 0;
                            NPregs_valid = 0;
                            redraw_status = 1;
                            break;
                        case 'a':                   /* Display AR */
                        case 'A':
                            if (!sysblk.hicpu)
                              break;
                            NPregdisp = 2;
                            NPregs_valid = 0;
                            redraw_status = 1;
                            break;
                        case 'c':
                        case 'C':                   /* Case CR */
                            if (!sysblk.hicpu)
                              break;
                            NPregdisp = 1;
                            NPregs_valid = 0;
                            redraw_status = 1;
                            break;
                        case 'f':                   /* Case FPR */
                        case 'F':
                            if (!sysblk.hicpu)
                              break;
                            NPregdisp = 3;
                            NPregs_valid = 0;
                            redraw_status = 1;
                            break;
                        case 'r':                   /* Enter address */
                        case 'R':
                            if (!sysblk.hicpu)
                              break;
                            NPdataentry = 1;
                            redraw_cmd = 1;
                            NPpending = 'r';
                            NPcurrow = 16;
                            NPcurcol = 12;
                            NPdatalen = 8;
                            NPcolorSwitch = 1;
                            NPcolorFore = COLOR_WHITE;
                            NPcolorBack = COLOR_BLUE;
                            strlcpy(NPentered, "", sizeof(NPentered) );
                            strlcpy(NPprompt1, "Enter Address", sizeof(NPprompt1) );
                            redraw_status = 1;
                            break;
                        case 'd':                   /* Enter data */
                        case 'D':
                            if (!sysblk.hicpu)
                              break;
                            NPdataentry = 1;
                            redraw_cmd = 1;
                            NPpending = 'd';
                            NPcurrow = 16;
                            NPcurcol = 30;
                            NPdatalen = 8;
                            NPcolorSwitch = 1;
                            NPcolorFore = COLOR_WHITE;
                            NPcolorBack = COLOR_BLUE;
                            strlcpy(NPentered, "", sizeof(NPentered) );
                            strlcpy(NPprompt1, "Enter Data Value", sizeof(NPprompt1) );
                            redraw_status = 1;
                            break;
                        case 'l':                   /* IPL */
                        case 'L':
                            if (!sysblk.hicpu)
                              break;
                            NPdevsel = 1;
                            NPsel2 = 1;
                            strlcpy(NPprompt2, "Select Device for IPL", sizeof(NPprompt2) );
                            redraw_status = 1;
                            break;
                        case 1:                     /* IPL - 2nd part */
                            if (!sysblk.hicpu)
                              break;
                            i = toupper(NPdevice) - 'A';
                            if (i < 0 || i > NPlastdev) {
                                memset(NPprompt2,0,sizeof(NPprompt2));
                                redraw_status = 1;
                                break;
                            }
                            sprintf (cmdline, "ipl %4.4x", NPdevnum[i]);
                            do_panel_command(cmdline);
                            memset(NPprompt2,0,sizeof(NPprompt2));
                            redraw_status = 1;
                            break;
                        case 'u':                   /* Device interrupt */
                        case 'U':
                            NPdevsel = 1;
                            NPsel2 = 2;
                            strlcpy(NPprompt2, "Select Device for Interrupt", sizeof(NPprompt2));
                            redraw_status = 1;
                            break;
                        case 2:                     /* Device int: part 2 */
                            if (!sysblk.hicpu)
                              break;
                            i = toupper(NPdevice) - 'A';
                            if (i < 0 || i > NPlastdev) {
                                memset(NPprompt2,0,sizeof(NPprompt2));
                                redraw_status = 1;
                                break;
                            }
                            MSGBUF( cmdline, "i %4.4x", NPdevnum[i]);
                            do_panel_command(cmdline);
                            memset(NPprompt2,0,sizeof(NPprompt2));
                            redraw_status = 1;
                            break;
                        case 'n':                   /* Device Assignment */
                        case 'N':
                            NPdevsel = 1;
                            NPsel2 = 3;
                            strlcpy(NPprompt2, "Select Device to Reassign", sizeof(NPprompt2));
                            redraw_status = 1;
                            break;
                        case 3:                     /* Device asgn: part 2 */
                            i = toupper(NPdevice) - 'A';
                            if (i < 0 || i > NPlastdev) {
                                memset(NPprompt2,0,sizeof(NPprompt2));
                                redraw_status = 1;
                                break;
                            }
                            NPdataentry = 1;
                            redraw_cmd = 1;
                            NPpending = 'n';
                            NPasgn = i;
                            NPcurrow = 3 + i;
                            NPcurcol = 58;
                            NPdatalen = cons_cols - 57;
                            NPcolorSwitch = 1;
                            NPcolorFore = COLOR_DEFAULT_LIGHT;
                            NPcolorBack = COLOR_BLUE;
                            memset(NPentered,0,sizeof(NPentered));
                            strlcpy(NPprompt2, "New Name, or [enter] to Reload", sizeof(NPprompt2) );
                            redraw_status = 1;
                            break;
                        case 'W':                   /* POWER */
                        case 'w':
                            NPdevsel = 1;
                            NPsel2 = 4;
                            strlcpy(NPprompt1, "Confirm Powerdown Y or N", sizeof(NPprompt1) );
                            redraw_status = 1;
                            break;
                        case 4:                     /* POWER - 2nd part */
                            if (NPdevice == 'y' || NPdevice == 'Y')
                                do_panel_command( "quit" );
                            memset(NPprompt1, 0, sizeof(NPprompt1));
                            redraw_status = 1;
                            break;
                        case 'T':                   /* Restart */
                        case 't':
                            if (!sysblk.hicpu)
                              break;
                            NPdevsel = 1;
                            NPsel2 = 5;
                            strlcpy(NPprompt1, "Confirm Restart Y or N", sizeof(NPprompt1) );
                            redraw_status = 1;
                            break;
                        case 5:                    /* Restart - part 2 */
                            if (!sysblk.hicpu)
                              break;
                            if (NPdevice == 'y' || NPdevice == 'Y')
                                do_panel_command( "restart" );
                            memset(NPprompt1, 0, sizeof(NPprompt1));
                            redraw_status = 1;
                            break;
                        case 'E':                   /* Ext int */
                        case 'e':
                            if (!sysblk.hicpu)
                              break;
                            NPdevsel = 1;
                            NPsel2 = 6;
                            strlcpy(NPprompt1, "Confirm External Interrupt Y or N", sizeof(NPprompt1));
                            redraw_status = 1;
                            break;
                        case 6:                    /* External - part 2 */
                            if (!sysblk.hicpu)
                              break;
                            if (NPdevice == 'y' || NPdevice == 'Y')
                                do_panel_command( "ext" );
                            memset(NPprompt1, 0, sizeof(NPprompt1));
                            redraw_status = 1;
                            break;
                        default:
                            break;
                    }
                    NPcmd = 1;
                } else {  /* We are in data entry mode */
                    if (kbbuf[0] == 0x1B) {
                        /* Switch back to command mode */
                        NPdataentry = 0;
                        NPaddr_valid = 0;
                        NPdata_valid = 0;
                        memset(NPprompt1, 0,sizeof(NPprompt1));
                        memset(NPprompt2, 0, sizeof(NPprompt2));
                        NPcmd = 1;
                    }
                    else
                        NPcmd = 0;
                }
                if (NPcmd == 1)
                    kblen = 0;                  /* don't process as command */
            }
            /* =NP END= */

            /* Process characters in the keyboard buffer */
            for (i = 0; i < kblen; )
            {
#if defined ( _MSVC_ )
                /* Test for PF key  Windows */
                if ( strlen(kbbuf+i) == 4 && kbbuf[i] == '\x1b' && kbbuf[i+1] == ')' ) /* this is a PF Key */
                {
                    char szPF[6];
                    char msgbuf[32];
                    char *pf;
                    char *psz_PF;
                    int j;

                    MSGBUF( szPF, "PF%s", kbbuf+2 );
                    szPF[4] = '\0';

#else   // ! _MSVC_
                if ( !strcmp(kbbuf+i, KBD_PF1) || !strcmp(kbbuf+i, KBD_PF1_a) ||
                     !strcmp(kbbuf+i, KBD_PF2) || !strcmp(kbbuf+i, KBD_PF2_a) ||
                     !strcmp(kbbuf+i, KBD_PF3) || !strcmp(kbbuf+i, KBD_PF3_a) ||
                     !strcmp(kbbuf+i, KBD_PF4) || !strcmp(kbbuf+i, KBD_PF4_a) ||
                     !strcmp(kbbuf+i, KBD_PF5) || !strcmp(kbbuf+i, KBD_PF6  ) ||
                     !strcmp(kbbuf+i, KBD_PF7) || !strcmp(kbbuf+i, KBD_PF8  ) ||
                     !strcmp(kbbuf+i, KBD_PF9) || !strcmp(kbbuf+i, KBD_PF10 ) ||
                     !strcmp(kbbuf+i, KBD_PF11)|| !strcmp(kbbuf+i, KBD_PF12 ) ||
                     !strcmp(kbbuf+i, KBD_PF13)|| !strcmp(kbbuf+i, KBD_PF14 ) ||
                     !strcmp(kbbuf+i, KBD_PF15)|| !strcmp(kbbuf+i, KBD_PF16 ) ||
                     !strcmp(kbbuf+i, KBD_PF17)|| !strcmp(kbbuf+i, KBD_PF18 ) ||
                     !strcmp(kbbuf+i, KBD_PF19)|| !strcmp(kbbuf+i, KBD_PF20 ) )
                {
                    char *szPF;
                    char msgbuf[32];
                    char *pf;
                    char *psz_PF;
                    int j;

                    if      ( !strcmp(kbbuf+i, KBD_PF1) || !strcmp(kbbuf+i, KBD_PF1_a) ) szPF = "PF01";
                    else if ( !strcmp(kbbuf+i, KBD_PF2) || !strcmp(kbbuf+i, KBD_PF2_a) ) szPF = "PF02";
                    else if ( !strcmp(kbbuf+i, KBD_PF3) || !strcmp(kbbuf+i, KBD_PF3_a) ) szPF = "PF03";
                    else if ( !strcmp(kbbuf+i, KBD_PF4) || !strcmp(kbbuf+i, KBD_PF4_a) ) szPF = "PF04";
                    else if ( !strcmp(kbbuf+i, KBD_PF5)                                ) szPF = "PF05";
                    else if ( !strcmp(kbbuf+i, KBD_PF6)                                ) szPF = "PF06";
                    else if ( !strcmp(kbbuf+i, KBD_PF7)                                ) szPF = "PF07";
                    else if ( !strcmp(kbbuf+i, KBD_PF8)                                ) szPF = "PF08";
                    else if ( !strcmp(kbbuf+i, KBD_PF9)                                ) szPF = "PF09";
                    else if ( !strcmp(kbbuf+i, KBD_PF10)                               ) szPF = "PF10";
                    else if ( !strcmp(kbbuf+i, KBD_PF11)                               ) szPF = "PF11";
                    else if ( !strcmp(kbbuf+i, KBD_PF12)                               ) szPF = "PF12";
                    else if ( !strcmp(kbbuf+i, KBD_PF13)                               ) szPF = "PF13";
                    else if ( !strcmp(kbbuf+i, KBD_PF14)                               ) szPF = "PF14";
                    else if ( !strcmp(kbbuf+i, KBD_PF15)                               ) szPF = "PF15";
                    else if ( !strcmp(kbbuf+i, KBD_PF16)                               ) szPF = "PF16";
                    else if ( !strcmp(kbbuf+i, KBD_PF17)                               ) szPF = "PF17";
                    else if ( !strcmp(kbbuf+i, KBD_PF18)                               ) szPF = "PF18";
                    else if ( !strcmp(kbbuf+i, KBD_PF19)                               ) szPF = "PF19";
                    else if ( !strcmp(kbbuf+i, KBD_PF20)                               ) szPF = "PF20";
                    else szPF = NULL;
#endif

#if defined(ENABLE_BUILTIN_SYMBOLS)
                    pf = (char*)get_symbol(szPF);
#else
                    pf = NULL;
#endif

                    if ( pf == NULL )
                    {
                        MSGBUF( msgbuf, "DELAY * %s UNDEFINED", szPF );
                        pf = msgbuf;
                    }

                    psz_PF = strdup(pf);

                    /* test for 1st of IMMED, DELAY or SUBST */
                    for ( j = 0; j < (int)strlen(psz_PF); j++ )
                        if ( psz_PF[j] != ' ' ) break;

                    if ( !strncasecmp( psz_PF+j, "IMMED ", 6 ) )
                    {
                        for ( j += 5; j < (int)strlen(psz_PF); j++ )
                            if ( psz_PF[j] != ' ' ) break;
                        do_panel_command( psz_PF+j );
                    }
                    else if ( !strncasecmp( psz_PF+j, "DELAY ", 6 ) )
                    {
                        for ( j += 5; j < (int)strlen(psz_PF); j++ )
                            if ( psz_PF[j] != ' ' ) break;
                        strcpy( cmdline, psz_PF+j );
                        cmdlen = (int)strlen(cmdline);
                        cmdoff = cmdlen < cmdcols ? cmdlen : 0;
                        ADJ_CMDCOL();
                    }
                    else if ( !strncasecmp( psz_PF+j, "SUBST ", 6 ) )
                    {
                        int  isdelay = TRUE;
                        char *cmd_tok[11] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
                        int   ncmd_tok = 0;
                        char *pt1;

                        for ( j += 5; j < (int)strlen(psz_PF); j++ )
                            if ( psz_PF[j] != ' ' ) break;

                        if ( !strncasecmp( psz_PF+j, "IMMED ", 6 ) )
                        {
                            isdelay = FALSE;
                            for ( j += 5; j < (int)strlen(psz_PF); j++ )
                                if ( psz_PF[j] != ' ' ) break;

                        }
                        else if ( !strncasecmp( psz_PF+j, "DELAY ", 6 ) )
                        {
                            for ( j += 5; j < (int)strlen(psz_PF); j++ )
                                if ( psz_PF[j] != ' ' ) break;
                        }

                        if ( ( cmdlen = (int)strlen(cmdline) ) > 0 )
                        {
                            char    psz_cmdline[sizeof(cmdline)];
                            char   *p = cmdline;

                            while (*p && ncmd_tok < 10 )
                            {
                                while (*p && isspace(*p)) p++; if (!*p) break; // find start of arg

                                if (*p == '#') break; // stop on comments

                                cmd_tok[ncmd_tok] = p; ++ncmd_tok; // count new arg

                                while ( *p && !isspace(*p) &&
                                        *p != '\"' && *p != '\'' ) p++; if (!*p) break; // find end of arg

                                if (*p == '\"' || *p == '\'')
                                {
                                    char delim = *p;

                                    do {} while (*++p && *p != delim);
                                    if (!*p) break;                    // find end of quoted string
                                    p++;
                                    if (!*p) break;                    // found end of args

                                    if ( *p != ' ')
                                    {
                                        strlcpy(psz_cmdline, p, sizeof(cmdline));
                                        *p = ' ';                       // insert a space
                                        strcpy(p+1, psz_cmdline);
                                        psz_cmdline[0] = 0;
                                    }
                                }

                                *p++ = 0; // mark end of arg
                            }

                            ncmd_tok--;

                            /* token 10 represents the rest of the line */
                            if ( ncmd_tok == 9 && strlen(p) > 0 )
                                cmd_tok[++ncmd_tok] = p;
                        }

                        {
                            int     ctok = -1;
                            int     odx  = 0;
                            int     idx  = 0;
                            char    psz_cmdline[(sizeof(cmdline) * 11)];

                            memset(psz_cmdline, 0, sizeof(psz_cmdline));

                            pt1 = psz_PF+j;

                            for ( idx = 0; idx < (int)strlen(pt1); idx++ )
                            {
                                if ( pt1[idx] != '&' )
                                {
                                    psz_cmdline[odx++] = pt1[idx];
                                }
                                else
                                {
                                    if ( pt1[idx+1] == '&' )
                                    {
                                        idx++;
                                        psz_cmdline[odx++] = pt1[idx];
                                    }
                                    else if ( pt1[idx+1] == '*' )
                                    {
                                        idx++;

                                        if ( ctok < 9 )
                                        {
                                            int first = TRUE;

                                            for( ctok++; ctok <= 10; ctok++ )
                                            {
                                                if ( cmd_tok[ctok] != NULL )
                                                {
                                                    if ( first )
                                                        first = FALSE;
                                                    else
                                                        psz_cmdline[odx++] = ' ';         // add one space
                                                    strcpy( &psz_cmdline[odx], cmd_tok[ctok] );
                                                    odx += (int)strlen(cmd_tok[ctok]);

                                                }
                                            }
                                        }
                                    }
                                    else if ( !isdigit( pt1[idx+1] ) && ( pt1[idx+1] != '$' ) )
                                    {
                                        psz_cmdline[odx++] = pt1[idx];
                                    }
                                    else
                                    {
                                        idx++;
                                        if ( pt1[idx] == '$' )
                                            ctok = 10;
                                        else
                                        {
                                            ctok = (int)pt1[idx] - '0';
                                            if ( ctok < 0 || ctok > 9 ) ctok = 10;
                                        }
                                        if ( cmd_tok[ctok] != NULL && strlen( cmd_tok[ctok] ) > 0 )
                                        {
                                            strncpy(&psz_cmdline[odx], cmd_tok[ctok], strlen( cmd_tok[ctok] ) );
                                            odx += (int)strlen( cmd_tok[ctok] );
                                        }
                                        else
                                            psz_cmdline[odx++] = ' ';
                                    }
                                }

                                if ( odx > (int)sizeof(cmdline) )
                                {
                                    WRMSG(HHC01608, "W", ((int)sizeof(cmdline) - 1) );
                                    break;
                                }
                            }

                            if ( isdelay )
                            {
                                strncpy( cmdline, psz_cmdline, sizeof(cmdline) );
                                cmdline[sizeof(cmdline) - 1] = 0;
                                cmdlen = (int)strlen(cmdline);
                                cmdoff = cmdlen < cmdcols ? cmdlen : 0;
                                ADJ_CMDCOL();
                            }
                            else
                                do_panel_command( psz_cmdline );
                        }
                    }
                    else /* this is the same as IMMED */
                    {
                        do_panel_command( psz_PF );
                    }
                    free(psz_PF);
                    redraw_cmd = 1;
                    redraw_msgs = 1;
                    break;
                }

                /* Test for HOME */
                if (strcmp(kbbuf+i, KBD_HOME) == 0) {
                    if (NPDup == 1 || !is_cursor_on_cmdline() || cmdlen) {
                        cursor_cmdline_home();
                        redraw_cmd = 1;
                    } else {
                        scroll_to_top_line();
                        redraw_msgs = 1;
                    }
                    break;
                }

                /* Test for END */
                if (strcmp(kbbuf+i, KBD_END) == 0) {
                    if (NPDup == 1 || !is_cursor_on_cmdline() || cmdlen) {
                        cursor_cmdline_end();
                        redraw_cmd = 1;
                    } else {
                        scroll_to_bottom_screen();
                        redraw_msgs = 1;
                    }
                    break;
                }

                /* Test for CTRL+HOME */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_CTRL_HOME) == 0) {
                    scroll_to_top_line();
                    redraw_msgs = 1;
                    break;
                }

                /* Test for CTRL+END */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_CTRL_END) == 0) {
                    scroll_to_bottom_line();
                    redraw_msgs = 1;
                    break;
                }

                /* Process UPARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_UP_ARROW) == 0)
                {
                    do_prev_history();
                    redraw_cmd = 1;
                    break;
                }

                /* Process DOWNARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_DOWN_ARROW) == 0)
                {
                    do_next_history();
                    redraw_cmd = 1;
                    break;
                }

#if defined(OPTION_EXTCURS)
                /* Process ALT+UPARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_ALT_UP_ARROW) == 0) {
                    get_cursor_pos( keybfd, confp, &cur_cons_row, &cur_cons_col );
                    if (cur_cons_row <= 1)
                        cur_cons_row = cons_rows + 1;
                    set_pos( --cur_cons_row, cur_cons_col );
                    break;
                }

                /* Process ALT+DOWNARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_ALT_DOWN_ARROW) == 0) {
                    get_cursor_pos( keybfd, confp, &cur_cons_row, &cur_cons_col );
                    if (cur_cons_row >= cons_rows)
                        cur_cons_row = 1 - 1;
                    set_pos( ++cur_cons_row, cur_cons_col );
                    break;
                }
#endif // defined(OPTION_EXTCURS)

                /* Test for PAGEUP */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_PAGE_UP) == 0) {
                    page_up();
                    redraw_msgs = 1;
                    break;
                }

                /* Test for PAGEDOWN */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_PAGE_DOWN) == 0) {
                    page_down();
                    redraw_msgs = 1;
                    break;
                }

                /* Test for CTRL+UPARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_CTRL_UP_ARROW) == 0) {
                    scroll_up_lines(1);
                    redraw_msgs = 1;
                    break;
                }

                /* Test for CTRL+DOWNARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_CTRL_DOWN_ARROW) == 0) {
                    scroll_down_lines(1);
                    redraw_msgs = 1;
                    break;
                }

                /* Process BACKSPACE */
                if (kbbuf[i] == '\b' || kbbuf[i] == '\x7F') {
                    if (NPDup == 0 && !is_cursor_on_cmdline())
                        beep();
                    else {
                        if (cmdoff > 0) {
                            int j;
                            for (j = cmdoff-1; j<cmdlen; j++)
                                cmdline[j] = cmdline[j+1];
                            cmdoff--;
                            cmdlen--;
                            ADJ_CMDCOL();
                        }
                        i++;
                        redraw_cmd = 1;
                    }
                    break;
                }

                /* Process DELETE */
                if (strcmp(kbbuf+i, KBD_DELETE) == 0) {
                    if (NPDup == 0 && !is_cursor_on_cmdline())
                        beep();
                    else {
                        if (cmdoff < cmdlen) {
                            int j;
                            for (j = cmdoff; j<cmdlen; j++)
                                cmdline[j] = cmdline[j+1];
                            cmdlen--;
                        }
                        i++;
                        redraw_cmd = 1;
                    }
                    break;
                }

                /* Process LEFTARROW */
                if (strcmp(kbbuf+i, KBD_LEFT_ARROW) == 0) {
                    if (cmdoff > 0) cmdoff--;
                    ADJ_CMDCOL();
                    i++;
                    redraw_cmd = 1;
                    break;
                }

                /* Process RIGHTARROW */
                if (strcmp(kbbuf+i, KBD_RIGHT_ARROW) == 0) {
                    if (cmdoff < cmdlen) cmdoff++;
                    ADJ_CMDCOL();
                    i++;
                    redraw_cmd = 1;
                    break;
                }

#if defined(OPTION_EXTCURS)
                /* Process ALT+LEFTARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_ALT_LEFT_ARROW) == 0) {
                    get_cursor_pos( keybfd, confp, &cur_cons_row, &cur_cons_col );
                    if (cur_cons_col <= 1)
                    {
                        cur_cons_row--;
                        cur_cons_col = cons_cols + 1;
                    }
                    if (cur_cons_row < 1)
                        cur_cons_row = cons_rows;
                    set_pos( cur_cons_row, --cur_cons_col );
                    break;
                }

                /* Process ALT+RIGHTARROW */
                if (NPDup == 0 && strcmp(kbbuf+i, KBD_ALT_RIGHT_ARROW) == 0) {
                    get_cursor_pos( keybfd, confp, &cur_cons_row, &cur_cons_col );
                    if (cur_cons_col >= cons_cols)
                    {
                        cur_cons_row++;
                        cur_cons_col = 0;
                    }
                    if (cur_cons_row > cons_rows)
                        cur_cons_row = 1;
                    set_pos( cur_cons_row, ++cur_cons_col );
                    break;
                }
#endif // defined(OPTION_EXTCURS)

                /* Process INSERT */
                if (strcmp(kbbuf+i, KBD_INSERT) == 0 ) {
                    cmdins = !cmdins;
                    set_console_cursor_shape( confp, cmdins );
                    i++;
                    break;
                }

                /* Process ESCAPE */
                if (kbbuf[i] == '\x1B') {
                    /* If data on cmdline, erase it */
                    if ((NPDup == 1 || is_cursor_on_cmdline()) && cmdlen) {
                        cmdline[0] = '\0';
                        cmdlen = 0;
                        cmdoff = 0;
                        ADJ_CMDCOL();
                        redraw_cmd = 1;
                    } else {
                        /* =NP= : Switch to new panel display */
                        save_command_line();
                        NP_init();
                        NPDup = 1;
                        /* =END= */
                    }
                    break;
                }

                /* Process TAB */
                if (kbbuf[i] == '\t' || kbbuf[i] == '\x7F')
                {
                    if (NPDup == 1 || !is_cursor_on_cmdline())
                    {
                        cursor_cmdline_home();
                        redraw_cmd = 1;
                    }
                    else
                    {
                        tab_pressed(cmdline, sizeof(cmdline), &cmdoff);
                        cmdlen = (int)strlen(cmdline);
                        ADJ_CMDCOL();
                        i++;
                        redraw_cmd = 1;
                    }
                    break;
                }

#if defined(OPTION_EXTCURS)
                /* ENTER key special handling */
                if (NPDup == 0 && kbbuf[i] == '\n')
                {
                    /* Get cursor pos and check if on cmdline */
                    if (!is_cursor_on_cmdline())
                    {
                        beep();
                        break;
                    }
                }
#endif // defined(OPTION_EXTCURS)

                /* Process the command when the ENTER key is pressed */
                if (kbbuf[i] == '\n') {
                    if (1
                        && cmdlen == 0
                        && NPDup == 0
                        && !sysblk.inststep
                    ) {
                        history_show();
                    } else {
                        cmdline[cmdlen] = '\0';
                        /* =NP= create_thread replaced with: */
                        if (NPDup == 0) {
                            if ('#' == cmdline[0] || '*' == cmdline[0]) {
                                if (!is_currline_visible())
                                    scroll_to_bottom_screen();
                                history_requested = 0;
                                do_panel_command(cmdline);
                                redraw_cmd = 1;
                                cmdlen = 0;
                                cmdoff = 0;
                                ADJ_CMDCOL();
                                redraw_cmd = 1;
                            } else {
                                history_requested = 0;
                                do_panel_command(cmdline);
                                redraw_cmd = 1;
                                if (history_requested == 1) {
                                    strcpy(cmdline, historyCmdLine);
                                    cmdlen = (int)strlen(cmdline);
                                    cmdoff = cmdlen < cmdcols ? cmdlen : 0;
                                    ADJ_CMDCOL();
                                    redraw_cmd = 1;
                                    cursor_cmdline_end();
                                    break;
                                }
                            }
                        } else {
                            NPdataentry = 0;
                            NPcurrow = cons_rows;
                            NPcurcol = cons_cols;
                            NPcolorSwitch = 0;
                            switch (NPpending) {
                                case 'r':
                                    sscanf(cmdline, "%x", &NPaddress);
                                    NPaddr_valid = 0;
                                    strcpy(NPprompt1, "");
                                    break;
                                case 'd':
                                    sscanf(cmdline, "%x", &NPdata);
                                    NPdata_valid = 0;
                                    strcpy(NPprompt1, "");
                                    break;
                                case 'n':
                                    if (strlen(cmdline) < 1) {
                                        strcpy(cmdline, NPdevnam[NPasgn]);
                                    }
                                    strcpy(NPdevnam[NPasgn], "");
                                    sprintf (NPentered, "devinit %4.4x %s",
                                             NPdevnum[NPasgn], cmdline);
                                    do_panel_command(NPentered);
                                    strcpy(NPprompt2, "");
                                    break;
                                default:
                                    break;
                            }
                            redraw_status = 1;
                            cmdline[0] = '\0';
                            cmdlen = 0;
                            cmdoff = 0;
                            ADJ_CMDCOL();
                        }
                        /* =END= */
                        redraw_cmd = 1;
                    }
                    break;
                } /* end if (kbbuf[i] == '\n') */

                /* Ignore non-printable characters */
                if (!isprint(kbbuf[i])) {
                    beep();
                    i++;
                    continue;
                }

                /* Ignore all other keystrokes not on cmdline */
                if (NPDup == 0 && !is_cursor_on_cmdline()) {
                    beep();
                    break;
                }

                /* Append the character to the command buffer */
                ASSERT(cmdlen <= CMD_SIZE-1 && cmdoff <= cmdlen);
                if (0
                    || (cmdoff >= CMD_SIZE-1)
                    || (cmdins && cmdlen >= CMD_SIZE-1)
                )
                {
                    /* (no more room!) */
                    beep();
                }
                else /* (there's still room) */
                {
                    ASSERT(cmdlen < CMD_SIZE-1 || (!cmdins && cmdoff < cmdlen));
                    if (cmdoff >= cmdlen)
                    {
                        /* Append to end of buffer */
                        ASSERT(!(cmdoff > cmdlen)); // (sanity check)
                        cmdline[cmdoff++] = kbbuf[i];
                        cmdline[cmdoff] = '\0';
                        cmdlen++;
                    }
                    else
                    {
                        ASSERT(cmdoff < cmdlen);
                        if (cmdins)
                        {
                            /* Insert: make room by sliding all
                               following chars right one position */
                            int j;
                            for (j=cmdlen-1; j>=cmdoff; j--)
                                cmdline[j+1] = cmdline[j];
                            cmdline[cmdoff++] = kbbuf[i];
                            cmdlen++;
                        }
                        else
                        {
                            /* Overlay: replace current position */
                            cmdline[cmdoff++] = kbbuf[i];
                        }
                    }
                    ADJ_CMDCOL();
                    redraw_cmd = 1;
                }
                i++;
            } /* end for(i) */
        } /* end if keystroke */

FinishShutdown:

        // If we finished processing all of the message data
        // the last time we were here, then get some more...

        if ( lmsndx >= lmscnt )  // (all previous data processed?)
        {
            lmscnt = log_read( &lmsbuf, &lmsnum, LOG_NOBLOCK );
            lmsndx = 0;
        }
        else if ( lmsndx >= lmsmax )
        {
            lmsbuf += lmsndx;   // pick up where we left off at...
            lmscnt -= lmsndx;   // pick up where we left off at...
            lmsndx = 0;
        }

        // Process all message data or until limit reached...

        // (limiting the amount of data we process a console message flood
        // from preventing keyboard from being read since we need to break
        // out of the below message data processing loop to loop back up
        // to read the keyboard again...)

        /* Read message bytes until newline... */
        while ( lmsndx < lmscnt && lmsndx < lmsmax )
        {
            /* Initialize the read buffer */
            if (!readoff || readoff >= MSG_SIZE) {
                memset (readbuf, SPACE, MSG_SIZE);
                readoff = 0;
            }

            /* Read message bytes and copy into read buffer
               until we either encounter a newline character
               or our buffer is completely filled with data. */
            while ( lmsndx < lmscnt && lmsndx < lmsmax )
            {
                /* Read a byte from the message pipe */
                c = *(lmsbuf + lmsndx); lmsndx++;

                /* Break to process received message
                   whenever a newline is encountered */
                if (c == '\n' || c == '\r') {
                    readoff = 0;    /* (for next time) */
                    break;
                }

                /* Handle tab character */
                if (c == '\t') {
                    readoff += 8;
                    readoff &= 0xFFFFFFF8;
                    /* Messages longer than one screen line will
                       be continued on the very next screen line */
                    if (readoff >= MSG_SIZE)
                        break;
                    else continue;
                }

                /* Eliminate non-displayable characters */
                if (!isgraph(c)) c = SPACE;

                /* Stuff byte into message processing buffer */
                readbuf[readoff++] = c;

                /* Messages longer than one screen line will
                   be continued on the very next screen line */
                if (readoff >= MSG_SIZE)
                    break;
            } /* end while ( lmsndx < lmscnt && lmsndx < lmsmax ) */

            /* If we have a message to be displayed (or a complete
               part of one), then copy it to the circular buffer. */
            if (!readoff || readoff >= MSG_SIZE) {

                /* First-time here? */
                if (curmsg == NULL) {
                    curmsg = topmsg = msgbuf;
                } else {
                    /* Perform autoscroll if needed */
                    if (is_currline_visible()) {
                        while (lines_remaining() < 1)
                            scroll_down_lines(1);
                        /* Set the display update indicator */
                        redraw_msgs = 1;
                    }

                    /* Go on to next available msg buffer */
                    curmsg = curmsg->next;

                    /* Updated wrapped indicator */
                    if (curmsg == msgbuf)
                        wrapped = 1;
                }

                /* Copy message into next available PANMSG slot */
                memcpy( curmsg->msg, readbuf, MSG_SIZE );

            } /* end if (!readoff || readoff >= MSG_SIZE) */
        } /* end Read message bytes until newline... */

        /* Don't read or otherwise process any input
           once system shutdown has been initiated
        */
        if ( sysblk.shutdown )
        {
            if ( sysblk.shutfini ) break;
            /* wait for system to finish shutting down */
            usleep(10000);
            lmsmax = INT_MAX;
            goto FinishShutdown;
        }

        /* =NP= : Reinit traditional panel if NP is down */
        if (NPDup == 0 && NPDinit == 1) {
            redraw_msgs = redraw_status = redraw_cmd = 1;
            set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
            clr_screen ();
        }
        /* =END= */

        /* Obtain the PSW for target CPU */
        regs = copy_regs(sysblk.pcpu);
        memset( curpsw, 0, sizeof(curpsw) );
        copy_psw (regs, curpsw);

        totalcount = 0;
        numcpu = 0;
        for ( i = 0; i < sysblk.maxcpu; ++i )
            if ( IS_CPU_ONLINE(i) )
                ++numcpu,
                totalcount += INSTCOUNT(sysblk.regs[i]);

        /* Set the display update indicator if the PSW has changed
           or if the instruction counter has changed, or if
           the CPU stopped state has changed */
        if (memcmp(curpsw, prvpsw, sizeof(curpsw)) != 0
         || prvicount != totalcount
         || prvcpupct != regs->cpupct
#if defined(OPTION_SHARED_DEVICES)
         || prvscount != sysblk.shrdcount
#endif // defined(OPTION_SHARED_DEVICES)
         || prvstate != regs->cpustate
#if defined(OPTION_MIPS_COUNTING)
         || (NPDup && NPcpugraph && prvtcount != sysblk.instcount)
#endif /*defined(OPTION_MIPS_COUNTING)*/
           )
        {
            redraw_status = 1;
            memcpy (prvpsw, curpsw, sizeof(prvpsw));
            prvicount = totalcount;
            prvcpupct = regs->cpupct;
            prvstate  = regs->cpustate;
#if defined(OPTION_SHARED_DEVICES)
            prvscount = sysblk.shrdcount;
#endif // defined(OPTION_SHARED_DEVICES)
#if defined(OPTION_MIPS_COUNTING)
            prvtcount = sysblk.instcount;
#endif /*defined(OPTION_MIPS_COUNTING)*/
        }

        /* =NP= : Display the screen - traditional or NP */
        /*        Note: this is the only code block modified rather */
        /*        than inserted.  It makes the block of 3 ifs in the */
        /*        original code dependent on NPDup == 0, and inserts */
        /*        the NP display as an else after those ifs */

        if (NPDup == 0) {
            /* Rewrite the screen if display update indicators are set */
            if (redraw_msgs && !npquiet)
            {
                /* Display messages in scrolling area */
                PANMSG* p;

                /* Save cursor location */
                saved_cons_row = cur_cons_row;
                saved_cons_col = cur_cons_col;

                i = 0;
                /* Then draw current screen */
                for (p=topmsg; i < (SCROLL_LINES + numkept) && (p != curmsg->next || p == topmsg); i++, p = p->next)
                {
                    set_pos (i+1, 1);
                    set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
                    write_text (p->msg, MSG_SIZE);
                }

                /* Pad remainder of screen with blank lines */
                for (; i < (SCROLL_LINES + numkept); i++)
                {
                    set_pos (i+1, 1);
                    set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
                    erase_to_eol( confp );
                }

                /* Display the scroll indicators */
                if (topmsg != oldest_msg())
                {
                    /* More messages precede top line */
                    set_pos (1, cons_cols);
                    set_color (COLOR_DEFAULT_LIGHT, COLOR_DEFAULT_BG);
                    draw_text ("+");
                }
                if (!is_currline_visible())
                {
                    /* More messages follow bottom line */
                    set_pos (cons_rows-2, cons_cols);
                    set_color (COLOR_DEFAULT_LIGHT, COLOR_DEFAULT_BG);
                    draw_text ("V");
                }

                /* restore cursor location */
                cur_cons_row = saved_cons_row;
                cur_cons_col = saved_cons_col;
            } /* end if(redraw_msgs) */

            if (redraw_cmd)
            {
                /* Save cursor location */
                saved_cons_row = cur_cons_row;
                saved_cons_col = cur_cons_col;

                /* Display the command line */
                set_pos (CMDLINE_ROW, 1);
                set_color (COLOR_DEFAULT_LIGHT, COLOR_DEFAULT_BG);
                draw_text( CMD_PREFIX_HERC );
                set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
                PUTC_CMDLINE ();
                fill_text (' ',cons_cols);

                /* restore cursor location */
                cur_cons_row = saved_cons_row;
                cur_cons_col = saved_cons_col;
            } /* end if(redraw_cmd) */

            /* Determine if redraw required for CPU or architecture
             * change.
             */
            if ((sysblk.pcpu != prvpcpu &&
                 (regs = sysblk.regs[sysblk.pcpu]) != NULL) ||
                ((regs = sysblk.regs[prvpcpu]) != NULL &&
                 regs->arch_mode != prvparch))
            {
                redraw_status = 1;
                prvpcpu = sysblk.pcpu;
                prvparch = regs->arch_mode;
            }

            if (redraw_status && !npquiet)
            {
                char    ibuf[64];       /* Rate buffer                */

                {
                    int cnt_disabled = 0;
                    int cnt_stopped  = 0;
                    int cnt_online = 0;
                    char   *state;
                    for ( i = 0; i < sysblk.maxcpu; i++ )
                    {
                        if ( IS_CPU_ONLINE(i) )
                        {
                            cnt_online++;
                            if ( sysblk.regs[i]->cpustate != CPUSTATE_STARTED )
                                cnt_stopped++;
                            if ( WAITSTATE(&sysblk.regs[i]->psw) &&
                                 IS_IC_DISABLED_WAIT_PSW( sysblk.regs[i] ) )
                                cnt_disabled++;
                        }
                    }
                    state = "RED";

                    if ( cnt_online > cnt_stopped && cnt_disabled == 0 )
                        state = "AMBER";

                    if (0
                        || ( sysblk.hicpu && (cnt_stopped == 0 && cnt_disabled == 0))
#if defined(OPTION_SHARED_DEVICES)
                        || (!sysblk.hicpu && (sysblk.shrdport))
#endif // defined(OPTION_SHARED_DEVICES)
                    )
                        state = "GREEN";
                    set_console_title(state);
                }

                /* Save cursor location */
                saved_cons_row = cur_cons_row;
                saved_cons_col = cur_cons_col;

                memset (buf, ' ', cons_cols);
                len = sprintf ( buf, "%s%02X ",
                    PTYPSTR(sysblk.pcpu), sysblk.pcpu ) ;
                if (IS_CPU_ONLINE(sysblk.pcpu))
                {
                    len += sprintf(buf+len, "PSW=%8.8X%8.8X ",
                                   fetch_fw(curpsw), fetch_fw(curpsw+4));
                    if (regs->arch_mode == ARCH_900)
                        len += sprintf (buf+len, "%16.16"PRIX64" ",
                                        fetch_dw (curpsw+8));
#if defined(_FEATURE_SIE)
                    else
                        if( SIE_MODE(regs) )
                        {
                            for(i = 0;i < 16;i++)
                                buf[len++] = '-';
                            buf[len++] = ' ';
                        }
#endif /*defined(_FEATURE_SIE)*/
                    len += sprintf (buf+len, "%2d%c%c%c%c%c%c%c%c",
                           regs->psw.amode64                  ? 64 :
                           regs->psw.amode                    ? 31 : 24,
                           regs->cpustate == CPUSTATE_STOPPED ? 'M' : '.',
                           sysblk.inststep                    ? 'T' : '.',
                           WAITSTATE(&regs->psw)              ? 'W' : '.',
                           regs->loadstate                    ? 'L' : '.',
                           regs->checkstop                    ? 'C' : '.',
                           PROBSTATE(&regs->psw)              ? 'P' : '.',
                           SIE_MODE(regs)                     ? 'S' : '.',
                           regs->arch_mode == ARCH_900        ? 'Z' : '.');
                }
                else
                    len += sprintf (buf+len,"%s", "Offline");
                buf[len++] = ' ';


#if defined(OPTION_MIPS_COUNTING)
                /* Bottom line right corner can be when there is space:
                 * ""
                 * "instcnt <string>"
                 * "instcnt <string>; mips nnnnn"
                 * nnnnn can be nnnnn, nnn.n, nn.nn or n.nnn
                 * "instcnt <string>; mips nnnnn; IO/s nnnnnn"
                 * "IO/s nnnnnn"
                 */

                i = 0;
                if (numcpu)
                {
                    U32 mipsrate = sysblk.mipsrate / 1000000;

                    /* Format instruction count */
                    i = snprintf(ibuf, sizeof(ibuf),
                                 "instcnt %s",
                                 format_int(totalcount));

                    if ((len + i + 12) < cons_cols)
                    {
                        if (mipsrate > 999)
                            i += snprintf(ibuf + i, sizeof(ibuf) - i,
                                          "; mips %1d,%03d",
                                          sysblk.mipsrate / 1000000000,
                                          ((sysblk.mipsrate % 1000000000) +
                                            500000) / 1000000);
                        else
                        {
                            U32 mipsfrac = sysblk.mipsrate % 1000000;

                            if (mipsrate > 99)
                                i += snprintf(ibuf + i, sizeof(ibuf) - i,
                                              "; mips %3d.%01d",
                                              mipsrate,
                                              (mipsfrac + 50000) / 100000);
                            else if (mipsrate > 9)
                                i += snprintf(ibuf + i, sizeof(ibuf) - i,
                                              "; mips %2d.%02d",
                                              mipsrate,
                                              (mipsfrac + 5000) / 10000);
                            else
                                i += snprintf(ibuf + i, sizeof(ibuf) - i,
                                              "; mips %1d.%03d",
                                              mipsrate,
                                              (mipsfrac + 500) / 1000);
                        }
                    }
                }

                /* Prepare I/O statistics */
                if (1
                    && (len + i + (numcpu ? 13 : 11)) < cons_cols
                    && (0
                        ||   numcpu
#if defined(OPTION_SHARED_DEVICES)
                        || (!numcpu && sysblk.shrdport)
#endif // defined(OPTION_SHARED_DEVICES)
                       )
                )
                {
                    if (numcpu)
                        ibuf[(int)i++] = ';',
                        ibuf[(int)i++] = ' ';
                    i += snprintf(ibuf + i, sizeof(ibuf) - i,
                                  "I/O %6.6s",
                                  format_int(sysblk.siosrate));
                }

                /* Copy prepared statistics to buffer */
                if (i)
                {
                    if ((len + i) < cons_cols)
                        len = cons_cols - i;
                    strcpy (buf + len, ibuf);
                    len = cons_cols - 1;
                }
#endif /* OPTION_MIPS_COUNTING */

                buf[cons_cols] = '\0';
                set_pos (cons_rows, 1);
                set_color (COLOR_LIGHT_YELLOW, COLOR_RED);
                draw_text (buf);

                /* restore cursor location */
                cur_cons_row = saved_cons_row;
                cur_cons_col = saved_cons_col;
            } /* end if(redraw_status) */

            /* Flush screen buffer and reset display update indicators */
            if (redraw_msgs || redraw_cmd || redraw_status)
            {
                set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
                if (NPDup == 0 && NPDinit == 1)
                {
                    NPDinit = 0;
                    restore_command_line();
                    set_pos (cur_cons_row, cur_cons_col);
                }
                else if (redraw_cmd)
                    set_pos (CMDLINE_ROW, CMDLINE_COL + cmdoff - cmdcol);
                else
                    set_pos (cur_cons_row, cur_cons_col);
                fflush (confp);
                redraw_msgs = redraw_cmd = redraw_status = 0;
            }

        } else { /* (NPDup == 1) */

            if (redraw_status || (NPDinit == 0 && NPDup == 1)
                   || (redraw_cmd && NPdataentry == 1)) {
                if (NPDinit == 0) {
                    NPDinit = 1;
                    NP_screen_redraw(regs);
                    NP_update(regs);
                    fflush (confp);
                }
            }
            /* Update New Panel every panrate interval */
            if (!npquiet) {
                NP_update(regs);
                fflush (confp);
            }
            redraw_msgs = redraw_cmd = redraw_status = 0;
        }

    /* =END= */

        /* Force full screen repaint if needed */
        if (!sysblk.npquiet && npquiet)
            redraw_msgs = redraw_cmd = redraw_status = 1;
        npquiet = sysblk.npquiet;

    } /* end while */

    sysblk.panel_init = 0;

    WRMSG (HHC00101, "I", thread_id(), get_thread_priority(0), "Control panel");

    ASSERT( sysblk.shutdown );  // (why else would we be here?!)

} /* end function panel_display */

static void panel_cleanup(void *unused)
{
int i;
PANMSG* p;

    UNREFERENCED(unused);

    log_wakeup(NULL);

    if(topmsg)
    {
        set_screen_color( stderr, COLOR_DEFAULT_FG, COLOR_DEFAULT_BG );
        clear_screen( stderr );

        /* Scroll to last full screen's worth of messages */
        scroll_to_bottom_screen();

        /* Display messages in scrolling area */
        for (i=0, p = topmsg; i < SCROLL_LINES && p != curmsg->next; i++, p = p->next)
        {
            set_pos (i+1, 1);
            set_color (COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);
            write_text (p->msg, MSG_SIZE);
        }
    }
    sysblk.panel_init = 0;                          /* Panel is no longer running */

    /* Restore the terminal mode */
    set_or_reset_console_mode( keybfd, 0 );

    /* Position to next line */
    fwrite("\n",1,1,stderr);

#ifdef OPTION_MIPS_COUNTING
    {
        char*   pszCurrIntervalStartDateTime;
        char*   pszCurrentDateTime;
        char    buf[128];
        time_t  current_time;

        current_time = time( NULL );

        pszCurrIntervalStartDateTime = strdup( ctime( &curr_int_start_time ) );
        pszCurrIntervalStartDateTime[strlen(pszCurrIntervalStartDateTime) - 1] = 0;
        pszCurrentDateTime           = strdup( ctime(    &current_time     ) );
        pszCurrentDateTime[strlen(pszCurrentDateTime) - 1] = 0;

        WRMSG(HHC02272, "I", "Highest observed MIPS and IO/s rates");
        MSGBUF( buf, "  from %s", pszCurrIntervalStartDateTime);
        WRMSG(HHC02272, "I", buf);
        MSGBUF( buf, "    to %s", pszCurrentDateTime);
        WRMSG(HHC02272, "I", buf);
        MSGBUF( buf, "  MIPS: %d.%02d  IO/s: %d",
                    curr_high_mips_rate / 1000000,
                    curr_high_mips_rate % 1000000,
                    curr_high_sios_rate );
        WRMSG(HHC02272, "I", buf);

        free( pszCurrIntervalStartDateTime );
        free( pszCurrentDateTime           );
    }
#endif

    set_screen_color(stderr, COLOR_DEFAULT_FG, COLOR_DEFAULT_BG);

    fflush(stderr);
}