cc65/libsrc/dbg/dbg.c

/*
** dbg.c
**
** Ullrich von Bassewitz, 08.08.1998
**
*/



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
#include <6502.h>
#include <dbg.h>



/*****************************************************************************/
/*                             Function forwards                             */
/*****************************************************************************/



/* Forwards for handler functions */
static char AsmHandler (void);
static char RegHandler (void);
static char StackHandler (void);
static char CStackHandler (void);
static char DumpHandler (void);
static char HelpHandler (void);

/* Forwards for other functions */
static void DisplayPrompt (const char* s);
static void SingleStep (char StepInto);
static void RedrawStatic (char  Frame);
static void Redraw (char Frame);
static char GetKeyUpdate (void);



/*****************************************************************************/
/*                                   Data                                    */
/*****************************************************************************/



/* Color definitions */
#if defined(__C16__)
#  define COLOR_BORDER          (BCOLOR_DARKBLUE | CATTR_LUMA6)
#  define COLOR_BACKGROUND      COLOR_WHITE
#  define COLOR_TEXTHIGH        COLOR_BLACK
#  define COLOR_TEXTLOW         COLOR_GRAY1
#  define COLOR_FRAMEHIGH       COLOR_BLACK
#  define COLOR_FRAMELOW        COLOR_GRAY2
#else
#  if defined(COLOR_GRAY3)
#    define COLOR_BORDER        COLOR_BLACK
#    define COLOR_BACKGROUND    COLOR_BLACK
#    define COLOR_TEXTHIGH      COLOR_WHITE
#    define COLOR_TEXTLOW       COLOR_GRAY3
#    define COLOR_FRAMEHIGH     COLOR_WHITE
#    define COLOR_FRAMELOW      COLOR_GRAY3
#  else
#    if defined(__APPLE2__)
#      define COLOR_BORDER      COLOR_BLACK
#      define COLOR_BACKGROUND  COLOR_BLACK
#      define COLOR_TEXTHIGH    COLOR_BLACK
#      define COLOR_TEXTLOW     COLOR_BLACK
#      define COLOR_FRAMEHIGH   COLOR_BLACK
#      define COLOR_FRAMELOW    COLOR_BLACK
#    else
#      define COLOR_BORDER      COLOR_BLACK
#      define COLOR_BACKGROUND  COLOR_BLACK
#      define COLOR_TEXTHIGH    COLOR_WHITE
#      define COLOR_TEXTLOW     COLOR_WHITE
#      define COLOR_FRAMEHIGH   COLOR_WHITE
#      define COLOR_FRAMELOW    COLOR_WHITE
#    endif
#  endif
#endif
#ifndef COLOR_BLACK
#  define COLOR_BLACK   0
#endif
#ifndef COLOR_WHITE
#  define COLOR_WHITE   1
#endif

/* Screen definitions */
#if defined(__CBM610__)
#  define BIGSCREEN
#  define MAX_X         80
#  define MAX_Y         25
#  define DUMP_BYTES    16
#elif defined(__APPLE2__) || defined(__ATARI__)
#  define MAX_X         40
#  define MAX_Y         24
#  define DUMP_BYTES     8
#else
#  define MAX_X         40
#  define MAX_Y         25
#  define DUMP_BYTES     8
#endif

/* Replacement key definitions */
#ifndef CH_DEL
#  define CH_DEL        ('H' - 'A' + 1)         /* Ctrl+H */
#endif

/* Replacement char definitions */
#ifndef CH_ULCORNER
#  define CH_ULCORNER   '+'
#endif
#ifndef CH_URCORNER
#  define CH_URCORNER   '+'
#endif
#ifndef CH_LLCORNER
#  define CH_LLCORNER   '+'
#endif
#ifndef CH_LRCORNER
#  define CH_LRCORNER   '+'
#endif
#ifndef CH_TTEE
#  define CH_TTEE       '+'
#endif
#ifndef CH_LTEE
#  define CH_LTEE       '+'
#endif
#ifndef CH_RTEE
#  define CH_RTEE       '+'
#endif
#ifndef CH_BTEE
#  define CH_BTEE       '+'
#endif
#ifndef CH_CROSS
#  define CH_CROSS      '+'
#endif

/* Defines for opcodes */
#define OPC_BRK         0x00
#define OPC_BPL         0x10
#define OPC_JSR         0x20
#define OPC_BMI         0x30
#define OPC_RTI         0x40
#define OPC_JMP         0x4C
#define OPC_BVC         0x50
#define OPC_RTS         0x60
#define OPC_JMPIND      0x6C
#define OPC_BVS         0x70
#define OPC_BCC         0x90
#define OPC_BCS         0xB0
#define OPC_BNE         0xD0
#define OPC_BEQ         0xF0



