s51: add breakpoints and the ability to block awaiting a breakpoint.

Signed-off-by: Keith Packard <keithp@keithp.com>

4 files changed, 347 insertions, 147 deletions

diff --git a/s51/s51-command.c b/s51/s51-command.c
index 278bca25..7538a94a 100644
--- a/s51/s51-command.c
+++ b/s51/s51-command.c
@@ -26,7 +26,7 @@ parse_int(char *value, int *result)
 	*result = strtol(value, &endptr, 0);
 	if (endptr == value)
 		return command_syntax;
-	return command_proceed;
+	return command_success;
 }
 
 static enum command_result
@@ -36,44 +36,44 @@ parse_uint16(char *value, uint16_t *uint16)
 	enum command_result result;
 
 	result = parse_int(value, &v);
-	if (result != command_proceed)
+	if (result != command_success)
 		return command_error;
 	if (v < 0 || v > 0xffff)
 		return command_error;
 	*uint16 = v;
-	return command_proceed;
+	return command_success;
 }
 
 enum command_result
-command_quit (FILE *output, int argc, char **argv)
+command_quit (int argc, char **argv)
 {
 	exit(0);
 	return command_error;
 }
 
 static void
-dump_bytes(FILE *output, uint8_t *memory, int length, uint16_t start)
+dump_bytes(uint8_t *memory, int length, uint16_t start)
 {
 	int group, i;
 	
 	for (group = 0; group < length; group += 8) {
-		fprintf(output, "0x%04x ", start + group);
+		s51_printf("0x%04x ", start + group);
 		for (i = group; i < length && i < group + 8; i++)
-			fprintf(output, "%02x ", memory[i]);
+			s51_printf("%02x ", memory[i]);
 		for (; i < group + 8; i++)
-			fprintf(output, "   ");
+			s51_printf("   ");
 		for (i = group; i < length && i < group + 8; i++) {
 			if (isascii(memory[i]) && isprint(memory[i]))
-				fprintf(output, "%c", memory[i]);
+				s51_printf("%c", memory[i]);
 			else
-				fprintf(output, ".");
+				s51_printf(".");
 		}
-		fprintf(output, "\n");
+		s51_printf("\n");
 	}
 }
 
 enum command_result
-command_di (FILE *output, int argc, char **argv)
+command_di (int argc, char **argv)
 {
 	uint16_t start, end;
 	uint8_t	memory[65536];
@@ -82,18 +82,18 @@ command_di (FILE *output, int argc, char **argv)
 	
 	if (argc != 3)
 		return command_error;
-	if (parse_uint16(argv[1], &start) != command_proceed)
+	if (parse_uint16(argv[1], &start) != command_success)
 		return command_error;
-	if (parse_uint16(argv[2], &end) != command_proceed)
+	if (parse_uint16(argv[2], &end) != command_success)
 		return command_error;
 	length = (int) end - (int) start + 1;
 	status = ccdbg_read_memory(s51_dbg, start + 0xff00, memory, length);
-	dump_bytes(output, memory, length, start);
-	return command_proceed;
+	dump_bytes(memory, length, start);
+	return command_success;
 }
 
 enum command_result
-command_ds (FILE *output, int argc, char **argv)
+command_ds (int argc, char **argv)
 {
 	uint16_t start, end;
 	uint8_t	memory[65536];
@@ -102,18 +102,18 @@ command_ds (FILE *output, int argc, char **argv)
 	
 	if (argc != 3)
 		return command_error;
-	if (parse_uint16(argv[1], &start) != command_proceed)
+	if (parse_uint16(argv[1], &start) != command_success)
 		return command_error;
-	if (parse_uint16(argv[2], &end) != command_proceed)
+	if (parse_uint16(argv[2], &end) != command_success)
 		return command_error;
 	length = (int) end - (int) start + 1;
 	status = ccdbg_read_memory(s51_dbg, start + 0xdf00, memory, length);
-	dump_bytes(output, memory, length, start);
-	return command_proceed;
+	dump_bytes(memory, length, start);
+	return command_success;
 }
 
 enum command_result
