4 * Ullrich von Bassewitz, 08.08.1998
20 /*****************************************************************************/
21 /* Function forwards */
22 /*****************************************************************************/
26 /* Forwards for handler functions */
27 static char AsmHandler (void);
28 static char RegHandler (void);
29 static char StackHandler (void);
30 static char CStackHandler (void);
31 static char DumpHandler (void);
32 static char HelpHandler (void);
34 /* Forwards for other functions */
35 static void DisplayPrompt (char* s);
36 static void SingleStep (char StepInto);
37 static void RedrawStatic (char Frame);
38 static void Redraw (char Frame);
39 static char GetKeyUpdate (void);
43 /*****************************************************************************/
45 /*****************************************************************************/
47 /* Color definitions */
48 #if defined(__PLUS4__) || defined(__C16__)
49 # define COLOR_BORDER (BCOLOR_DARKBLUE | CATTR_LUMA6)
50 # define COLOR_BACKGROUND COLOR_WHITE
51 # define COLOR_TEXTHIGH COLOR_BLACK
52 # define COLOR_TEXTLOW COLOR_GRAY1
53 # define COLOR_FRAMEHIGH COLOR_BLACK
54 # define COLOR_FRAMELOW COLOR_GRAY2
57 # define COLOR_BORDER COLOR_BLACK
58 # define COLOR_BACKGROUND COLOR_BLACK
59 # define COLOR_TEXTHIGH COLOR_WHITE
60 # define COLOR_TEXTLOW COLOR_GRAY3
61 # define COLOR_FRAMEHIGH COLOR_WHITE
62 # define COLOR_FRAMELOW COLOR_GRAY3
65 # define COLOR_BORDER COLOR_BLACK
66 # define COLOR_BACKGROUND COLOR_BLACK
67 # define COLOR_TEXTHIGH COLOR_BLACK
68 # define COLOR_TEXTLOW COLOR_BLACK
69 # define COLOR_FRAMEHIGH COLOR_BLACK
70 # define COLOR_FRAMELOW COLOR_BLACK
72 # define COLOR_BORDER COLOR_BLACK
73 # define COLOR_BACKGROUND COLOR_BLACK
74 # define COLOR_TEXTHIGH COLOR_WHITE
75 # define COLOR_TEXTLOW COLOR_WHITE
76 # define COLOR_FRAMEHIGH COLOR_WHITE
77 # define COLOR_FRAMELOW COLOR_WHITE
82 /* Screen definitions */
83 #if defined(__CBM610__)
87 # define DUMP_BYTES 16
88 #elif defined(__APPLE2__) || defined(__ATARI__)
100 /* Defines for opcodes */
109 #define OPC_JMPIND 0x6C
118 /* Register values that are used also in the assembler stuff */
119 extern unsigned char DbgSP; /* Stack pointer */
120 extern unsigned DbgCS; /* C stack pointer */
121 extern unsigned DbgHI; /* High 16 bit of primary reg */
125 /* Descriptor for one text line */
132 /* Window descriptor */
134 unsigned char fd_tl; /* Top left char */
135 unsigned char fd_tr; /* Top right char */
136 unsigned char fd_bl; /* Bottom left char */
137 unsigned char fd_br; /* Bottom right char */
138 unsigned char fd_x1, fd_y1; /* Upper left corner */
139 unsigned char fd_x2, fd_y2; /* Lower right corner */
140 unsigned char fd_width, fd_height; /* Redundant but faster */
141 unsigned char fd_visible; /* Is the window currently visible? */
142 char (*fd_func) (void); /* Handler function */
143 unsigned char fd_textcount; /* Number of text lines to print */
144 TextDesc* fd_text; /* Static text in the window */
149 /* Texts for the windows */
150 static TextDesc RegText [] = {
160 static TextDesc HelpText [] = {
161 { 1, 0, "F1, ? Help" },
162 { 1, 1, "F2, t Toggle breakpoint" },
163 { 1, 2, "F3, u Run until subroutine returns" },
164 { 1, 3, "F4, h Run to cursor" },
165 { 1, 4, "F7, space Step into" },
166 { 1, 5, "F8, enter Step over" },
167 { 1, 6, "1-5 Select active window" },
168 { 1, 7, "+ Page down" },
169 { 1, 8, "- Page up" },
170 { 1, 9, "Cursor Move up/down" },
171 { 1, 10, "c Continue" },
172 { 1, 11, "f Follow instruction" },
173 { 1, 12, "o Goto origin" },
174 { 1, 13, "p Use as new PC value" },
176 { 1, 15, "r Redraw screen" },
177 { 1, 16, "s Skip next instruction" },
182 static FrameDesc AsmFrame = {
183 CH_ULCORNER, CH_TTEE, CH_LTEE, CH_CROSS,
184 0, 0, MAX_X - 10, 15,
190 static FrameDesc RegFrame = {
191 CH_TTEE, CH_URCORNER, CH_LTEE, CH_RTEE,
192 MAX_X - 10, 0, MAX_X - 1, 9,
196 sizeof (RegText) / sizeof (RegText [0]), RegText
198 static FrameDesc StackFrame = {
199 CH_LTEE, CH_RTEE, CH_CROSS, CH_RTEE,
200 MAX_X - 10, 9, MAX_X - 1, 15,
206 static FrameDesc CStackFrame = {
207 CH_CROSS, CH_RTEE, CH_BTEE, CH_LRCORNER,
208 MAX_X - 10, 15, MAX_X - 1, MAX_Y - 1,
214 static FrameDesc DumpFrame = {
215 CH_LTEE, CH_CROSS, CH_LLCORNER, CH_BTEE,
216 0, 15, MAX_X - 10, MAX_Y-1,
217 MAX_X - 11, MAX_Y - 17,
222 static FrameDesc HelpFrame = {
223 CH_ULCORNER, CH_URCORNER, CH_LLCORNER, CH_LRCORNER,
224 0, 0, MAX_X - 1, MAX_Y-1,
225 MAX_X - 2, MAX_Y - 2,
228 sizeof (HelpText) / sizeof (HelpText [0]), HelpText
230 static FrameDesc* Frames [] = {
239 /* Number of active frame, -1 = none */
240 static int ActiveFrame = -1;
250 /* Other window data */
251 static unsigned AsmAddr; /* Start address of output */
252 static unsigned DumpAddr; /* Start address of output */
253 static unsigned CStackAddr; /* Start address of output */
254 static unsigned char StackAddr; /* Start address of output */
258 /* Prompt line data */
259 static char* ActivePrompt = 0; /* Last prompt line displayed */
260 static char PromptColor; /* Color behind prompt */
261 static char PromptLength; /* Length of current prompt string */
265 /* Values for the bk_use field of struct BreakPoint */
266 #define BRK_EMPTY 0x00
267 #define BRK_USER 0x01
270 /* Structure describing a breakpoint */
272 unsigned bk_addr; /* Address, 0 if unused */
273 unsigned char bk_opc; /* Opcode */
274 unsigned char bk_use; /* 1 if in use, 0 otherwise */
279 /* Temporary breakpoints - also accessed from the assembler source */
280 #define MAX_USERBREAKS 10
281 unsigned char DbgBreakCount = 0;
282 BreakPoint DbgBreaks [MAX_USERBREAKS+2];
286 /*****************************************************************************/
287 /* Forwards for functions in the assembler source */
288 /*****************************************************************************/
292 BreakPoint* DbgGetBreakSlot (void);
293 /* Search for a free breakpoint slot. Return a pointer to the slot or 0 */
295 BreakPoint* DbgIsBreak (unsigned Addr);
296 /* Check if there is a user breakpoint at the given address, if so, return
297 * a pointer to the slot, else return 0.
302 /*****************************************************************************/
303 /* Frame/window drawing code */
304 /*****************************************************************************/
308 static void DrawFrame (register FrameDesc* F, char Active)
309 /* Draw one window frame */
313 unsigned char tl, tr, bl, br;
314 unsigned char x1, y1, width;
315 unsigned char OldColor;
317 /* Determine the characters for the corners, set frame color */
319 OldColor = textcolor (COLOR_FRAMEHIGH);
325 OldColor = textcolor (COLOR_FRAMELOW);
332 /* Get the coordinates into locals for faster access */
338 cputcxy (x1, y1, tl);
343 cvlinexy (x1, ++y1, F->fd_height);
351 cvlinexy (F->fd_x2, y1, F->fd_height);
353 /* If the window has static text associated, print the text */
354 textcolor (COLOR_TEXTLOW);
355 Count = F->fd_textcount;
358 cputsxy (x1 + T->x, y1 + T->y, T->text);
362 /* Set the old color */
363 textcolor (OldColor);
368 static void DrawFrames (void)
369 /* Draw all frames */
374 /* Build the frame layout of the screen */
375 for (I = 0; I < sizeof (Frames) / sizeof (Frames [0]); ++I) {
385 static void ActivateFrame (int Num, unsigned char Clear)
386 /* Activate a new frame, deactivate the old one */
389 register FrameDesc* F;
391 if (ActiveFrame != Num) {
393 /* Deactivate the old one */
394 if (ActiveFrame >= 0) {
395 DrawFrame (Frames [ActiveFrame], 0);
398 /* Activate the new one */
399 if ((ActiveFrame = Num) >= 0) {
400 F = Frames [ActiveFrame];
401 /* Clear the frame if requested */
403 for (y = F->fd_y1+1; y < F->fd_y2; ++y) {
404 cclearxy (F->fd_x1+1, y, F->fd_width);
410 /* Redraw the current prompt line */
411 DisplayPrompt (ActivePrompt);
418 /*****************************************************************************/
420 /*****************************************************************************/
424 static void DisplayPrompt (char* s)
425 /* Display a prompt */
427 unsigned char OldColor;
429 /* Remember the current color */
430 OldColor = textcolor (COLOR_TEXTHIGH);
432 /* Clear the old prompt if there is one */
434 textcolor (PromptColor);
435 chlinexy ((MAX_X - PromptLength) / 2, MAX_Y-1, PromptLength);
438 /* Get the new prompt data */
440 PromptColor = OldColor;
441 PromptLength = strlen (ActivePrompt);
443 /* Display the new prompt */
444 textcolor (COLOR_TEXTHIGH);
445 cputsxy ((MAX_X - PromptLength) / 2, MAX_Y-1, ActivePrompt);
447 /* Restore the old color */
448 textcolor (PromptColor);
453 static void HelpPrompt (void)
454 /* Display a prompt line mentioning the help key */
456 DisplayPrompt ("Press F1 for help");
461 static void AnyKeyPrompt (void)
463 DisplayPrompt ("Press any key to continue");
468 static char IsAbortKey (char C)
469 /* Return true if C is an abort key */
486 static char Input (char* Prompt, char* Buf, unsigned char Count)
487 /* Read input from the user, return 1 on success, 0 if aborted */
490 unsigned char OldColor;
491 unsigned char OldCursor;
497 /* Clear the current prompt line */
498 cclearxy (0, MAX_Y-1, MAX_X);
500 /* Display the new prompt */
501 OldColor = textcolor (COLOR_TEXTHIGH);
502 cputsxy (0, MAX_Y-1, Prompt);
503 textcolor (COLOR_TEXTLOW);
505 /* Remember where we are, enable the cursor */
507 OldCursor = cursor (1);
509 /* Get input and handle it */
513 if (isalnum (c) && i < Count) {
515 cputcxy (x1 + i, MAX_Y-1, c);
517 } else if (i > 0 && c == CH_DEL) {
519 cputcxy (x1 + i, MAX_Y-1, ' ');
520 gotoxy (x1 + i, MAX_Y-1);
521 } else if (c == '\n') {
524 } else if (IsAbortKey (c)) {
530 /* Reset settings, display old prompt line */
532 textcolor (OldColor);
536 ActivateFrame (Frame, 0);
543 static char InputHex (char* Prompt, unsigned* Val)
544 /* Prompt for a hexadecimal value. Return 0 on failure. */
551 /* Read input from the user (4 digits max), check input */
552 if (Input (Prompt, Buf, sizeof (Buf)-1) && isxdigit (Buf [0])) {
554 /* Check the characters and convert to hex */
557 while ((C = *P) && isxdigit (C)) {
562 C = toupper (C) - ('A' - 10);
568 /* Assign the value */
584 static void ErrorPrompt (char* Msg)
585 /* Display an error message and wait for a key */
587 /* Save the current prompt */
588 char* OldPrompt = ActivePrompt;
590 /* Display the new one */
593 /* Wait for a key and discard it */
596 /* Restore the old prompt */
597 DisplayPrompt (OldPrompt);
602 static char InputGoto (unsigned* Addr)
603 /* Prompt "Goto" and read an address. Print an error and return 0 on failure. */
606 Ok = InputHex ("Goto: ", Addr);
608 ErrorPrompt ("Invalid input - press a key");
615 static void BreakInRomError (void)
616 /* Print an error message if we cannot set a breakpoint */
618 ErrorPrompt ("Cannot set breakpoint - press a key");
623 /*****************************************************************************/
624 /* Breakpoint handling */
625 /*****************************************************************************/
629 static void DbgSetTmpBreak (unsigned Addr)
630 /* Set a breakpoint */
632 BreakPoint* B = DbgGetBreakSlot ();
639 static void DbgToggleUserBreak (unsigned Addr)
640 /* Set a breakpoint */
642 register BreakPoint* B = DbgIsBreak (Addr);
645 /* We have a breakpoint, remove it */
646 B->bk_use = BRK_EMPTY;
649 /* We don't have a breakpoint, set one */
650 if (DbgBreakCount >= MAX_USERBREAKS) {
651 ErrorPrompt ("Too many breakpoints - press a key");
653 /* Test if we can set a breakpoint at that address */
654 if (!DbgIsRAM (Addr)) {
657 /* Set the breakpoint */
658 B = DbgGetBreakSlot ();
660 B->bk_use = BRK_USER;
669 static void DbgResetTmpBreaks (void)
670 /* Reset all temporary breakpoints */
673 BreakPoint* B = DbgBreaks;
675 for (i = 0; i < MAX_USERBREAKS; ++i) {
676 if (B->bk_use == BRK_TMP) {
677 B->bk_use = BRK_EMPTY;
685 static unsigned char DbgTmpBreaksOk (void)
686 /* Check if the temporary breakpoints can be set, if so, return 1, if not,
687 * reset them all and return 0.
691 BreakPoint* B = DbgBreaks;
692 for (i = 0; i < MAX_USERBREAKS; ++i) {
693 if (B->bk_use == BRK_TMP && !DbgIsRAM (B->bk_addr)) {
695 DbgResetTmpBreaks ();
705 /*****************************************************************************/
706 /* Assembler window stuff */
707 /*****************************************************************************/
711 static unsigned AsmBack (unsigned mem, unsigned char lines)
712 /* Go back in the assembler window the given number of lines (calculate
713 * new start address).
723 cur = mem - (lines * 3) - offs;
725 cur += DbgDisAsmLen (cur);
727 in = (in + 1) & 0x1F;
729 if (cur == mem || offs == 12) {
731 return adr [(in - lines - 1) & 0x1F];
733 /* The requested address is inside an instruction, go back
734 * one more byte and try again.
746 static unsigned UpdateAsm (void)
747 /* Update the assembler window starting at the given address */
752 unsigned char width = AsmFrame.fd_width;
753 unsigned char x = AsmFrame.fd_x1 + 1;
754 unsigned m = AsmBack (AsmAddr, 2);
756 for (y = AsmFrame.fd_y1+1; y < AsmFrame.fd_y2; ++y) {
757 len = DbgDisAsm (m, buf, width);
762 if (DbgIsBreak (m)) {
779 static unsigned AsmArg16 (void)
780 /* Return a 16 bit argument */
782 return *(unsigned*)(AsmAddr+1);
787 static void AsmFollow (void)
788 /* Follow the current instruction */
790 switch (*(unsigned char*) AsmAddr) {
794 AsmAddr = AsmArg16 ();
798 AsmAddr = *(unsigned*)AsmArg16 ();
809 AsmAddr = AsmAddr + 2 + *(signed char*)(AsmAddr+1);
813 AsmAddr = (*(unsigned*) (DbgSP + 0x101) + 1);
817 AsmAddr = *(unsigned*) (DbgSP + 0x102);
825 static void AsmHome (void)
826 /* Set the cursor to home position */
833 static void InitAsm (void)
834 /* Initialize the asm window */
842 static char AsmHandler (void)
843 /* Get characters and handle them */
850 /* Update the window contents */
853 /* Read and handle input */
854 switch (c = GetKeyUpdate ()) {
861 AsmAddr = AsmBack (AsmAddr, AsmFrame.fd_height);
868 DbgToggleUserBreak (AsmAddr);
876 InputGoto (&AsmAddr);
888 AsmAddr = AsmBack (AsmAddr, 1);
892 AsmAddr += DbgDisAsmLen (AsmAddr);
904 /*****************************************************************************/
905 /* Register window stuff */
906 /*****************************************************************************/
910 static unsigned UpdateReg (void)
911 /* Update the register window */
913 unsigned char x1 = RegFrame.fd_x1 + 5;
914 unsigned char x2 = x1 + 2;
915 unsigned char y = RegFrame.fd_y1;
917 /* Print the register contents */
918 gotoxy (x1, ++y); cputhex16 (brk_pc);
919 gotoxy (x2, ++y); cputhex8 (brk_sr);
920 gotoxy (x2, ++y); cputhex8 (brk_a);
921 gotoxy (x2, ++y); cputhex8 (brk_x);
922 gotoxy (x2, ++y); cputhex8 (brk_y);
923 gotoxy (x2, ++y); cputhex8 (DbgSP);
924 gotoxy (x1, ++y); cputhex16 (DbgCS);
925 gotoxy (x1, ++y); cputhex16 (DbgHI);
933 static void InitReg (void)
934 /* Initialize the register window */
941 static char RegHandler (void)
942 /* Get characters and handle them */
944 return GetKeyUpdate ();
949 /*****************************************************************************/
950 /* Stack window stuff */
951 /*****************************************************************************/
955 static unsigned UpdateStack (void)
956 /* Update the stack window */
958 unsigned char mem = StackAddr;
959 unsigned char x1 = StackFrame.fd_x1 + 1;
960 unsigned char x2 = x1 + 6;
963 for (y = StackFrame.fd_y2-1; y > StackFrame.fd_y1; --y) {
967 cputhex8 (* (unsigned char*) (mem + 0x100));
975 static void StackHome (void)
976 /* Set the cursor to home position */
978 StackAddr = DbgSP + 1;
983 static void InitStack (void)
984 /* Initialize the stack window */
992 static char StackHandler (void)
993 /* Get characters and handle them */
996 unsigned char BytesPerPage = StackFrame.fd_height;
1000 /* Read and handle input */
1001 switch (c = GetKeyUpdate ()) {
1004 StackAddr += BytesPerPage;
1008 StackAddr -= BytesPerPage;
1028 /* Update the window contents */
1035 /*****************************************************************************/
1036 /* C Stack window stuff */
1037 /*****************************************************************************/
1041 static unsigned UpdateCStack (void)
1042 /* Update the C stack window */
1044 unsigned mem = CStackAddr;
1045 unsigned char x = CStackFrame.fd_x1 + 5;
1048 for (y = CStackFrame.fd_y2-1; y > CStackFrame.fd_y1; --y) {
1050 cputhex16 (* (unsigned*)mem);
1053 cputsxy (CStackFrame.fd_x1+1, CStackFrame.fd_y2-1, "->");
1059 static void CStackHome (void)
1060 /* Set the cursor to home position */
1067 static void InitCStack (void)
1068 /* Initialize the C stack window */
1076 static char CStackHandler (void)
1077 /* Get characters and handle them */
1080 unsigned char BytesPerPage = CStackFrame.fd_height * 2;
1084 /* Read and handle input */
1085 switch (c = GetKeyUpdate ()) {
1088 CStackAddr += BytesPerPage;
1092 CStackAddr -= BytesPerPage;
1112 /* Update the window contents */
1119 /*****************************************************************************/
1120 /* Dump window stuff */
1121 /*****************************************************************************/
1125 static unsigned UpdateDump (void)
1126 /* Update the dump window */
1130 unsigned mem = DumpAddr;
1131 unsigned char x = DumpFrame.fd_x1 + 1;
1132 unsigned char* p = (unsigned char*) mem;
1134 for (y = DumpFrame.fd_y1+1; y < DumpFrame.fd_y2; ++y) {
1135 cputsxy (x, y, DbgMemDump (mem, Buf, DUMP_BYTES));
1143 static void DumpHome (void)
1144 /* Set the cursor to home position */
1151 static char DumpHandler (void)
1152 /* Get characters and handle them */
1155 unsigned BytesPerPage = DumpFrame.fd_height * 8;
1159 /* Read and handle input */
1160 switch (c = GetKeyUpdate ()) {
1163 DumpAddr += BytesPerPage;
1167 DumpAddr -= BytesPerPage;
1171 InputGoto (&DumpAddr);
1191 /* Update the window contents */
1198 /*****************************************************************************/
1199 /* Help window stuff */
1200 /*****************************************************************************/
1204 static char HelpHandler (void)
1205 /* Get characters and handle them */
1207 /* Activate the frame */
1208 int OldActive = ActiveFrame;
1209 ActivateFrame (WIN_HELP, 1);
1211 /* Say that we're waiting for a key */
1214 /* Get a character and discard it */
1217 /* Redraw the old stuff */
1220 /* Done, return no char */
1226 /*****************************************************************************/
1228 /*****************************************************************************/
1232 static unsigned GetArg16 (void)
1233 /* Read an argument */
1235 return *(unsigned*)(brk_pc+1);
1240 static unsigned GetStack16 (unsigned char Offs)
1241 /* Fetch a 16 bit value from stack top */
1243 return *(unsigned*)(DbgSP+Offs+0x101);
1248 static void SetRTSBreak (void)
1249 /* Set a breakpoint at the return target */
1251 DbgSetTmpBreak (GetStack16 (0) + 1);
1256 static void SingleStep (char StepInto)
1260 switch (*(unsigned char*) brk_pc) {
1263 /* Set breakpoint at target */
1264 DbgSetTmpBreak (GetArg16 ());
1268 /* Indirect jump, ignore CPU error when crossing page */
1269 DbgSetTmpBreak (*(unsigned*)GetArg16 ());
1280 /* Be sure not to set the breakpoint twice if this is a jump to
1281 * the following instruction.
1283 Offs = *(signed char*)(brk_pc+1);
1285 DbgSetTmpBreak (brk_pc + Offs + 2);
1290 /* Set a breakpoint at the return target */
1295 /* Set a breakpoint at the return target */
1296 DbgSetTmpBreak (GetStack16 (1));
1301 /* Set breakpoint at target */
1302 DbgSetTmpBreak (GetArg16 ());
1308 /* Place a breakpoint behind the instruction */
1309 DbgSetTmpBreak (brk_pc + DbgDisAsmLen (brk_pc));
1314 /*****************************************************************************/
1315 /* High level window handling */
1316 /*****************************************************************************/
1320 static void RedrawStatic (char Frame)
1321 /* Redraw static display stuff */
1323 /* Reset the active frame */
1326 /* Clear the screen hide the cursor */
1327 bordercolor (COLOR_BORDER);
1328 bgcolor (COLOR_BACKGROUND);
1332 /* Build the frame layout of the screen */
1333 textcolor (COLOR_FRAMELOW);
1336 /* Draw the prompt line */
1339 /* Activate the active frame */
1340 ActivateFrame (Frame, 0);
1345 static void Redraw (char Frame)
1346 /* Redraw the display in case it's garbled */
1348 /* Redraw the static stuff */
1349 RedrawStatic (Frame);
1351 /* Init the window contents */
1361 static char GetKeyUpdate (void)
1362 /* Wait for a key updating the windows in the background */
1364 static unsigned char Win;
1366 /* While there are no keys... */
1388 Win = (Win + 1) & 0x03;
1392 /* We have a key - return it */
1398 /*****************************************************************************/
1399 /* Externally visible functions */
1400 /*****************************************************************************/
1404 void DbgEntry (void)
1405 /* Start up the debugger */
1407 static unsigned char FirstTime = 1;
1411 /* If this is the first call, setup the display */
1415 /* Draw the window, default active frame is ASM frame */
1416 RedrawStatic (WIN_ASM);
1424 /* Only initialize variables here, don't do a display update. The actual
1425 * display update will be done while waiting for user input.
1428 UpdateReg (); /* Must update this (static later) */
1432 /* Wait for user input */
1435 c = Frames [ActiveFrame]->fd_func ();
1443 ActivateFrame (c - '1', 0);
1457 /* Go until return */
1466 /* Go to cursor, only possible if cursor not at current PC */
1467 if (AsmAddr != brk_pc) {
1468 DbgSetTmpBreak (AsmAddr);
1478 if (DbgTmpBreaksOk ()) {
1479 /* Could set breakpoints */
1489 if (DbgTmpBreaksOk ()) {
1490 /* Could set breakpoints */
1501 /* Skip instruction */
1502 brk_pc += DbgDisAsmLen (brk_pc);
1508 Redraw (ActiveFrame);