/* Register values that are used also in the assembler stuff */
extern unsigned char DbgSP;             /* Stack pointer */
extern unsigned      DbgCS;             /* C stack pointer */
extern unsigned      DbgHI;             /* High 16 bit of primary reg */



/* Descriptor for one text line */
typedef struct {
    unsigned char x;
    unsigned char y;
    const char*   text;
} TextDesc;

/* Window descriptor */
typedef struct {
    unsigned char fd_tl;                /* Top left char */
    unsigned char fd_tr;                /* Top right char */
    unsigned char fd_bl;                /* Bottom left char */
    unsigned char fd_br;                /* Bottom right char */
    unsigned char fd_x1, fd_y1;         /* Upper left corner */
    unsigned char fd_x2, fd_y2;         /* Lower right corner */
    unsigned char fd_width, fd_height;  /* Redundant but faster */
    unsigned char fd_visible;           /* Is the window currently visible? */
    char (*fd_func) (void);             /* Handler function */
    unsigned char fd_textcount;         /* Number of text lines to print */
    const TextDesc* fd_text;            /* Static text in the window */
} FrameDesc;



/* Texts for the windows */
static const TextDesc RegText [] = {
    { 1,  0, "PC" },
    { 1,  1, "SR" },
    { 1,  2, "A"  },
    { 1,  3, "X"  },
    { 1,  4, "Y"  },
    { 1,  5, "SP" },
    { 1,  6, "CS" },
    { 1,  7, "HI" }
};
static const TextDesc HelpText [] = {
    { 1,  0, "F1, ?     Help"                           },
    { 1,  1, "F2, t     Toggle breakpoint"              },
    { 1,  2, "F3, u     Run until subroutine returns"   },
    { 1,  3, "F4, h     Run to cursor"                  },
    { 1,  4, "F7, space Step into"                      },
    { 1,  5, "F8, enter Step over"                      },
    { 1,  6, "1-5       Select active window"           },
    { 1,  7, "+         Page down"                      },
    { 1,  8, "-         Page up"                        },
    { 1,  9, "Cursor    Move up/down"                   },
    { 1, 10, "a/z       Move up/down"                   },
    { 1, 11, "c         Continue"                       },
    { 1, 12, "f         Follow instruction"             },
    { 1, 13, "o         Goto origin"                    },
    { 1, 14, "p         Use as new PC value"            },
    { 1, 15, "q         Quit"                           },
    { 1, 16, "r         Redraw screen"                  },
    { 1, 17, "s         Skip next instruction"          },
};


/* Window data */
static const FrameDesc AsmFrame = {
    CH_ULCORNER, CH_TTEE, CH_LTEE, CH_CROSS,
    0, 0, MAX_X - 10, 15,
    MAX_X - 11, 14,
    1,
    AsmHandler,
    0, 0
};
static const FrameDesc RegFrame = {
    CH_TTEE, CH_URCORNER, CH_LTEE, CH_RTEE,
    MAX_X - 10, 0, MAX_X - 1, 9,
    8, 8,
    1,
    RegHandler,
    sizeof (RegText) / sizeof (RegText [0]), RegText
};
static const FrameDesc StackFrame = {
    CH_LTEE, CH_RTEE, CH_CROSS, CH_RTEE,
    MAX_X - 10, 9, MAX_X - 1, 15,
    8, 5,
    1,
    StackHandler,
    0, 0
};
static const FrameDesc CStackFrame = {
    CH_CROSS, CH_RTEE, CH_BTEE, CH_LRCORNER,
    MAX_X - 10, 15, MAX_X - 1, MAX_Y - 1,
    8, MAX_Y - 17,
    1,
    CStackHandler,
    0, 0
};
static const FrameDesc DumpFrame = {
    CH_LTEE, CH_CROSS, CH_LLCORNER, CH_BTEE,
    0, 15, MAX_X - 10, MAX_Y-1,
    MAX_X - 11, MAX_Y - 17,
    1,
    DumpHandler,
    0, 0
};
static const FrameDesc HelpFrame = {
    CH_ULCORNER, CH_URCORNER, CH_LLCORNER, CH_LRCORNER,
    0, 0, MAX_X - 1, MAX_Y-1,
    MAX_X - 2, MAX_Y - 2,
    0,
    HelpHandler,
    sizeof (HelpText) / sizeof (HelpText [0]), HelpText
};
static const FrameDesc* const Frames [] = {
    &AsmFrame,
    &RegFrame,
    &StackFrame,
    &CStackFrame,
    &DumpFrame,
    &HelpFrame
};

/* Number of active frame, -1 = none */
static int ActiveFrame = -1;