-command_dx (FILE *output, int argc, char **argv)
+command_dx (int argc, char **argv)
 {
 	uint16_t start, end;
 	uint8_t	memory[65536];
@@ -122,43 +122,52 @@ command_dx (FILE *output, int argc, char **argv)
 	
 	if (argc != 3)
 		return command_error;
-	if (parse_uint16(argv[1], &start) != command_proceed)
+	if (parse_uint16(argv[1], &start) != command_success)
 		return command_error;
-	if (parse_uint16(argv[2], &end) != command_proceed)
+	if (parse_uint16(argv[2], &end) != command_success)
 		return command_error;
 	length = (int) end - (int) start + 1;
 	status = ccdbg_read_memory(s51_dbg, start, memory, length);
-	dump_bytes(output, memory, length, start);
-	return command_proceed;
+	dump_bytes(memory, length, start);
+	return command_success;
 }
 
 enum command_result
-command_set (FILE *output, int argc, char **argv)
+command_set (int argc, char **argv)
 {
 	return command_error;
 }
 
 enum command_result
-command_dump (FILE *output, int argc, char **argv)
+command_dump (int argc, char **argv)
 {
 	return command_error;
 }
 
 enum command_result
-command_pc (FILE *output, int argc, char **argv)
+command_file (int argc, char **argv)
+{
+	if (argc != 2)
+		return command_error;
+	s51_printf("some words read from %s\n", argv[1]);
+	return command_success;
+}
+
+enum command_result
+command_pc (int argc, char **argv)
 {
 	uint16_t	pc;
 	if (argv[1]) {
 		enum command_result result;
 		result = parse_uint16(argv[1], &pc);
-		if (result != command_proceed)
+		if (result != command_success)
 			return result;
 		ccdbg_set_pc(s51_dbg, pc);
 	} else {
 		pc = ccdbg_get_pc(s51_dbg);
-		printf (" 0x%04x\n", pc);
+		s51_printf("   0x%04x 00\n", pc);
 	}
-	return command_proceed;
+	return command_success;
 }
 
 struct cc_break {
@@ -171,8 +180,28 @@ struct cc_break {
 
 static struct cc_break	breakpoints[CC_NUM_BREAKPOINTS];
 
+static void
+disable_breakpoint(int b)
+{
+	uint8_t status;
+	
+	status = ccdbg_set_hw_brkpnt(s51_dbg, b, 0, breakpoints[b].address);
+	if (status != 0x00 && status != 0xff)
+		s51_printf("disable_breakpoint status 0x%02x\n", status);
+}
+
+static void
+enable_breakpoint(int b)
+{
+	uint8_t status;
+	
+	status = ccdbg_set_hw_brkpnt(s51_dbg, b, 1, breakpoints[b].address);
+	if (status != 0xff)
+		s51_printf("enable_breakpoint status 0x%02x\n", status);
+}
+
 enum command_result
-set_breakpoint(FILE *output, uint16_t address, int temporary)
+set_breakpoint(uint16_t address, int temporary)
 {
 	int b;
 	uint8_t status;
@@ -183,22 +212,21 @@ set_breakpoint(FILE *output, uint16_t address, int temporary)
 			break;
 	}
 	if (b == CC_NUM_BREAKPOINTS) {
-		fprintf(output, "Error: too many breakpoints requested\n");
-		return command_proceed;
+		s51_printf("Error: too many breakpoints requested\n");
+		return command_success;
 	}
 	if (breakpoints[b].enabled == 0) {
 		breakpoints[b].address = address;
-		status = ccdbg_set_hw_brkpnt(s51_dbg, b, 1, address);
-		fprintf(output, "set_hw_brkpnt status 0x%02x\n", status);
+		enable_breakpoint(b);
 	}
 	++breakpoints[b].enabled;
-	fprintf(output, "Breakpoint %d at 0x%04x\n", b, address);
+	s51_printf("Breakpoint %d at 0x%04x\n", b, address);
 	breakpoints[b].temporary += temporary;
-	return command_proceed;
+	return command_success;
 }
 
 enum command_result
-clear_breakpoint(FILE *output, uint16_t address, int temporary)
+clear_breakpoint(uint16_t address, int temporary)
 {
 	int b;
 	uint8_t status;
@@ -210,21 +238,35 @@ clear_breakpoint(FILE *output, uint16_t address, int temporary)
 			break;
 	}
 	if (b == CC_NUM_BREAKPOINTS) {
-		fprintf(output, "Error: no matching breakpoint found\n");
-		return command_proceed;
+		s51_printf("Error: no matching breakpoint found\n");
+		return command_success;
 	}
 	--breakpoints[b].enabled;
-	--breakpoints[b].temporary;
+	breakpoints[b].temporary -= temporary;
 	if (breakpoints[b].enabled == 0) {
+		disable_breakpoint(b);
 		breakpoints[b].address = -1;
-		ccdbg_set_hw_brkpnt(s51_dbg, b, 0, address);
-		fprintf(output, "set_hw_brkpnt status 0x%02x\n", status);
 	}
-	return command_proceed;
+	return command_success;
+}
+
+
+int
+find_breakpoint(uint16_t address)
+{
+	int b;
+
+	for (b = 0; b < CC_NUM_BREAKPOINTS; b++)
+		if (breakpoints[b].enabled && breakpoints[b].address == address)
+			break;
+	if (b == CC_NUM_BREAKPOINTS)
+		return -1;
+	if (breakpoints[b].temporary)
+		clear_breakpoint(address, 1);
 }
 
 enum command_result
