build: cleanup src/target directory

Change-Id: Ia055b6d2b5f6449a38afd0539a8c66e7d7e0c059
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/430
Tested-by: jenkins

1 files changed, 530 insertions, 892 deletions

diff --git a/src/target/target.c b/src/target/target.c
index ab094f96..5b2117df 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -35,6 +35,7 @@
  *   Free Software Foundation, Inc.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -52,15 +53,14 @@
 #include "image.h"
 #include "rtos/rtos.h"
 
-
 static int target_read_buffer_default(struct target *target, uint32_t address,
 		uint32_t size, uint8_t *buffer);
 static int target_write_buffer_default(struct target *target, uint32_t address,
 		uint32_t size, const uint8_t *buffer);
 static int target_array2mem(Jim_Interp *interp, struct target *target,
-		int argc, Jim_Obj *const *argv);
+		int argc, Jim_Obj * const *argv);
 static int target_mem2array(Jim_Interp *interp, struct target *target,
-		int argc, Jim_Obj *const *argv);
+		int argc, Jim_Obj * const *argv);
 static int target_register_user_commands(struct command_context *cmd_ctx);
 
 /* targets */
@@ -86,8 +86,7 @@ extern struct target_type testee_target;
 extern struct target_type avr32_ap7k_target;
 extern struct target_type stm32_stlink_target;
 