/* Window names */
#define WIN_ASM         0
#define WIN_REG         1
#define WIN_STACK       2
#define WIN_CSTACK      3
#define WIN_DUMP        4
#define WIN_HELP        5

/* Other window data */
static unsigned AsmAddr;        /* Start address of output */
static unsigned DumpAddr;       /* Start address of output */
static unsigned CStackAddr;     /* Start address of output */
static unsigned char StackAddr; /* Start address of output */



/* Prompt line data */
static const char* ActivePrompt = 0;  /* Last prompt line displayed */
static char PromptColor;        /* Color behind prompt */
static char PromptLength;       /* Length of current prompt string */



/* Values for the bk_use field of struct BreakPoint */
#define BRK_EMPTY       0x00
#define BRK_USER        0x01
#define BRK_TMP         0x80

/* Structure describing a breakpoint */
typedef struct {
    unsigned      bk_addr;      /* Address, 0 if unused */
    unsigned char bk_opc;       /* Opcode */
    unsigned char bk_use;       /* 1 if in use, 0 otherwise */
} BreakPoint;



/* Temporary breakpoints - also accessed from the assembler source */
#define MAX_USERBREAKS  10
unsigned char DbgBreakCount = 0;
BreakPoint DbgBreaks [MAX_USERBREAKS+2];



/*****************************************************************************/
/*              Forwards for functions in the assembler source               */
/*****************************************************************************/



BreakPoint* DbgGetBreakSlot (void);
/* Search for a free breakpoint slot. Return a pointer to the slot or 0 */

BreakPoint* DbgIsBreak (unsigned Addr);
/* Check if there is a user breakpoint at the given address, if so, return
** a pointer to the slot, else return 0.
*/



/*****************************************************************************/
/*                         Frame/window drawing code                         */
/*****************************************************************************/



static void DrawFrame (register const FrameDesc* F, char Active)
/* Draw one window frame */
{
    const TextDesc* T;
    unsigned char Count;
    unsigned char tl, tr, bl, br;
    unsigned char x1, y1, width;
    unsigned char OldColor;

    /* Determine the characters for the corners, set frame color */
    if (Active) {
        OldColor = textcolor (COLOR_FRAMEHIGH);
        tl = CH_ULCORNER;
        tr = CH_URCORNER;
        bl = CH_LLCORNER;
        br = CH_LRCORNER;
    } else {
        OldColor = textcolor (COLOR_FRAMELOW);
        tl = F->fd_tl;
        tr = F->fd_tr;
        bl = F->fd_bl;
        br = F->fd_br;
    }

    /* Get the coordinates into locals for faster access */
    x1 = F->fd_x1;
    y1 = F->fd_y1;
    width = F->fd_width;

    /* Top line */
    cputcxy (x1, y1, tl);
    chline (width);
    cputc (tr);

    /* Left line */
    cvlinexy (x1, ++y1, F->fd_height);

    /* Bottom line */
    cputc (bl);
    chline (width);
    cputc (br);

    /* Right line */
    cvlinexy (F->fd_x2, y1, F->fd_height);

    /* If the window has static text associated, print the text */
    (void) textcolor (COLOR_TEXTLOW);
    Count = F->fd_textcount;
    T = F->fd_text;
    while (Count--) {
        cputsxy (x1 + T->x, y1 + T->y, T->text);
        ++T;
    }

    /* Set the old color */
    (void) textcolor (OldColor);
}



static void DrawFrames (void)
/* Draw all frames */
{
    unsigned char I;
    const FrameDesc* F;

    /* Build the frame layout of the screen */
    for (I = 0; I < sizeof (Frames) / sizeof (Frames [0]); ++I) {
        F = Frames [I];
        if (F->fd_visible) {
            DrawFrame (F, 0);
        }
    }
}



static void ActivateFrame (int Num, unsigned char Clear)
/* Activate a new frame, deactivate the old one */
{
    unsigned char y;
    register const FrameDesc* F;

    if (ActiveFrame != Num) {

        /* Deactivate the old one */
        if (ActiveFrame >= 0) {
            DrawFrame (Frames [ActiveFrame], 0);
        }

        /* Activate the new one */
        if ((ActiveFrame = Num) >= 0) {
            F = Frames [ActiveFrame];
            /* Clear the frame if requested */
            if (Clear) {
                for (y = F->fd_y1+1; y < F->fd_y2; ++y) {
                    cclearxy (F->fd_x1+1, y, F->fd_width);
                }
            }
            DrawFrame (F, 1);
        }

        /* Redraw the current prompt line */
        DisplayPrompt (ActivePrompt);

    }
}



/*****************************************************************************/
/*                                Prompt line                                */
/*****************************************************************************/