-command_break (FILE *output, int argc, char **argv)
+command_break (int argc, char **argv)
 {
 	int b;
 	uint16_t address;
@@ -233,21 +275,21 @@ command_break (FILE *output, int argc, char **argv)
 	if (argc == 1) {
 		for (b = 0; b < CC_NUM_BREAKPOINTS; b++)
 			if (breakpoints[b].enabled)
-				fprintf(output, "Breakpoint %d 0x%04x\n",
+				s51_printf("Breakpoint %d 0x%04x\n",
 					b, breakpoints[b].address);
-		return command_proceed;
+		return command_success;
 	}
 	if (argc != 2)
 		return command_error;
 	result = parse_uint16(argv[1], &address);
-	if (result != command_proceed)
+	if (result != command_success)
 		return result;
 
-	return set_breakpoint(output, address, 0);
+	return set_breakpoint(address, 0);
 }
 
 enum command_result
-command_clear (FILE *output, int argc, char **argv)
+command_clear (int argc, char **argv)
 {
 	int b;
 	uint16_t address;
@@ -256,116 +298,179 @@ command_clear (FILE *output, int argc, char **argv)
 	if (argc != 2)
 		return command_error;
 	result = parse_uint16(argv[1], &address);
-	if (result != command_proceed)
+	if (result != command_success)
 		return result;
-	return clear_breakpoint(output, address, 0);
+	return clear_breakpoint(address, 0);
+}
+
+void
+cc_stopped(uint8_t status)
+{
+	uint16_t pc;
+	int b;
+	int code;
+	char *reason;
+
+	pc = ccdbg_get_pc(s51_dbg);
+	if (status & CC_STATUS_CPU_HALTED) {
+		if ((status & CC_STATUS_HALT_STATUS) != 0) {
+			pc = pc - 1;
+			code = 104;
+			reason = "Breakpoint";
+			ccdbg_set_pc(s51_dbg, pc);
+		} else {
+			code = 105;
+			reason = "Interrupt";
+		}
+		s51_printf("Stop at 0x%04x: (%d) %s\n",
+			pc, code, reason);
+	}
+}
+
+uint8_t
+cc_step(uint16_t pc)
+{
+	int b;
+	uint8_t status;
+
+	b = find_breakpoint(pc);
+	if (b != -1)
+		disable_breakpoint(b);
+	status = ccdbg_step_instr(s51_dbg);
+	if (b != -1)
+		enable_breakpoint(b);
+	return status;
 }
 
 enum command_result
-command_run (FILE *output, int argc, char **argv)
+command_run (int argc, char **argv)
 {
 	uint16_t start, end;
 	enum command_result result;
+	uint16_t pc;
+	uint8_t status;
+	int b;
 	
 	if (argv[1]) {
 		result = parse_uint16(argv[1], &start);
-		if (result != command_proceed)
+		if (result != command_success)
 			return result;
 		if (argv[2]) {
 			result = parse_uint16(argv[2], &end);
-			if (result != command_proceed)
+			if (result != command_success)
 				return result;
 		}
 		ccdbg_set_pc(s51_dbg, start);
 	}
 	else
 		start = ccdbg_get_pc(s51_dbg);
-	fprintf(output, "Resume at 0x%04x\n", start);
+	s51_printf("Resume at 0x%04x\n", start);
+	pc = start;
+	b = find_breakpoint(pc);
+	if (b != -1) {
+		cc_step(pc);
+		pc = ccdbg_get_pc(s51_dbg);
+		if (find_breakpoint(pc) != -1) {
+			status = ccdbg_read_status(s51_dbg);
+			cc_stopped(status);
+			return command_success;
+		}
+	}
 	ccdbg_resume(s51_dbg);
-//	cc_wait(s51_dbg);
-	return command_proceed;
+	result = cc_wait();
+	return result;
 }
 
 enum command_result
-command_next (FILE *output, int argc, char **argv)
+command_next (int argc, char **argv)
 {
-	return command_step(output, argc, argv);
+	return command_step(argc, argv);
 }
 
 enum command_result
-command_step (FILE *output, int argc, char **argv)
+command_step (int argc, char **argv)
 {
 	uint16_t pc;
 	uint8_t	opcode;
 	uint8_t a;
 
-	a = ccdbg_step_instr(s51_dbg);
-	fprintf(output, " ACC= 0x%02x\n", a);
+	a = cc_step(ccdbg_get_pc(s51_dbg));
+	s51_printf(" ACC= 0x%02x\n", a);
 	pc = ccdbg_get_pc(s51_dbg);
 	ccdbg_read_memory(s51_dbg, pc, &opcode, 1);
-	fprintf(output, " ? 0x%04x %02x\n", pc, opcode);
-	return command_proceed;
+	s51_printf(" ? 0x%04x %02x\n", pc, opcode);
+	return command_success;
 }
 
 enum command_result
-command_load (FILE *output, int argc, char **argv)
+command_load (int argc, char **argv)
 {
 	return command_error;
 }
 
 enum command_result
-command_halt (FILE *output, int argc, char **argv)
+command_halt (int argc, char **argv)
 {
 	uint16_t	pc;
 	ccdbg_halt(s51_dbg);
 	pc = ccdbg_get_pc(s51_dbg);
-	fprintf(output, "Halted at 0x%04x\n", pc);
-	return command_proceed;
+	s51_printf("Halted at 0x%04x\n", pc);
+	return command_success;
 }
 
 enum command_result
-command_reset (FILE *output, int argc, char **argv)
+command_reset (int argc, char **argv)
 {
 	ccdbg_debug_mode(s51_dbg);
-	return command_proceed;
+	return command_success;
 }
 
 enum command_result
-command_status(FILE *output, int argc, char **argv)
+command_status(int argc, char **argv)
 {
 	uint8_t	status;
 
 	status = ccdbg_read_status(s51_dbg);
 	if ((status & CC_STATUS_CHIP_ERASE_DONE) == 0)
-		fprintf(output, "\tChip erase in progress\n");
+		s51_printf("\tChip erase in progress\n");
 	if (status & CC_STATUS_PCON_IDLE)
-		fprintf(output, "\tCPU is idle (clock gated)\n");
+		s51_printf("\tCPU is idle (clock gated)\n");
 	if (status & CC_STATUS_CPU_HALTED)
-		fprintf(output, "\tCPU halted\n");
+		s51_printf("\tCPU halted\n");
 	else
-		fprintf(output, "\tCPU running\n");
+		s51_printf("\tCPU running\n");
 	if ((status & CC_STATUS_POWER_MODE_0) == 0)
-		fprintf(output, "\tPower Mode 1-3 selected\n");
+		s51_printf("\tPower Mode 1-3 selected\n");
 	if (status & CC_STATUS_HALT_STATUS)
-		fprintf(output, "\tHalted by software or hw breakpoint\n");
+		s51_printf("\tHalted by software or hw breakpoint\n");
 	else
-		fprintf(output, "\tHalted by debug command\n");
+		s51_printf("\tHalted by debug command\n");
 	if (status & CC_STATUS_DEBUG_LOCKED)
-		fprintf(output, "\tDebug interface is locked\n");
+		s51_printf("\tDebug interface is locked\n");
 	if ((status & CC_STATUS_OSCILLATOR_STABLE) == 0)
-		fprintf(output, "\tOscillators are not stable\n");
+		s51_printf("\tOscillators are not stable\n");
 	if (status & CC_STATUS_STACK_OVERFLOW)
-		fprintf(output, "\tStack overflow\n");
-	return command_proceed;
+		s51_printf("\tStack overflow\n");
+	return command_success;
 }
 
-uint8_t cc_wait(struct ccdbg *dbg)
+enum command_result
+cc_wait(void)
 {
-	uint8_t status;
 	for(;;) {
-		status = ccdbg_read_status(dbg);
-		if (status & CC_STATUS_CPU_HALTED)
-			break;
+		uint8_t status;
+		status = ccdbg_read_status(s51_dbg);
+		if (status & CC_STATUS_CPU_HALTED) {
+			cc_stopped(status);
+			return command_success;
+		}
+		if (s51_interrupted || s51_check_input()) {
+			
+			ccdbg_halt(s51_dbg);
+			status = ccdbg_read_status(s51_dbg);
+			cc_stopped(status);
+			return command_interrupt;
+		}
 	}
-	return status;
 }
+
diff --git a/s51/s51-main.c b/s51/s51-main.c
index 9a5ca7c2..28a774d2 100644
--- a/s51/s51-main.c
+++ b/s51/s51-main.c
@@ -21,12 +21,19 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <poll.h>
 
 static int s51_port = 0;
 static char *cpu = "8051";
 static double freq = 11059200;
 char *s51_prompt = "> ";
 struct ccdbg *s51_dbg;
+int s51_interrupted = 0;
+
+static FILE *s51_input;
+static FILE *s51_output;
 
 static void
 usage(void)
@@ -35,13 +42,17 @@ usage(void)
 	exit(1);
 }
 