-static struct target_type *target_types[] =
-{
+static struct target_type *target_types[] = {
 	&arm7tdmi_target,
 	&arm9tdmi_target,
 	&arm920t_target,
@@ -112,9 +111,9 @@ static struct target_type *target_types[] =
 	NULL,
 };
 
-struct target *all_targets = NULL;
-static struct target_event_callback *target_event_callbacks = NULL;
-static struct target_timer_callback *target_timer_callbacks = NULL;
+struct target *all_targets;
+static struct target_event_callback *target_event_callbacks;
+static struct target_timer_callback *target_timer_callbacks;
 static const int polling_interval = 100;
 
 static const Jim_Nvp nvp_assert[] = {
@@ -147,11 +146,10 @@ static const char *target_strerror_safe(int err)
 	const Jim_Nvp *n;
 
 	n = Jim_Nvp_value2name_simple(nvp_error_target, err);
-	if (n->name == NULL) {
+	if (n->name == NULL)
 		return "unknown";
-	} else {
+	else
 		return n->name;
-	}
 }
 
 static const Jim_Nvp nvp_target_event[] = {
@@ -214,7 +212,7 @@ static const Jim_Nvp nvp_target_state[] = {
 	{ .name = NULL, .value = -1 },
 };
 
-static const Jim_Nvp nvp_target_debug_reason [] = {
+static const Jim_Nvp nvp_target_debug_reason[] = {
 	{ .name = "debug-request"            , .value = DBG_REASON_DBGRQ },
 	{ .name = "breakpoint"               , .value = DBG_REASON_BREAKPOINT },
 	{ .name = "watchpoint"               , .value = DBG_REASON_WATCHPOINT },
@@ -254,12 +252,11 @@ const char *debug_reason_name(struct target *t)
 	return cp;
 }
 
-const char *
-target_state_name( struct target *t )
+const char *target_state_name(struct target *t)
 {
 	const char *cp;
 	cp = Jim_Nvp_value2name_simple(nvp_target_state, t->state)->name;
-	if( !cp ){
+	if (!cp) {
 		LOG_ERROR("Invalid target state: %d", (int)(t->state));
 		cp = "(*BUG*unknown*BUG*)";
 	}
@@ -276,9 +273,8 @@ static int new_target_number(void)
 	x = -1;
 	t = all_targets;
 	while (t) {
-		if (x < t->target_number) {
+		if (x < t->target_number)
 			x = t->target_number;
-		}
 		t = t->next;
 	}
 	return x + 1;
@@ -354,32 +350,32 @@ static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t
 void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
 {
 	uint32_t i;
-	for(i = 0; i < count; i ++)
-		dstbuf[i] = target_buffer_get_u32(target,&buffer[i*4]);
+	for (i = 0; i < count; i++)
+		dstbuf[i] = target_buffer_get_u32(target, &buffer[i * 4]);
 }
 
 /* write a uint16_t array to a buffer in target memory endianness */
 void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf)
 {
 	uint32_t i;
-	for(i = 0; i < count; i ++)
-		dstbuf[i] = target_buffer_get_u16(target,&buffer[i*2]);
+	for (i = 0; i < count; i++)
+		dstbuf[i] = target_buffer_get_u16(target, &buffer[i * 2]);
 }
 
 /* write a uint32_t array to a buffer in target memory endianness */
 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, uint32_t *srcbuf)
 {
 	uint32_t i;
-	for(i = 0; i < count; i ++)
-		target_buffer_set_u32(target,&buffer[i*4],srcbuf[i]);
+	for (i = 0; i < count; i++)
+		target_buffer_set_u32(target, &buffer[i * 4], srcbuf[i]);
 }
 
 /* write a uint16_t array to a buffer in target memory endianness */
 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, uint16_t *srcbuf)
 {
 	uint32_t i;
-	for(i = 0; i < count; i ++)
-		target_buffer_set_u16(target,&buffer[i*2],srcbuf[i]);
+	for (i = 0; i < count; i++)
+		target_buffer_set_u16(target, &buffer[i * 2], srcbuf[i]);
 }
 
 /* return a pointer to a configured target; id is name or number */
@@ -419,21 +415,19 @@ static struct target *get_target_by_num(int num)
 	struct target *target = all_targets;
 
 	while (target) {
-		if (target->target_number == num) {
+		if (target->target_number == num)
 			return target;
-		}
 		target = target->next;
 	}
 
 	return NULL;
 }
 
-struct target* get_current_target(struct command_context *cmd_ctx)
+struct target *get_current_target(struct command_context *cmd_ctx)
 {
 	struct target *target = get_target_by_num(cmd_ctx->current_target);
 
-	if (target == NULL)
-	{
+	if (target == NULL) {
 		LOG_ERROR("BUG: current_target out of bounds");
 		exit(-1);
 	}
@@ -446,8 +440,7 @@ int target_poll(struct target *target)
 	int retval;
 
 	/* We can't poll until after examine */
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		/* Fail silently lest we pollute the log */
 		return ERROR_FAIL;
 	}
@@ -456,16 +449,12 @@ int target_poll(struct target *target)
 	if (retval != ERROR_OK)
 		return retval;
 
-	if (target->halt_issued)
-	{
+	if (target->halt_issued) {
 		if (target->state == TARGET_HALTED)
-		{
 			target->halt_issued = false;
-		} else
-		{
+		else {
 			long long t = timeval_ms() - target->halt_issued_time;
-			if (t>1000)
-			{
+			if (t > 1000) {
 				target->halt_issued = false;
 				LOG_INFO("Halt timed out, wake up GDB.");
 				target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
@@ -480,8 +469,7 @@ int target_halt(struct target *target)
 {
 	int retval;
 	/* We can't poll until after examine */
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -531,8 +519,7 @@ int target_resume(struct target *target, int current, uint32_t address, int hand
 	int retval;
 
 	/* We can't poll until after examine */
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -541,7 +528,8 @@ int target_resume(struct target *target, int current, uint32_t address, int hand
 	 * we poll. The CPU can even halt at the current PC as a result of
 	 * a software breakpoint being inserted by (a bug?) the application.
 	 */
-	if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
+	retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution);
+	if (retval != ERROR_OK)
 		return retval;
 
 	return retval;
@@ -573,7 +561,7 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 
 	if (retval != JIM_OK) {
 		Jim_MakeErrorMessage(cmd_ctx->interp);
-		command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(cmd_ctx->interp), NULL));
+		command_print(NULL, "%s\n", Jim_GetString(Jim_GetResult(cmd_ctx->interp), NULL));
 		return ERROR_FAIL;
 	}
 
@@ -581,9 +569,8 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 	retval = target_call_timer_callbacks_now();
 
 	struct target *target;
-	for (target = all_targets; target; target = target->next) {
+	for (target = all_targets; target; target = target->next)
 		target->type->check_reset(target);
-	}
 
 	return retval;
 }
@@ -640,15 +627,15 @@ int target_examine(void)
 	int retval = ERROR_OK;
 	struct target *target;
 
-	for (target = all_targets; target; target = target->next)
-	{
+	for (target = all_targets; target; target = target->next) {
 		/* defer examination, but don't skip it */
 		if (!target->tap->enabled) {
 			jtag_register_event_callback(jtag_enable_callback,
 					target);
 			continue;
 		}
-		if ((retval = target_examine_one(target)) != ERROR_OK)
+		retval = target_examine_one(target);
+		if (retval != ERROR_OK)
 			return retval;
 	}
 	return retval;
@@ -658,20 +645,20 @@ const char *target_type_name(struct target *target)
 	return target->type->name;
 }
 
-static int target_write_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
+static int target_write_memory_imp(struct target *target, uint32_t address,
+		uint32_t size, uint32_t count, const uint8_t *buffer)
 {
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 	return target->type->write_memory_imp(target, address, size, count, buffer);
 }
 
-static int target_read_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int target_read_memory_imp(struct target *target, uint32_t address,
+		uint32_t size, uint32_t count, uint8_t *buffer)
 {
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -680,8 +667,7 @@ static int target_read_memory_imp(struct target *target, uint32_t address, uint3
 
 static int target_soft_reset_halt_imp(struct target *target)
 {
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -712,8 +698,7 @@ int target_run_algorithm(struct target *target,
 {
 	int retval = ERROR_FAIL;
 
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		goto done;
 	}
@@ -749,8 +734,7 @@ int target_start_algorithm(struct target *target,
 {
 	int retval = ERROR_FAIL;
 
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		goto done;
 	}
@@ -843,7 +827,7 @@ int target_bulk_write_memory(struct target *target,
 int target_add_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
-	if ((target->state != TARGET_HALTED)&&(breakpoint->type!=BKPT_HARD)) {
+	if ((target->state != TARGET_HALTED) && (breakpoint->type != BKPT_HARD)) {
 		LOG_WARNING("target %s is not halted", target->cmd_name);
 		return ERROR_TARGET_NOT_HALTED;
 	}
@@ -902,7 +886,6 @@ int target_step(struct target *target,
 	return target->type->step(target, current, address, handle_breakpoints);
 }
 
-
 /**
  * Reset the @c examined flag for the given target.
  * Pure paranoia -- targets are zeroed on allocation.
@@ -912,16 +895,14 @@ static void target_reset_examined(struct target *target)
 	target->examined = false;
 }
 
-static int
-err_read_phys_memory(struct target *target, uint32_t address,
+static int err_read_phys_memory(struct target *target, uint32_t address,
 		uint32_t size, uint32_t count, uint8_t *buffer)
 {
 	LOG_ERROR("Not implemented: %s", __func__);
 	return ERROR_FAIL;
 }
 
-static int
-err_write_phys_memory(struct target *target, uint32_t address,
+static int err_write_phys_memory(struct target *target, uint32_t address,
 		uint32_t size, uint32_t count, const uint8_t *buffer)
 {
 	LOG_ERROR("Not implemented: %s", __func__);
@@ -939,14 +920,13 @@ static int target_init_one(struct command_context *cmd_ctx,
 	if (type->examine == NULL)
 		type->examine = default_examine;
 
-	if (type->check_reset== NULL)
+	if (type->check_reset == NULL)
 		type->check_reset = default_check_reset;
 
 	assert(type->init_target != NULL);
 
 	int retval = type->init_target(cmd_ctx, target);
-	if (ERROR_OK != retval)
-	{
+	if (ERROR_OK != retval) {
 		LOG_ERROR("target '%s' init failed", target_name(target));
 		return retval;
 	}
@@ -971,37 +951,28 @@ static int target_init_one(struct command_context *cmd_ctx,
 	/* Sanity-check MMU support ... stub in what we must, to help
 	 * implement it in stages, but warn if we need to do so.
 	 */
-	if (type->mmu)
-	{
-		if (type->write_phys_memory == NULL)
-		{
+	if (type->mmu) {
+		if (type->write_phys_memory == NULL) {
 			LOG_ERROR("type '%s' is missing write_phys_memory",
 					type->name);
 			type->write_phys_memory = err_write_phys_memory;
 		}
-		if (type->read_phys_memory == NULL)
-		{
+		if (type->read_phys_memory == NULL) {
 			LOG_ERROR("type '%s' is missing read_phys_memory",
 					type->name);
 			type->read_phys_memory = err_read_phys_memory;
 		}
-		if (type->virt2phys == NULL)
-		{
+		if (type->virt2phys == NULL) {
 			LOG_ERROR("type '%s' is missing virt2phys", type->name);
 			type->virt2phys = identity_virt2phys;
 		}
-	}
-	else
-	{
+	} else {
 		/* Make sure no-MMU targets all behave the same:  make no
 		 * distinction between physical and virtual addresses, and
 		 * ensure that virt2phys() is always an identity mapping.
 		 */
-		if (type->write_phys_memory || type->read_phys_memory
-				|| type->virt2phys)
-		{
+		if (type->write_phys_memory || type->read_phys_memory || type->virt2phys)
 			LOG_WARNING("type '%s' has bad MMU hooks", type->name);
-		}
 
 		type->mmu = no_mmu;
 		type->write_phys_memory = type->write_memory;
@@ -1023,8 +994,7 @@ static int target_init(struct command_context *cmd_ctx)
 	struct target *target;
 	int retval;
 
-	for (target = all_targets; target; target = target->next)
-	{
+	for (target = all_targets; target; target = target->next) {
 		retval = target_init_one(cmd_ctx, target);
 		if (ERROR_OK != retval)
 			return retval;
@@ -1052,9 +1022,8 @@ COMMAND_HANDLER(handle_target_init_command)
 	if (CMD_ARGC != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	static bool target_initialized = false;
-	if (target_initialized)
-	{
+	static bool target_initialized;
+	if (target_initialized) {
 		LOG_INFO("'target init' has already been called");
 		return ERROR_OK;
 	}
@@ -1068,17 +1037,15 @@ COMMAND_HANDLER(handle_target_init_command)
 	return target_init(CMD_CTX);
 }
 
-int target_register_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv)
+int target_register_event_callback(int (*callback)(struct target *target,
+		enum target_event event, void *priv), void *priv)
 {
 	struct target_event_callback **callbacks_p = &target_event_callbacks;
 
 	if (callback == NULL)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
-	if (*callbacks_p)
-	{
+	if (*callbacks_p) {
 		while ((*callbacks_p)->next)
 			callbacks_p = &((*callbacks_p)->next);
 		callbacks_p = &((*callbacks_p)->next);
@@ -1098,12 +1065,9 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 	struct timeval now;
 
 	if (callback == NULL)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
-	if (*callbacks_p)
-	{
+	if (*callbacks_p) {
 		while ((*callbacks_p)->next)
 			callbacks_p = &((*callbacks_p)->next);
 		callbacks_p = &((*callbacks_p)->next);
@@ -1118,8 +1082,7 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 	(*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
 	time_ms -= (time_ms % 1000);
 	(*callbacks_p)->when.tv_sec = now.tv_sec + (time_ms / 1000);
-	if ((*callbacks_p)->when.tv_usec > 1000000)
-	{
+	if ((*callbacks_p)->when.tv_usec > 1000000) {
 		(*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
 		(*callbacks_p)->when.tv_sec += 1;
 	}
@@ -1130,26 +1093,22 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 	return ERROR_OK;
 }
 
-int target_unregister_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv)
+int target_unregister_event_callback(int (*callback)(struct target *target,
+		enum target_event event, void *priv), void *priv)
 {
 	struct target_event_callback **p = &target_event_callbacks;
 	struct target_event_callback *c = target_event_callbacks;
 
 	if (callback == NULL)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
-	while (c)
-	{
+	while (c) {
 		struct target_event_callback *next = c->next;
-		if ((c->callback == callback) && (c->priv == priv))
-		{
+		if ((c->callback == callback) && (c->priv == priv)) {
 			*p = next;
 			free(c);
 			return ERROR_OK;
-		}
-		else
+		} else
 			p = &(c->next);
 		c = next;
 	}
@@ -1163,20 +1122,15 @@ static int target_unregister_timer_callback(int (*callback)(void *priv), void *p
 	struct target_timer_callback *c = target_timer_callbacks;
 
 	if (callback == NULL)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
-	while (c)
-	{
+	while (c) {
 		struct target_timer_callback *next = c->next;
-		if ((c->callback == callback) && (c->priv == priv))
-		{
+		if ((c->callback == callback) && (c->priv == priv)) {
 			*p = next;
 			free(c);
 			return ERROR_OK;
-		}
-		else
+		} else
 			p = &(c->next);
 		c = next;
 	}
@@ -1189,20 +1143,17 @@ int target_call_event_callbacks(struct target *target, enum target_event event)
 	struct target_event_callback *callback = target_event_callbacks;
 	struct target_event_callback *next_callback;
 
-	if (event == TARGET_EVENT_HALTED)
-	{
+	if (event == TARGET_EVENT_HALTED) {
 		/* execute early halted first */
 		target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
 	}
 
-	LOG_DEBUG("target event %i (%s)",
-			  event,
-			  Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
+	LOG_DEBUG("target event %i (%s)", event,
+			Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
 
 	target_handle_event(target, event);
 
-	while (callback)
-	{
+	while (callback) {
 		next_callback = callback->next;
 		callback->callback(target, event, callback->priv);
 		callback = next_callback;
@@ -1218,8 +1169,7 @@ static int target_timer_callback_periodic_restart(
 	cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000;
 	time_ms -= (time_ms % 1000);
 	cb->when.tv_sec = now->tv_sec + time_ms / 1000;
-	if (cb->when.tv_usec > 1000000)
-	{
+	if (cb->when.tv_usec > 1000000) {
 		cb->when.tv_usec = cb->when.tv_usec - 1000000;
 		cb->when.tv_sec += 1;
 	}
@@ -1245,9 +1195,8 @@ static int target_call_timer_callbacks_check_time(int checktime)
 	gettimeofday(&now, NULL);
 
 	struct target_timer_callback *callback = target_timer_callbacks;
-	while (callback)
-	{
-		// cleaning up may unregister and free this callback
+	while (callback) {
+		/* cleaning up may unregister and free this callback */
 		struct target_timer_callback *next_callback = callback->next;
 
 		bool call_it = callback->callback &&
@@ -1256,8 +1205,7 @@ static int target_call_timer_callbacks_check_time(int checktime)
 			 (now.tv_sec == callback->when.tv_sec &&
 			  now.tv_usec >= callback->when.tv_usec));
 
-		if (call_it)
-		{
+		if (call_it) {
 			int retval = target_call_timer_callback(callback, &now);
 			if (retval != ERROR_OK)
 				return retval;
@@ -1286,16 +1234,13 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
 	struct working_area *new_wa = NULL;
 
 	/* Reevaluate working area address based on MMU state*/
-	if (target->working_areas == NULL)
-	{
+	if (target->working_areas == NULL) {
 		int retval;
 		int enabled;
 
 		retval = target->type->mmu(target, &enabled);
 		if (retval != ERROR_OK)
-		{
 			return retval;
-		}
 
 		if (!enabled) {
 			if (target->working_area_phys_spec) {
@@ -1323,17 +1268,14 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
 	}
 
 	/* only allocate multiples of 4 byte */
-	if (size % 4)
-	{
+	if (size % 4) {
 		LOG_ERROR("BUG: code tried to allocate unaligned number of bytes (0x%08x), padding", ((unsigned)(size)));
 		size = (size + 3) & (~3);
 	}
 
 	/* see if there's already a matching working area */
-	while (c)
-	{
-		if ((c->free) && (c->size == size))
-		{
+	while (c) {
+		if ((c->free) && (c->size == size)) {
 			new_wa = c;
 			break;
 		}
@@ -1341,15 +1283,13 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
 	}
 
 	/* if not, allocate a new one */
-	if (!new_wa)
-	{
+	if (!new_wa) {
 		struct working_area **p = &target->working_areas;
 		uint32_t first_free = target->working_area;
 		uint32_t free_size = target->working_area_size;
 
 		c = target->working_areas;
-		while (c)
-		{
+		while (c) {
 			first_free += c->size;
 			free_size -= c->size;
 			p = &c->next;
@@ -1357,9 +1297,7 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
 		}
 
 		if (free_size < size)
-		{
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
-		}
 
 		LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free);
 
@@ -1368,21 +1306,18 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
 		new_wa->size = size;
 		new_wa->address = first_free;
 
-		if (target->backup_working_area)
-		{
+		if (target->backup_working_area) {
 			int retval;
 			new_wa->backup = malloc(new_wa->size);
-			if ((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
-			{
+			retval = target_read_memory(target, new_wa->address, 4,
+					new_wa->size / 4, new_wa->backup);
+			if (retval != ERROR_OK) {
 				free(new_wa->backup);
 				free(new_wa);
 				return retval;
 			}
-		}
-		else
-		{
+		} else
 			new_wa->backup = NULL;
-		}
 
 		/* put new entry in list */
 		*p = new_wa;
@@ -1404,9 +1339,7 @@ int target_alloc_working_area(struct target *target, uint32_t size, struct worki
 
 	retval = target_alloc_working_area_try(target, size, area);
 	if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
-	{
 		LOG_WARNING("not enough working area available(requested %u)", (unsigned)(size));
-	}
 	return retval;
 
 }
@@ -1416,10 +1349,10 @@ static int target_free_working_area_restore(struct target *target, struct workin
 	if (area->free)
 		return ERROR_OK;
 
-	if (restore && target->backup_working_area)
-	{
-		int retval;
-		if ((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
+	if (restore && target->backup_working_area) {
+		int retval = target_write_memory(target,
+				area->address, 4, area->size / 4, area->backup);
+		if (retval != ERROR_OK)
 			return retval;
 	}
 
@@ -1444,8 +1377,7 @@ static void target_free_all_working_areas_restore(struct target *target, int res
 {
 	struct working_area *c = target->working_areas;
 
-	while (c)
-	{
+	while (c) {
 		struct working_area *next = c->next;
 		target_free_working_area_restore(target, c, restore);
 
@@ -1468,13 +1400,12 @@ void target_free_all_working_areas(struct target *target)
 int target_arch_state(struct target *target)
 {
 	int retval;
-	if (target == NULL)
-	{
+	if (target == NULL) {
 		LOG_USER("No target has been configured");
 		return ERROR_OK;
 	}
 
-	LOG_USER("target state: %s", target_state_name( target ));
+	LOG_USER("target state: %s", target_state_name(target));
 
 	if (target->state != TARGET_HALTED)
 		return ERROR_OK;
@@ -1490,20 +1421,17 @@ int target_arch_state(struct target *target)
 int target_write_buffer(struct target *target, uint32_t address, uint32_t size, const uint8_t *buffer)
 {
 	LOG_DEBUG("writing buffer of %i byte at 0x%8.8x",
-		  (int)size, (unsigned)address);
+			(int)size, (unsigned)address);
 
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	if (size == 0) {
+	if (size == 0)
 		return ERROR_OK;
-	}
 
-	if ((address + size - 1) < address)
-	{
+	if ((address + size - 1) < address) {
 		/* GDB can request this when e.g. PC is 0xfffffffc*/
 		LOG_ERROR("address + size wrapped(0x%08x, 0x%08x)",
 				  (unsigned)address,
@@ -1519,19 +1447,17 @@ static int target_write_buffer_default(struct target *target, uint32_t address,
 	int retval = ERROR_OK;
 
 	if (((address % 2) == 0) && (size == 2))
-	{
 		return target_write_memory(target, address, 2, 1, buffer);
-	}
 
 	/* handle unaligned head bytes */
-	if (address % 4)
-	{
+	if (address % 4) {
 		uint32_t unaligned = 4 - (address % 4);
 
 		if (unaligned > size)
 			unaligned = size;
 
-		if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+		retval = target_write_memory(target, address, 1, unaligned, buffer);
+		if (retval != ERROR_OK)
 			return retval;
 
 		buffer += unaligned;
@@ -1540,19 +1466,17 @@ static int target_write_buffer_default(struct target *target, uint32_t address,
 	}
 
 	/* handle aligned words */
-	if (size >= 4)
-	{
+	if (size >= 4) {
 		int aligned = size - (size % 4);
 
 		/* use bulk writes above a certain limit. This may have to be changed */
-		if (aligned > 128)
-		{
-			if ((retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer)) != ERROR_OK)
+		if (aligned > 128) {
+			retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer);
+			if (retval != ERROR_OK)
 				return retval;
-		}
-		else
-		{
-			if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+		} else {
+			retval = target_write_memory(target, address, 4, aligned / 4, buffer);
+			if (retval != ERROR_OK)
 				return retval;
 		}
 
@@ -1562,9 +1486,9 @@ static int target_write_buffer_default(struct target *target, uint32_t address,
 	}
 
 	/* handle tail writes of less than 4 bytes */
-	if (size > 0)
-	{
-		if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
+	if (size > 0) {
+		retval = target_write_memory(target, address, 1, size, buffer);
+		if (retval != ERROR_OK)
 			return retval;
 	}
 
@@ -1580,18 +1504,15 @@ int target_read_buffer(struct target *target, uint32_t address, uint32_t size, u
 	LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
 			  (int)size, (unsigned)address);
 
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	if (size == 0) {
+	if (size == 0)
 		return ERROR_OK;
-	}
 
-	if ((address + size - 1) < address)
-	{
+	if ((address + size - 1) < address) {
 		/* GDB can request this when e.g. PC is 0xfffffffc*/
 		LOG_ERROR("address + size wrapped(0x%08" PRIx32 ", 0x%08" PRIx32 ")",
 				  address,
@@ -1607,19 +1528,17 @@ static int target_read_buffer_default(struct target *target, uint32_t address, u
 	int retval = ERROR_OK;
 
 	if (((address % 2) == 0) && (size == 2))
-	{
 		return target_read_memory(target, address, 2, 1, buffer);
-	}
 
 	/* handle unaligned head bytes */
-	if (address % 4)
-	{
+	if (address % 4) {
 		uint32_t unaligned = 4 - (address % 4);
 
 		if (unaligned > size)
 			unaligned = size;
 
-		if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+		retval = target_read_memory(target, address, 1, unaligned, buffer);
+		if (retval != ERROR_OK)
 			return retval;
 
 		buffer += unaligned;
@@ -1628,11 +1547,11 @@ static int target_read_buffer_default(struct target *target, uint32_t address, u
 	}
 
 	/* handle aligned words */
-	if (size >= 4)
-	{
+	if (size >= 4) {
 		int aligned = size - (size % 4);
 
-		if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+		retval = target_read_memory(target, address, 4, aligned / 4, buffer);
+		if (retval != ERROR_OK)
 			return retval;
 
 		buffer += aligned;
@@ -1641,9 +1560,8 @@ static int target_read_buffer_default(struct target *target, uint32_t address, u
 	}
 
 	/*prevent byte access when possible (avoid AHB access limitations in some cases)*/
-	if(size	>=2)
-	{
-		int aligned = size - (size%2);
+	if (size	>= 2) {
+		int aligned = size - (size % 2);
 		retval = target_read_memory(target, address, 2, aligned / 2, buffer);
 		if (retval != ERROR_OK)
 			return retval;
@@ -1653,9 +1571,9 @@ static int target_read_buffer_default(struct target *target, uint32_t address, u
 		size -= aligned;
 	}
 	/* handle tail writes of less than 4 bytes */
-	if (size > 0)
-	{
-		if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
+	if (size > 0) {
+		retval = target_read_memory(target, address, 1, size, buffer);
+		if (retval != ERROR_OK)
 			return retval;
 	}
 
@@ -1668,31 +1586,26 @@ int target_checksum_memory(struct target *target, uint32_t address, uint32_t siz
 	int retval;
 	uint32_t i;
 	uint32_t checksum = 0;
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	if ((retval = target->type->checksum_memory(target, address,
-		size, &checksum)) != ERROR_OK)
-	{
+	retval = target->type->checksum_memory(target, address, size, &checksum);
+	if (retval != ERROR_OK) {
 		buffer = malloc(size);
-		if (buffer == NULL)
-		{
+		if (buffer == NULL) {
 			LOG_ERROR("error allocating buffer for section (%d bytes)", (int)size);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
 		retval = target_read_buffer(target, address, size, buffer);
-		if (retval != ERROR_OK)
-		{
+		if (retval != ERROR_OK) {
 			free(buffer);
 			return retval;
 		}
 
 		/* convert to target endianness */
-		for (i = 0; i < (size/sizeof(uint32_t)); i++)
-		{
+		for (i = 0; i < (size/sizeof(uint32_t)); i++) {
 			uint32_t target_data;
 			target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
 			target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
@@ -1710,8 +1623,7 @@ int target_checksum_memory(struct target *target, uint32_t address, uint32_t siz
 int target_blank_check_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* blank)
 {
 	int retval;
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -1727,23 +1639,19 @@ int target_blank_check_memory(struct target *target, uint32_t address, uint32_t
 int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
 {
 	uint8_t value_buf[4];
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
 	int retval = target_read_memory(target, address, 4, 1, value_buf);
 
-	if (retval == ERROR_OK)
-	{
+	if (retval == ERROR_OK) {
 		*value = target_buffer_get_u32(target, value_buf);
 		LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
 				  address,
 				  *value);
-	}
-	else
-	{
+	} else {
 		*value = 0x0;
 		LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
 				  address);
@@ -1755,23 +1663,19 @@ int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
 int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
 {
 	uint8_t value_buf[2];
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
 	int retval = target_read_memory(target, address, 2, 1, value_buf);
 
-	if (retval == ERROR_OK)
-	{
+	if (retval == ERROR_OK) {
 		*value = target_buffer_get_u16(target, value_buf);
 		LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4x",
 				  address,
 				  *value);
-	}
-	else
-	{
+	} else {
 		*value = 0x0;
 		LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
 				  address);
@@ -1783,20 +1687,16 @@ int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
 int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
 {
 	int retval = target_read_memory(target, address, 1, 1, value);
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
-	if (retval == ERROR_OK)
-	{
+	if (retval == ERROR_OK) {
 		LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
 				  address,
 				  *value);
-	}
-	else
-	{
+	} else {
 		*value = 0x0;
 		LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
 				  address);
@@ -1809,8 +1709,7 @@ int target_write_u32(struct target *target, uint32_t address, uint32_t value)
 {
 	int retval;
 	uint8_t value_buf[4];
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -1820,10 +1719,9 @@ int target_write_u32(struct target *target, uint32_t address, uint32_t value)
 			  value);
 
 	target_buffer_set_u32(target, value_buf, value);
-	if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
-	{
+	retval = target_write_memory(target, address, 4, 1, value_buf);
+	if (retval != ERROR_OK)
 		LOG_DEBUG("failed: %i", retval);
-	}
 
 	return retval;
 }
@@ -1832,8 +1730,7 @@ int target_write_u16(struct target *target, uint32_t address, uint16_t value)
 {
 	int retval;
 	uint8_t value_buf[2];
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -1843,10 +1740,9 @@ int target_write_u16(struct target *target, uint32_t address, uint16_t value)
 			  value);
 
 	target_buffer_set_u16(target, value_buf, value);
-	if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
-	{
+	retval = target_write_memory(target, address, 2, 1, value_buf);
+	if (retval != ERROR_OK)
 		LOG_DEBUG("failed: %i", retval);
-	}
 
 	return retval;
 }
@@ -1854,8 +1750,7 @@ int target_write_u16(struct target *target, uint32_t address, uint16_t value)
 int target_write_u8(struct target *target, uint32_t address, uint8_t value)
 {
 	int retval;
-	if (!target_was_examined(target))
-	{
+	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
@@ -1863,10 +1758,9 @@ int target_write_u8(struct target *target, uint32_t address, uint8_t value)
 	LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
 			  address, value);
 
-	if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
-	{
+	retval = target_write_memory(target, address, 1, 1, &value);
+	if (retval != ERROR_OK)
 		LOG_DEBUG("failed: %i", retval);
-	}
 
 	return retval;
 }
@@ -1893,8 +1787,7 @@ static int find_target(struct command_context *cmd_ctx, const char *name)
 COMMAND_HANDLER(handle_targets_command)
 {
 	int retval = ERROR_OK;
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		retval = find_target(CMD_CTX, CMD_ARGV[0]);
 		if (retval == ERROR_OK) {
 			/* we're done! */
@@ -1905,13 +1798,12 @@ COMMAND_HANDLER(handle_targets_command)
 	struct target *target = all_targets;
 	command_print(CMD_CTX, "    TargetName         Type       Endian TapName            State       ");
 	command_print(CMD_CTX, "--  ------------------ ---------- ------ ------------------ ------------");
-	while (target)
-	{
+	while (target) {
 		const char *state;
 		char marker = ' ';
 
 		if (target->tap->enabled)
-			state = target_state_name( target );
+			state = target_state_name(target);
 		else
 			state = "tap-disabled";
 
@@ -1947,53 +1839,47 @@ static int runSrstDeasserted;
 
 static int sense_handler(void)
 {
-	static int prevSrstAsserted = 0;
-	static int prevPowerdropout = 0;
+	static int prevSrstAsserted;
+	static int prevPowerdropout;
 
-	int retval;
-	if ((retval = jtag_power_dropout(&powerDropout)) != ERROR_OK)
+	int retval = jtag_power_dropout(&powerDropout);
+	if (retval != ERROR_OK)
 		return retval;
 
 	int powerRestored;
 	powerRestored = prevPowerdropout && !powerDropout;
 	if (powerRestored)
-	{
 		runPowerRestore = 1;
-	}
 
 	long long current = timeval_ms();
-	static long long lastPower = 0;
+	static long long lastPower;
 	int waitMore = lastPower + 2000 > current;
-	if (powerDropout && !waitMore)
-	{
+	if (powerDropout && !waitMore) {
 		runPowerDropout = 1;
 		lastPower = current;
 	}
 
-	if ((retval = jtag_srst_asserted(&srstAsserted)) != ERROR_OK)
+	retval = jtag_srst_asserted(&srstAsserted);
+	if (retval != ERROR_OK)
 		return retval;
 
 	int srstDeasserted;
 	srstDeasserted = prevSrstAsserted && !srstAsserted;
 
-	static long long lastSrst = 0;
+	static long long lastSrst;
 	waitMore = lastSrst + 2000 > current;
-	if (srstDeasserted && !waitMore)
-	{
+	if (srstDeasserted && !waitMore) {
 		runSrstDeasserted = 1;
 		lastSrst = current;
 	}
 
 	if (!prevSrstAsserted && srstAsserted)
-	{
 		runSrstAsserted = 1;
-	}
 
 	prevSrstAsserted = srstAsserted;
 	prevPowerdropout = powerDropout;
 
-	if (srstDeasserted || powerRestored)
-	{
+	if (srstDeasserted || powerRestored) {
 		/* Other than logging the event we can't do anything here.
 		 * Issuing a reset is a particularly bad idea as we might
 		 * be inside a reset already.
@@ -2003,8 +1889,8 @@ static int sense_handler(void)
 	return ERROR_OK;
 }
 
-static int backoff_times = 0;
-static int backoff_count = 0;
+static int backoff_times;
+static int backoff_count;
 
 /* process target state changes */
 static int handle_target(void *priv)
@@ -2012,16 +1898,14 @@ static int handle_target(void *priv)
 	Jim_Interp *interp = (Jim_Interp *)priv;
 	int retval = ERROR_OK;
 
-	if (!is_jtag_poll_safe())
-	{
+	if (!is_jtag_poll_safe()) {
 		/* polling is disabled currently */
 		return ERROR_OK;
 	}
 
 	/* we do not want to recurse here... */
-	static int recursive = 0;
-	if (! recursive)
-	{
+	static int recursive;
+	if (!recursive) {
 		recursive = 1;
 		sense_handler();
 		/* danger! running these procedures can trigger srst assertions and power dropouts.
@@ -2029,31 +1913,26 @@ static int handle_target(void *priv)
 		 * clearing the flags after running these events.
 		 */
 		int did_something = 0;
-		if (runSrstAsserted)
-		{
+		if (runSrstAsserted) {
 			LOG_INFO("srst asserted detected, running srst_asserted proc.");
 			Jim_Eval(interp, "srst_asserted");
 			did_something = 1;
 		}
-		if (runSrstDeasserted)
-		{
+		if (runSrstDeasserted) {
 			Jim_Eval(interp, "srst_deasserted");
 			did_something = 1;
 		}
-		if (runPowerDropout)
-		{
+		if (runPowerDropout) {
 			LOG_INFO("Power dropout detected, running power_dropout proc.");
 			Jim_Eval(interp, "power_dropout");
 			did_something = 1;
 		}
-		if (runPowerRestore)
-		{
+		if (runPowerRestore) {
 			Jim_Eval(interp, "power_restore");
 			did_something = 1;
 		}
 
-		if (did_something)
-		{
+		if (did_something) {
 			/* clear detect flags */
 			sense_handler();
 		}
@@ -2068,8 +1947,7 @@ static int handle_target(void *priv)
 		recursive = 0;
 	}
 
-	if (backoff_times > backoff_count)
-	{
+	if (backoff_times > backoff_count) {
 		/* do not poll this time as we failed previously */
 		backoff_count++;
 		return ERROR_OK;
@@ -2081,24 +1959,22 @@ static int handle_target(void *priv)
 	 */
 	for (struct target *target = all_targets;
 			is_jtag_poll_safe() && target;
-			target = target->next)
-	{
+			target = target->next) {
 		if (!target->tap->enabled)
 			continue;
 
 		/* only poll target if we've got power and srst isn't asserted */
-		if (!powerDropout && !srstAsserted)
-		{
+		if (!powerDropout && !srstAsserted) {
 			/* polling may fail silently until the target has been examined */
-			if ((retval = target_poll(target)) != ERROR_OK)
-			{
+			retval = target_poll(target);
+			if (retval != ERROR_OK) {
 				/* 100ms polling interval. Increase interval between polling up to 5000ms */
-				if (backoff_times * polling_interval < 5000)
-				{
+				if (backoff_times * polling_interval < 5000) {
 					backoff_times *= 2;
 					backoff_times++;
 				}
-				LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms", backoff_times * polling_interval);
+				LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms",
+						backoff_times * polling_interval);
 
 				/* Tell GDB to halt the debugger. This allows the user to
 				 * run monitor commands to handle the situation.
@@ -2108,9 +1984,7 @@ static int handle_target(void *priv)
 			}
 			/* Since we succeeded, we reset backoff count */
 			if (backoff_times > 0)
-			{
 				LOG_USER("Polling succeeded again");
-			}
 			backoff_times = 0;
 		}
 	}
@@ -2130,21 +2004,18 @@ COMMAND_HANDLER(handle_reg_command)
 	target = get_current_target(CMD_CTX);
 
 	/* list all available registers for the current target */
-	if (CMD_ARGC == 0)
-	{
+	if (CMD_ARGC == 0) {
 		struct reg_cache *cache = target->reg_cache;
 
 		count = 0;
-		while (cache)
-		{
+		while (cache) {
 			unsigned i;
 
 			command_print(CMD_CTX, "===== %s", cache->name);
 
 			for (i = 0, reg = cache->reg_list;
 					i < cache->num_regs;
-					i++, reg++, count++)
-			{
+					i++, reg++, count++) {
 				/* only print cached values if they are valid */
 				if (reg->valid) {
 					value = buf_to_str(reg->value,
@@ -2170,20 +2041,16 @@ COMMAND_HANDLER(handle_reg_command)
 	}
 
 	/* access a single register by its ordinal number */
-	if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9'))
-	{
+	if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9')) {
 		unsigned num;
 		COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 
 		struct reg_cache *cache = target->reg_cache;
 		count = 0;
-		while (cache)
-		{
+		while (cache) {
 			unsigned i;
-			for (i = 0; i < cache->num_regs; i++)
-			{
-				if (count++ == num)
-				{
+			for (i = 0; i < cache->num_regs; i++) {
+				if (count++ == num) {
 					reg = &cache->reg_list[i];
 					break;
 				}
@@ -2193,17 +2060,16 @@ COMMAND_HANDLER(handle_reg_command)
 			cache = cache->next;
 		}
 
-		if (!reg)
-		{
-			command_print(CMD_CTX, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
+		if (!reg) {
+			command_print(CMD_CTX, "%i is out of bounds, the current target "
+					"has only %i registers (0 - %i)", num, count, count - 1);
 			return ERROR_OK;
 		}
-	} else /* access a single register by its name */
-	{
+	} else {
+		/* access a single register by its name */
 		reg = register_get_by_name(target->reg_cache, CMD_ARGV[0], 1);
 
-		if (!reg)
-		{
+		if (!reg) {
 			command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
 			return ERROR_OK;
 		}
@@ -2212,15 +2078,13 @@ COMMAND_HANDLER(handle_reg_command)
 	assert(reg != NULL); /* give clang a hint that we *know* reg is != NULL here */
 
 	/* display a register */
-	if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0') && (CMD_ARGV[1][0] <= '9'))))
-	{
+	if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0')
+			&& (CMD_ARGV[1][0] <= '9')))) {
 		if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0))
 			reg->valid = 0;
 
 		if (reg->valid == 0)
-		{
 			reg->type->get(reg);
-		}
 		value = buf_to_str(reg->value, reg->size, 16);
 		command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
 		free(value);
@@ -2228,8 +2092,7 @@ COMMAND_HANDLER(handle_reg_command)
 	}
 
 	/* set register value */
-	if (CMD_ARGC == 2)
-	{
+	if (CMD_ARGC == 2) {
 		uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
 		if (buf == NULL)
 			return ERROR_FAIL;
@@ -2254,8 +2117,7 @@ COMMAND_HANDLER(handle_poll_command)
 	int retval = ERROR_OK;
 	struct target *target = get_current_target(CMD_CTX);
 
-	if (CMD_ARGC == 0)
-	{
+	if (CMD_ARGC == 0) {
 		command_print(CMD_CTX, "background polling: %s",
 				jtag_poll_get_enabled() ? "on" : "off");
 		command_print(CMD_CTX, "TAP: %s (%s)",
@@ -2263,21 +2125,18 @@ COMMAND_HANDLER(handle_poll_command)
 				target->tap->enabled ? "enabled" : "disabled");
 		if (!target->tap->enabled)
 			return ERROR_OK;
-		if ((retval = target_poll(target)) != ERROR_OK)
+		retval = target_poll(target);
+		if (retval != ERROR_OK)
 			return retval;
-		if ((retval = target_arch_state(target)) != ERROR_OK)
+		retval = target_arch_state(target);
+		if (retval != ERROR_OK)
 			return retval;
-	}
-	else if (CMD_ARGC == 1)
-	{
+	} else if (CMD_ARGC == 1) {
 		bool enable;
 		COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
 		jtag_poll_set_enabled(enable);
-	}
-	else
-	{
+	} else
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
 	return retval;
 }
@@ -2288,14 +2147,11 @@ COMMAND_HANDLER(handle_wait_halt_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	unsigned ms = 5000;
-	if (1 == CMD_ARGC)
-	{
+	if (1 == CMD_ARGC) {
 		int retval = parse_uint(CMD_ARGV[0], &ms);
 		if (ERROR_OK != retval)
-		{
 			return ERROR_COMMAND_SYNTAX_ERROR;
-		}
-		// convert seconds (given) to milliseconds (needed)
+		/* convert seconds (given) to milliseconds (needed) */
 		ms *= 1000;
 	}
 
@@ -2315,32 +2171,26 @@ int target_wait_state(struct target *target, enum target_state state, int ms)
 	long long then = 0, cur;
 	int once = 1;
 
-	for (;;)
-	{
-		if ((retval = target_poll(target)) != ERROR_OK)
+	for (;;) {
+		retval = target_poll(target);
+		if (retval != ERROR_OK)
 			return retval;
 		if (target->state == state)
-		{
 			break;
-		}
 		cur = timeval_ms();
-		if (once)
-		{
+		if (once) {
 			once = 0;
 			then = timeval_ms();
 			LOG_DEBUG("waiting for target %s...",
-				Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
+				Jim_Nvp_value2name_simple(nvp_target_state, state)->name);
 		}
 
 		if (cur-then > 500)
-		{
 			keep_alive();
-		}
 
-		if ((cur-then) > ms)
-		{
+		if ((cur-then) > ms) {
 			LOG_ERROR("timed out while waiting for target %s",
-				Jim_Nvp_value2name_simple(nvp_target_state,state)->name);
+				Jim_Nvp_value2name_simple(nvp_target_state, state)->name);
 			return ERROR_FAIL;
 		}
 	}
@@ -2357,8 +2207,7 @@ COMMAND_HANDLER(handle_halt_command)
 	if (ERROR_OK != retval)
 		return retval;
 
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		unsigned wait_local;
 		retval = parse_uint(CMD_ARGV[0], &wait_local);
 		if (ERROR_OK != retval)
@@ -2387,13 +2236,11 @@ COMMAND_HANDLER(handle_reset_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	enum target_reset_mode reset_mode = RESET_RUN;
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		const Jim_Nvp *n;
 		n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]);
-		if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
+		if ((n->name == NULL) || (n->value == RESET_UNKNOWN))
 			return ERROR_COMMAND_SYNTAX_ERROR;
-		}
 		reset_mode = n->value;
 	}
 
@@ -2415,8 +2262,7 @@ COMMAND_HANDLER(handle_resume_command)
 	 * with one arguments, addr = CMD_ARGV[0],
 	 * handle breakpoints, not debugging */
 	uint32_t addr = 0;
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
 		current = 0;
 	}
@@ -2436,8 +2282,7 @@ COMMAND_HANDLER(handle_step_command)
 	 * handle breakpoints, debugging */
 	uint32_t addr = 0;
 	int current_pc = 1;
-	if (CMD_ARGC == 1)
-	{
+	if (CMD_ARGC == 1) {
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
 		current_pc = 0;
 	}
@@ -2459,19 +2304,23 @@ static void handle_md_output(struct command_context *cmd_ctx,
 
 	const char *value_fmt;
 	switch (size) {
-	case 4: value_fmt = "%8.8x "; break;
-	case 2: value_fmt = "%4.4x "; break;
-	case 1: value_fmt = "%2.2x "; break;
+	case 4:
+		value_fmt = "%8.8x ";
+		break;
+	case 2:
+		value_fmt = "%4.4x ";
+		break;
+	case 1:
+		value_fmt = "%2.2x ";
+		break;
 	default:
 		/* "can't happen", caller checked */
 		LOG_ERROR("invalid memory read size: %u", size);
 		return;
 	}
 
-	for (unsigned i = 0; i < count; i++)
-	{
-		if (i % line_modulo == 0)
-		{
+	for (unsigned i = 0; i < count; i++) {
+		if (i % line_modulo == 0) {
 			output_len += snprintf(output + output_len,
 					sizeof(output) - output_len,
 					"0x%8.8x: ",
@@ -2481,16 +2330,20 @@ static void handle_md_output(struct command_context *cmd_ctx,
 		uint32_t value = 0;
 		const uint8_t *value_ptr = buffer + i * size;
 		switch (size) {
-		case 4: value = target_buffer_get_u32(target, value_ptr); break;
-		case 2: value = target_buffer_get_u16(target, value_ptr); break;
-		case 1: value = *value_ptr;
+		case 4:
+			value = target_buffer_get_u32(target, value_ptr);
+			break;
+		case 2:
+			value = target_buffer_get_u16(target, value_ptr);
+			break;
+		case 1:
+			value = *value_ptr;
 		}
 		output_len += snprintf(output + output_len,
 				sizeof(output) - output_len,
 				value_fmt, value);
 
-		if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
-		{
+		if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
 			command_print(cmd_ctx, "%s", output);
 			output_len = 0;
 		}
@@ -2504,28 +2357,30 @@ COMMAND_HANDLER(handle_md_command)
 
 	unsigned size = 0;
 	switch (CMD_NAME[2]) {
-	case 'w': size = 4; break;
-	case 'h': size = 2; break;
-	case 'b': size = 1; break;
-	default: return ERROR_COMMAND_SYNTAX_ERROR;
+	case 'w':
+		size = 4;
+		break;
+	case 'h':
+		size = 2;
+		break;
+	case 'b':
+		size = 1;
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
-	bool physical=strcmp(CMD_ARGV[0], "phys")==0;
+	bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
 	int (*fn)(struct target *target,
 			uint32_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);
-	if (physical)
-	{
+	if (physical) {
 		CMD_ARGC--;
 		CMD_ARGV++;
-		fn=target_read_phys_memory;
+		fn = target_read_phys_memory;
 	} else
-	{
-		fn=target_read_memory;
-	}
+		fn = target_read_memory;
 	if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
 	uint32_t address;
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
@@ -2568,24 +2423,21 @@ static int target_fill_mem(struct target *target,
 	 * to fill large memory areas with any sane speed */
 	const unsigned chunk_size = 16384;
 	uint8_t *target_buf = malloc(chunk_size * data_size);
-	if (target_buf == NULL)
-	{
+	if (target_buf == NULL) {
 		LOG_ERROR("Out of memory");
 		return ERROR_FAIL;
 	}
 
-	for (unsigned i = 0; i < chunk_size; i ++)
-	{
-		switch (data_size)
-		{
+	for (unsigned i = 0; i < chunk_size; i++) {
+		switch (data_size) {
 		case 4:
-			target_buffer_set_u32(target, target_buf + i*data_size, b);
+			target_buffer_set_u32(target, target_buf + i * data_size, b);
 			break;
 		case 2:
-			target_buffer_set_u16(target, target_buf + i*data_size, b);
+			target_buffer_set_u16(target, target_buf + i * data_size, b);
 			break;
 		case 1:
-			target_buffer_set_u8(target, target_buf + i*data_size, b);
+			target_buffer_set_u8(target, target_buf + i * data_size, b);
 			break;
 		default:
 			exit(-1);
@@ -2594,19 +2446,14 @@ static int target_fill_mem(struct target *target,
 
 	int retval = ERROR_OK;
 
-	for (unsigned x = 0; x < c; x += chunk_size)
-	{
+	for (unsigned x = 0; x < c; x += chunk_size) {
 		unsigned current;
 		current = c - x;
 		if (current > chunk_size)
-		{
 			current = chunk_size;
-		}
 		retval = fn(target, address + x * data_size, data_size, current, target_buf);
 		if (retval != ERROR_OK)
-		{
 			break;
-		}
 		/* avoid GDB timeouts */
 		keep_alive();
 	}
@@ -2619,20 +2466,15 @@ static int target_fill_mem(struct target *target,
 COMMAND_HANDLER(handle_mw_command)
 {
 	if (CMD_ARGC < 2)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
-	bool physical=strcmp(CMD_ARGV[0], "phys")==0;
+	bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
 	target_write_fn fn;
-	if (physical)
-	{
+	if (physical) {
 		CMD_ARGC--;
 		CMD_ARGV++;
-		fn=target_write_phys_memory;
+		fn = target_write_phys_memory;
 	} else
-	{
 		fn = target_write_memory_fast;
-	}
 	if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
@@ -2648,8 +2490,7 @@ COMMAND_HANDLER(handle_mw_command)
 
 	struct target *target = get_current_target(CMD_CTX);
 	unsigned wordsize;
-	switch (CMD_NAME[2])
-	{
+	switch (CMD_NAME[2]) {
 		case 'w':
 			wordsize = 4;
 			break;
@@ -2674,26 +2515,21 @@ static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
 
 	/* a base address isn't always necessary,
 	 * default to 0x0 (i.e. don't relocate) */
-	if (CMD_ARGC >= 2)
-	{
+	if (CMD_ARGC >= 2) {
 		uint32_t addr;
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
 		image->base_address = addr;
 		image->base_address_set = 1;
-	}
-	else
+	} else
 		image->base_address_set = 0;
 
 	image->start_address_set = 0;
 
 	if (CMD_ARGC >= 4)
-	{
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
-	}
-	if (CMD_ARGC == 5)
-	{
+	if (CMD_ARGC == 5) {
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
-		// use size (given) to find max (required)
+		/* use size (given) to find max (required) */
 		*max_address += *min_address;
 	}
 
@@ -2724,25 +2560,21 @@ COMMAND_HANDLER(handle_load_image_command)
 	duration_start(&bench);
 
 	if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
-	{
 		return ERROR_OK;
-	}
 
 	image_size = 0x0;
 	retval = ERROR_OK;
-	for (i = 0; i < image.num_sections; i++)
-	{
+	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
-		if (buffer == NULL)
-		{
+		if (buffer == NULL) {
 			command_print(CMD_CTX,
 						  "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			break;
 		}
 
-		if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
-		{
+		retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
+		if (retval != ERROR_OK) {
 			free(buffer);
 			break;
 		}
@@ -2752,37 +2584,34 @@ COMMAND_HANDLER(handle_load_image_command)
 
 		/* DANGER!!! beware of unsigned comparision here!!! */
 
-		if ((image.sections[i].base_address + buf_cnt >= min_address)&&
-				(image.sections[i].base_address < max_address))
-		{
-			if (image.sections[i].base_address < min_address)
-			{
+		if ((image.sections[i].base_address + buf_cnt >= min_address) &&
+				(image.sections[i].base_address < max_address)) {
+
+			if (image.sections[i].base_address < min_address) {
 				/* clip addresses below */
 				offset += min_address-image.sections[i].base_address;
 				length -= offset;
 			}
 
 			if (image.sections[i].base_address + buf_cnt > max_address)
-			{
 				length -= (image.sections[i].base_address + buf_cnt)-max_address;
-			}
 
-			if ((retval = target_write_buffer(target, image.sections[i].base_address + offset, length, buffer + offset)) != ERROR_OK)
-			{
+			retval = target_write_buffer(target,
+					image.sections[i].base_address + offset, length, buffer + offset);
+			if (retval != ERROR_OK) {
 				free(buffer);
 				break;
 			}
 			image_size += length;
 			command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
-						  (unsigned int)length,
-						  image.sections[i].base_address + offset);
+					(unsigned int)length,
+					image.sections[i].base_address + offset);
 		}
 
 		free(buffer);
 	}
 
-	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
-	{
+	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
 		command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
@@ -2822,21 +2651,16 @@ COMMAND_HANDLER(handle_dump_image_command)
 
 	duration_start(&bench);
 
-	while (size > 0)
-	{
+	while (size > 0) {
 		size_t size_written;
 		uint32_t this_run_size = (size > buf_size) ? buf_size : size;
 		retval = target_read_buffer(target, address, this_run_size, buffer);
 		if (retval != ERROR_OK)
-		{
 			break;
-		}
 
 		retval = fileio_write(&fileio, this_run_size, buffer, &size_written);
 		if (retval != ERROR_OK)
-		{
 			break;
-		}
 
 		size -= this_run_size;
 		address += this_run_size;
@@ -2844,8 +2668,7 @@ COMMAND_HANDLER(handle_dump_image_command)
 
 	free(buffer);
 
-	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
-	{
+	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
 		int filesize;
 		retval = fileio_size(&fileio, &filesize);
 		if (retval != ERROR_OK)
@@ -2855,7 +2678,8 @@ COMMAND_HANDLER(handle_dump_image_command)
 				duration_elapsed(&bench), duration_kbps(&bench, filesize));
 	}
 
-	if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
+	retvaltemp = fileio_close(&fileio);
+	if (retvaltemp != ERROR_OK)
 		return retvaltemp;
 
 	return retval;
@@ -2876,12 +2700,9 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 	struct target *target = get_current_target(CMD_CTX);
 
 	if (CMD_ARGC < 1)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 
-	if (!target)
-	{
+	if (!target) {
 		LOG_ERROR("no target selected");
 		return ERROR_FAIL;
 	}
@@ -2889,98 +2710,81 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 	struct duration bench;
 	duration_start(&bench);
 
-	if (CMD_ARGC >= 2)
-	{
+	if (CMD_ARGC >= 2) {
 		uint32_t addr;
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
 		image.base_address = addr;
 		image.base_address_set = 1;
-	}
-	else
-	{
+	} else {
 		image.base_address_set = 0;
 		image.base_address = 0x0;
 	}
 
 	image.start_address_set = 0;
 
-	if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK)
-	{
+	retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
+	if (retval != ERROR_OK)
 		return retval;
-	}
 
 	image_size = 0x0;
 	int diffs = 0;
 	retval = ERROR_OK;
-	for (i = 0; i < image.num_sections; i++)
-	{
+	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
-		if (buffer == NULL)
-		{
+		if (buffer == NULL) {
 			command_print(CMD_CTX,
-						  "error allocating buffer for section (%d bytes)",
-						  (int)(image.sections[i].size));
+					"error allocating buffer for section (%d bytes)",
+					(int)(image.sections[i].size));
 			break;
 		}
-		if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
-		{
+		retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
+		if (retval != ERROR_OK) {
 			free(buffer);
 			break;
 		}
 
-		if (verify)
-		{
+		if (verify) {
 			/* calculate checksum of image */
 			retval = image_calculate_checksum(buffer, buf_cnt, &checksum);
-			if (retval != ERROR_OK)
-			{
+			if (retval != ERROR_OK) {
 				free(buffer);
 				break;
 			}
 
 			retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum);
-			if (retval != ERROR_OK)
-			{
+			if (retval != ERROR_OK) {
 				free(buffer);
 				break;
 			}
 
-			if (checksum != mem_checksum)
-			{
+			if (checksum != mem_checksum) {
 				/* failed crc checksum, fall back to a binary compare */
 				uint8_t *data;
 
 				if (diffs == 0)
-				{
 					LOG_ERROR("checksum mismatch - attempting binary compare");
-				}
 
-				data = (uint8_t*)malloc(buf_cnt);
+				data = (uint8_t *)malloc(buf_cnt);
 
 				/* Can we use 32bit word accesses? */
 				int size = 1;
 				int count = buf_cnt;
-				if ((count % 4) == 0)
-				{
+				if ((count % 4) == 0) {
 					size *= 4;
 					count /= 4;
 				}
 				retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
-				if (retval == ERROR_OK)
-				{
+				if (retval == ERROR_OK) {
 					uint32_t t;
-					for (t = 0; t < buf_cnt; t++)
-					{
-						if (data[t] != buffer[t])
-						{
+					for (t = 0; t < buf_cnt; t++) {
+						if (data[t] != buffer[t]) {
 							command_print(CMD_CTX,
 										  "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
 										  diffs,
 										  (unsigned)(t + image.sections[i].base_address),
 										  data[t],
 										  buffer[t]);
-							if (diffs++ >= 127)
-							{
+							if (diffs++ >= 127) {
 								command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
 								free(data);
 								free(buffer);
@@ -2992,8 +2796,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 				}
 				free(data);
 			}
-		} else
-		{
+		} else {
 			command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
 						  image.sections[i].base_address,
 						  buf_cnt);
@@ -3003,16 +2806,11 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 		image_size += buf_cnt;
 	}
 	if (diffs > 0)
-	{
 		command_print(CMD_CTX, "No more differences found.");
-	}
 done:
 	if (diffs > 0)
-	{
 		retval = ERROR_FAIL;
-	}
-	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
-	{
+	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
 		command_print(CMD_CTX, "verified %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
@@ -3037,33 +2835,27 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
 {
 	struct target *target = get_current_target(cmd_ctx);
 	struct breakpoint *breakpoint = target->breakpoints;
-	while (breakpoint)
-	{
-		if (breakpoint->type == BKPT_SOFT)
-		{
-			char* buf = buf_to_str(breakpoint->orig_instr,
+	while (breakpoint) {
+		if (breakpoint->type == BKPT_SOFT) {
+			char *buf = buf_to_str(breakpoint->orig_instr,
 					breakpoint->length, 16);
 			command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
 					breakpoint->address,
 					breakpoint->length,
 					breakpoint->set, buf);
 			free(buf);
-		}
-		else
-		{
+		} else {
 			if ((breakpoint->address == 0) && (breakpoint->asid != 0))
 				command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
 							breakpoint->asid,
 							breakpoint->length, breakpoint->set);
-			else if ((breakpoint->address != 0) && (breakpoint->asid != 0))
-			{
+			else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
 				command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
 				command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
 							breakpoint->asid);
-			}
-			else
+			} else
 				command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
 							breakpoint->address,
 							breakpoint->length, breakpoint->set);
@@ -3079,35 +2871,27 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 {
 	struct target *target = get_current_target(cmd_ctx);
 
-	if (asid == 0)
-	{
+	if (asid == 0) {
 		int retval = breakpoint_add(target, addr, length, hw);
 		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
-		else
-		{
+		else {
 			LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
 			return retval;
 		}
-	}
-	else if (addr == 0)
-	{
+	} else if (addr == 0) {
 		int retval = context_breakpoint_add(target, asid, length, hw);
 		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
-		else
-		{
+		else {
 			LOG_ERROR("Failure setting breakpoint, the same address(CONTEXTID) is already used");
 			return retval;
 		}
-	}
-	else
-	{
+	} else {
 		int retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
-		if(ERROR_OK == retval)
+		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
-		else
-		{
+		else {
 			LOG_ERROR("Failure setting breakpoint, the same address is already used");
 			return retval;
 		}
@@ -3121,8 +2905,8 @@ COMMAND_HANDLER(handle_bp_command)
 	uint32_t asid;
 	uint32_t length;
 	int hw = BKPT_SOFT;
-	switch(CMD_ARGC)
-	{
+
+	switch (CMD_ARGC) {
 		case 0:
 			return handle_bp_command_list(CMD_CTX);
 
@@ -3133,8 +2917,7 @@ COMMAND_HANDLER(handle_bp_command)
 			return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
 
 		case 3:
-			if(strcmp(CMD_ARGV[2], "hw") == 0)
-			{
+			if (strcmp(CMD_ARGV[2], "hw") == 0) {
 				hw = BKPT_HARD;
 				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
 
@@ -3142,9 +2925,7 @@ COMMAND_HANDLER(handle_bp_command)
 
 				asid = 0;
 				return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
-			}
-			else if(strcmp(CMD_ARGV[2], "hw_ctx") == 0)
-			{
+			} else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) {
 				hw = BKPT_HARD;
 				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid);
 				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
@@ -3182,12 +2963,10 @@ COMMAND_HANDLER(handle_wp_command)
 {
 	struct target *target = get_current_target(CMD_CTX);
 
-	if (CMD_ARGC == 0)
-	{
+	if (CMD_ARGC == 0) {
 		struct watchpoint *watchpoint = target->watchpoints;
 
-		while (watchpoint)
-		{
+		while (watchpoint) {
 			command_print(CMD_CTX, "address: 0x%8.8" PRIx32
 					", len: 0x%8.8" PRIx32
 					", r/w/a: %i, value: 0x%8.8" PRIx32
@@ -3208,17 +2987,15 @@ COMMAND_HANDLER(handle_wp_command)
 	uint32_t data_value = 0x0;
 	uint32_t data_mask = 0xffffffff;
 
-	switch (CMD_ARGC)
-	{
+	switch (CMD_ARGC) {
 	case 5:
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
-		// fall through
+		/* fall through */
 	case 4:
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
-		// fall through
+		/* fall through */
 	case 3:
-		switch (CMD_ARGV[2][0])
-		{
+		switch (CMD_ARGV[2][0]) {
 		case 'r':
 			type = WPT_READ;
 			break;
@@ -3232,7 +3009,7 @@ COMMAND_HANDLER(handle_wp_command)
 			LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
 			return ERROR_COMMAND_SYNTAX_ERROR;
 		}
-		// fall through
+		/* fall through */
 	case 2:
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
 		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
@@ -3264,7 +3041,6 @@ COMMAND_HANDLER(handle_rwp_command)
 	return ERROR_OK;
 }
 
-
 /**
  * Translate a virtual address to a physical address.
  *
@@ -3298,8 +3074,7 @@ static void writeData(FILE *f, const void *data, size_t len)
 static void writeLong(FILE *f, int l)
 {
 	int i;
-	for (i = 0; i < 4; i++)
-	{
+	for (i = 0; i < 4; i++) {
 		char c = (l >> (i*8))&0xff;
 		writeData(f, &c, 1);
 	}
@@ -3330,16 +3105,11 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 	/* figure out bucket size */
 	uint32_t min = samples[0];
 	uint32_t max = samples[0];
-	for (i = 0; i < sampleNum; i++)
-	{
+	for (i = 0; i < sampleNum; i++) {
 		if (min > samples[i])
-		{
 			min = samples[i];
-		}
 		if (max < samples[i])
-		{
 			max = samples[i];
-		}
 	}
 
 	int addressSpace = (max - min + 1);
@@ -3348,31 +3118,27 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 	static const uint32_t maxBuckets = 16 * 1024; /* maximum buckets. */
 	uint32_t length = addressSpace;
 	if (length > maxBuckets)
-	{
 		length = maxBuckets;
-	}
 	int *buckets = malloc(sizeof(int)*length);
-	if (buckets == NULL)
-	{
+	if (buckets == NULL) {
 		fclose(f);
 		return;
 	}
-	memset(buckets, 0, sizeof(int)*length);
-	for (i = 0; i < sampleNum;i++)
-	{
+	memset(buckets, 0, sizeof(int) * length);
+	for (i = 0; i < sampleNum; i++) {
 		uint32_t address = samples[i];
-		long long a = address-min;
-		long long b = length-1;
-		long long c = addressSpace-1;
-		int index_t = (a*b)/c; /* danger!!!! int32 overflows */
+		long long a = address - min;
+		long long b = length - 1;
+		long long c = addressSpace - 1;
+		int index_t = (a * b) / c; /* danger!!!! int32 overflows */
 		buckets[index_t]++;
 	}
 
 	/* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
-	writeLong(f, min); 			/* low_pc */
+	writeLong(f, min);			/* low_pc */
 	writeLong(f, max);			/* high_pc */
 	writeLong(f, length);		/* # of samples */
-	writeLong(f, 100); 			/* KLUDGE! We lie, ca. 100Hz best case. */
+	writeLong(f, 100);			/* KLUDGE! We lie, ca. 100Hz best case. */
 	writeString(f, "seconds");
 	for (i = 0; i < (15-strlen("seconds")); i++)
 		writeData(f, &zero, 1);
@@ -3380,27 +3146,21 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 
 	/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
 
-	char *data = malloc(2*length);
-	if (data != NULL)
-	{
-		for (i = 0; i < length;i++)
-		{
+	char *data = malloc(2 * length);
+	if (data != NULL) {
+		for (i = 0; i < length; i++) {
 			int val;
 			val = buckets[i];
 			if (val > 65535)
-			{
 				val = 65535;
-			}
-			data[i*2]=val&0xff;
-			data[i*2 + 1]=(val >> 8)&0xff;
+			data[i * 2] = val&0xff;
+			data[i * 2 + 1] = (val >> 8) & 0xff;
 		}
 		free(buckets);
 		writeData(f, data, length * 2);
 		free(data);
 	} else
-	{
 		free(buckets);
-	}
 
 	fclose(f);
 }
@@ -3414,9 +3174,7 @@ COMMAND_HANDLER(handle_profile_command)
 
 	gettimeofday(&timeout, NULL);
 	if (CMD_ARGC != 2)
-	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
 	unsigned offset;
 	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
 
@@ -3440,50 +3198,46 @@ COMMAND_HANDLER(handle_profile_command)
 	struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
 
 	int retval = ERROR_OK;
-	for (;;)
-	{
+	for (;;) {
 		target_poll(target);
-		if (target->state == TARGET_HALTED)
-		{
-			uint32_t t=*((uint32_t *)reg->value);
-			samples[numSamples++]=t;
-			retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
+		if (target->state == TARGET_HALTED) {
+			uint32_t t = *((uint32_t *)reg->value);
+			samples[numSamples++] = t;
+			/* current pc, addr = 0, do not handle breakpoints, not debugging */
+			retval = target_resume(target, 1, 0, 0, 0);
 			target_poll(target);
 			alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
-		} else if (target->state == TARGET_RUNNING)
-		{
+		} else if (target->state == TARGET_RUNNING) {
 			/* We want to quickly sample the PC. */
-			if ((retval = target_halt(target)) != ERROR_OK)
-			{
+			retval = target_halt(target);
+			if (retval != ERROR_OK) {
 				free(samples);
 				return retval;
 			}
-		} else
-		{
+		} else {
 			command_print(CMD_CTX, "Target not halted or running");
 			retval = ERROR_OK;
 			break;
 		}
 		if (retval != ERROR_OK)
-		{
 			break;
-		}
 
 		gettimeofday(&now, NULL);
-		if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
-		{
+		if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec)
+				&& (now.tv_usec >= timeout.tv_usec))) {
 			command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
-			if ((retval = target_poll(target)) != ERROR_OK)
-			{
+			retval = target_poll(target);
+			if (retval != ERROR_OK) {
 				free(samples);
 				return retval;
 			}
-			if (target->state == TARGET_HALTED)
-			{
-				target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
+			if (target->state == TARGET_HALTED) {
+				/* current pc, addr = 0, do not handle
+				 * breakpoints, not debugging */
+				target_resume(target, 1, 0, 0, 0);
 			}
-			if ((retval = target_poll(target)) != ERROR_OK)
-			{
+			retval = target_poll(target);
+			if (retval != ERROR_OK) {
 				free(samples);
 				return retval;
 			}
@@ -3497,7 +3251,7 @@ COMMAND_HANDLER(handle_profile_command)
 	return retval;
 }
 
-static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
+static int new_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t val)
 {
 	char *namebuf;
 	Jim_Obj *nameObjPtr, *valObjPtr;
@@ -3509,8 +3263,7 @@ static int new_int_array_element(Jim_Interp * interp, const char *varname, int i
 
 	nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
 	valObjPtr = Jim_NewIntObj(interp, val);
-	if (!nameObjPtr || !valObjPtr)
-	{
+	if (!nameObjPtr || !valObjPtr) {
 		free(namebuf);
 		return JIM_ERR;
 	}
@@ -3531,16 +3284,15 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	struct target *target;
 
 	context = current_command_context(interp);
-	assert (context != NULL);
+	assert(context != NULL);
 
 	target = get_current_target(context);
-	if (target == NULL)
-	{
+	if (target == NULL) {
 		LOG_ERROR("mem2array: no current target");
 		return JIM_ERR;
 	}
 
-	return 	target_mem2array(interp, target, argc-1, argv + 1);
+	return target_mem2array(interp, target, argc - 1, argv + 1);
 }
 
 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
@@ -3569,20 +3321,17 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 
 	e = Jim_GetLong(interp, argv[1], &l);
 	width = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 
 	e = Jim_GetLong(interp, argv[2], &l);
 	addr = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 	e = Jim_GetLong(interp, argv[3], &l);
 	len = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 	switch (width) {
 		case 8:
 			width = 1;
@@ -3645,9 +3394,8 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 		/* Slurp... in buffer size chunks */
 
 		count = len; /* in objects.. */
-		if (count > (buffersize/width)) {
-			count = (buffersize/width);
-		}
+		if (count > (buffersize / width))
+			count = (buffersize / width);
 
 		retval = target_read_memory(target, addr, width, count, buffer);
 		if (retval != ERROR_OK) {
@@ -3662,7 +3410,7 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 			break;
 		} else {
 			v = 0; /* shut up gcc */
-			for (i = 0 ;i < count ;i++, n++) {
+			for (i = 0; i < count ; i++, n++) {
 				switch (width) {
 					case 4:
 						v = target_buffer_get_u32(target, &buffer[i*width]);
@@ -3687,7 +3435,7 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 	return e;
 }
 
-static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
+static int get_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t *val)
 {
 	char *namebuf;
 	Jim_Obj *nameObjPtr, *valObjPtr;
@@ -3699,8 +3447,7 @@ static int get_int_array_element(Jim_Interp * interp, const char *varname, int i
 		return JIM_ERR;
 
 	nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
-	if (!nameObjPtr)
-	{
+	if (!nameObjPtr) {
 		free(namebuf);
 		return JIM_ERR;
 	}
@@ -3724,7 +3471,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	struct target *target;
 
 	context = current_command_context(interp);
-	assert (context != NULL);
+	assert(context != NULL);
 
 	target = get_current_target(context);
 	if (target == NULL) {
@@ -3732,7 +3479,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return JIM_ERR;
 	}
 
-	return target_array2mem(interp,target, argc-1, argv + 1);
+	return target_array2mem(interp, target, argc-1, argv + 1);
 }
 
 static int target_array2mem(Jim_Interp *interp, struct target *target,
@@ -3762,20 +3509,17 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 
 	e = Jim_GetLong(interp, argv[1], &l);
 	width = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 
 	e = Jim_GetLong(interp, argv[2], &l);
 	addr = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 	e = Jim_GetLong(interp, argv[3], &l);
 	len = l;
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 	switch (width) {
 		case 8:
 			width = 1;
@@ -3788,23 +3532,27 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 			break;
 		default:
 			Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-			Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
+			Jim_AppendStrings(interp, Jim_GetResult(interp),
+					"Invalid width param, must be 8/16/32", NULL);
 			return JIM_ERR;
 	}
 	if (len == 0) {
 		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL);
+		Jim_AppendStrings(interp, Jim_GetResult(interp),
+				"array2mem: zero width read?", NULL);
 		return JIM_ERR;
 	}
 	if ((addr + (len * width)) < addr) {
 		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL);
+		Jim_AppendStrings(interp, Jim_GetResult(interp),
+				"array2mem: addr + len - wraps to zero?", NULL);
 		return JIM_ERR;
 	}
 	/* absurd transfer size? */
 	if (len > 65536) {
 		Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-		Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
+		Jim_AppendStrings(interp, Jim_GetResult(interp),
+				"array2mem: absurd > 64K item request", NULL);
 		return JIM_ERR;
 	}
 
@@ -3838,19 +3586,18 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 		/* Slurp... in buffer size chunks */
 
 		count = len; /* in objects.. */
-		if (count > (buffersize/width)) {
-			count = (buffersize/width);
-		}
+		if (count > (buffersize / width))
+			count = (buffersize / width);
 
 		v = 0; /* shut up gcc */
-		for (i = 0 ;i < count ;i++, n++) {
+		for (i = 0; i < count; i++, n++) {
 			get_int_array_element(interp, varname, n, &v);
 			switch (width) {
 			case 4:
-				target_buffer_set_u32(target, &buffer[i*width], v);
+				target_buffer_set_u32(target, &buffer[i * width], v);
 				break;
 			case 2:
-				target_buffer_set_u16(target, &buffer[i*width], v);
+				target_buffer_set_u16(target, &buffer[i * width], v);
 				break;
 			case 1:
 				buffer[i] = v & 0x0ff;
@@ -3896,10 +3643,9 @@ void target_handle_event(struct target *target, enum target_event e)
 					   e,
 					   Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
 					   Jim_GetString(teap->body, NULL));
-			if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK)
-			{
+			if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK) {
 				Jim_MakeErrorMessage(teap->interp);
-				command_print(NULL,"%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
+				command_print(NULL, "%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL));
 			}
 		}
 	}
@@ -3990,7 +3736,7 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 						"not settable: %s", n->name);
 				return JIM_ERR;
 			} else {
-			no_params:
+no_params:
 				if (goi->argc != 0) {
 					Jim_WrongNumArgs(goi->interp,
 							goi->argc, goi->argv,
@@ -4032,9 +3778,8 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 				teap = target->event_action;
 				/* replace existing? */
 				while (teap) {
-					if (teap->event == (enum target_event)n->value) {
+					if (teap->event == (enum target_event)n->value)
 						break;
-					}
 					teap = teap->next;
 				}
 
@@ -4048,9 +3793,8 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 					teap->event = n->value;
 					teap->interp = goi->interp;
 					Jim_GetOpt_Obj(goi, &o);
-					if (teap->body) {
+					if (teap->body)
 						Jim_DecrRefCount(teap->interp, teap->body);
-					}
 					teap->body  = Jim_DuplicateObj(goi->interp, o);
 					/*
 					 * FIXME:
@@ -4064,8 +3808,7 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 					 */
 					Jim_IncrRefCount(teap->body);
 
-					if (!replace)
-					{
+					if (!replace) {
 						/* add to head of event list */
 						teap->next = target->event_action;
 						target->event_action = teap;
@@ -4073,11 +3816,10 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 					Jim_SetEmptyResult(goi->interp);
 				} else {
 					/* get */
-					if (teap == NULL) {
+					if (teap == NULL)
 						Jim_SetEmptyResult(goi->interp);
-					} else {
+					else
 						Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, teap->body));
-					}
 				}
 			}
 			/* loop for more */
@@ -4087,15 +3829,13 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 			if (goi->isconfigure) {
 				target_free_all_working_areas(target);
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				target->working_area_virt = w;
 				target->working_area_virt_spec = true;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_virt));
 			/* loop for more */
@@ -4105,15 +3845,13 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 			if (goi->isconfigure) {
 				target_free_all_working_areas(target);
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				target->working_area_phys = w;
 				target->working_area_phys_spec = true;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_phys));
 			/* loop for more */
@@ -4123,14 +3861,12 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 			if (goi->isconfigure) {
 				target_free_all_working_areas(target);
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				target->working_area_size = w;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
 			/* loop for more */
@@ -4140,15 +3876,13 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 			if (goi->isconfigure) {
 				target_free_all_working_areas(target);
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				/* make this exactly 1 or 0 */
 				target->backup_working_area = (!!w);
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->backup_working_area));
 			/* loop for more e*/
@@ -4164,9 +3898,8 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 				}
 				target->endianness = n->value;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			n = Jim_Nvp_value2name_simple(nvp_target_endian, target->endianness);
 			if (n->name == NULL) {
@@ -4185,33 +3918,29 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 										   n->name);
 					return JIM_ERR;
 				}
-				if (target->variant) {
+				if (target->variant)
 					free((void *)(target->variant));
-				}
 				e = Jim_GetOpt_String(goi, &cp, NULL);
 				if (e != JIM_OK)
 					return e;
 				target->variant = strdup(cp);
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
-			Jim_SetResultString(goi->interp, target->variant,-1);
+			Jim_SetResultString(goi->interp, target->variant, -1);
 			/* loop for more */
 			break;
 
 		case TCFG_COREID:
 			if (goi->isconfigure) {
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				target->coreid = (int32_t)w;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size));
 			/* loop for more */
@@ -4223,19 +3952,16 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 				struct jtag_tap *tap;
 				target_free_all_working_areas(target);
 				e = Jim_GetOpt_Obj(goi, &o_t);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				tap = jtag_tap_by_jim_obj(goi->interp, o_t);
-				if (tap == NULL) {
+				if (tap == NULL)
 					return JIM_ERR;
-				}
 				/* make this exactly 1 or 0 */
 				target->tap = tap;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResultString(goi->interp, target->tap->dotted_name, -1);
 			/* loop for more e*/
@@ -4243,15 +3969,13 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 		case TCFG_DBGBASE:
 			if (goi->isconfigure) {
 				e = Jim_GetOpt_Wide(goi, &w);
-				if (e != JIM_OK) {
+				if (e != JIM_OK)
 					return e;
-				}
 				target->dbgbase = (uint32_t)w;
 				target->dbgbase_set = true;
 			} else {
-				if (goi->argc != 0) {
+				if (goi->argc != 0)
 					goto no_params;
-				}
 			}
 			Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->dbgbase));
 			/* loop for more */
@@ -4260,11 +3984,9 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 		case TCFG_RTOS:
 			/* RTOS */
 			{
-				int result = rtos_create( goi, target );
-				if ( result != JIM_OK )
-				{
+				int result = rtos_create(goi, target);
+				if (result != JIM_OK)
 					return result;
-				}
 			}
 			/* loop for more */
 			break;
@@ -4276,16 +3998,14 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 	return JIM_OK;
 }
 
-static int
-jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+static int jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
 {
 	Jim_GetOptInfo goi;
 
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 	goi.isconfigure = !strcmp(Jim_GetString(argv[0], NULL), "configure");
 	int need_args = 1 + goi.isconfigure;
-	if (goi.argc < need_args)
-	{
+	if (goi.argc < need_args) {
 		Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
 			goi.isconfigure
 				? "missing: -option VALUE ..."
@@ -4303,8 +4023,7 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	if (goi.argc < 2 || goi.argc > 4)
-	{
+	if (goi.argc < 2 || goi.argc > 4) {
 		Jim_SetResultFormatted(goi.interp,
 				"usage: %s [phys] <address> <data> [<count>]", cmd_name);
 		return JIM_ERR;
@@ -4314,8 +4033,7 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	fn = target_write_memory_fast;
 
 	int e;
-	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
-	{
+	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) {
 		/* consume it */
 		struct Jim_Obj *obj;
 		e = Jim_GetOpt_Obj(&goi, &obj);
@@ -4336,8 +4054,7 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return e;
 
 	jim_wide c = 1;
-	if (goi.argc == 1)
-	{
+	if (goi.argc == 1) {
 		e = Jim_GetOpt_Wide(&goi, &c);
 		if (e != JIM_OK)
 			return e;
@@ -4345,21 +4062,17 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 	/* all args must be consumed */
 	if (goi.argc != 0)
-	{
 		return JIM_ERR;
-	}
 
 	struct target *target = Jim_CmdPrivData(goi.interp);
 	unsigned data_size;
-	if (strcasecmp(cmd_name, "mww") == 0) {
+	if (strcasecmp(cmd_name, "mww") == 0)
 		data_size = 4;
-	}
-	else if (strcasecmp(cmd_name, "mwh") == 0) {
+	else if (strcasecmp(cmd_name, "mwh") == 0)
 		data_size = 2;
-	}
-	else if (strcasecmp(cmd_name, "mwb") == 0) {
+	else if (strcasecmp(cmd_name, "mwb") == 0)
 		data_size = 1;
-	} else {
+	else {
 		LOG_ERROR("command '%s' unknown: ", cmd_name);
 		return JIM_ERR;
 	}
@@ -4374,8 +4087,7 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	if ((goi.argc < 1) || (goi.argc > 3))
-	{
+	if ((goi.argc < 1) || (goi.argc > 3)) {
 		Jim_SetResultFormatted(goi.interp,
 				"usage: %s [phys] <address> [<count>]", cmd_name);
 		return JIM_ERR;
@@ -4383,40 +4095,34 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 	int (*fn)(struct target *target,
 			uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-	fn=target_read_memory;
+	fn = target_read_memory;
 
 	int e;
-	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0)
-	{
+	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) {
 		/* consume it */
 		struct Jim_Obj *obj;
 		e = Jim_GetOpt_Obj(&goi, &obj);
 		if (e != JIM_OK)
 			return e;
 
-		fn=target_read_phys_memory;
+		fn = target_read_phys_memory;
 	}
 
 	jim_wide a;
 	e = Jim_GetOpt_Wide(&goi, &a);
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return JIM_ERR;
-	}
 	jim_wide c;
 	if (goi.argc == 1) {
 		e = Jim_GetOpt_Wide(&goi, &c);
-		if (e != JIM_OK) {
+		if (e != JIM_OK)
 			return JIM_ERR;
-		}
-	} else {
+	} else
 		c = 1;
-	}
 
 	/* all args must be consumed */
 	if (goi.argc != 0)
-	{
 		return JIM_ERR;
-	}
 
 	jim_wide b = 1; /* shut up gcc */
 	if (strcasecmp(cmd_name, "mdw") == 0)
@@ -4438,9 +4144,8 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	jim_wide x, y, z;
 	while (c > 0) {
 		y = c;
-		if (y > 16) {
+		if (y > 16)
 			y = 16;
-		}
 		e = fn(target, a, b, y / b, target_buf);
 		if (e != ERROR_OK) {
 			char tmp[10];
@@ -4452,34 +4157,29 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		command_print(NULL, "0x%08x ", (int)(a));
 		switch (b) {
 		case 4:
-			for (x = 0; x < 16 && x < y; x += 4)
-			{
-				z = target_buffer_get_u32(target, &(target_buf[ x ]));
+			for (x = 0; x < 16 && x < y; x += 4) {
+				z = target_buffer_get_u32(target, &(target_buf[x]));
 				command_print(NULL, "%08x ", (int)(z));
 			}
-			for (; (x < 16) ; x += 4) {
+			for (; (x < 16) ; x += 4)
 				command_print(NULL, "         ");
-			}
 			break;
 		case 2:
-			for (x = 0; x < 16 && x < y; x += 2)
-			{
-				z = target_buffer_get_u16(target, &(target_buf[ x ]));
+			for (x = 0; x < 16 && x < y; x += 2) {
+				z = target_buffer_get_u16(target, &(target_buf[x]));
 				command_print(NULL, "%04x ", (int)(z));
 			}
-			for (; (x < 16) ; x += 2) {
+			for (; (x < 16) ; x += 2)
 				command_print(NULL, "     ");
-			}
 			break;
 		case 1:
 		default:
 			for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
-				z = target_buffer_get_u8(target, &(target_buf[ x ]));
+				z = target_buffer_get_u8(target, &(target_buf[x]));
 				command_print(NULL, "%02x ", (int)(z));
 			}
-			for (; (x < 16) ; x += 1) {
+			for (; (x < 16) ; x += 1)
 				command_print(NULL, "   ");
-			}
 			break;
 		}
 		/* ascii-ify the bytes */
@@ -4530,8 +4230,7 @@ static int jim_target_tap_disabled(Jim_Interp *interp)
 
 static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
 		return JIM_ERR;
 	}
@@ -4541,16 +4240,13 @@ static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 
 	int e = target->type->examine(target);
 	if (e != ERROR_OK)
-	{
 		return JIM_ERR;
-	}
 	return JIM_OK;
 }
 
 static int jim_target_halt_gdb(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
 		return JIM_ERR;
 	}
@@ -4564,8 +4260,7 @@ static int jim_target_halt_gdb(Jim_Interp *interp, int argc, Jim_Obj *const *arg
 
 static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
 		return JIM_ERR;
 	}
@@ -4574,15 +4269,12 @@ static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return jim_target_tap_disabled(interp);
 
 	int e;
-	if (!(target_was_examined(target))) {
+	if (!(target_was_examined(target)))
 		e = ERROR_TARGET_NOT_EXAMINED;
-	} else {
+	else
 		e = target->type->poll(target);
-	}
 	if (e != ERROR_OK)
-	{
 		return JIM_ERR;
-	}
 	return JIM_OK;
 }
 
@@ -4591,8 +4283,7 @@ static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	if (goi.argc != 2)
-	{
+	if (goi.argc != 2) {
 		Jim_WrongNumArgs(interp, 0, argv,
 				"([tT]|[fF]|assert|deassert) BOOL");
 		return JIM_ERR;
@@ -4600,8 +4291,7 @@ static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 	Jim_Nvp *n;
 	int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
-	if (e != JIM_OK)
-	{
+	if (e != JIM_OK) {
 		Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
 		return e;
 	}
@@ -4614,13 +4304,11 @@ static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	struct target *target = Jim_CmdPrivData(goi.interp);
 	if (!target->tap->enabled)
 		return jim_target_tap_disabled(interp);
-	if (!(target_was_examined(target)))
-	{
+	if (!(target_was_examined(target))) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_TARGET_NOT_EXAMINED;
 	}
-	if (!target->type->assert_reset || !target->type->deassert_reset)
-	{
+	if (!target->type->assert_reset || !target->type->deassert_reset) {
 		Jim_SetResultFormatted(interp,
 				"No target-specific reset for %s",
 				target_name(target));
@@ -4632,11 +4320,10 @@ static int jim_target_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	target_free_all_working_areas_restore(target, 0);
 
 	/* do the assert */
-	if (n->value == NVP_ASSERT) {
+	if (n->value == NVP_ASSERT)
 		e = target->type->assert_reset(target);
-	} else {
+	else
 		e = target->type->deassert_reset(target);
-	}
 	return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
 }
 
@@ -4659,8 +4346,7 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
 	/* params:  <name>  statename timeoutmsecs */
-	if (goi.argc != 2)
-	{
+	if (goi.argc != 2) {
 		const char *cmd_name = Jim_GetString(argv[0], NULL);
 		Jim_SetResultFormatted(goi.interp,
 				"%s <state_name> <timeout_in_msec>", cmd_name);
@@ -4670,21 +4356,19 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
 	Jim_Nvp *n;
 	int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
 	if (e != JIM_OK) {
-		Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
+		Jim_GetOpt_NvpUnknown(&goi, nvp_target_state, 1);
 		return e;
 	}
 	jim_wide a;
 	e = Jim_GetOpt_Wide(&goi, &a);
-	if (e != JIM_OK) {
+	if (e != JIM_OK)
 		return e;
-	}
 	struct target *target = Jim_CmdPrivData(interp);
 	if (!target->tap->enabled)
 		return jim_target_tap_disabled(interp);
 
 	e = target_wait_state(target, n->value, a);
-	if (e != ERROR_OK)
-	{
+	if (e != ERROR_OK) {
 		Jim_Obj *eObj = Jim_NewIntObj(interp, e);
 		Jim_SetResultFormatted(goi.interp,
 				"target: %s wait %s fails (%#s) %s",
@@ -4701,7 +4385,7 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
 static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
 	struct command_context *cmd_ctx = current_command_context(interp);
-	assert (cmd_ctx != NULL);
+	assert(cmd_ctx != NULL);
 
 	struct target *target = Jim_CmdPrivData(interp);
 	struct target_event_action *teap = target->event_action;
@@ -4711,8 +4395,7 @@ static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *a
 	command_print(cmd_ctx, "%-25s | Body", "Event");
 	command_print(cmd_ctx, "------------------------- | "
 			"----------------------------------------");
-	while (teap)
-	{
+	while (teap) {
 		Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
 		command_print(cmd_ctx, "%-25s | %s",
 				opt->name, Jim_GetString(teap->body, NULL));
@@ -4723,8 +4406,7 @@ static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *a
 }
 static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
 		return JIM_ERR;
 	}
@@ -4736,16 +4418,14 @@ static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const
 {
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
-	if (goi.argc != 1)
-	{
+	if (goi.argc != 1) {
 		const char *cmd_name = Jim_GetString(argv[0], NULL);
 		Jim_SetResultFormatted(goi.interp, "%s <eventname>", cmd_name);
 		return JIM_ERR;
 	}
 	Jim_Nvp *n;
 	int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
-	if (e != JIM_OK)
-	{
+	if (e != JIM_OK) {
 		Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
 		return e;
 	}
@@ -4897,7 +4577,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	struct command_context *cmd_ctx;
 
 	cmd_ctx = current_command_context(goi->interp);
-	assert (cmd_ctx != NULL);
+	assert(cmd_ctx != NULL);
 
 	if (goi->argc < 3) {
 		Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
@@ -4938,19 +4618,19 @@ static int target_create(Jim_GetOptInfo *goi)
 				Jim_AppendStrings(goi->interp,
 								   Jim_GetResult(goi->interp),
 								   " or ",
-								   target_types[x]->name,NULL);
+								   target_types[x]->name, NULL);
 			}
 		}
 		return JIM_ERR;
 	}
 
 	/* Create it */
-	target = calloc(1,sizeof(struct target));
+	target = calloc(1, sizeof(struct target));
 	/* set target number */
 	target->target_number = new_target_number();
 
 	/* allocate memory for each unique target type */
-	target->type = (struct target_type*)calloc(1,sizeof(struct target_type));
+	target->type = (struct target_type *)calloc(1, sizeof(struct target_type));
 
 	memcpy(target->type, target_types[x], sizeof(struct target_type));
 
@@ -4999,8 +4679,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	goi->isconfigure = 1;
 	e = target_configure(goi, target);
 
-	if (target->tap == NULL)
-	{
+	if (target->tap == NULL) {
 		Jim_SetResultString(goi->interp, "-chain-position required when creating target", -1);
 		e = JIM_ERR;
 	}
@@ -5029,17 +4708,15 @@ static int target_create(Jim_GetOptInfo *goi)
 		if (ERROR_OK != e)
 			LOG_ERROR("unable to register '%s' commands", cp);
 	}
-	if (target->type->target_create) {
+	if (target->type->target_create)
 		(*(target->type->target_create))(target, goi->interp);
-	}
 
 	/* append to end of list */
 	{
 		struct target **tpp;
 		tpp = &(all_targets);
-		while (*tpp) {
+		while (*tpp)
 			tpp = &((*tpp)->next);
-		}
 		*tpp = target;
 	}
 
@@ -5076,13 +4753,12 @@ static int target_create(Jim_GetOptInfo *goi)
 
 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 		return JIM_ERR;
 	}
 	struct command_context *cmd_ctx = current_command_context(interp);
-	assert (cmd_ctx != NULL);
+	assert(cmd_ctx != NULL);
 
 	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
 	return JIM_OK;
@@ -5090,14 +4766,12 @@ static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 
 static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 		return JIM_ERR;
 	}
 	Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
-	for (unsigned x = 0; NULL != target_types[x]; x++)
-	{
+	for (unsigned x = 0; NULL != target_types[x]; x++) {
 		Jim_ListAppendElement(interp, Jim_GetResult(interp),
 			Jim_NewStringObj(interp, target_types[x]->name, -1));
 	}
@@ -5106,15 +4780,13 @@ static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 		return JIM_ERR;
 	}
 	Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
 	struct target *target = all_targets;
-	while (target)
-	{
+	while (target) {
 		Jim_ListAppendElement(interp, Jim_GetResult(interp),
 			Jim_NewStringObj(interp, target_name(target), -1));
 		target = target->next;
@@ -5126,7 +4798,7 @@ static int jim_target_smp(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
 	int i;
 	const char *targetname;
-	int retval,len;
+	int retval, len;
 	struct target *target = (struct target *) NULL;
 	struct target_list *head, *curr, *new;
 	curr = (struct target_list *) NULL;
@@ -5134,40 +4806,34 @@ static int jim_target_smp(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	new = (struct target_list *) NULL;
 
 	retval = 0;
-	LOG_DEBUG("%d",argc);
+	LOG_DEBUG("%d", argc);
 	/* argv[1] = target to associate in smp
 	 * argv[2] = target to assoicate in smp
 	 * argv[3] ...
 	 */
 
-	for(i=1;i<argc;i++)
-	{
+	for (i = 1; i < argc; i++) {
 
 		targetname = Jim_GetString(argv[i], &len);
 		target = get_target(targetname);
-		LOG_DEBUG("%s ",targetname);
-		if (target)
-		{
-			new=malloc(sizeof(struct target_list));
+		LOG_DEBUG("%s ", targetname);
+		if (target) {
+			new = malloc(sizeof(struct target_list));
 			new->target = target;
-			new->next = (struct target_list*)NULL;
-			if (head == (struct target_list*)NULL)
-			{
+			new->next = (struct target_list *)NULL;
+			if (head == (struct target_list *)NULL) {
 				head = new;
 				curr = head;
-			}
-			else
-			{
+			} else {
 				curr->next = new;
 				curr = new;
 			}
 		}
 	}
-    /*  now parse the list of cpu and put the target in smp mode*/
-	curr=head;
+	/*  now parse the list of cpu and put the target in smp mode*/
+	curr = head;
 
-    while(curr!=(struct target_list *)NULL)
-	{
+	while (curr != (struct target_list *)NULL) {
 		target = curr->target;
 		target->smp = 1;
 		target->head = head;
@@ -5183,8 +4849,7 @@ static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
 	Jim_GetOptInfo goi;
 	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
-	if (goi.argc < 3)
-	{
+	if (goi.argc < 3) {
 		Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
 			"<name> <target_type> [<target_options> ...]");
 		return JIM_ERR;
@@ -5199,8 +4864,7 @@ static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 	/* It's OK to remove this mechanism sometime after August 2010 or so */
 	LOG_WARNING("don't use numbers as target identifiers; use names");
-	if (goi.argc != 1)
-	{
+	if (goi.argc != 1) {
 		Jim_SetResultFormatted(goi.interp, "usage: target number <number>");
 		return JIM_ERR;
 	}
@@ -5210,8 +4874,7 @@ static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		return JIM_ERR;
 
 	struct target *target;
-	for (target = all_targets; NULL != target; target = target->next)
-	{
+	for (target = all_targets; NULL != target; target = target->next) {
 		if (target->target_number != w)
 			continue;
 
@@ -5229,15 +4892,13 @@ static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	if (argc != 1)
-	{
+	if (argc != 1) {
 		Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
 		return JIM_ERR;
 	}
 	unsigned count = 0;
 	struct target *target = all_targets;
-	while (NULL != target)
-	{
+	while (NULL != target) {
 		target = target->next;
 		count++;
 	}
@@ -5305,8 +4966,7 @@ static const struct command_registration target_subcommand_handlers[] = {
 	COMMAND_REGISTRATION_DONE
 };
 
-struct FastLoad
-{
+struct FastLoad {
 	uint32_t address;
 	uint8_t *data;
 	int length;
@@ -5318,11 +4978,9 @@ static struct FastLoad *fastload;
 
 static void free_fastload(void)
 {
-	if (fastload != NULL)
-	{
+	if (fastload != NULL) {
 		int i;
-		for (i = 0; i < fastload_num; i++)
-		{
+		for (i = 0; i < fastload_num; i++) {
 			if (fastload[i].data)
 				free(fastload[i].data);
 		}
@@ -5331,9 +4989,6 @@ static void free_fastload(void)
 	}
 }
 
-
-
-
 COMMAND_HANDLER(handle_fast_load_image_command)
 {
 	uint8_t *buffer;
@@ -5355,34 +5010,29 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 
 	retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL);
 	if (retval != ERROR_OK)
-	{
 		return retval;
-	}
 
 	image_size = 0x0;
 	retval = ERROR_OK;
 	fastload_num = image.num_sections;
 	fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
-	if (fastload == NULL)
-	{
+	if (fastload == NULL) {
 		command_print(CMD_CTX, "out of memory");
 		image_close(&image);
 		return ERROR_FAIL;
 	}
 	memset(fastload, 0, sizeof(struct FastLoad)*image.num_sections);
-	for (i = 0; i < image.num_sections; i++)
-	{
+	for (i = 0; i < image.num_sections; i++) {
 		buffer = malloc(image.sections[i].size);
-		if (buffer == NULL)
-		{
+		if (buffer == NULL) {
 			command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
 						  (int)(image.sections[i].size));
 			retval = ERROR_FAIL;
 			break;
 		}
 
-		if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
-		{
+		retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt);
+		if (retval != ERROR_OK) {
 			free(buffer);
 			break;
 		}
@@ -5390,28 +5040,22 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 		uint32_t offset = 0;
 		uint32_t length = buf_cnt;
 
-
 		/* DANGER!!! beware of unsigned comparision here!!! */
 
-		if ((image.sections[i].base_address + buf_cnt >= min_address)&&
-				(image.sections[i].base_address < max_address))
-		{
-			if (image.sections[i].base_address < min_address)
-			{
+		if ((image.sections[i].base_address + buf_cnt >= min_address) &&
+				(image.sections[i].base_address < max_address)) {
+			if (image.sections[i].base_address < min_address) {
 				/* clip addresses below */
 				offset += min_address-image.sections[i].base_address;
 				length -= offset;
 			}
 
 			if (image.sections[i].base_address + buf_cnt > max_address)
-			{
 				length -= (image.sections[i].base_address + buf_cnt)-max_address;
-			}
 
 			fastload[i].address = image.sections[i].base_address + offset;
 			fastload[i].data = malloc(length);
-			if (fastload[i].data == NULL)
-			{
+			if (fastload[i].data == NULL) {
 				free(buffer);
 				command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
 							  length);
@@ -5430,8 +5074,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 		free(buffer);
 	}
 
-	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
-	{
+	if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
 		command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
 				"in %fs (%0.3f KiB/s)", image_size,
 				duration_elapsed(&bench), duration_kbps(&bench, image_size));
@@ -5444,9 +5087,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	image_close(&image);
 
 	if (retval != ERROR_OK)
-	{
 		free_fastload();
-	}
 
 	return retval;
 }
@@ -5455,8 +5096,7 @@ COMMAND_HANDLER(handle_fast_load_command)
 {
 	if (CMD_ARGC > 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	if (fastload == NULL)
-	{
+	if (fastload == NULL) {
 		LOG_ERROR("No image in memory");
 		return ERROR_FAIL;
 	}
@@ -5464,21 +5104,17 @@ COMMAND_HANDLER(handle_fast_load_command)
 	int ms = timeval_ms();
 	int size = 0;
 	int retval = ERROR_OK;
-	for (i = 0; i < fastload_num;i++)
-	{
+	for (i = 0; i < fastload_num; i++) {
 		struct target *target = get_current_target(CMD_CTX);
 		command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
 					  (unsigned int)(fastload[i].address),
 					  (unsigned int)(fastload[i].length));
 		retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
 		if (retval != ERROR_OK)
-		{
 			break;
-		}
 		size += fastload[i].length;
 	}
-	if (retval == ERROR_OK)
-	{
+	if (retval == ERROR_OK) {
 		int after = timeval_ms();
 		command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
 	}
@@ -5769,10 +5405,12 @@ static const struct command_registration target_exec_command_handlers[] = {
 static int target_register_user_commands(struct command_context *cmd_ctx)
 {
 	int retval = ERROR_OK;
-	if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
+	retval = target_request_register_commands(cmd_ctx);
+	if (retval != ERROR_OK)
 		return retval;
 
-	if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
+	retval = trace_register_commands(cmd_ctx);
+	if (retval != ERROR_OK)
 		return retval;