static void DisplayPrompt (const char* s)
/* Display a prompt */
{
    unsigned char OldColor;

    /* Remember the current color */
    OldColor = textcolor (COLOR_TEXTHIGH);

    /* Clear the old prompt if there is one */
    if (ActivePrompt) {
        (void) textcolor (PromptColor);
        chlinexy ((MAX_X - PromptLength) / 2, MAX_Y-1, PromptLength);
    }

    /* Get the new prompt data */
    ActivePrompt = s;
    PromptColor  = OldColor;
    PromptLength = strlen (ActivePrompt);

    /* Display the new prompt */
    (void) textcolor (COLOR_TEXTHIGH);
    cputsxy ((MAX_X - PromptLength) / 2, MAX_Y-1, ActivePrompt);

    /* Restore the old color */
    (void) textcolor (PromptColor);
}



static void HelpPrompt (void)
/* Display a prompt line mentioning the help key */
{
    DisplayPrompt ("Press F1 for help");
}



static void AnyKeyPrompt (void)
{
    DisplayPrompt ("Press any key to continue");
}



static char IsAbortKey (char C)
/* Return true if C is an abort key */
{
#if defined(CH_ESC)
    if (C == CH_ESC) {
        return 1;
    }
#endif
#if defined(CH_STOP)
    if (C == CH_STOP) {
        return 1;
    }
#endif
#if !defined(CH_ESC) && !defined(CH_STOP)
    /* Avoid compiler warning about unused parameter */
    (void) C;
#endif
    return 0;
}



static char Input (char* Prompt, char* Buf, unsigned char Count)
/* Read input from the user, return 1 on success, 0 if aborted */
{
    int Frame;
    unsigned char OldColor;
    unsigned char OldCursor;
    unsigned char x1;
    unsigned char i;
    unsigned char done;
    char c;

    /* Clear the current prompt line */
    cclearxy (0, MAX_Y-1, MAX_X);

    /* Display the new prompt */
    OldColor = textcolor (COLOR_TEXTHIGH);
    cputsxy (0, MAX_Y-1, Prompt);
    (void) textcolor (COLOR_TEXTLOW);

    /* Remember where we are, enable the cursor */
    x1 = wherex ();
    OldCursor = cursor (1);

    /* Get input and handle it */
    i = done = 0;
    do {
        c = cgetc ();
        if (isalnum (c) && i < Count) {
            Buf [i] = c;
            cputcxy (x1 + i, MAX_Y-1, c);
            ++i;
        } else if (i > 0 && c == CH_DEL) {
            --i;
            cputcxy (x1 + i, MAX_Y-1, ' ');
            gotoxy (x1 + i, MAX_Y-1);
        } else if (c == '\n') {
            Buf [i] = '\0';
            done = 1;
        } else if (IsAbortKey (c)) {
            /* Abort */
            done = 2;
        }
    } while (!done);

    /* Reset settings, display old prompt line */
    cursor (OldCursor);
    (void) textcolor (OldColor);
    DrawFrames ();
    Frame = ActiveFrame;
    ActiveFrame = -1;
    ActivateFrame (Frame, 0);

    return (done == 1);
}



static char InputHex (char* Prompt, unsigned* Val)
/* Prompt for a hexadecimal value. Return 0 on failure. */
{
    char Buf [5];
    char* P;
    char C;
    unsigned V;

    /* Read input from the user (4 digits max), check input */
    if (Input (Prompt, Buf, sizeof (Buf)-1) && isxdigit (Buf [0])) {

        /* Check the characters and convert to hex */
        P = Buf;
        V = 0;
        while ((C = *P) && isxdigit (C)) {
            V <<= 4;
            if (isdigit (C)) {
                C -= '0';
            } else {
                C = toupper (C) - ('A' - 10);
            }
            V += C;
            ++P;
        }

        /* Assign the value */
        *Val = V;

        /* Success */
        return 1;

    } else {

        /* Failure */
        return 0;

    }
}



static void ErrorPrompt (const char* Msg)
/* Display an error message and wait for a key */
{
    /* Save the current prompt */
    const char* OldPrompt = ActivePrompt;

    /* Display the new one */
    DisplayPrompt (Msg);

    /* Wait for a key and discard it */
    cgetc ();

    /* Restore the old prompt */
    DisplayPrompt (OldPrompt);
}



static char InputGoto (unsigned* Addr)
/* Prompt "Goto" and read an address. Print an error and return 0 on failure. */
{
    char Ok;
    Ok = InputHex ("Goto: ", Addr);
    if (!Ok) {
        ErrorPrompt ("Invalid input - press a key");
    }
    return Ok;
}



static void BreakInRomError (void)
/* Print an error message if we cannot set a breakpoint */
{
    ErrorPrompt ("Cannot set breakpoint - press a key");
}