+void s51_sigint()
+{
+	s51_interrupted = 1;
+}
+
 int
 main(int argc, char **argv)
 {
 	int flags, opt;
-	FILE *console_in = stdin;
-	FILE *console_out = stdout;
 	char *endptr;
+	struct sigvec vec, ovec;
 
 	while ((opt = getopt(argc, argv, "PVvHht:X:c:r:Z:s:S:p:")) != -1) {
 		switch (opt) {
@@ -122,7 +133,6 @@ main(int argc, char **argv)
 		for (;;) {
 			struct sockaddr_in client_addr;
 			socklen_t client_len = sizeof (struct sockaddr_in);
-			FILE *client_in, *client_out;
 			
 			s = accept(l, (struct sockaddr *)
 				   &client_addr, &client_len);
@@ -130,17 +140,82 @@ main(int argc, char **argv)
 				perror("accept");
 				exit(1);
 			}
-			client_in = fdopen(s, "r");
-			client_out = fdopen(s, "w");
-			if (!client_in || !client_out) {
+			s51_input = fdopen(s, "r");
+			s51_output = fdopen(s, "w");
+			if (!s51_input || !s51_output) {
 				perror("fdopen");
 				exit(1);
 			}
-			command_read(client_in, client_out);
-			fclose(client_in);
-			fclose(client_out);
+			vec.sv_handler = s51_sigint;
+			vec.sv_mask = 0;
+			vec.sv_flags = 0;
+			sigvec(SIGINT, &vec, &ovec);
+			command_read();
+			sigvec(SIGINT, &ovec, NULL);
+			fclose(s51_input);
+			fclose(s51_output);
 		}
-	} else
-		command_read(console_in, console_out);
+	} else {
+		s51_input = stdin;
+		s51_output = stdout;
+		vec.sv_handler = s51_sigint;
+		vec.sv_mask = 0;
+		vec.sv_flags = 0;
+		sigvec(SIGINT, &vec, &ovec);
+		command_read();
+	}
 	exit(0);
 }
