X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=c2f479add0fe6818c84d16eebfb3d34e14a8eedb;hp=5c432389174ce63331b92433486ff51748016c7c;hb=6f9aac189206328568866244f471b5f27bbb0c45;hpb=8e899d43ef8c049200e4558c4ba2b7f052468935

diff --git a/src/target/target.c b/src/target/target.c
index 5c43238917..c2f479add0 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -323,8 +323,6 @@ void target_buffer_set_u8(target_t *target, u8 *buffer, u8 value)
 target_t *get_target(const char *id)
 {
 	target_t *target;
-	char *endptr;
-	int num;
 
 	/* try as tcltarget name */
 	for (target = all_targets; target; target = target->next) {
@@ -335,12 +333,12 @@ target_t *get_target(const char *id)
 	}
 
 	/* no match, try as number */
-	num = strtoul(id, &endptr, 0);
-	if (*endptr != 0)
+	unsigned num;
+	if (parse_uint(id, &num) != ERROR_OK)
 		return NULL;
 
 	for (target = all_targets; target; target = target->next) {
-		if (target->target_number == num)
+		if (target->target_number == (int)num)
 			return target;
 	}
 
@@ -1706,16 +1704,19 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char
 	/* access a single register by its ordinal number */
 	if ((args[0][0] >= '0') && (args[0][0] <= '9'))
 	{
-		int num = strtoul(args[0], NULL, 0);
-		reg_cache_t *cache = target->reg_cache;
+		unsigned num;
+		int retval = parse_uint(args[0], &num);
+		if (ERROR_OK != retval)
+			return ERROR_COMMAND_SYNTAX_ERROR;
 
+		reg_cache_t *cache = target->reg_cache;
 		count = 0;
 		while(cache)
 		{
 			int i;
 			for (i = 0; i < cache->num_regs; i++)
 			{
-				if (count++ == num)
+				if (count++ == (int)num)
 				{
 					reg = &cache->reg_list[i];
 					break;
@@ -1821,21 +1822,23 @@ static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, cha
 
 static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-	int ms = 5000;
+	if (argc > 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (argc > 0)
+	unsigned ms = 5000;
+	if (1 == argc)
 	{
-		char *end;
-
-		ms = strtoul(args[0], &end, 0) * 1000;
-		if (*end)
+		int retval = parse_uint(args[0], &ms);
+		if (ERROR_OK != retval)
 		{
 			command_print(cmd_ctx, "usage: %s [seconds]", cmd);
-			return ERROR_OK;
+			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
+		// convert seconds (given) to milliseconds (needed)
+		ms *= 1000;
 	}
-	target_t *target = get_current_target(cmd_ctx);
 
+	target_t *target = get_current_target(cmd_ctx);
 	return target_wait_state(target, TARGET_HALTED, ms);
 }
 
@@ -1886,23 +1889,20 @@ int target_wait_state(target_t *target, enum target_state state, int ms)
 
 static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-	int retval;
-	target_t *target = get_current_target(cmd_ctx);
-
 	LOG_DEBUG("-");
 
-	if ((retval = target_halt(target)) != ERROR_OK)
-	{
+	target_t *target = get_current_target(cmd_ctx);
+	int retval = target_halt(target);
+	if (ERROR_OK != retval)
 		return retval;
-	}
 
 	if (argc == 1)
 	{
-		int wait;
-		char *end;
-
-		wait = strtoul(args[0], &end, 0);
-		if (!*end && !wait)
+		unsigned wait;
+		retval = parse_uint(args[0], &wait);
+		if (ERROR_OK != retval)
+			return ERROR_COMMAND_SYNTAX_ERROR;
+		if (!wait)
 			return ERROR_OK;
 	}
 
@@ -1954,7 +1954,11 @@ static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, c
 	 * handle breakpoints, not debugging */
 	u32 addr = 0;
 	if (argc == 1)
-		addr = strtoul(args[0], NULL, 0);
+	{
+		int retval = parse_u32(args[0], &addr);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
 	return target_resume(target, 0, addr, 1, 0);
 }
@@ -1971,7 +1975,11 @@ static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, cha
 	 * handle breakpoints, debugging */
 	u32 addr = 0;
 	if (argc == 1)
-		addr = strtoul(args[0], NULL, 0);
+	{
+		int retval = parse_u32(args[0], &addr);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
 	target_t *target = get_current_target(cmd_ctx);
 	return target->type->step(target, 0, addr, 1);
@@ -2038,16 +2046,23 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char
 	default: return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	u32 address = strtoul(args[0], NULL, 0);
+	u32 address;
+	int retval = parse_u32(args[0], &address);
+	if (ERROR_OK != retval)
+		return retval;
 
 	unsigned count = 1;
 	if (argc == 2)
-		count = strtoul(args[1], NULL, 0);
+	{
+		retval = parse_uint(args[1], &count);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
 	u8 *buffer = calloc(count, size);
 
 	target_t *target = get_current_target(cmd_ctx);
-	int retval = target_read_memory(target,
+	retval = target_read_memory(target,
 				address, size, count, buffer);
 	if (ERROR_OK == retval)
 		handle_md_output(cmd_ctx, target, address, size, count, buffer);
@@ -2059,22 +2074,30 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-	u32 address = 0;
-	u32 value = 0;
-	int count = 1;
-	int i;
-	int wordsize;
-	target_t *target = get_current_target(cmd_ctx);
-	u8 value_buf[4];
-
 	 if ((argc < 2) || (argc > 3))
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	address = strtoul(args[0], NULL, 0);
-	value = strtoul(args[1], NULL, 0);
+	u32 address;
+	int retval = parse_u32(args[0], &address);
+	if (ERROR_OK != retval)
+		return retval;
+
+	u32 value;
+	retval = parse_u32(args[1], &value);
+	if (ERROR_OK != retval)
+		return retval;
+
+	unsigned count = 1;
 	if (argc == 3)
-		count = strtoul(args[2], NULL, 0);
+	{
+		retval = parse_uint(args[2], &count);
+		if (ERROR_OK != retval)
+			return retval;
+	}
 
+	target_t *target = get_current_target(cmd_ctx);
+	unsigned wordsize;
+	u8 value_buf[4];
 	switch (cmd[2])
 	{
 		case 'w':
@@ -2092,9 +2115,9 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char
 		default:
 			return ERROR_COMMAND_SYNTAX_ERROR;
 	}
-	for (i=0; i<count; i++)
+	for (unsigned i = 0; i < count; i++)
 	{
-		int retval = target_write_memory(target,
+		retval = target_write_memory(target,
 				address + i * wordsize, wordsize, 1, value_buf);
 		if (ERROR_OK != retval)
 			return retval;
@@ -2449,57 +2472,69 @@ static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cm
 	return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
 }
 
-static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_bp_command_list(struct command_context_s *cmd_ctx)
 {
-	int retval;
 	target_t *target = get_current_target(cmd_ctx);
-
-	if (argc == 0)
-	{
-		breakpoint_t *breakpoint = target->breakpoints;
-
-		while (breakpoint)
-		{
-			if (breakpoint->type == BKPT_SOFT)
-			{
-				char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
-				command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
-				free(buf);
-			}
-			else
-			{
-				command_print(cmd_ctx, "0x%8.8x, 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set);
-			}
-			breakpoint = breakpoint->next;
-		}
-	}
-	else if (argc >= 2)
+	breakpoint_t *breakpoint = target->breakpoints;
+	while (breakpoint)
 	{
-		int hw = BKPT_SOFT;
-		u32 length = 0;
-
-		length = strtoul(args[1], NULL, 0);
-
-		if (argc >= 3)
-			if (strcmp(args[2], "hw") == 0)
-				hw = BKPT_HARD;
-
-		if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
+		if (breakpoint->type == BKPT_SOFT)
 		{
-			LOG_ERROR("Failure setting breakpoints");
+			char* buf = buf_to_str(breakpoint->orig_instr,
+					breakpoint->length, 16);
+			command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s",
+					breakpoint->address, breakpoint->length,
+					breakpoint->set, buf);
+			free(buf);
 		}
 		else
 		{
-			command_print(cmd_ctx, "breakpoint added at address 0x%8.8lx",
-					strtoul(args[0], NULL, 0));
+			command_print(cmd_ctx, "0x%8.8x, 0x%x, %i",
+					breakpoint->address, breakpoint->length, breakpoint->set);
 		}
+
+		breakpoint = breakpoint->next;
 	}
+	return ERROR_OK;
+}
+
+static int handle_bp_command_set(struct command_context_s *cmd_ctx,
+		u32 addr, u32 length, int hw)
+{
+	target_t *target = get_current_target(cmd_ctx);
+	int retval = breakpoint_add(target, addr, length, hw);
+	if (ERROR_OK == retval)
+		command_print(cmd_ctx, "breakpoint set at 0x%8.8x", addr);
 	else
+		LOG_ERROR("Failure setting breakpoint");
+	return retval;
+}
+
+static int handle_bp_command(struct command_context_s *cmd_ctx,
+		char *cmd, char **args, int argc)
+{
+	if (argc == 0)
+		return handle_bp_command_list(cmd_ctx);
+
+	if (argc < 2 || argc > 3)
 	{
 		command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	return ERROR_OK;
+	u32 addr = strtoul(args[0], NULL, 0);
+	u32 length = strtoul(args[1], NULL, 0);
+
+	int hw = BKPT_SOFT;
+	if (argc == 3)
+	{
+		if (strcmp(args[2], "hw") == 0)
+			hw = BKPT_HARD;
+		else
+			return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+
+	return handle_bp_command_set(cmd_ctx, addr, length, hw);
 }
 
 static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
@@ -2611,7 +2646,7 @@ static int handle_virt2phys_command(command_context_t *cmd_ctx,
 
 static void writeData(FILE *f, const void *data, size_t len)
 {
-	size_t written = fwrite(data, len, 1, f);
+	size_t written = fwrite(data, 1, len, f);
 	if (written != len)
 		LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
 }