/*****************************************************************************/
/*                            Breakpoint handling                            */
/*****************************************************************************/



static void DbgSetTmpBreak (unsigned Addr)
/* Set a breakpoint */
{
    BreakPoint* B = DbgGetBreakSlot ();
    B->bk_addr    = Addr;
    B->bk_use     = BRK_TMP;
}



static void DbgToggleUserBreak (unsigned Addr)
/* Set a breakpoint */
{
    register BreakPoint* B = DbgIsBreak (Addr);

    if (B) {
        /* We have a breakpoint, remove it */
        B->bk_use = BRK_EMPTY;
        --DbgBreakCount;
    } else {
        /* We don't have a breakpoint, set one */
        if (DbgBreakCount >= MAX_USERBREAKS) {
            ErrorPrompt ("Too many breakpoints - press a key");
        } else {
            /* Test if we can set a breakpoint at that address */
            if (!DbgIsRAM (Addr)) {
                BreakInRomError ();
            } else {
                /* Set the breakpoint */
                B = DbgGetBreakSlot ();
                B->bk_addr = Addr;
                B->bk_use  = BRK_USER;
                ++DbgBreakCount;
            }
        }
    }
}



static void DbgResetTmpBreaks (void)
/* Reset all temporary breakpoints */
{
    unsigned char i;
    BreakPoint* B = DbgBreaks;

    for (i = 0; i < MAX_USERBREAKS; ++i) {
        if (B->bk_use == BRK_TMP) {
            B->bk_use = BRK_EMPTY;
        }
        ++B;
    }
}



static unsigned char DbgTmpBreaksOk (void)
/* Check if the temporary breakpoints can be set, if so, return 1, if not,
** reset them all and return 0.
*/
{
    unsigned char i;
    BreakPoint* B = DbgBreaks;
    for (i = 0; i < MAX_USERBREAKS; ++i) {
        if (B->bk_use == BRK_TMP && !DbgIsRAM (B->bk_addr)) {
            BreakInRomError ();
            DbgResetTmpBreaks ();
            return 0;
        }
        ++B;
    }
    return 1;
}



/*****************************************************************************/
/*                          Assembler window stuff                           */
/*****************************************************************************/



static unsigned AsmBack (unsigned mem, unsigned char lines)
/* Go back in the assembler window the given number of lines (calculate
** new start address).
*/
{
    unsigned cur;
    unsigned adr [32];
    unsigned char in;

    unsigned offs = 6;
    while (1) {
        in = 0;
        cur = mem - (lines * 3) - offs;
        while (1) {
            cur += DbgDisAsmLen (cur);
            adr [in] = cur;
            in = (in + 1) & 0x1F;
            if (cur >= mem) {
                if (cur == mem || offs == 12) {
                    /* Found */
                    return adr [(in - lines - 1) & 0x1F];
                } else {
                    /* The requested address is inside an instruction, go back
                    ** one more byte and try again.
                    */
                    ++offs;
                    break;
                }
            }
        }
    }
}



static unsigned UpdateAsm (void)
/* Update the assembler window starting at the given address */
{
    char buf [MAX_X];
    unsigned char len;
    unsigned char y;
    unsigned char width = AsmFrame.fd_width;
    unsigned char x = AsmFrame.fd_x1 + 1;
    unsigned      m = AsmBack (AsmAddr, 2);

    for (y = AsmFrame.fd_y1+1; y < AsmFrame.fd_y2; ++y) {
        len = DbgDisAsm (m, buf, width);
        if (m == brk_pc) {
            buf [4] = '-';
            buf [5] = '>';
        }
        if (DbgIsBreak (m)) {
            buf [5] = '*';
        }
        if (m == AsmAddr) {
            revers (1);
            cputsxy (1, y, buf);
            revers (0);
        } else {
            cputsxy (1, y, buf);
        }
        m += len;
    }
    return m;
}



static unsigned AsmArg16 (void)
/* Return a 16 bit argument */
{
    return *(unsigned*)(AsmAddr+1);
}



static void AsmFollow (void)
/* Follow the current instruction */
{
    switch (*(unsigned char*) AsmAddr) {

        case OPC_JMP:
        case OPC_JSR:
            AsmAddr = AsmArg16 ();
            break;

        case OPC_JMPIND:
            AsmAddr = *(unsigned*)AsmArg16 ();
            break;

        case OPC_BPL:
        case OPC_BMI:
        case OPC_BVC:
        case OPC_BVS:
        case OPC_BCC:
        case OPC_BCS:
        case OPC_BNE:
        case OPC_BEQ:
            AsmAddr = AsmAddr + 2 + *(signed char*)(AsmAddr+1);
            break;

        case OPC_RTS:
            AsmAddr = (*(unsigned*) (DbgSP + 0x101) + 1);
            break;

        case OPC_RTI:
            AsmAddr = *(unsigned*) (DbgSP + 0x102);
            break;

    }
}