+
+void
+s51_printf(char *format, ...)
+{
+	va_list	ap;
+
+	va_start(ap, format);
+	vfprintf(s51_output, format, ap);
+	if (s51_port)
+		vfprintf(stdout, format, ap);
+	va_end(ap);
+}
+
+void
+s51_putc(int c)
+{
+	putc(c, s51_output);
+}
+
+int
+s51_read_line(char *line, int len)
+{
+	int ret;
+	if (s51_prompt)
+		s51_printf("%s", s51_prompt);
+	else
+		s51_putc('\0');
+	fflush(s51_output);
+	ret = fgets(line, len, s51_input) != NULL;
+	if (s51_port)
+		printf("> %s", line);
+	fflush(stdout);
+	return ret;
+}
+
+int
+s51_check_input(void)
+{
+	struct pollfd	input;
+	int r;
+	int c;
+
+	input.fd = fileno(s51_input);
+	input.events = POLLIN;
+	r = poll(&input, 1, 0);
+	if (r > 0) {
+		char line[256];
+		(void) s51_read_line(line, sizeof (line));
+		return 1; 
+	}
+	return 0;
+}
+
diff --git a/s51/s51-parse.c b/s51/s51-parse.c
index 56a63e24..d0bfb45b 100644
--- a/s51/s51-parse.c
+++ b/s51/s51-parse.c
@@ -21,7 +21,7 @@
 struct command_function {
 	char			*name;
 	char			*alias;
-	enum command_result	(*func)(FILE *output, int argc, char **argv);
+	enum command_result	(*func)(int argc, char **argv);
 	char			*usage;
 	char			*help;
 };
