--- hatari/src/debug/breakcond.c	2019/04/09 08:48:37	1.1.1.1
+++ hatari/src/debug/breakcond.c	2019/04/09 08:53:03	1.1.1.5
@@ -1,10 +1,10 @@
 /*
   Hatari - breakcond.c
 
-  Copyright (c) 2009-2010 by Eero Tamminen
+  Copyright (c) 2009-2012 by Eero Tamminen
 
-  This file is distributed under the GNU Public License, version 2 or at
-  your option any later version. Read the file gpl.txt for details.
+  This file is distributed under the GNU General Public License, version 2
+  or at your option any later version. Read the file gpl.txt for details.
 
   breakcond.c - code for breakpoint conditions that can check variable
   and memory values against each other, mask them etc. before deciding
@@ -17,18 +17,24 @@ const char BreakCond_fileid[] = "Hatari
 #include <stdlib.h>
 #include "config.h"
 #include "main.h"
+#include "file.h"
 #include "m68000.h"
 #include "memorySnapShot.h"
 #include "dsp.h"
 #include "stMemory.h"
 #include "str.h"
+#include "screen.h"	/* for defines needed by video.h */
 #include "video.h"	/* for Hatari video variable addresses */
 
 #include "debug_priv.h"
 #include "breakcond.h"
 #include "debugcpu.h"
+#include "debugInfo.h"
+#include "debugui.h"
 #include "evaluate.h"
+#include "history.h"
 #include "symbols.h"
+#include "68kDisass.h"
 
 
 /* set to 1 to enable parsing function tracing / debug output */
@@ -42,7 +48,7 @@ const char BreakCond_fileid[] = "Hatari
 
 #define BC_DEFAULT_DSP_SPACE 'P'
 