static void AsmHome (void)
/* Set the cursor to home position */
{
    AsmAddr = brk_pc;
}



static void InitAsm (void)
/* Initialize the asm window */
{
    AsmHome ();
    UpdateAsm ();
}



static char AsmHandler (void)
/* Get characters and handle them */
{
    char c;
    unsigned Last;

    while (1) {

        /* Update the window contents */
        Last = UpdateAsm ();

        /* Read and handle input */
        switch (c = GetKeyUpdate ()) {

            case  '+':
                AsmAddr = Last;
                break;

            case '-':
                AsmAddr = AsmBack (AsmAddr, AsmFrame.fd_height);
                break;

            case 't':
#ifdef CH_F2
            case CH_F2:
#endif
                DbgToggleUserBreak (AsmAddr);
                break;

            case 'f':
                AsmFollow ();
                break;

            case 'g':
                InputGoto (&AsmAddr);
                break;

            case 'o':
                AsmHome ();
                break;

            case 'p':
                brk_pc = AsmAddr;
                break;

            case 'a':
#ifdef CH_CURS_UP
            case CH_CURS_UP:
#endif
                AsmAddr = AsmBack (AsmAddr, 1);
                break;

            case 'z':
#ifdef CH_CURS_DOWN
            case CH_CURS_DOWN:
#endif
                AsmAddr += DbgDisAsmLen (AsmAddr);
                break;

            default:
                return c;

        }
    }
}



/*****************************************************************************/
/*                           Register window stuff                           */
/*****************************************************************************/



static unsigned UpdateReg (void)
/* Update the register window */
{
    unsigned char x1 = RegFrame.fd_x1 + 5;
    unsigned char x2 = x1 + 2;
    unsigned char y = RegFrame.fd_y1;

    /* Print the register contents */
    gotoxy (x1, ++y);   cputhex16 (brk_pc);
    gotoxy (x2, ++y);   cputhex8  (brk_sr);
    gotoxy (x2, ++y);   cputhex8  (brk_a);
    gotoxy (x2, ++y);   cputhex8  (brk_x);
    gotoxy (x2, ++y);   cputhex8  (brk_y);
    gotoxy (x2, ++y);   cputhex8  (DbgSP);
    gotoxy (x1, ++y);   cputhex16 (DbgCS);
    gotoxy (x1, ++y);   cputhex16 (DbgHI);

    /* Not needed */
    return 0;
}



static void InitReg (void)
/* Initialize the register window */
{
    UpdateReg ();
}



static char RegHandler (void)
/* Get characters and handle them */
{
    return GetKeyUpdate ();
}



/*****************************************************************************/
/*                             Stack window stuff                            */
/*****************************************************************************/



static unsigned UpdateStack (void)
/* Update the stack window */
{
    unsigned char mem = StackAddr;
    unsigned char x1 = StackFrame.fd_x1 + 1;
    unsigned char x2 = x1 + 6;
    unsigned char y;

    for (y = StackFrame.fd_y2-1; y > StackFrame.fd_y1; --y) {
        gotoxy (x1, y);
        cputhex8 (mem);
        gotoxy (x2, y);
        cputhex8 (* (unsigned char*) (mem + 0x100));
        ++mem;
    }
    return mem;
}



static void StackHome (void)
/* Set the cursor to home position */
{
    StackAddr = DbgSP + 1;
}



static void InitStack (void)
/* Initialize the stack window */
{
    StackHome ();
    UpdateStack ();
}



static char StackHandler (void)
/* Get characters and handle them */
{
    char c;
    unsigned char BytesPerPage = StackFrame.fd_height;

    while (1) {

        /* Read and handle input */
        switch (c = GetKeyUpdate ()) {

            case  '+':
                StackAddr += BytesPerPage;
                break;

            case '-':
                StackAddr -= BytesPerPage;
                break;

            case 'o':
                StackHome ();
                break;

            case 'a':
#ifdef CH_CURS_UP:
            case CH_CURS_UP:
#endif
                --StackAddr;
                break;

            case 'z':
#ifdef CH_CURS_DOWN
            case CH_CURS_DOWN:
#endif
                ++StackAddr;
                break;

            default:
                return c;

        }

        /* Update the window contents */
        UpdateStack ();
    }
}



/*****************************************************************************/
/*                           C Stack window stuff                            */
/*****************************************************************************/