@@ -40,6 +40,8 @@ static struct command_function functions[] = {
 		"set bit <addr>\n" },
 	{ "dump",   "d",  command_dump,	"[d]ump <prefix> <start> <end>",
 		"Dump {xram|rom|iram|sfr} <start> <end>\n" },
+	{ "file", "file", command_file, "file <filename>",
+		"Pretend to load executable from <filename>\n" },
 	{ "pc",	    "p",  command_pc, "[p]c [addr]",
 		"Get or set pc value\n" },
 	{ "break",  "b",  command_break,"[b]reak <addr>",
@@ -149,23 +151,23 @@ command_split_into_words(char *line, char **argv)
 }
 
 enum command_result
-command_help(FILE *output, int argc, char **argv)
+command_help(int argc, char **argv)
 {
 	int i;
 	struct command_function *func;
 
 	if (argc == 1) {
 		for (i = 0; i < NUM_FUNCTIONS; i++)
-			fprintf(output, "%-10s%s\n", functions[i].name,
+			s51_printf("%-10s%s\n", functions[i].name,
 			       functions[i].usage);
 	} else {
 		for (i = 1; i < argc; i++) {
 			func = command_string_to_function(argv[i]);
 			if (!func) {
-				fprintf(output, "%-10s unknown command\n", argv[i]);
+				s51_printf("%-10s unknown command\n", argv[i]);
 				return command_syntax;
 			}
-			fprintf(output, "%-10s %s\n%s", func->name,
+			s51_printf("%-10s %s\n%s", func->name,
 			       func->usage, func->help);
 		}
 	}
@@ -173,16 +175,16 @@ command_help(FILE *output, int argc, char **argv)
 }
     
 static void
-command_syntax_error(FILE *output, int argc, char **argv)
+command_syntax_error(int argc, char **argv)
 {
-	fprintf(output, "Syntax error in:");
+	s51_printf("Syntax error in:");
 	while (*argv)
-		fprintf(output, " %s", *argv++);
-	fprintf(output, "\n");
+		s51_printf(" %s", *argv++);
+	s51_printf("\n");
 }
 
 void
-command_read (FILE *input, FILE *output)
+command_read (void)
 {
 	int argc;
 	char line[1024];
@@ -196,31 +198,34 @@ command_read (FILE *input, FILE *output)
 		exit(1);
 	}
 	ccdbg_debug_mode(s51_dbg);
-	fprintf(output, "Welcome to the non-simulated processor\n");
+	ccdbg_halt(s51_dbg);
+	s51_printf("Welcome to the non-simulated processor\n");
 	for (;;) {
-		if (s51_prompt)
-			fprintf(output, "%s", s51_prompt);
-		else
-			putc('\0', output);
-		fflush(output);
-		if (!fgets (line, sizeof line, input))
+		if (s51_read_line (line, sizeof line) == 0)
 			break;
+		s51_interrupted = 0;
 		argc = command_split_into_words(line, argv);
 		if (argc > 0) {
 			func = command_string_to_function(argv[0]);
 			if (!func)
-				command_syntax_error(output, argc, argv);
+				command_syntax_error(argc, argv);
 			else
 			{
-				result = (*func->func)(output, argc, argv);
+				result = (*func->func)(argc, argv);
+				if (s51_interrupted)
+					result = command_interrupt;
 				switch (result) {
 				case command_syntax:
-					command_syntax_error(output, argc, argv);
+					command_syntax_error(argc, argv);
 					break;
 				case command_error:
-					fprintf(output, "Error\n");
+					s51_printf("Error\n");
 					break;
-				case command_proceed:
+				case command_success:
+					break;
+				case command_interrupt:
+					ccdbg_halt(s51_dbg);
+					s51_printf("Interrupted\n");
 					break;
 				default:
 					break;
@@ -229,6 +234,6 @@ command_read (FILE *input, FILE *output)
 		}
 	}
 	ccdbg_close(s51_dbg);
-	fprintf(output, "...\n");
+	s51_printf("...\n");
 }
 
diff --git a/s51/s51.h b/s51/s51.h
index 3ca4734c..7c96e2a6 100644
--- a/s51/s51.h
+++ b/s51/s51.h
@@ -19,66 +19,81 @@
 #include <ccdbg.h>
 
 extern char *s51_prompt;
-
 extern struct ccdbg *s51_dbg;
+extern int s51_interrupted;
 
 enum command_result {
-	command_proceed, command_debug, command_syntax, command_error
+	command_success, command_debug, command_syntax, command_interrupt, command_error,
 };
 
 enum command_result
-command_quit (FILE *output, int argc, char **argv);
+command_quit (int argc, char **argv);
+
+enum command_result
+command_help (int argc, char **argv);
+
+enum command_result
+command_di (int argc, char **argv);
 
 enum command_result
-command_help (FILE *output, int argc, char **argv);
+command_ds (int argc, char **argv);
 
 enum command_result
-command_di (FILE *output, int argc, char **argv);
+command_dx (int argc, char **argv);
 
 enum command_result
-command_ds (FILE *output, int argc, char **argv);
+command_set (int argc, char **argv);
 
 enum command_result
-command_dx (FILE *output, int argc, char **argv);
+command_dump (int argc, char **argv);
 
 enum command_result
-command_set (FILE *output, int argc, char **argv);
+command_file (int argc, char **argv);
 
 enum command_result
-command_dump (FILE *output, int argc, char **argv);
+command_pc (int argc, char **argv);
 
 enum command_result
-command_pc (FILE *output, int argc, char **argv);
+command_break (int argc, char **argv);
 
 enum command_result
-command_break (FILE *output, int argc, char **argv);
+command_clear (int argc, char **argv);
 
 enum command_result
-command_clear (FILE *output, int argc, char **argv);
+command_run (int argc, char **argv);
 
 enum command_result
-command_run (FILE *output, int argc, char **argv);
+command_next (int argc, char **argv);
 
 enum command_result
-command_next (FILE *output, int argc, char **argv);
+command_step (int argc, char **argv);
 
 enum command_result
-command_step (FILE *output, int argc, char **argv);
+command_load (int argc, char **argv);
 
 enum command_result
-command_load (FILE *output, int argc, char **argv);
+command_halt (int argc, char **argv);
 
 enum command_result
-command_halt (FILE *output, int argc, char **argv);
+command_reset (int argc, char **argv);
 
 enum command_result
-command_reset (FILE *output, int argc, char **argv);
+command_status (int argc, char **argv);
 
 enum command_result
-command_status (FILE *output, int argc, char **argv);
+cc_wait(void);
 
-uint8_t
-cc_wait(struct ccdbg *dbg);
+void
+command_read (void);
+
+void
+s51_printf(char *format, ...);
 
 void
-command_read (FILE *input, FILE *output);
+s51_putc(int c);
+
+int
+s51_check_input(void);
+
+int
+s51_read_line(char *line, int len);