-enum {	
+typedef enum {	
 	/* plain number */
 	VALUE_TYPE_NUMBER     = 0,
 
@@ -55,7 +61,7 @@ enum {
 	/* size must match register size used in BreakCond_ParseRegister() */
 	VALUE_TYPE_REG16      = 16,
 	VALUE_TYPE_REG32      = 32
-} typedef value_t;
+} value_t;
 
 static inline bool is_register_type(value_t vtype) {
 	/* type used for CPU/DSP registers */
@@ -85,13 +91,21 @@ typedef struct {
 } bc_condition_t;
 
 typedef struct {
+	char *filename;	/* file where to read commands to do on hit */
+	int skip;	/* how many times to hit before breaking */
+	bool once;	/* remove after hit&break */
+	bool quiet;	/* no output from setting & hitting */
+	bool trace;	/* trace mode, don't break */
+	bool noinit;	/* prevent debugger inits on break */
+	bool lock;	/* tracing + show locked info */
+} bc_options_t;
+
+typedef struct {
 	char *expression;
+	bc_options_t options;
 	bc_condition_t conditions[BC_MAX_CONDITIONS_PER_BREAKPOINT];
 	int ccount;	/* condition count */
 	int hits;	/* how many times breakpoint hit */
-	int skip;	/* how many times to hit before breaking */
-	bool once;	/* remove after hit&break */
-	bool trace;	/* trace mode, don't break */
 } bc_breakpoint_t;
 
 static bc_breakpoint_t BreakPointsCpu[BC_MAX_CONDITION_BREAKPOINTS];
@@ -115,9 +129,11 @@ bool BreakCond_Save(const char *filename
 	int i;
 
 	if (!(BreakPointCpuCount || BreakPointDspCount)) {
-		if (remove(filename)) {
-			perror("ERROR");
-			return false;
+		if (File_Exists(filename)) {
+			if (remove(filename)) {
+				perror("ERROR");
+				return false;
+			}
 		}
 		return true;
 	}
@@ -232,9 +248,31 @@ static Uint32 BreakCond_GetValue(const b
 
 
 /**
+ * Show & update rvalue for a tracked breakpoint condition to lvalue
+ */
+static void BreakCond_UpdateTracked(bc_condition_t *condition, Uint32 value)
+{
+	Uint32 addr;
+
+	/* next monitor changes to this new value */
+	condition->rvalue.value.number = value;
+
+	if (condition->lvalue.is_indirect &&
+	    condition->lvalue.valuetype == VALUE_TYPE_NUMBER) {
+		/* simple memory address */
+		addr = condition->lvalue.value.number;
+		fprintf(stderr, "  $%x = $%x\n", addr, value);
+	} else {
+		/* register tms. */
+		fprintf(stderr, "  $%x\n", value);
+	}
+}
+
+
+/**
  * Return true if all of the given breakpoint's conditions match
  */
-static bool BreakCond_MatchConditions(const bc_condition_t *condition, int count)
+static bool BreakCond_MatchConditions(bc_condition_t *condition, int count)
 {
 	Uint32 lvalue, rvalue;
 	bool hit = false;
@@ -257,6 +295,9 @@ static bool BreakCond_MatchConditions(co
 			break;
 		case '!':
 			hit = (lvalue != rvalue);
+			if (hit && condition->track) {
+				BreakCond_UpdateTracked(condition, lvalue);
+			}
 			break;
 		default:
 			fprintf(stderr, "ERROR: Unknown breakpoint value comparison operator '%c'!\n",
@@ -273,75 +314,71 @@ static bool BreakCond_MatchConditions(co
 
 
 /**
- * Show values for the tracked breakpoint conditions
- */
-static void BreakCond_ShowTracked(bc_condition_t *condition, int count)
-{
-	Uint32 addr, value;
-	char sep;
-	int i;
-	
-	sep = ' ';
-	for (i = 0; i < count; condition++, i++) {
-		if (!condition->track) {
-			continue;
-		}
-
-		/* get the new value in address */
-		value = BreakCond_GetValue(&(condition->lvalue));
-		/* next monitor changes to this new value */
-		condition->rvalue.value.number = value;
-		
-		if (condition->lvalue.is_indirect &&
-		    condition->lvalue.valuetype == VALUE_TYPE_NUMBER) {
-			/* simple memory address */
-			addr = condition->lvalue.value.number;
-			fprintf(stderr, "%c $%x = $%x", sep, addr, value);
-		} else {
-			/* register tms. */
-			fprintf(stderr, "%c $%x", sep, value);
-		}
-		sep = ',';
-	}
-	fprintf(stderr, "\n");
-}
-
-
-/**
- * Return which of the given condition breakpoints match
- * or zero if none matched
+ * Show all breakpoints which conditions matched and return which matched
+ * @return	index to last matching (non-tracing) breakpoint,
+ *		or zero if none matched
  */
 static int BreakCond_MatchBreakPoints(bc_breakpoint_t *bp, int count, const char *name)
 {
-	int i;
-	
+	int i, ret = 0;
+
 	for (i = 0; i < count; bp++, i++) {
+
 		if (BreakCond_MatchConditions(bp->conditions, bp->ccount)) {
-			BreakCond_ShowTracked(bp->conditions, bp->ccount);
+			bool for_dsp;
+
 			bp->hits++;
-			if (bp->skip && (bp->hits % bp->skip) == 0) {
-				return 0;
+			if (bp->options.skip) {
+				if (bp->hits % bp->options.skip) {
+					/* check next */
+					continue;
+				}
 			}
-			fprintf(stderr, "%d. %s breakpoint condition(s) matched %d times.\n",
-				i+1, name, bp->hits);
-			if (bp->trace) {
-				return 0;
+			if (!bp->options.quiet) {
+				fprintf(stderr, "%d. %s breakpoint condition(s) matched %d times.\n",
+					i+1, name, bp->hits);			
+				BreakCond_Print(bp);
 			}
-			BreakCond_Print(bp);
-			if (bp->once) {
-				BreakCond_Remove(i+1, (bp-i == BreakPointsDsp));
+			for_dsp = (bp-i == BreakPointsDsp);
+			if (for_dsp) {
+				History_Mark(REASON_DSP_BREAKPOINT);
+			} else {
+				History_Mark(REASON_CPU_BREAKPOINT);
 			}
-			/* indexes for BreakCond_Remove() start from 1 */
-			return i + 1;
+
+			if (bp->options.lock || bp->options.filename) {
+				bool reinit = !bp->options.noinit;
+
+				if (reinit) {
+					DebugCpu_InitSession();
+					DebugDsp_InitSession();
+				}
+
+				if (bp->options.lock) {
+					DebugInfo_ShowSessionInfo();
+				}
+				if (bp->options.filename) {
+					DebugUI_ParseFile(bp->options.filename, reinit);
+				}
+			}
+			if (bp->options.once) {
+				BreakCond_Remove(i+1, for_dsp);
+				count--;
+			}
+			if (!bp->options.trace) {
+				/* index for current hit (BreakCond_Remove() indexes start from 1) */
+				ret = i + 1;
+			}
+			/* continue checking breakpoints to make sure all relevant actions get performed */
 		}
 	}
-	return 0;
+	return ret;
 }
 
 /* ------------- breakpoint condition checking, public API ------------- */
 
 /**
- * Return matched CPU breakpoint index or zero for an error.
+ * Return matched CPU breakpoint index or zero for no hits.
  */
 int BreakCond_MatchCpu(void)
 {
@@ -349,7 +386,7 @@ int BreakCond_MatchCpu(void)
 }
 
 /**
- * Return matched DSP breakpoint index or zero for an error.
+ * Return matched DSP breakpoint index or zero for no hits.
  */
 int BreakCond_MatchDsp(void)
 {
@@ -403,12 +440,119 @@ static Uint32 GetFrameCycles(void)
 	return fcycles;
 }
 
+/* helpers for TOS OS call opcode accessor functions */
+#define INVALID_OPCODE 0xFFFFu
+
+static inline Uint16 getLineOpcode(Uint8 line)
+{
+	Uint32 pc;
+	Uint16 instr;
+	pc = M68000_GetPC();
+	instr = STMemory_ReadWord(pc);
+	/* for opcode X, Line-A = 0xA00X, Line-F = 0xF00X */
+	if ((instr >> 12) == line) {
+		return instr & 0xFF;
+	}
+	return INVALID_OPCODE;
+}
+static inline bool isTrap(Uint8 trap)
+{
+	Uint32 pc;
+	Uint16 instr;
+	pc = M68000_GetPC();
+	instr = STMemory_ReadWord(pc);
+	return (instr == (Uint16)0x4e40u + trap);
+}
+static inline Uint16 getControlOpcode(void)
+{
+	/* Control[] address from D1, opcode in Control[0] */
+	return STMemory_ReadWord(STMemory_ReadLong(Regs[REG_D1]));
+}
+static inline Uint16 getStackOpcode(void)
+{
+	return STMemory_ReadWord(Regs[REG_A7]);
+}
+
+/* Actual TOS OS call opcode accessor functions */
+static Uint32 GetLineAOpcode(void)
+{
+	return getLineOpcode(0xA);
+}
+static Uint32 GetLineFOpcode(void)
+{
+	return getLineOpcode(0xF);
+}
+static Uint32 GetGemdosOpcode(void)
+{
+	if (isTrap(1)) {
+		return getStackOpcode();
+	}
+	return INVALID_OPCODE;
+}
+static Uint32 GetBiosOpcode(void)
+{
+	if (isTrap(13)) {
+		return getStackOpcode();
+	}
+	return INVALID_OPCODE;
+}
+static Uint32 GetXbiosOpcode(void)
+{
+	if (isTrap(14)) {
+		return getStackOpcode();
+	}
+	return INVALID_OPCODE;
+}
+static Uint32 GetAesOpcode(void)
+{
+	if (isTrap(2)) {
+		Uint16 d0 = Regs[REG_D0];
+		if (d0 == 0xC8) {
+			return getControlOpcode();
+		} else if (d0 == 0xC9) {
+			/* same as appl_yield() */
+			return 0x11;
+		}
+	}
+	return INVALID_OPCODE;
+}
+static Uint32 GetVdiOpcode(void)
+{
+	if (isTrap(2)) {
+		Uint16 d0 = Regs[REG_D0];
+		if (d0 == 0x73) {
+			return getControlOpcode();
+		} else if (d0 == 0xFFFE) {
+			/* -2 = vq_[v]gdos() */
+			return 0xFFFE;
+		}
+	}
+	return INVALID_OPCODE;
+}
+
+static Uint32 GetNextPC(void)
+{
+	return Disasm_GetNextPC(M68000_GetPC());
+}
+
 /* sorted by variable name so that this can be bisected */
 static const var_addr_t hatari_vars[] = {
+	{ "AesOpcode", (Uint32*)GetAesOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
+	{ "BiosOpcode", (Uint32*)GetBiosOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
+	{ "BSS", (Uint32*)DebugInfo_GetBSS, VALUE_TYPE_FUNCTION32, 0, "invalid before Desktop is up" },
+	{ "DATA", (Uint32*)DebugInfo_GetDATA, VALUE_TYPE_FUNCTION32, 0, "invalid before Desktop is up" },
 	{ "FrameCycles", (Uint32*)GetFrameCycles, VALUE_TYPE_FUNCTION32, 0, NULL },
+	{ "GemdosOpcode", (Uint32*)GetGemdosOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
 	{ "HBL", (Uint32*)&nHBL, VALUE_TYPE_VAR32, sizeof(nHBL)*8, NULL },
+	{ "LineAOpcode", (Uint32*)GetLineAOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
 	{ "LineCycles", (Uint32*)GetLineCycles, VALUE_TYPE_FUNCTION32, 0, "is always divisable by 4" },
-	{ "VBL", (Uint32*)&nVBLs, VALUE_TYPE_VAR32, sizeof(nVBLs)*8, NULL }
+	{ "LineFOpcode", (Uint32*)GetLineFOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
+	{ "NextPC", (Uint32*)GetNextPC, VALUE_TYPE_FUNCTION32, 0, NULL },
+	{ "TEXT", (Uint32*)DebugInfo_GetTEXT, VALUE_TYPE_FUNCTION32, 0, "invalid before Desktop is up" },
+	{ "TEXTEnd", (Uint32*)DebugInfo_GetTEXTEnd, VALUE_TYPE_FUNCTION32, 0, "invalid before Desktop is up" },
+	{ "VBL", (Uint32*)&nVBLs, VALUE_TYPE_VAR32, sizeof(nVBLs)*8, NULL },
+	{ "VdiOpcode", (Uint32*)GetVdiOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" },
+	{ "XbiosOpcode", (Uint32*)GetXbiosOpcode, VALUE_TYPE_FUNCTION32, 16, "by default FFFF" }
 };
 
 
@@ -483,6 +627,22 @@ static bool BreakCond_ParseVariable(cons
 	return false;
 }
 
+/**
+ * If given string is a Hatari variable name, set value to given
+ * variable value and return true, otherwise return false.
+ */
+bool BreakCond_GetHatariVariable(const char *name, Uint32 *value)
+{
+	bc_value_t bc_value;
+	if (!BreakCond_ParseVariable(name, &bc_value)) {
+		return false;
+	}
+	bc_value.mask = 0xffffffff;
+	bc_value.is_indirect = false;
+	*value = BreakCond_GetValue(&bc_value);
+	return true;
+}
+
 
 /**
  * If given string matches a suitable symbol, set bc_value
@@ -583,7 +743,7 @@ static bool BreakCond_ParseRegister(cons
 		return true;
 	}
 	/* Exact UAE core 32-bit PC & 16-bit SR register values
-	 * can be gotten only through AUE accessors, not directly
+	 * can be gotten only through UAE accessors, not directly
 	 */
 	if (strcasecmp(regname, "PC") == 0) {
 		bc_value->bits = 32;
@@ -1202,7 +1362,7 @@ static void BreakCond_CheckTracking(bc_b
  * Parse given breakpoint expression and store it.
  * Return true for success and false for failure.
  */
-static bool BreakCond_Parse(const char *expression, bool bForDsp, bool trace, bool once, int skip)
+static bool BreakCond_Parse(const char *expression, bc_options_t *options, bool bForDsp)
 {
 	parser_state_t pstate;
 	bc_breakpoint_t *bp;
@@ -1233,20 +1393,38 @@ static bool BreakCond_Parse(const char *
 	}
 	if (ccount > 0) {
 		(*bcount)++;
-		fprintf(stderr, "%s condition breakpoint %d with %d condition(s) added:\n\t%s\n",
-			name, *bcount, ccount, bp->expression);
+		if (!options->quiet) {
+			fprintf(stderr, "%s condition breakpoint %d with %d condition(s) added:\n\t%s\n",
+				name, *bcount, ccount, bp->expression);
+			if (options->skip) {
+				fprintf(stderr, "-> Break only on every %d hit.\n", options->skip);
+			}
+			if (options->once) {
+				fprintf(stderr, "-> Once, delete after breaking.\n");
+			}
+			if (options->trace) {
+				fprintf(stderr, "-> Trace instead of breaking, but show still hits.\n");
+				if (options->lock) {
+					fprintf(stderr, "-> Show also info selected with lock command.\n");
+				}				
+				if (options->noinit) {
+					fprintf(stderr, "-> Skip debugger inits on hit.\n");
+				}				
+			}
+			if (options->filename) {
+				fprintf(stderr, "-> Execute debugger commands from '%s' file on hit.\n", options->filename);
+			}
+		}
 		BreakCond_CheckTracking(bp);
-		if (skip) {
-			fprintf(stderr, "-> Break only on every %d hit.\n", skip);
-			bp->skip = skip;
-		}
-		if (once) {
-			fprintf(stderr, "-> Once, delete after breaking.\n");
-			bp->once = once;
-		}
-		if (trace) {
-			fprintf(stderr, "-> Trace instead of breaking, but show still hits.\n");
-			bp->trace = trace;
+
+		bp->options.quiet = options->quiet;
+		bp->options.skip = options->skip;
+		bp->options.once = options->once;
+		bp->options.trace = options->trace;
+		bp->options.lock = options->lock;
+		bp->options.noinit = options->noinit;
+		if (options->filename) {
+			bp->options.filename = strdup(options->filename);
 		}
 	} else {
 		if (normalized) {
@@ -1283,14 +1461,24 @@ static bool BreakCond_Parse(const char *
 static void BreakCond_Print(bc_breakpoint_t *bp)
 {
 		fprintf(stderr, "\t%s", bp->expression);
-		if (bp->skip) {
-			fprintf(stderr, " :%d", bp->skip);
+		if (bp->options.skip) {
+			fprintf(stderr, " :%d", bp->options.skip);
 		}
-		if (bp->once) {
+		if (bp->options.once) {
 			fprintf(stderr, " :once");
 		}
-		if (bp->trace) {
-			fprintf(stderr, " :trace");
+		if (bp->options.trace) {
+			if (bp->options.lock) {
+				fprintf(stderr, " :lock");
+			} else {
+				fprintf(stderr, " :trace");
+			}
+			if (bp->options.noinit) {
+				fprintf(stderr, " :noinit");
+			}
+		}
+		if (bp->options.filename) {
+			fprintf(stderr, " :file %s", bp->options.filename);
 		}
 		fprintf(stderr, "\n");
 }
@@ -1326,10 +1514,10 @@ static bool BreakCond_Remove(int positio
 	const char *name;
 	bc_breakpoint_t *bp;
 	int *bcount, offset;
-	
+
 	bcount = BreakCond_GetListInfo(&bp, &name, bForDsp);
 	if (!*bcount) {
-		fprintf(stderr, "No (more) breakpoints to remove.\n");
+		fprintf(stderr, "No (more) %s breakpoints to remove.\n", name);
 		return false;
 	}
 	if (position < 1 || position > *bcount) {
@@ -1337,9 +1525,14 @@ static bool BreakCond_Remove(int positio
 		return false;
 	}
 	offset = position - 1;
-	fprintf(stderr, "Removed %s breakpoint %d:\n", name, position);
-	BreakCond_Print(&(bp[offset]));
+	if (!bp[offset].options.quiet) {
+		fprintf(stderr, "Removed %s breakpoint %d:\n", name, position);
+		BreakCond_Print(&(bp[offset]));
+	}
 	free(bp[offset].expression);
+	if (bp[offset].options.filename) {
+		free(bp[offset].options.filename);
+	}
 	bp[offset].expression = NULL;
 
 	if (position < *bcount) {
@@ -1385,26 +1578,23 @@ static void BreakCond_Help(void)
 	Uint32 value;
 	int i;
 	fputs(
-"  breakpoint = <condition> [ && <condition> ... ] [option]\n"
-"  condition = <value>[.mode] [& <number>] <comparison> <value>[.mode]\n"
+"  condition = <value>[.mode] [& <mask>] <comparison> <value>[.mode]\n"
 "\n"
 "  where:\n"
 "  	value = [(] <register/symbol/variable name | number> [)]\n"
-"  	number = [#|$|%]<digits>\n"
+"  	number/mask = [#|$|%]<digits>\n"
 "  	comparison = '<' | '>' | '=' | '!'\n"
 "  	addressing mode (width) = 'b' | 'w' | 'l'\n"
 "  	addressing mode (space) = 'p' | 'x' | 'y'\n"
-"  	option = : <count> | 'once' | 'trace'\n"
 "\n"
 "  If the value is in parenthesis like in '($ff820)' or '(a0)', then\n"
 "  the used value will be read from the memory address pointed by it.\n"
 "\n"
-"  If the value expressions on both sides of the comparison are exactly\n"
-"  the same, right side is replaced with its current value and for\n"
-"  inequality ('!') comparison, the breakpoint tracks all further changes\n"
-"  for the given address/register expression.  'trace' option for continuing\n"
-"  without breaking can be useful with this. 'once' option removes breakpoint\n"
-"  after hit and giving count as option will break only on every <count> hit.\n"
+"  If the parsed value expressions on both sides of it are exactly\n"
+"  the same, right side is replaced with its current value.  For\n"
+"  inequality ('!') comparison, the breakpoint will additionally track\n"
+"  all further changes for the given address/register expression value.\n"
+"  (This is useful for tracking register and memory value changes.)\n"
 "\n"
 "  M68k addresses can have byte (b), word (w) or long (l, default) width.\n"
 "  DSP addresses belong to different address spaces: P, X or Y. Note that\n"
@@ -1424,7 +1614,7 @@ static void BreakCond_Help(void)
 				hatari_vars[i].name, hatari_vars[i].vtype);
 			continue;
 		}
-		fprintf(stderr, "  - %s (%d)", hatari_vars[i].name, value);
+		fprintf(stderr, "  - %s ($%x)", hatari_vars[i].name, value);
 		if (hatari_vars[i].constraints) {
 			fprintf(stderr, ", %s\n", hatari_vars[i].constraints);
 		} else {
@@ -1443,14 +1633,84 @@ static void BreakCond_Help(void)
 /* ------------- breakpoint condition parsing, public API ------------ */
 
 const char BreakCond_Description[] =
-	"[ <condition> [:<count>|once|trace] | <index> | help | all ]\n"
-	"\tSet breakpoint with given <condition>, remove breakpoint with\n"
-	"\tgiven <index> or list all breakpoints when no args are given.\n"
-	"\tAdding ':trace' to end of condition causes breakpoint match\n"
-	"\tjust to be printed, not break.  Adding ':once' will delete\n"
-	"\tthe breakpoint after it's hit.  Adding ':<count>' will break\n"
-	"\tonly on every <count> hit.  'help' outputs breakpoint condition\n"
-	"\tsyntax help, 'all' removes all breakpoints.";
+	"<condition> [&& <condition> ...] [:<option>] | <index> | help | all\n"
+	"\n"
+	"\tSet breakpoint with given <conditions>, remove breakpoint with\n"
+	"\tgiven <index>, remove all breakpoints with 'all' or output\n"
+	"\tbreakpoint condition syntax with 'help'.  Without arguments,\n"
+	"\tlists currently active breakpoints.\n"
+	"\n"
+	"\tMultiple breakpoint action options can be specified after\n"
+	"\tthe breakpoint condition(s):\n"
+	"\t- 'trace', print the breakpoint match without stopping\n"
+	"\t- 'lock', print the debugger entry info without stopping\n"
+	"\t- 'noinit', no debugger inits on hit, useful for stack tracing\n"
+	"\t- 'file <file>', execute debugger commands from given <file>\n"
+	"\t- 'once', delete the breakpoint after it's hit\n"
+	"\t- 'quiet', no output from setting & hitting breakpoint\n"
+	"\t- '<count>', break only on every <count> hit";
+
+/**
+ * Parse options for the given breakpoint command.
+ * Return true for success and false for failure.
+ */
+static bool BreakCond_Options(char *str, bc_options_t *options, char marker)
+{
+	char *option, *next, *filename;
+	int skip;
+	
+	memset(options, 0, sizeof(*options));
+
+	option = strchr(str, marker);
+	if (option) {
+		/* end breakcond command at options */
+		*option = 0;
+	}
+	for (next = option; option; option = next) {
+
+		/* skip marker + end & trim this option */
+		option = next + 1;
+		next = strchr(option, marker);
+		if (next) {
+			*next = 0;
+		}
+		option = Str_Trim(option);
+
+		if (strcmp(option, "once") == 0) {
+			options->once = true;
+		} else if (strcmp(option, "quiet") == 0) {
+			options->quiet = true;
+		} else if (strcmp(option, "trace") == 0) {
+			options->trace = true;
+		} else if (strcmp(option, "lock") == 0) {
+			options->trace = true;
+			options->lock = true;
+		} else if (strcmp(option, "noinit") == 0) {
+			options->trace = true;
+			options->noinit = true;
+		} else if (strncmp(option, "file ", 5) == 0) {
+			filename = Str_Trim(option+4);
+			if (!File_Exists(filename)) {
+				fprintf(stderr, "ERROR: given file '%s' doesn't exist!\n", filename);
+				fprintf(stderr, "(if you use 'cd' command, do it before setting breakpoints)\n");
+				return false;
+			}
+			options->filename = filename;
+		} else if (isdigit(*option)) {
+			/* :<value> */
+			skip = atoi(option);
+			if (skip < 2) {
+				fprintf(stderr, "ERROR: invalid breakpoint skip count '%s'!\n", option);
+				return false;
+			}
+			options->skip = skip;
+		} else {
+			fprintf(stderr, "ERROR: unrecognized breakpoint option '%s'!\n", option);
+			return false;
+		}
+	}
+	return true;
+}
 
 /**
  * Parse given command expression to set/remove/list
@@ -1459,11 +1719,11 @@ const char BreakCond_Description[] =
  */
 bool BreakCond_Command(const char *args, bool bForDsp)
 {
-	bool trace, once, ret = true;
-	char *cut, *expression, *argscopy;
+	char *expression, *argscopy;
 	unsigned int position;
+	bc_options_t options;
 	const char *end;
-	int skip;
+	bool ret = true;
 	
 	if (!args) {
 		BreakCond_List(bForDsp);
@@ -1474,7 +1734,7 @@ bool BreakCond_Command(const char *args,
 	
 	expression = Str_Trim(argscopy);
 	
-	/* subcommands */
+	/* subcommands? */
 	if (strncmp(expression, "help", 4) == 0) {
 		BreakCond_Help();
 		goto cleanup;
@@ -1490,28 +1750,13 @@ bool BreakCond_Command(const char *args,
 		goto cleanup;
 	}
 
-	/* postfix options */
-	skip = 0;
-	once = false;
-	trace = false;
-	if ((cut = strchr(expression, ':'))) {
-		*cut = '\0';
-		cut = Str_Trim(cut+1);
-		if (strcmp(cut, "trace") == 0) {
-			trace = true;
-		} else if (strcmp(cut, "once") == 0) {
-			once = true;
-		} else {
-			skip = atoi(cut);
-			if (skip < 2) {
-				ret = false;
-				fprintf(stderr, "ERROR: invalid breakpoint skip count '%s'!\n", cut);
-				goto cleanup;
-			}
-		}
+	/* postfix options? */
+	if (!BreakCond_Options(expression, &options, ':')) {
+		ret = false;
+		goto cleanup;
 	}
 
-	/* index (for removal) */
+	/* index (for breakcond removal)? */
 	end = expression;
 	while (isdigit(*end)) {
 		end++;
@@ -1521,7 +1766,7 @@ bool BreakCond_Command(const char *args,
 		ret = BreakCond_Remove(position, bForDsp);
 	} else {
 		/* add breakpoint? */
-		ret = BreakCond_Parse(expression, bForDsp, trace, once, skip);
+		ret = BreakCond_Parse(expression, &options, bForDsp);
 	}
 cleanup:
 	free(argscopy);
@@ -1530,12 +1775,17 @@ cleanup:
 
 
 const char BreakAddr_Description[] =
-	"<address> [:<count>|once|trace]\n"
+	"<address> [:<option>]\n"
 	"\tCreate conditional breakpoint for given PC <address>.\n"
-	"\tAdding ':trace' causes breakpoint match just to be printed,\n"
-	"\tnot break. Adding ':once' will delete the breakpoint after\n"
-	"\tit's hit.  Adding ':<count>' will break only on every <count>\n"
-	"\thit.  Use conditional breakpoint commands to manage the created\n"
+	"\n"
+	"\tBreakpoint action option alternatives:\n"
+	"\t- 'trace', print the breakpoint match without stopping\n"
+	"\t- 'lock', print the debugger entry info without stopping\n"
+	"\t- 'once', delete the breakpoint after it's hit\n"
+	"\t- 'quiet', no output from setting & hitting breakpoint\n"
+	"\t- '<count>', break only on every <count> hit\n"
+	"\n"
+	"\tUse conditional breakpoint commands to manage the created\n"
 	"\tbreakpoints.";
 
 /**
@@ -1550,12 +1800,21 @@ bool BreakAddr_Command(char *args, bool
 	Uint32 addr;
 	int offset;
 
+	if (!args) {
+		if (bForDsp) {
+			DebugUI_PrintCmdHelp("dspaddress");
+		} else {
+			DebugUI_PrintCmdHelp("address");
+		}
+		return true;
+	}
+
 	/* split options */
 	if ((cut = strchr(args, ':'))) {
 		*cut = '\0';
 		cut = Str_Trim(cut+1);
-		if (strlen(cut) > 8) {
-			cut[8] = '\0';
+		if (strlen(cut) > 5) {
+			cut[5] = '\0';
 		}
 	}
 
@@ -1575,10 +1834,10 @@ bool BreakAddr_Command(char *args, bool
 
 	/* on success, show on what instruction it was added */
 	if (bForDsp) {
-		DSP_DisasmAddress(addr, addr);
+		DSP_DisasmAddress(stderr, addr, addr);
 	} else {
 		uaecptr dummy;
-		m68k_disasm(stderr, (uaecptr)addr, &dummy, 1);
+		Disasm(stderr, (uaecptr)addr, &dummy, 1);
 	}
 	return true;
 }