static unsigned UpdateCStack (void)
/* Update the C stack window */
{
    unsigned mem     = CStackAddr;
    unsigned char x  = CStackFrame.fd_x1 + 5;
    unsigned char y;

    for (y = CStackFrame.fd_y2-1; y > CStackFrame.fd_y1; --y) {
        gotoxy (x, y);
        cputhex16 (* (unsigned*)mem);
        mem += 2;
    }
    cputsxy (CStackFrame.fd_x1+1, CStackFrame.fd_y2-1, "->");
    return mem;
}



static void CStackHome (void)
/* Set the cursor to home position */
{
    CStackAddr = DbgCS;
}



static void InitCStack (void)
/* Initialize the C stack window */
{
    CStackHome ();
    UpdateCStack ();
}



static char CStackHandler (void)
/* Get characters and handle them */
{
    char c;
    unsigned char BytesPerPage = CStackFrame.fd_height * 2;

    while (1) {

        /* Read and handle input */
        switch (c = GetKeyUpdate ()) {

            case  '+':
                CStackAddr += BytesPerPage;
                break;

            case '-':
                CStackAddr -= BytesPerPage;
                break;

            case 'o':
                CStackHome ();
                break;

            case 'a':
#ifdef CH_CURS_UP
            case CH_CURS_UP:
#endif
                CStackAddr -= 2;
                break;

            case 'z':
#ifdef CH_CURS_DOWN
            case CH_CURS_DOWN:
#endif
                CStackAddr += 2;
                break;

            default:
                return c;

        }

        /* Update the window contents */
        UpdateCStack ();
    }
}



/*****************************************************************************/
/*                             Dump window stuff                             */
/*****************************************************************************/



static unsigned UpdateDump (void)
/* Update the dump window */
{
    char Buf [MAX_X];
    unsigned char y;
    unsigned mem = DumpAddr;
    unsigned char x = DumpFrame.fd_x1 + 1;
    unsigned char* p = (unsigned char*) mem;

    for (y = DumpFrame.fd_y1+1; y < DumpFrame.fd_y2; ++y) {
        cputsxy (x, y, DbgMemDump (mem, Buf, DUMP_BYTES));
        mem += DUMP_BYTES;
    }
    return mem;
}



static void DumpHome (void)
/* Set the cursor to home position */
{
    DumpAddr = 0;
}



static char DumpHandler (void)
/* Get characters and handle them */
{
    char c;
    unsigned BytesPerPage = DumpFrame.fd_height * 8;

    while (1) {

        /* Read and handle input */
        switch (c = GetKeyUpdate ()) {

            case  '+':
                DumpAddr += BytesPerPage;
                break;

            case '-':
                DumpAddr -= BytesPerPage;
                break;

            case 'g':
                InputGoto (&DumpAddr);
                break;

            case 'o':
                DumpHome ();
                break;

            case 'a':
#ifdef CH_CURS_UP
            case CH_CURS_UP:
#endif
                DumpAddr -= 8;
                break;

            case 'z':
#ifdef CH_CURS_DOWN
            case CH_CURS_DOWN:
#endif
                DumpAddr += 8;
                break;

            default:
                return c;

        }

        /* Update the window contents */
        UpdateDump ();
    }
}



/*****************************************************************************/
/*                             Help window stuff                             */
/*****************************************************************************/



static char HelpHandler (void)
/* Get characters and handle them */
{
    /* Activate the frame */
    int OldActive = ActiveFrame;
    ActivateFrame (WIN_HELP, 1);

    /* Say that we're waiting for a key */
    AnyKeyPrompt ();

    /* Get a character and discard it */
    cgetc ();

    /* Redraw the old stuff */
    Redraw (OldActive);

    /* Done, return no char */
    return 0;
}



/*****************************************************************************/
/*                                Singlestep                                 */
/*****************************************************************************/



static unsigned GetArg16 (void)
/* Read an argument */
{
    return *(unsigned*)(brk_pc+1);
}



static unsigned GetStack16 (unsigned char Offs)
/* Fetch a 16 bit value from stack top */
{
    return *(unsigned*)(DbgSP+Offs+0x101);
}



static void SetRTSBreak (void)
/* Set a breakpoint at the return target */
{
    DbgSetTmpBreak (GetStack16 (0) + 1);
}



