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 /*****************************************************************************/
49 /* Color definitions */
50 #if defined(__PLUS4__) || defined(__C16__)
51 # define COLOR_BORDER (BCOLOR_DARKBLUE | CATTR_LUMA6)
52 # define COLOR_BACKGROUND COLOR_WHITE
53 # define COLOR_TEXTHIGH COLOR_BLACK
54 # define COLOR_TEXTLOW COLOR_GRAY1
55 # define COLOR_FRAMEHIGH COLOR_BLACK
56 # define COLOR_FRAMELOW COLOR_GRAY2
58 # if defined(COLOR_GRAY3)
59 # define COLOR_BORDER COLOR_BLACK
60 # define COLOR_BACKGROUND COLOR_BLACK
61 # define COLOR_TEXTHIGH COLOR_WHITE
62 # define COLOR_TEXTLOW COLOR_GRAY3
63 # define COLOR_FRAMEHIGH COLOR_WHITE
64 # define COLOR_FRAMELOW COLOR_GRAY3
66 # if defined(__APPLE2__) || defined(__APPLE2ENH__)
67 # define COLOR_BORDER COLOR_BLACK
68 # define COLOR_BACKGROUND COLOR_BLACK
69 # define COLOR_TEXTHIGH COLOR_BLACK
70 # define COLOR_TEXTLOW COLOR_BLACK
71 # define COLOR_FRAMEHIGH COLOR_BLACK
72 # define COLOR_FRAMELOW COLOR_BLACK
74 # define COLOR_BORDER COLOR_BLACK
75 # define COLOR_BACKGROUND COLOR_BLACK
76 # define COLOR_TEXTHIGH COLOR_WHITE
77 # define COLOR_TEXTLOW COLOR_WHITE
78 # define COLOR_FRAMEHIGH COLOR_WHITE
79 # define COLOR_FRAMELOW COLOR_WHITE
84 /* Screen definitions */
85 #if defined(__CBM610__)
89 # define DUMP_BYTES 16
90 #elif defined(__APPLE2__) || defined(__APPLE2ENH__) || defined(__ATARI__)
100 /* Replacement key definitions */
101 #if defined(__APPLE2__)
102 # define CH_DEL ('H' - 'A' + 1) /* Ctrl+H */
105 /* Defines for opcodes */
114 #define OPC_JMPIND 0x6C
123 /* Register values that are used also in the assembler stuff */
124 extern unsigned char DbgSP; /* Stack pointer */
125 extern unsigned DbgCS; /* C stack pointer */
126 extern unsigned DbgHI; /* High 16 bit of primary reg */
130 /* Descriptor for one text line */
137 /* Window descriptor */
139 unsigned char fd_tl; /* Top left char */
140 unsigned char fd_tr; /* Top right char */
141 unsigned char fd_bl; /* Bottom left char */
142 unsigned char fd_br; /* Bottom right char */
143 unsigned char fd_x1, fd_y1; /* Upper left corner */
144 unsigned char fd_x2, fd_y2; /* Lower right corner */
145 unsigned char fd_width, fd_height; /* Redundant but faster */
146 unsigned char fd_visible; /* Is the window currently visible? */
147 char (*fd_func) (void); /* Handler function */
148 unsigned char fd_textcount; /* Number of text lines to print */
149 TextDesc* fd_text; /* Static text in the window */
154 /* Texts for the windows */
155 static TextDesc RegText [] = {
165 static TextDesc HelpText [] = {
166 { 1, 0, "F1, ? Help" },
167 { 1, 1, "F2, t Toggle breakpoint" },
168 { 1, 2, "F3, u Run until subroutine returns" },
169 { 1, 3, "F4, h Run to cursor" },
170 { 1, 4, "F7, space Step into" },
171 { 1, 5, "F8, enter Step over" },
172 { 1, 6, "1-5 Select active window" },
173 { 1, 7, "+ Page down" },
174 { 1, 8, "- Page up" },
175 { 1, 9, "Cursor Move up/down" },
176 { 1, 10, "a/z Move up/down" },
177 { 1, 11, "c Continue" },
178 { 1, 12, "f Follow instruction" },
179 { 1, 13, "o Goto origin" },
180 { 1, 14, "p Use as new PC value" },
182 { 1, 16, "r Redraw screen" },
183 { 1, 17, "s Skip next instruction" },
188 static FrameDesc AsmFrame = {
189 CH_ULCORNER, CH_TTEE, CH_LTEE, CH_CROSS,
190 0, 0, MAX_X - 10, 15,
196 static FrameDesc RegFrame = {
197 CH_TTEE, CH_URCORNER, CH_LTEE, CH_RTEE,
198 MAX_X - 10, 0, MAX_X - 1, 9,
202 sizeof (RegText) / sizeof (RegText [0]), RegText
204 static FrameDesc StackFrame = {
205 CH_LTEE, CH_RTEE, CH_CROSS, CH_RTEE,
206 MAX_X - 10, 9, MAX_X - 1, 15,
212 static FrameDesc CStackFrame = {
213 CH_CROSS, CH_RTEE, CH_BTEE, CH_LRCORNER,
214 MAX_X - 10, 15, MAX_X - 1, MAX_Y - 1,
220 static FrameDesc DumpFrame = {
221 CH_LTEE, CH_CROSS, CH_LLCORNER, CH_BTEE,
222 0, 15, MAX_X - 10, MAX_Y-1,
223 MAX_X - 11, MAX_Y - 17,
228 static FrameDesc HelpFrame = {
229 CH_ULCORNER, CH_URCORNER, CH_LLCORNER, CH_LRCORNER,
230 0, 0, MAX_X - 1, MAX_Y-1,
231 MAX_X - 2, MAX_Y - 2,
234 sizeof (HelpText) / sizeof (HelpText [0]), HelpText
236 static FrameDesc* Frames [] = {
245 /* Number of active frame, -1 = none */
246 static int ActiveFrame = -1;
256 /* Other window data */
257 static unsigned AsmAddr; /* Start address of output */
258 static unsigned DumpAddr; /* Start address of output */
259 static unsigned CStackAddr; /* Start address of output */
260 static unsigned char StackAddr; /* Start address of output */
264 /* Prompt line data */
265 static char* ActivePrompt = 0; /* Last prompt line displayed */
266 static char PromptColor; /* Color behind prompt */
267 static char PromptLength; /* Length of current prompt string */
271 /* Values for the bk_use field of struct BreakPoint */
272 #define BRK_EMPTY 0x00
273 #define BRK_USER 0x01
276 /* Structure describing a breakpoint */
278 unsigned bk_addr; /* Address, 0 if unused */
279 unsigned char bk_opc; /* Opcode */
280 unsigned char bk_use; /* 1 if in use, 0 otherwise */
285 /* Temporary breakpoints - also accessed from the assembler source */
286 #define MAX_USERBREAKS 10
287 unsigned char DbgBreakCount = 0;
288 BreakPoint DbgBreaks [MAX_USERBREAKS+2];
292 /*****************************************************************************/
293 /* Forwards for functions in the assembler source */
294 /*****************************************************************************/
298 BreakPoint* DbgGetBreakSlot (void);
299 /* Search for a free breakpoint slot. Return a pointer to the slot or 0 */
301 BreakPoint* DbgIsBreak (unsigned Addr);
302 /* Check if there is a user breakpoint at the given address, if so, return
303 * a pointer to the slot, else return 0.
308 /*****************************************************************************/
309 /* Frame/window drawing code */
310 /*****************************************************************************/
314 static void DrawFrame (register FrameDesc* F, char Active)
315 /* Draw one window frame */
319 unsigned char tl, tr, bl, br;
320 unsigned char x1, y1, width;
321 unsigned char OldColor;
323 /* Determine the characters for the corners, set frame color */
325 OldColor = textcolor (COLOR_FRAMEHIGH);
331 OldColor = textcolor (COLOR_FRAMELOW);
338 /* Get the coordinates into locals for faster access */
344 cputcxy (x1, y1, tl);
349 cvlinexy (x1, ++y1, F->fd_height);
357 cvlinexy (F->fd_x2, y1, F->fd_height);
359 /* If the window has static text associated, print the text */
360 (void) textcolor (COLOR_TEXTLOW);
361 Count = F->fd_textcount;
364 cputsxy (x1 + T->x, y1 + T->y, T->text);
368 /* Set the old color */
369 (void) textcolor (OldColor);
374 static void DrawFrames (void)
375 /* Draw all frames */
380 /* Build the frame layout of the screen */
381 for (I = 0; I < sizeof (Frames) / sizeof (Frames [0]); ++I) {
391 static void ActivateFrame (int Num, unsigned char Clear)
392 /* Activate a new frame, deactivate the old one */
395 register FrameDesc* F;
397 if (ActiveFrame != Num) {
399 /* Deactivate the old one */
400 if (ActiveFrame >= 0) {
401 DrawFrame (Frames [ActiveFrame], 0);
404 /* Activate the new one */
405 if ((ActiveFrame = Num) >= 0) {
406 F = Frames [ActiveFrame];
407 /* Clear the frame if requested */
409 for (y = F->fd_y1+1; y < F->fd_y2; ++y) {
410 cclearxy (F->fd_x1+1, y, F->fd_width);
416 /* Redraw the current prompt line */
417 DisplayPrompt (ActivePrompt);
424 /*****************************************************************************/
426 /*****************************************************************************/
430 static void DisplayPrompt (char* s)
431 /* Display a prompt */
433 unsigned char OldColor;
435 /* Remember the current color */
436 OldColor = textcolor (COLOR_TEXTHIGH);
438 /* Clear the old prompt if there is one */
440 (void) textcolor (PromptColor);
441 chlinexy ((MAX_X - PromptLength) / 2, MAX_Y-1, PromptLength);
444 /* Get the new prompt data */
446 PromptColor = OldColor;
447 PromptLength = strlen (ActivePrompt);
449 /* Display the new prompt */
450 (void) textcolor (COLOR_TEXTHIGH);
451 cputsxy ((MAX_X - PromptLength) / 2, MAX_Y-1, ActivePrompt);
453 /* Restore the old color */
454 (void) textcolor (PromptColor);
459 static void HelpPrompt (void)
460 /* Display a prompt line mentioning the help key */
462 DisplayPrompt ("Press F1 for help");
467 static void AnyKeyPrompt (void)
469 DisplayPrompt ("Press any key to continue");
474 static char IsAbortKey (char C)
475 /* Return true if C is an abort key */
492 static char Input (char* Prompt, char* Buf, unsigned char Count)
493 /* Read input from the user, return 1 on success, 0 if aborted */
496 unsigned char OldColor;
497 unsigned char OldCursor;
503 /* Clear the current prompt line */
504 cclearxy (0, MAX_Y-1, MAX_X);
506 /* Display the new prompt */
507 OldColor = textcolor (COLOR_TEXTHIGH);
508 cputsxy (0, MAX_Y-1, Prompt);
509 (void) textcolor (COLOR_TEXTLOW);
511 /* Remember where we are, enable the cursor */
513 OldCursor = cursor (1);
515 /* Get input and handle it */
519 if (isalnum (c) && i < Count) {
521 cputcxy (x1 + i, MAX_Y-1, c);
523 } else if (i > 0 && c == CH_DEL) {
525 cputcxy (x1 + i, MAX_Y-1, ' ');
526 gotoxy (x1 + i, MAX_Y-1);
527 } else if (c == '\n') {
530 } else if (IsAbortKey (c)) {
536 /* Reset settings, display old prompt line */
538 (void) textcolor (OldColor);
542 ActivateFrame (Frame, 0);
549 static char InputHex (char* Prompt, unsigned* Val)
550 /* Prompt for a hexadecimal value. Return 0 on failure. */
557 /* Read input from the user (4 digits max), check input */
558 if (Input (Prompt, Buf, sizeof (Buf)-1) && isxdigit (Buf [0])) {
560 /* Check the characters and convert to hex */
563 while ((C = *P) && isxdigit (C)) {
568 C = toupper (C) - ('A' - 10);
574 /* Assign the value */
590 static void ErrorPrompt (char* Msg)
591 /* Display an error message and wait for a key */
593 /* Save the current prompt */
594 char* OldPrompt = ActivePrompt;
596 /* Display the new one */
599 /* Wait for a key and discard it */
602 /* Restore the old prompt */
603 DisplayPrompt (OldPrompt);
608 static char InputGoto (unsigned* Addr)
609 /* Prompt "Goto" and read an address. Print an error and return 0 on failure. */
612 Ok = InputHex ("Goto: ", Addr);
614 ErrorPrompt ("Invalid input - press a key");
621 static void BreakInRomError (void)
622 /* Print an error message if we cannot set a breakpoint */
624 ErrorPrompt ("Cannot set breakpoint - press a key");
629 /*****************************************************************************/
630 /* Breakpoint handling */
631 /*****************************************************************************/
635 static void DbgSetTmpBreak (unsigned Addr)
636 /* Set a breakpoint */
638 BreakPoint* B = DbgGetBreakSlot ();
645 static void DbgToggleUserBreak (unsigned Addr)
646 /* Set a breakpoint */
648 register BreakPoint* B = DbgIsBreak (Addr);
651 /* We have a breakpoint, remove it */
652 B->bk_use = BRK_EMPTY;
655 /* We don't have a breakpoint, set one */
656 if (DbgBreakCount >= MAX_USERBREAKS) {
657 ErrorPrompt ("Too many breakpoints - press a key");
659 /* Test if we can set a breakpoint at that address */
660 if (!DbgIsRAM (Addr)) {
663 /* Set the breakpoint */
664 B = DbgGetBreakSlot ();
666 B->bk_use = BRK_USER;
675 static void DbgResetTmpBreaks (void)
676 /* Reset all temporary breakpoints */
679 BreakPoint* B = DbgBreaks;
681 for (i = 0; i < MAX_USERBREAKS; ++i) {
682 if (B->bk_use == BRK_TMP) {
683 B->bk_use = BRK_EMPTY;
691 static unsigned char DbgTmpBreaksOk (void)
692 /* Check if the temporary breakpoints can be set, if so, return 1, if not,
693 * reset them all and return 0.
697 BreakPoint* B = DbgBreaks;
698 for (i = 0; i < MAX_USERBREAKS; ++i) {
699 if (B->bk_use == BRK_TMP && !DbgIsRAM (B->bk_addr)) {
701 DbgResetTmpBreaks ();
711 /*****************************************************************************/
712 /* Assembler window stuff */
713 /*****************************************************************************/
717 static unsigned AsmBack (unsigned mem, unsigned char lines)
718 /* Go back in the assembler window the given number of lines (calculate
719 * new start address).
729 cur = mem - (lines * 3) - offs;
731 cur += DbgDisAsmLen (cur);
733 in = (in + 1) & 0x1F;
735 if (cur == mem || offs == 12) {
737 return adr [(in - lines - 1) & 0x1F];
739 /* The requested address is inside an instruction, go back
740 * one more byte and try again.
752 static unsigned UpdateAsm (void)
753 /* Update the assembler window starting at the given address */
758 unsigned char width = AsmFrame.fd_width;
759 unsigned char x = AsmFrame.fd_x1 + 1;
760 unsigned m = AsmBack (AsmAddr, 2);
762 for (y = AsmFrame.fd_y1+1; y < AsmFrame.fd_y2; ++y) {
763 len = DbgDisAsm (m, buf, width);
768 if (DbgIsBreak (m)) {
785 static unsigned AsmArg16 (void)
786 /* Return a 16 bit argument */
788 return *(unsigned*)(AsmAddr+1);
793 static void AsmFollow (void)
794 /* Follow the current instruction */
796 switch (*(unsigned char*) AsmAddr) {
800 AsmAddr = AsmArg16 ();
804 AsmAddr = *(unsigned*)AsmArg16 ();
815 AsmAddr = AsmAddr + 2 + *(signed char*)(AsmAddr+1);
819 AsmAddr = (*(unsigned*) (DbgSP + 0x101) + 1);
823 AsmAddr = *(unsigned*) (DbgSP + 0x102);
831 static void AsmHome (void)
832 /* Set the cursor to home position */
839 static void InitAsm (void)
840 /* Initialize the asm window */
848 static char AsmHandler (void)
849 /* Get characters and handle them */
856 /* Update the window contents */
859 /* Read and handle input */
860 switch (c = GetKeyUpdate ()) {
867 AsmAddr = AsmBack (AsmAddr, AsmFrame.fd_height);
874 DbgToggleUserBreak (AsmAddr);
882 InputGoto (&AsmAddr);
897 AsmAddr = AsmBack (AsmAddr, 1);
904 AsmAddr += DbgDisAsmLen (AsmAddr);
916 /*****************************************************************************/
917 /* Register window stuff */
918 /*****************************************************************************/
922 static unsigned UpdateReg (void)
923 /* Update the register window */
925 unsigned char x1 = RegFrame.fd_x1 + 5;
926 unsigned char x2 = x1 + 2;
927 unsigned char y = RegFrame.fd_y1;
929 /* Print the register contents */
930 gotoxy (x1, ++y); cputhex16 (brk_pc);
931 gotoxy (x2, ++y); cputhex8 (brk_sr);
932 gotoxy (x2, ++y); cputhex8 (brk_a);
933 gotoxy (x2, ++y); cputhex8 (brk_x);
934 gotoxy (x2, ++y); cputhex8 (brk_y);
935 gotoxy (x2, ++y); cputhex8 (DbgSP);
936 gotoxy (x1, ++y); cputhex16 (DbgCS);
937 gotoxy (x1, ++y); cputhex16 (DbgHI);
945 static void InitReg (void)
946 /* Initialize the register window */
953 static char RegHandler (void)
954 /* Get characters and handle them */
956 return GetKeyUpdate ();
961 /*****************************************************************************/
962 /* Stack window stuff */
963 /*****************************************************************************/
967 static unsigned UpdateStack (void)
968 /* Update the stack window */
970 unsigned char mem = StackAddr;
971 unsigned char x1 = StackFrame.fd_x1 + 1;
972 unsigned char x2 = x1 + 6;
975 for (y = StackFrame.fd_y2-1; y > StackFrame.fd_y1; --y) {
979 cputhex8 (* (unsigned char*) (mem + 0x100));
987 static void StackHome (void)
988 /* Set the cursor to home position */
990 StackAddr = DbgSP + 1;
995 static void InitStack (void)
996 /* Initialize the stack window */
1004 static char StackHandler (void)
1005 /* Get characters and handle them */
1008 unsigned char BytesPerPage = StackFrame.fd_height;
1012 /* Read and handle input */
1013 switch (c = GetKeyUpdate ()) {
1016 StackAddr += BytesPerPage;
1020 StackAddr -= BytesPerPage;
1046 /* Update the window contents */
1053 /*****************************************************************************/
1054 /* C Stack window stuff */
1055 /*****************************************************************************/
1059 static unsigned UpdateCStack (void)
1060 /* Update the C stack window */
1062 unsigned mem = CStackAddr;
1063 unsigned char x = CStackFrame.fd_x1 + 5;
1066 for (y = CStackFrame.fd_y2-1; y > CStackFrame.fd_y1; --y) {
1068 cputhex16 (* (unsigned*)mem);
1071 cputsxy (CStackFrame.fd_x1+1, CStackFrame.fd_y2-1, "->");
1077 static void CStackHome (void)
1078 /* Set the cursor to home position */
1085 static void InitCStack (void)
1086 /* Initialize the C stack window */
1094 static char CStackHandler (void)
1095 /* Get characters and handle them */
1098 unsigned char BytesPerPage = CStackFrame.fd_height * 2;
1102 /* Read and handle input */
1103 switch (c = GetKeyUpdate ()) {
1106 CStackAddr += BytesPerPage;
1110 CStackAddr -= BytesPerPage;
1136 /* Update the window contents */
1143 /*****************************************************************************/
1144 /* Dump window stuff */
1145 /*****************************************************************************/
1149 static unsigned UpdateDump (void)
1150 /* Update the dump window */
1154 unsigned mem = DumpAddr;
1155 unsigned char x = DumpFrame.fd_x1 + 1;
1156 unsigned char* p = (unsigned char*) mem;
1158 for (y = DumpFrame.fd_y1+1; y < DumpFrame.fd_y2; ++y) {
1159 cputsxy (x, y, DbgMemDump (mem, Buf, DUMP_BYTES));
1167 static void DumpHome (void)
1168 /* Set the cursor to home position */
1175 static char DumpHandler (void)
1176 /* Get characters and handle them */
1179 unsigned BytesPerPage = DumpFrame.fd_height * 8;
1183 /* Read and handle input */
1184 switch (c = GetKeyUpdate ()) {
1187 DumpAddr += BytesPerPage;
1191 DumpAddr -= BytesPerPage;
1195 InputGoto (&DumpAddr);
1221 /* Update the window contents */
1228 /*****************************************************************************/
1229 /* Help window stuff */
1230 /*****************************************************************************/
1234 static char HelpHandler (void)
1235 /* Get characters and handle them */
1237 /* Activate the frame */
1238 int OldActive = ActiveFrame;
1239 ActivateFrame (WIN_HELP, 1);
1241 /* Say that we're waiting for a key */
1244 /* Get a character and discard it */
1247 /* Redraw the old stuff */
1250 /* Done, return no char */
1256 /*****************************************************************************/
1258 /*****************************************************************************/
1262 static unsigned GetArg16 (void)
1263 /* Read an argument */
1265 return *(unsigned*)(brk_pc+1);
1270 static unsigned GetStack16 (unsigned char Offs)
1271 /* Fetch a 16 bit value from stack top */
1273 return *(unsigned*)(DbgSP+Offs+0x101);
1278 static void SetRTSBreak (void)
1279 /* Set a breakpoint at the return target */
1281 DbgSetTmpBreak (GetStack16 (0) + 1);
1286 static void SingleStep (char StepInto)
1290 switch (*(unsigned char*) brk_pc) {
1293 /* Set breakpoint at target */
1294 DbgSetTmpBreak (GetArg16 ());
1298 /* Indirect jump, ignore CPU error when crossing page */
1299 DbgSetTmpBreak (*(unsigned*)GetArg16 ());
1310 /* Be sure not to set the breakpoint twice if this is a jump to
1311 * the following instruction.
1313 Offs = ((signed char*)brk_pc)[1];
1315 DbgSetTmpBreak (brk_pc + Offs + 2);
1320 /* Set a breakpoint at the return target */
1325 /* Set a breakpoint at the return target */
1326 DbgSetTmpBreak (GetStack16 (1));
1331 /* Set breakpoint at target */
1332 DbgSetTmpBreak (GetArg16 ());
1338 /* Place a breakpoint behind the instruction */
1339 DbgSetTmpBreak (brk_pc + DbgDisAsmLen (brk_pc));
1344 /*****************************************************************************/
1345 /* High level window handling */
1346 /*****************************************************************************/
1350 static void RedrawStatic (char Frame)
1351 /* Redraw static display stuff */
1353 /* Reset the active frame */
1356 /* Clear the screen hide the cursor */
1357 (void) bordercolor (COLOR_BORDER);
1358 (void) bgcolor (COLOR_BACKGROUND);
1362 /* Build the frame layout of the screen */
1363 (void) textcolor (COLOR_FRAMELOW);
1366 /* Draw the prompt line */
1369 /* Activate the active frame */
1370 ActivateFrame (Frame, 0);
1375 static void Redraw (char Frame)
1376 /* Redraw the display in case it's garbled */
1378 /* Redraw the static stuff */
1379 RedrawStatic (Frame);
1381 /* Init the window contents */
1391 static char GetKeyUpdate (void)
1392 /* Wait for a key updating the windows in the background */
1394 static unsigned char Win;
1396 /* While there are no keys... */
1418 Win = (Win + 1) & 0x03;
1422 /* We have a key - return it */
1428 /*****************************************************************************/
1429 /* Externally visible functions */
1430 /*****************************************************************************/
1434 void DbgEntry (void)
1435 /* Start up the debugger */
1437 static unsigned char FirstTime = 1;
1441 /* If this is the first call, setup the display */
1445 /* Draw the window, default active frame is ASM frame */
1446 RedrawStatic (WIN_ASM);
1454 /* Only initialize variables here, don't do a display update. The actual
1455 * display update will be done while waiting for user input.
1458 UpdateReg (); /* Must update this (static later) */
1462 /* Wait for user input */
1465 c = Frames [ActiveFrame]->fd_func ();
1473 ActivateFrame (c - '1', 0);
1487 /* Go until return */
1496 /* Go to cursor, only possible if cursor not at current PC */
1497 if (AsmAddr != brk_pc) {
1498 DbgSetTmpBreak (AsmAddr);
1508 if (DbgTmpBreaksOk ()) {
1509 /* Could set breakpoints */
1519 if (DbgTmpBreaksOk ()) {
1520 /* Could set breakpoints */
1531 /* Skip instruction */
1532 brk_pc += DbgDisAsmLen (brk_pc);
1538 Redraw (ActiveFrame);