static void SingleStep (char StepInto)
{
    signed char Offs;

    switch (*(unsigned char*) brk_pc) {

        case OPC_JMP:
            /* Set breakpoint at target */
            DbgSetTmpBreak (GetArg16 ());
            return;

        case OPC_JMPIND:
            /* Indirect jump, ignore CPU error when crossing page */
            DbgSetTmpBreak (*(unsigned*)GetArg16 ());
            return;

        case OPC_BPL:
        case OPC_BMI:
        case OPC_BVC:
        case OPC_BVS:
        case OPC_BCC:
        case OPC_BCS:
        case OPC_BNE:
        case OPC_BEQ:
            /* Be sure not to set the breakpoint twice if this is a jump to
            ** the following instruction.
            */
            Offs = ((signed char*)brk_pc)[1];
            if (Offs) {
                DbgSetTmpBreak (brk_pc + Offs + 2);
            }
            break;

        case OPC_RTS:
            /* Set a breakpoint at the return target */
            SetRTSBreak ();
            return;

        case OPC_RTI:
            /* Set a breakpoint at the return target */
            DbgSetTmpBreak (GetStack16 (1));
            return;

        case OPC_JSR:
            if (StepInto) {
                /* Set breakpoint at target */
                DbgSetTmpBreak (GetArg16 ());
                return;
            }
            break;
    }

    /* Place a breakpoint behind the instruction */
    DbgSetTmpBreak (brk_pc + DbgDisAsmLen (brk_pc));
}



/*****************************************************************************/
/*                        High level window handling                         */
/*****************************************************************************/



static void RedrawStatic (char Frame)
/* Redraw static display stuff */
{
    /* Reset the active frame */
    ActiveFrame = -1;

    /* Clear the screen hide the cursor */
    (void) bordercolor (COLOR_BORDER);
    (void) bgcolor (COLOR_BACKGROUND);
    clrscr ();
    cursor (0);

    /* Build the frame layout of the screen */
    (void) textcolor (COLOR_FRAMELOW);
    DrawFrames ();

    /* Draw the prompt line */
    HelpPrompt ();

    /* Activate the active frame */
    ActivateFrame (Frame, 0);
}



static void Redraw (char Frame)
/* Redraw the display in case it's garbled */
{
    /* Redraw the static stuff */
    RedrawStatic (Frame);

    /* Init the window contents */
    UpdateAsm ();
    UpdateReg ();
    UpdateStack ();
    UpdateCStack ();
    UpdateDump ();
}



static char GetKeyUpdate (void)
/* Wait for a key updating the windows in the background */
{
    static unsigned char Win;

    /* While there are no keys... */
    while (!kbhit ()) {

        switch (Win) {

            case 0:
                UpdateAsm ();
                break;

            case 1:
                UpdateStack ();
                break;

            case 2:
                UpdateCStack ();
                break;

            case 3:
                UpdateDump ();
                break;
        }

        Win = (Win + 1) & 0x03;

    }

    /* We have a key - return it */
    return cgetc ();
}



/*****************************************************************************/
/*                       Externally visible functions                        */
/*****************************************************************************/



void DbgEntry (void)
/* Start up the debugger */
{
    static unsigned char FirstTime = 1;
    char c;
    char done;

    /* If this is the first call, setup the display */
    if (FirstTime) {
        FirstTime = 0;

        /* Draw the window, default active frame is ASM frame */
        RedrawStatic (WIN_ASM);
        InitAsm ();
        InitReg ();
        InitStack ();
        InitCStack ();
        UpdateDump ();
    }

    /* Only initialize variables here, don't do a display update. The actual
    ** display update will be done while waiting for user input.
    */
    AsmHome ();
    UpdateReg ();               /* Must update this (static later) */
    StackHome ();
    CStackHome ();

    /* Wait for user input */
    done = 0;
    while (!done) {
        c = Frames [ActiveFrame]->fd_func ();
        switch (c) {

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
                ActivateFrame (c - '1', 0);
                break;

            case '?':
#ifdef CH_F1
            case CH_F1:
#endif
                HelpHandler ();
                break;

            case 'u':
#ifdef CH_F3
            case CH_F3:
#endif
                /* Go until return */
                SetRTSBreak ();
                done = 1;
                break;

            case 'h':
#ifdef CH_F4
            case CH_F4:
#endif
                /* Go to cursor, only possible if cursor not at current PC */
                if (AsmAddr != brk_pc) {
                    DbgSetTmpBreak (AsmAddr);
                    done = 1;
                }
                break;

            case ' ':
#ifdef CH_F7
            case CH_F7:
#endif
                SingleStep (1);
                if (DbgTmpBreaksOk ()) {
                    /* Could set breakpoints */
                    done = 1;
                }
                break;

            case '\n':
#ifdef CH_F8
            case CH_F8:
#endif
                SingleStep (0);
                if (DbgTmpBreaksOk ()) {
                    /* Could set breakpoints */
                    done = 1;
                }
                break;

            case 'c':
            case 0:
                done = 1;
                break;

            case 's':
                /* Skip instruction */
                brk_pc += DbgDisAsmLen (brk_pc);
                InitAsm ();
                break;

            case 'r':
                /* Redraw screen */
                Redraw (ActiveFrame);
                break;

            case 'q':
                /* Quit program */
                clrscr ();
                exit (1);

        }
    }
}