openocd-commit

[Zach W. <zw...@us...>]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Main OpenOCD repository".

The branch, master has been updated
       via  070259cadbb0f142f6546c55f8044199c6aea9b9 (commit)
       via  cb8d567b7524b96d034344a2027e33d7f44f48ec (commit)
       via  f8a62fb9c62f165696cc34eeb23b2bc1f6a79000 (commit)
       via  7124be824792eee3f973eb2cf7e1c851cbd2a923 (commit)
       via  4ff5eda576d75ee57ba448d2136867c791d215a8 (commit)
       via  0377e5b54d6db196cfeeaaa70824c581317e2290 (commit)
       via  c4992c6d863d0ead91d84d19bbfe1643d720b205 (commit)
      from  2da2864632c281a2523f924b406e532d610857a6 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 070259cadbb0f142f6546c55f8044199c6aea9b9
Author: Zachary T Welch <zw...@su...>
Date:   Wed Nov 25 16:36:46 2009 -0800

    explode tcl_target_func into many handlers
    
    Eliminate the monolithic tcl_target_func by registering each of its
    commands using the new chained command registration mechanism.
    
    Also chains the target's commands under the CPU command, though these
    may not work properly without some further modification.

diff --git a/src/target/target.c b/src/target/target.c
index d9552a5..3a84040 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -3366,7 +3366,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc,
 	 * argv[4] = count to write
 	 */
 	if (argc != 4) {
-		Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
+		Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
 		return JIM_ERR;
 	}
 	varname = Jim_GetString(argv[0], &len);
@@ -3849,422 +3849,537 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 	return JIM_OK;
 }
 
-/** this is the 'tcl' handler for the target specific command */
-static int tcl_target_func(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_wide a,b,c;
-	int x,y,z;
-	uint8_t  target_buf[32];
-	Jim_Nvp *n;
-	struct target *target;
-	struct command_context *cmd_ctx;
-	int e;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+	goi.isconfigure = strcmp(Jim_GetString(argv[0], NULL), "configure") == 0;
+	int need_args = 1 + goi.isconfigure;
+	if (goi.argc < need_args)
+	{
+		Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
+			goi.isconfigure
+				? "missing: -option VALUE ..."
+				: "missing: -option ...");
+		return JIM_ERR;
+	}
+	struct target *target = Jim_CmdPrivData(goi.interp);
+	return target_configure(&goi, target);
+}
 
-	enum {
-		TS_CMD_CONFIGURE,
-		TS_CMD_CGET,
-
-		TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
-		TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
-		TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
-		TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
-		TS_CMD_EXAMINE,
-		TS_CMD_POLL,
-		TS_CMD_RESET,
-		TS_CMD_HALT,
-		TS_CMD_WAITSTATE,
-		TS_CMD_EVENTLIST,
-		TS_CMD_CURSTATE,
-		TS_CMD_INVOKE_EVENT,
-	};
+static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	const char *cmd_name = Jim_GetString(argv[0], NULL);
 
-	static const Jim_Nvp target_options[] = {
-		{ .name = "configure", .value = TS_CMD_CONFIGURE },
-		{ .name = "cget", .value = TS_CMD_CGET },
-		{ .name = "mww", .value = TS_CMD_MWW },
-		{ .name = "mwh", .value = TS_CMD_MWH },
-		{ .name = "mwb", .value = TS_CMD_MWB },
-		{ .name = "mdw", .value = TS_CMD_MDW },
-		{ .name = "mdh", .value = TS_CMD_MDH },
-		{ .name = "mdb", .value = TS_CMD_MDB },
-		{ .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
-		{ .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
-		{ .name = "eventlist", .value = TS_CMD_EVENTLIST },
-		{ .name = "curstate",  .value = TS_CMD_CURSTATE },
-
-		{ .name = "arp_examine", .value = TS_CMD_EXAMINE },
-		{ .name = "arp_poll", .value = TS_CMD_POLL },
-		{ .name = "arp_reset", .value = TS_CMD_RESET },
-		{ .name = "arp_halt", .value = TS_CMD_HALT },
-		{ .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
-		{ .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
-
-		{ .name = NULL, .value = -1 },
-	};
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-	/* go past the "command" */
-	Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+	if (goi.argc != 2 && goi.argc != 3)
+	{
+		Jim_SetResult_sprintf(goi.interp,
+				"usage: %s <address> <data> [<count>]", cmd_name);
+		return JIM_ERR;
+	}
 
-	target = Jim_CmdPrivData(goi.interp);
-	cmd_ctx = Jim_GetAssocData(goi.interp, "context");
+	jim_wide a;
+	int e = Jim_GetOpt_Wide(&goi, &a);
+	if (e != JIM_OK)
+		return e;
 
-	/* commands here are in an NVP table */
-	e = Jim_GetOpt_Nvp(&goi, target_options, &n);
-	if (e != JIM_OK) {
-		Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
+	jim_wide b;
+	e = Jim_GetOpt_Wide(&goi, &b);
+	if (e != JIM_OK)
 		return e;
+
+	jim_wide c = 1;
+	if (goi.argc == 3)
+	{
+		e = Jim_GetOpt_Wide(&goi, &c);
+		if (e != JIM_OK)
+			return e;
 	}
-	/* Assume blank result */
-	Jim_SetEmptyResult(goi.interp);
 
-	switch (n->value) {
-	case TS_CMD_CONFIGURE:
-		if (goi.argc < 2) {
-			Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
-			return JIM_ERR;
-		}
-		goi.isconfigure = 1;
-		return target_configure(&goi, target);
-	case TS_CMD_CGET:
-		// some things take params
-		if (goi.argc < 1) {
-			Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
-			return JIM_ERR;
-		}
-		goi.isconfigure = 0;
-		return target_configure(&goi, target);
-		break;
-	case TS_CMD_MWW:
-	case TS_CMD_MWH:
-	case TS_CMD_MWB:
-		/* argv[0] = cmd
-		 * argv[1] = address
-		 * argv[2] = data
-		 * argv[3] = optional count.
-		 */
+	struct target *target = Jim_CmdPrivData(goi.interp);
+	uint8_t  target_buf[32];
+	if (strcasecmp(cmd_name, "mww") == 0) {
+		target_buffer_set_u32(target, target_buf, b);
+		b = 4;
+	}
+	else if (strcasecmp(cmd_name, "mwh") == 0) {
+		target_buffer_set_u16(target, target_buf, b);
+		b = 2;
+	}
+	else if (strcasecmp(cmd_name, "mwb") == 0) {
+		target_buffer_set_u8(target, target_buf, b);
+		b = 1;
+	} else {
+		LOG_ERROR("command '%s' unknown: ", cmd_name);
+		return JIM_ERR;
+	}
 
-		if ((goi.argc == 2) || (goi.argc == 3)) {
-			/* all is well */
-		} else {
-		mwx_error:
-			Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
+	for (jim_wide x = 0; x < c; x++)
+	{
+		e = target_write_memory(target, a, b, 1, target_buf);
+		if (e != ERROR_OK)
+		{
+			Jim_SetResult_sprintf(interp,
+					"Error writing @ 0x%08x: %d\n", (int)(a), e);
 			return JIM_ERR;
 		}
+		/* b = width */
+		a = a + b;
+	}
+	return JIM_OK;
+}
 
-		e = Jim_GetOpt_Wide(&goi, &a);
-		if (e != JIM_OK) {
-			goto mwx_error;
-		}
+static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	const char *cmd_name = Jim_GetString(argv[0], NULL);
 
-		e = Jim_GetOpt_Wide(&goi, &b);
-		if (e != JIM_OK) {
-			goto mwx_error;
-		}
-		if (goi.argc == 3) {
-			e = Jim_GetOpt_Wide(&goi, &c);
-			if (e != JIM_OK) {
-				goto mwx_error;
-			}
-		} else {
-			c = 1;
-		}
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
 
-		switch (n->value) {
-		case TS_CMD_MWW:
-			target_buffer_set_u32(target, target_buf, b);
-			b = 4;
-			break;
-		case TS_CMD_MWH:
-			target_buffer_set_u16(target, target_buf, b);
-			b = 2;
-			break;
-		case TS_CMD_MWB:
-			target_buffer_set_u8(target, target_buf, b);
-			b = 1;
-			break;
-		}
-		for (x = 0 ; x < c ; x++) {
-			e = target_write_memory(target, a, b, 1, target_buf);
-			if (e != ERROR_OK) {
-				Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
-				return JIM_ERR;
-			}
-			/* b = width */
-			a = a + b;
-		}
-		return JIM_OK;
-		break;
+	if ((goi.argc == 2) || (goi.argc == 3))
+	{
+		Jim_SetResult_sprintf(goi.interp,
+				"usage: %s <address> [<count>]", cmd_name);
+		return JIM_ERR;
+	}
 
-		/* display */
-	case TS_CMD_MDW:
-	case TS_CMD_MDH:
-	case TS_CMD_MDB:
-		/* argv[0] = command
-		 * argv[1] = address
-		 * argv[2] = optional count
-		 */
-		if ((goi.argc == 2) || (goi.argc == 3)) {
-			Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
-			return JIM_ERR;
-		}
-		e = Jim_GetOpt_Wide(&goi, &a);
+	jim_wide a;
+	int e = Jim_GetOpt_Wide(&goi, &a);
+	if (e != JIM_OK) {
+		return JIM_ERR;
+	}
+	jim_wide c;
+	if (goi.argc) {
+		e = Jim_GetOpt_Wide(&goi, &c);
 		if (e != JIM_OK) {
 			return JIM_ERR;
 		}
-		if (goi.argc) {
-			e = Jim_GetOpt_Wide(&goi, &c);
-			if (e != JIM_OK) {
-				return JIM_ERR;
-			}
-		} else {
-			c = 1;
+	} else {
+		c = 1;
+	}
+	jim_wide b = 1; /* shut up gcc */
+	if (strcasecmp(cmd_name, "mdw") == 0)
+		b = 4;
+	else if (strcasecmp(cmd_name, "mdh") == 0)
+		b = 2;
+	else if (strcasecmp(cmd_name, "mdb") == 0)
+		b = 1;
+	else {
+		LOG_ERROR("command '%s' unknown: ", cmd_name);
+		return JIM_ERR;
+	}
+
+	/* convert count to "bytes" */
+	c = c * b;
+
+	struct target *target = Jim_CmdPrivData(goi.interp);
+	uint8_t  target_buf[32];
+	jim_wide x, y, z;
+	while (c > 0) {
+		y = c;
+		if (y > 16) {
+			y = 16;
 		}
-		b = 1; /* shut up gcc */
-		switch (n->value) {
-		case TS_CMD_MDW:
-			b =  4;
-			break;
-		case TS_CMD_MDH:
-			b = 2;
-			break;
-		case TS_CMD_MDB:
-			b = 1;
-			break;
+		e = target_read_memory(target, a, b, y / b, target_buf);
+		if (e != ERROR_OK) {
+			Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
+			return JIM_ERR;
 		}
 
-		/* convert to "bytes" */
-		c = c * b;
-		/* count is now in 'BYTES' */
-		while (c > 0) {
-			y = c;
-			if (y > 16) {
-				y = 16;
+		Jim_fprintf(interp, interp->cookie_stdout, "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 * 4 ]));
+				Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
 			}
-			e = target_read_memory(target, a, b, y / b, target_buf);
-			if (e != ERROR_OK) {
-				Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a));
-				return JIM_ERR;
+			for (; (x < 16) ; x += 4) {
+				Jim_fprintf(interp, interp->cookie_stdout, "         ");
 			}
-
-			Jim_fprintf(interp, interp->cookie_stdout, "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 * 4 ]));
-					Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
-				}
-				for (; (x < 16) ; x += 4) {
-					Jim_fprintf(interp, interp->cookie_stdout, "         ");
-				}
-				break;
-			case 2:
-				for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
-					z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
-					Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
-				}
-				for (; (x < 16) ; x += 2) {
-					Jim_fprintf(interp, interp->cookie_stdout, "     ");
-				}
-				break;
-			case 1:
-			default:
-				for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
-					z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
-					Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
-				}
-				for (; (x < 16) ; x += 1) {
-					Jim_fprintf(interp, interp->cookie_stdout, "   ");
-				}
-				break;
+			break;
+		case 2:
+			for (x = 0; x < 16 && x < y; x += 2)
+			{
+				z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
+				Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
 			}
-			/* ascii-ify the bytes */
-			for (x = 0 ; x < y ; x++) {
-				if ((target_buf[x] >= 0x20) &&
-					(target_buf[x] <= 0x7e)) {
-					/* good */
-				} else {
-					/* smack it */
-					target_buf[x] = '.';
-				}
+			for (; (x < 16) ; x += 2) {
+				Jim_fprintf(interp, interp->cookie_stdout, "     ");
 			}
-			/* space pad  */
-			while (x < 16) {
-				target_buf[x] = ' ';
-				x++;
+			break;
+		case 1:
+		default:
+			for (x = 0 ; (x < 16) && (x < y) ; x += 1) {
+				z = target_buffer_get_u8(target, &(target_buf[ x * 4 ]));
+				Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z));
 			}
-			/* terminate */
-			target_buf[16] = 0;
-			/* print - with a newline */
-			Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
-			/* NEXT... */
-			c -= 16;
-			a += 16;
-		}
-		return JIM_OK;
-	case TS_CMD_MEM2ARRAY:
-		return target_mem2array(goi.interp, target, goi.argc, goi.argv);
-		break;
-	case TS_CMD_ARRAY2MEM:
-		return target_array2mem(goi.interp, target, goi.argc, goi.argv);
-		break;
-	case TS_CMD_EXAMINE:
-		if (goi.argc) {
-			Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
-			return JIM_ERR;
-		}
-		if (!target->tap->enabled)
-			goto err_tap_disabled;
-		e = target->type->examine(target);
-		if (e != ERROR_OK) {
-			Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
-			return JIM_ERR;
-		}
-		return JIM_OK;
-	case TS_CMD_POLL:
-		if (goi.argc) {
-			Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
-			return JIM_ERR;
-		}
-		if (!target->tap->enabled)
-			goto err_tap_disabled;
-		if (!(target_was_examined(target))) {
-			e = ERROR_TARGET_NOT_EXAMINED;
-		} else {
-			e = target->type->poll(target);
-		}
-		if (e != ERROR_OK) {
-			Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
-			return JIM_ERR;
-		} else {
-			return JIM_OK;
-		}
-		break;
-	case TS_CMD_RESET:
-		if (goi.argc != 2) {
-			Jim_WrongNumArgs(interp, 2, argv,
-					"([tT]|[fF]|assert|deassert) BOOL");
-			return JIM_ERR;
-		}
-		e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
-		if (e != JIM_OK) {
-			Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
-			return e;
-		}
-		/* the halt or not param */
-		e = Jim_GetOpt_Wide(&goi, &a);
-		if (e != JIM_OK) {
-			return e;
-		}
-		if (!target->tap->enabled)
-			goto err_tap_disabled;
-		if (!target->type->assert_reset
-				|| !target->type->deassert_reset) {
-			Jim_SetResult_sprintf(interp,
-					"No target-specific reset for %s",
-					target_name(target));
-			return JIM_ERR;
-		}
-		/* determine if we should halt or not. */
-		target->reset_halt = !!a;
-		/* When this happens - all workareas are invalid. */
-		target_free_all_working_areas_restore(target, 0);
-
-		/* do the assert */
-		if (n->value == NVP_ASSERT) {
-			e = target->type->assert_reset(target);
-		} else {
-			e = target->type->deassert_reset(target);
-		}
-		return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
-	case TS_CMD_HALT:
-		if (goi.argc) {
-			Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
-			return JIM_ERR;
-		}
-		if (!target->tap->enabled)
-			goto err_tap_disabled;
-		e = target->type->halt(target);
-		return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
-	case TS_CMD_WAITSTATE:
-		/* params:  <name>  statename timeoutmsecs */
-		if (goi.argc != 2) {
-			Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
-			return JIM_ERR;
-		}
-		e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
-		if (e != JIM_OK) {
-			Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
-			return e;
-		}
-		e = Jim_GetOpt_Wide(&goi, &a);
-		if (e != JIM_OK) {
-			return e;
-		}
-		if (!target->tap->enabled)
-			goto err_tap_disabled;
-		e = target_wait_state(target, n->value, a);
-		if (e != ERROR_OK) {
-			Jim_SetResult_sprintf(goi.interp,
-					"target: %s wait %s fails (%d) %s",
-					target_name(target), n->name,
-					e, target_strerror_safe(e));
-			return JIM_ERR;
-		} else {
-			return JIM_OK;
-		}
-	case TS_CMD_EVENTLIST:
-		/* List for human, Events defined for this target.
-		 * scripts/programs should use 'name cget -event NAME'
-		 */
-		{
-			struct target_event_action *teap;
-			teap = target->event_action;
-			command_print(cmd_ctx,
-					"Event actions for target (%d) %s\n",
-					target->target_number,
-					target_name(target));
-			command_print(cmd_ctx, "%-25s | Body", "Event");
-			command_print(cmd_ctx, "------------------------- | ----------------------------------------");
-			while (teap) {
-				command_print(cmd_ctx,
-							   "%-25s | %s",
-							   Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
-							   Jim_GetString(teap->body, NULL));
-				teap = teap->next;
+			for (; (x < 16) ; x += 1) {
+				Jim_fprintf(interp, interp->cookie_stdout, "   ");
 			}
-			command_print(cmd_ctx, "***END***");
-			return JIM_OK;
-		}
-	case TS_CMD_CURSTATE:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
-			return JIM_ERR;
+			break;
 		}
-		Jim_SetResultString(goi.interp,
-							target_state_name( target ),
-							-1);
-		return JIM_OK;
-	case TS_CMD_INVOKE_EVENT:
-		if (goi.argc != 1) {
-			Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
-			return JIM_ERR;
+		/* ascii-ify the bytes */
+		for (x = 0 ; x < y ; x++) {
+			if ((target_buf[x] >= 0x20) &&
+				(target_buf[x] <= 0x7e)) {
+				/* good */
+			} else {
+				/* smack it */
+				target_buf[x] = '.';
+			}
 		}
-		e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
-		if (e != JIM_OK) {
-			Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
-			return e;
+		/* space pad  */
+		while (x < 16) {
+			target_buf[x] = ' ';
+			x++;
 		}
-		target_handle_event(target, n->value);
-		return JIM_OK;
+		/* terminate */
+		target_buf[16] = 0;
+		/* print - with a newline */
+		Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf);
+		/* NEXT... */
+		c -= 16;
+		a += 16;
 	}
-	return JIM_ERR;
+	return JIM_OK;
+}
+
+static int jim_target_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	struct target *target = Jim_CmdPrivData(interp);
+	return target_mem2array(interp, target, argc - 1, argv + 1);
+}
+
+static int jim_target_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	struct target *target = Jim_CmdPrivData(interp);
+	return target_array2mem(interp, target, argc - 1, argv + 1);
+}
 
-err_tap_disabled:
+static int jim_target_tap_disabled(Jim_Interp *interp)
+{
 	Jim_SetResult_sprintf(interp, "[TAP is disabled]");
 	return JIM_ERR;
 }
 
+static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+		return JIM_ERR;
+	}
+	struct target *target = Jim_CmdPrivData(interp);
+	if (!target->tap->enabled)
+		return jim_target_tap_disabled(interp);
+
+	int e = target->type->examine(target);
+	if (e != ERROR_OK)
+	{
+		Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
+		return JIM_ERR;
+	}
+	return JIM_OK;
+}
+
+static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+		return JIM_ERR;
+	}
+	struct target *target = Jim_CmdPrivData(interp);
+	if (!target->tap->enabled)
+		return jim_target_tap_disabled(interp);
+
+	int e;
+	if (!(target_was_examined(target))) {
+		e = ERROR_TARGET_NOT_EXAMINED;
+	} else {
+		e = target->type->poll(target);
+	}
+	if (e != ERROR_OK)
+	{
+		Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
+		return JIM_ERR;
+	}
+	return JIM_OK;
+}
+
+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)
+	{
+		Jim_WrongNumArgs(interp, 0, argv,
+				"([tT]|[fF]|assert|deassert) BOOL");
+		return JIM_ERR;
+	}
+
+	Jim_Nvp *n;
+	int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
+	if (e != JIM_OK)
+	{
+		Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
+		return e;
+	}
+	/* the halt or not param */
+	jim_wide a;
+	e = Jim_GetOpt_Wide(&goi, &a);
+	if (e != JIM_OK)
+		return e;
+
+	struct target *target = Jim_CmdPrivData(goi.interp);
+	if (!target->tap->enabled)
+		return jim_target_tap_disabled(interp);
+	if (!target->type->assert_reset || !target->type->deassert_reset)
+	{
+		Jim_SetResult_sprintf(interp,
+				"No target-specific reset for %s",
+				target_name(target));
+		return JIM_ERR;
+	}
+	/* determine if we should halt or not. */
+	target->reset_halt = !!a;
+	/* When this happens - all workareas are invalid. */
+	target_free_all_working_areas_restore(target, 0);
+
+	/* do the assert */
+	if (n->value == NVP_ASSERT) {
+		e = target->type->assert_reset(target);
+	} else {
+		e = target->type->deassert_reset(target);
+	}
+	return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
+}
+
+static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1) {
+		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+		return JIM_ERR;
+	}
+	struct target *target = Jim_CmdPrivData(interp);
+	if (!target->tap->enabled)
+		return jim_target_tap_disabled(interp);
+	int e = target->type->halt(target);
+	return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
+}
+
+static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+
+	/* params:  <name>  statename timeoutmsecs */
+	if (goi.argc != 2)
+	{
+		const char *cmd_name = Jim_GetString(argv[0], NULL);
+		Jim_SetResult_sprintf(goi.interp,
+				"%s <state_name> <timeout_in_msec>", cmd_name);
+		return JIM_ERR;
+	}
+
+	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);
+		return e;
+	}
+	jim_wide a;
+	e = Jim_GetOpt_Wide(&goi, &a);
+	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)
+	{
+		Jim_SetResult_sprintf(goi.interp,
+				"target: %s wait %s fails (%d) %s",
+				target_name(target), n->name,
+				e, target_strerror_safe(e));
+		return JIM_ERR;
+	}
+	return JIM_OK;
+}
+/* List for human, Events defined for this target.
+ * scripts/programs should use 'name cget -event NAME'
+ */
+static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+	struct target *target = Jim_CmdPrivData(interp);
+	struct target_event_action *teap = target->event_action;
+	command_print(cmd_ctx, "Event actions for target (%d) %s\n",
+				   target->target_number,
+				   target_name(target));
+	command_print(cmd_ctx, "%-25s | Body", "Event");
+	command_print(cmd_ctx, "------------------------- | "
+			"----------------------------------------");
+	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));
+		teap = teap->next;
+	}
+	command_print(cmd_ctx, "***END***");
+	return JIM_OK;
+}
+static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
+		return JIM_ERR;
+	}
+	struct target *target = Jim_CmdPrivData(interp);
+	Jim_SetResultString(interp, target_state_name(target), -1);
+	return JIM_OK;
+}
+static int jim_target_invoke_event(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)
+	{
+		const char *cmd_name = Jim_GetString(argv[0], NULL);
+		Jim_SetResult_sprintf(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)
+	{
+		Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
+		return e;
+	}
+	struct target *target = Jim_CmdPrivData(interp);
+	target_handle_event(target, n->value);
+	return JIM_OK;
+}
+
+static const struct command_registration target_instance_command_handlers[] = {
+	{
+		.name = "configure",
+		.mode = COMMAND_CONFIG,
+		.jim_handler = &jim_target_configure,
+		.usage = "[<target_options> ...]",
+		.help  = "configure a new target for use",
+	},
+	{
+		.name = "cget",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_configure,
+		.usage = "<target_type> [<target_options> ...]",
+		.help  = "configure a new target for use",
+	},
+	{
+		.name = "mww",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_mw,
+		.usage = "<address> <data> [<count>]",
+		.help = "Write 32-bit word(s) to target memory",
+	},
+	{
+		.name = "mwh",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_mw,
+		.usage = "<address> <data> [<count>]",
+		.help = "Write 16-bit half-word(s) to target memory",
+	},
+	{
+		.name = "mwb",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_mw,
+		.usage = "<address> <data> [<count>]",
+		.help = "Write byte(s) to target memory",
+	},
+	{
+		.name = "mdw",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_md,
+		.usage = "<address> [<count>]",
+		.help = "Display target memory as 32-bit words",
+	},
+	{
+		.name = "mdh",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_md,
+		.usage = "<address> [<count>]",
+		.help = "Display target memory as 16-bit half-words",
+	},
+	{
+		.name = "mdb",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_md,
+		.usage = "<address> [<count>]",
+		.help = "Display target memory as 8-bit bytes",
+	},
+	{
+		.name = "array2mem",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_array2mem,
+	},
+	{
+		.name = "mem2array",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_mem2array,
+	},
+	{
+		.name = "eventlist",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_event_list,
+	},
+	{
+		.name = "curstate",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_current_state,
+	},
+	{
+		.name = "arp_examine",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_examine,
+	},
+	{
+		.name = "arp_poll",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_poll,
+	},
+	{
+		.name = "arp_reset",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_reset,
+	},
+	{
+		.name = "arp_halt",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_halt,
+	},
+	{
+		.name = "arp_waitstate",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_wait_state,
+	},
+	{
+		.name = "invoke-event",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_target_invoke_event,
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 static int target_create(Jim_GetOptInfo *goi)
 {
 	Jim_Obj *new_cmd;
@@ -4412,16 +4527,35 @@ static int target_create(Jim_GetOptInfo *goi)
 		}
 		*tpp = target;
 	}
-
+	
 	/* now - create the new target name command */
-	const struct command_registration target_command = {
-		.name = cp,
-		.jim_handler = &tcl_target_func,
-		.jim_handler_data = target,
-		.help = "target command group",
+	const const struct command_registration target_subcommands[] = {
+		{
+			.chain = target_instance_command_handlers,
+		},
+		{
+			.chain = target->type->commands,
+		},
+		COMMAND_REGISTRATION_DONE
 	};
-	struct command *c = register_command(cmd_ctx, NULL, &target_command);
-	return (NULL != c) ? ERROR_OK : ERROR_FAIL;
+	const const struct command_registration target_commands[] = {
+		{
+			.name = cp,
+			.mode = COMMAND_ANY,
+			.help = "target command group",
+			.chain = target_subcommands,
+		},
+		COMMAND_REGISTRATION_DONE
+	};
+	e = register_commands(cmd_ctx, NULL, target_commands);
+	if (ERROR_OK != e)
+		return JIM_ERR;
+
+	struct command *c = command_find_in_context(cmd_ctx, cp);
+	assert(c);
+	command_set_handler_data(c, target);
+
+	return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
 }
 
 static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)

commit cb8d567b7524b96d034344a2027e33d7f44f48ec
Author: Zachary T Welch <zw...@su...>
Date:   Wed Nov 25 12:57:28 2009 -0800

    split jim_target into multiple handlers
    
    The 'target' command group was implemented using its own command
    dispatching, which can be eliminated by using the new chained command
    registration mechanism.  This patch splits the jim_target() function
    into individual handlers, which makes them to be visible to the help and
    usage commands.  These one-trick handlers are much easier to understand.

diff --git a/src/target/target.c b/src/target/target.c
index 28387f4..d9552a5 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -4424,129 +4424,156 @@ static int target_create(Jim_GetOptInfo *goi)
 	return (NULL != c) ? ERROR_OK : ERROR_FAIL;
 }
 
-static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	int x,r,e;
-	jim_wide w;
-	struct command_context *cmd_ctx;
-	struct target *target;
-	Jim_GetOptInfo goi;
-	enum tcmd {
-		/* TG = target generic */
-		TG_CMD_CREATE,
-		TG_CMD_TYPES,
-		TG_CMD_NAMES,
-		TG_CMD_CURRENT,
-		TG_CMD_NUMBER,
-		TG_CMD_COUNT,
-	};
-	const char *target_cmds[] = {
-		"create", "types", "names", "current", "number",
-		"count",
-		NULL /* terminate */
-	};
-
-	LOG_DEBUG("Target command params:");
-	LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
-
-	cmd_ctx = Jim_GetAssocData(interp, "context");
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
+		return JIM_ERR;
+	}
+	struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
+	return JIM_OK;
+}
 
-	Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	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++)
+	{
+		Jim_ListAppendElement(interp, Jim_GetResult(interp),
+			Jim_NewStringObj(interp, target_types[x]->name, -1));
+	}
+	return JIM_OK;
+}
 
-	if (goi.argc == 0) {
-		Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
+static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	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)
+	{
+		Jim_ListAppendElement(interp, Jim_GetResult(interp),
+			Jim_NewStringObj(interp, target_name(target), -1));
+		target = target->next;
+	}
+	return JIM_OK;
+}
 
-	/* Jim_GetOpt_Debug(&goi); */
-	r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
-	if (r != JIM_OK) {
-		return r;
+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)
+	{
+		Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
+			"<name> <target_type> [<target_options> ...]");
+		return JIM_ERR;
 	}
+	return target_create(&goi);
+}
 
-	switch (x) {
-	default:
-		Jim_Panic(goi.interp,"Why am I here?");
+static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+
+	/* 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)
+	{
+		Jim_SetResult_sprintf(goi.interp, "usage: target number <number>");
 		return JIM_ERR;
-	case TG_CMD_CURRENT:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResultString(goi.interp,
-				target_name(get_current_target(cmd_ctx)),
-				-1);
-		return JIM_OK;
-	case TG_CMD_TYPES:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
-		for (x = 0 ; target_types[x] ; x++) {
-			Jim_ListAppendElement(goi.interp,
-								   Jim_GetResult(goi.interp),
-								   Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
-		}
-		return JIM_OK;
-	case TG_CMD_NAMES:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
-		target = all_targets;
-		while (target) {
-			Jim_ListAppendElement(goi.interp,
-					Jim_GetResult(goi.interp),
-					Jim_NewStringObj(goi.interp,
-						target_name(target), -1));
-			target = target->next;
-		}
-		return JIM_OK;
-	case TG_CMD_CREATE:
-		if (goi.argc < 3) {
-			Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name  ... config options ...");
-			return JIM_ERR;
-		}
-		return target_create(&goi);
-		break;
-	case TG_CMD_NUMBER:
-		/* 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) {
-			Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
-			return JIM_ERR;
-		}
-		e = Jim_GetOpt_Wide(&goi, &w);
-		if (e != JIM_OK) {
-			return JIM_ERR;
-		}
-		for (x = 0, target = all_targets; target; target = target->next, x++) {
-			if (target->target_number == w)
-				break;
-		}
-		if (target == NULL) {
-			Jim_SetResult_sprintf(goi.interp,
-					"Target: number %d does not exist", (int)(w));
-			return JIM_ERR;
-		}
-		Jim_SetResultString(goi.interp, target_name(target), -1);
-		return JIM_OK;
-	case TG_CMD_COUNT:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
-			return JIM_ERR;
-		}
-		for (x = 0, target = all_targets; target; target = target->next, x++)
+	}
+	jim_wide w;
+	int e = Jim_GetOpt_Wide(&goi, &w);
+	if (e != JIM_OK)
+		return JIM_ERR;
+
+	struct target *target;
+	for (target = all_targets; NULL != target; target = target->next)
+	{
+		if (target->target_number != w)
 			continue;
-		Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
+
+		Jim_SetResultString(goi.interp, target_name(target), -1);
 		return JIM_OK;
 	}
-
+	Jim_SetResult_sprintf(goi.interp,
+			"Target: number %d does not exist", (int)(w));
 	return JIM_ERR;
 }
 
+static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
+		return JIM_ERR;
+	}
+	unsigned count = 0;
+	struct target *target = all_targets;
+	while (NULL != target)
+	{
+		target = target->next;
+		count++;
+	}
+	Jim_SetResult(interp, Jim_NewIntObj(interp, count));
+	return JIM_OK;
+}
+
+static const struct command_registration target_subcommand_handlers[] = {
+	{
+		.name = "create",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_create,
+		.usage = "<name> <type> ...",
+		.help = "Returns the currently selected target",
+	},
+	{
+		.name = "current",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_current,
+		.help = "Returns the currently selected target",
+	},
+	{
+		.name = "types",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_types,
+		.help = "Returns the available target types as a list of strings",
+	},
+	{
+		.name = "names",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_names,
+		.help = "Returns the names of all targets as a list of strings",
+	},
+	{
+		.name = "number",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_number,
+		.usage = "<number>",
+		.help = "Returns the name of target <n>",
+	},
+	{
+		.name = "count",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_count,
+		.help = "Returns the number of targets as an integer",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 
 struct FastLoad
 {
@@ -4816,8 +4843,9 @@ static const struct command_registration target_command_handlers[] = {
 	{
 		.name = "target",
 		.mode = COMMAND_CONFIG,
-		.jim_handler = &jim_target,
 		.help = "configure target",
+
+		.chain = target_subcommand_handlers,
 	},
 	COMMAND_REGISTRATION_DONE
 };

commit f8a62fb9c62f165696cc34eeb23b2bc1f6a79000
Author: Zachary T Welch <zw...@su...>
Date:   Thu Nov 26 14:04:02 2009 -0800

    split jim_newtap_cmd into pieces
    
    Moves the ID and IR-related option parsing to static helpers, removing
    two levels of indent.

diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index bb86a32..7ec7fa4 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -406,26 +406,106 @@ static int is_bad_irval(int ir_length, jim_wide w)
 	return (w & v) != 0;
 }
 
+static int jim_newtap_expected_id(Jim_Nvp *n, Jim_GetOptInfo *goi,
+		struct jtag_tap *pTap)
+{
+	jim_wide w;
+	int e = Jim_GetOpt_Wide(goi, &w);
+	if (e != JIM_OK) {
+		Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
+		return e;
+	}
+
+	unsigned expected_len = sizeof(uint32_t) * pTap->expected_ids_cnt;
+	uint32_t *new_expected_ids = malloc(expected_len + sizeof(uint32_t));
+	if (new_expected_ids == NULL)
+	{
+		Jim_SetResult_sprintf(goi->interp, "no memory");
+		return JIM_ERR;
+	}
+
+	memcpy(new_expected_ids, pTap->expected_ids, expected_len);
+
+	new_expected_ids[pTap->expected_ids_cnt] = w;
+
+	free(pTap->expected_ids);
+	pTap->expected_ids = new_expected_ids;
+	pTap->expected_ids_cnt++;
+
+	return JIM_OK;
+}
+
+#define NTAP_OPT_IRLEN     0
+#define NTAP_OPT_IRMASK    1
+#define NTAP_OPT_IRCAPTURE 2
+#define NTAP_OPT_ENABLED   3
+#define NTAP_OPT_DISABLED  4
+#define NTAP_OPT_EXPECTED_ID 5
+
+static int jim_newtap_ir_param(Jim_Nvp *n, Jim_GetOptInfo *goi,
+		struct jtag_tap *pTap)
+{
+	jim_wide w;
+	int e = Jim_GetOpt_Wide(goi, &w);
+	if (e != JIM_OK)
+	{
+		Jim_SetResult_sprintf(goi->interp,
+				"option: %s bad parameter", n->name);
+		free((void *)pTap->dotted_name);
+		return e;
+	}
+	switch (n->value) {
+	case NTAP_OPT_IRLEN:
+		if (w > (jim_wide) (8 * sizeof(pTap->ir_capture_value)))
+		{
+			LOG_WARNING("%s: huge IR length %d",
+					pTap->dotted_name, (int) w);
+		}
+		pTap->ir_length = w;
+		break;
+	case NTAP_OPT_IRMASK:
+		if (is_bad_irval(pTap->ir_length, w))
+		{
+			LOG_ERROR("%s: IR mask %x too big",
+					pTap->dotted_name,
+					(int) w);
+			return JIM_ERR;
+		}
+		if ((w & 3) != 3)
+			LOG_WARNING("%s: nonstandard IR mask", pTap->dotted_name);
+		pTap->ir_capture_mask = w;
+		break;
+	case NTAP_OPT_IRCAPTURE:
+		if (is_bad_irval(pTap->ir_length, w))
+		{
+			LOG_ERROR("%s: IR capture %x too big",
+					pTap->dotted_name, (int) w);
+			return JIM_ERR;
+		}
+		if ((w & 3) != 1)
+			LOG_WARNING("%s: nonstandard IR value",
+					pTap->dotted_name);
+		pTap->ir_capture_value = w;
+		break;
+	default:
+		return JIM_ERR;
+	}
+	return JIM_OK;
+}
+
 static int jim_newtap_cmd(Jim_GetOptInfo *goi)
 {
 	struct jtag_tap *pTap;
-	jim_wide w;
 	int x;
 	int e;
 	Jim_Nvp *n;
 	char *cp;
 	const Jim_Nvp opts[] = {
-#define NTAP_OPT_IRLEN     0
 		{ .name = "-irlen"			,	.value = NTAP_OPT_IRLEN },
-#define NTAP_OPT_IRMASK    1
 		{ .name = "-irmask"			,	.value = NTAP_OPT_IRMASK },
-#define NTAP_OPT_IRCAPTURE 2
 		{ .name = "-ircapture"		,	.value = NTAP_OPT_IRCAPTURE },
-#define NTAP_OPT_ENABLED   3
 		{ .name = "-enable"			,	.value = NTAP_OPT_ENABLED },
-#define NTAP_OPT_DISABLED  4
 		{ .name = "-disable"		,	.value = NTAP_OPT_DISABLED },
-#define NTAP_OPT_EXPECTED_ID 5
 		{ .name = "-expected-id"	,	.value = NTAP_OPT_EXPECTED_ID },
 		{ .name = NULL				,	.value = -1 },
 	};
@@ -483,81 +563,25 @@ static int jim_newtap_cmd(Jim_GetOptInfo *goi)
 			pTap->disabled_after_reset = true;
 			break;
 		case NTAP_OPT_EXPECTED_ID:
-		{
-			uint32_t *new_expected_ids;
-
-			e = Jim_GetOpt_Wide(goi, &w);
-			if (e != JIM_OK) {
-				Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
+			e = jim_newtap_expected_id(n, goi, pTap);
+			if (JIM_OK != e)
+			{
 				free((void *)pTap->dotted_name);
 				free(pTap);
 				return e;
 			}
-
-			new_expected_ids = malloc(sizeof(uint32_t) * (pTap->expected_ids_cnt + 1));
-			if (new_expected_ids == NULL) {
-				Jim_SetResult_sprintf(goi->interp, "no memory");
-				free((void *)pTap->dotted_name);
-				free(pTap);
-				return JIM_ERR;
-			}
-
-			memcpy(new_expected_ids, pTap->expected_ids, sizeof(uint32_t) * pTap->expected_ids_cnt);
-
-			new_expected_ids[pTap->expected_ids_cnt] = w;
-
-			free(pTap->expected_ids);
-			pTap->expected_ids = new_expected_ids;
-			pTap->expected_ids_cnt++;
 			break;
-		}
 		case NTAP_OPT_IRLEN:
 		case NTAP_OPT_IRMASK:
 		case NTAP_OPT_IRCAPTURE:
-			e = Jim_GetOpt_Wide(goi, &w);
-			if (e != JIM_OK) {
-				Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
+			e = jim_newtap_ir_param(n, goi, pTap);
+			if (JIM_OK != e)
+			{
 				free((void *)pTap->dotted_name);
 				free(pTap);
 				return e;
 			}
-			switch (n->value) {
-			case NTAP_OPT_IRLEN:
-				if (w > (jim_wide) (8 * sizeof(pTap->ir_capture_value)))
-					LOG_WARNING("%s: huge IR length %d",
-							pTap->dotted_name,
-							(int) w);
-				pTap->ir_length = w;
-				break;
-			case NTAP_OPT_IRMASK:
-				if (is_bad_irval(pTap->ir_length, w)) {
-					LOG_ERROR("%s: IR mask %x too big",
-							pTap->dotted_name,
-							(int) w);
-					free((void *)pTap->dotted_name);
-					free(pTap);
-					return ERROR_FAIL;
-				}
-				if ((w & 3) != 3)
-					LOG_WARNING("%s: nonstandard IR mask",
-							pTap->dotted_name);
-				pTap->ir_capture_mask = w;
-				break;
-			case NTAP_OPT_IRCAPTURE:
-				if (is_bad_irval(pTap->ir_length, w)) {
-					LOG_ERROR("%s: IR capture %x too big",
-							pTap->dotted_name,
-							(int) w);
-					free((void *)pTap->dotted_name);
-					free(pTap);
-					return ERROR_FAIL;
-				}
-				if ((w & 3) != 1)
-					LOG_WARNING("%s: nonstandard IR value",
-							pTap->dotted_name);
-				pTap->ir_capture_value = w;
-				break;
-			}
+			break;
 		} /* switch (n->value) */
 	} /* while (goi->argc) */
 

commit 7124be824792eee3f973eb2cf7e1c851cbd2a923
Author: Zachary T Welch <zw...@su...>
Date:   Thu Nov 26 13:52:04 2009 -0800

    improve jtag_tap_configure
    
    Splits bulk of the jtag_tap_configure into jtag_tap_configure_event,
    removing three or four levels of indentation in the process.
    The resulting code was stylistically improved in other ways, but it
    should be functionally identical.

diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index 8371967..bb86a32 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -293,94 +293,105 @@ static Jim_Nvp nvp_config_opts[] = {
 	{ .name = NULL,          .value = -1 }
 };
 
-static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, struct jtag_tap * tap)
+static int jtag_tap_configure_event(Jim_GetOptInfo *goi, struct jtag_tap * tap)
 {
+	if (goi->argc == 0)
+	{
+		Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name> ...");
+		return JIM_ERR;
+	}
+
 	Jim_Nvp *n;
-	Jim_Obj *o;
-	int e;
+	int e = Jim_GetOpt_Nvp(goi, nvp_jtag_tap_event, &n);
+	if (e != JIM_OK)
+	{
+		Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
+		return e;
+	}
+
+	if (goi->isconfigure) {
+		if (goi->argc != 1) {
+			Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name> <event-body>");
+			return JIM_ERR;
+		}
+	} else {
+		if (goi->argc != 0) {
+			Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name>");
+			return JIM_ERR;
+		}
+	}
+
+	struct jtag_tap_event_action *jteap  = tap->event_action;
+	/* replace existing event body */
+	bool found = false;
+	while (jteap)
+	{
+		if (jteap->event == (enum jtag_event)n->value)
+		{
+			found = true;
+			break;
+		}
+		jteap = jteap->next;
+	}
+
+	Jim_SetEmptyResult(goi->interp);
+
+	if (goi->isconfigure)
+	{
+		if (!found)
+			jteap = calloc(1, sizeof(*jteap));
+		else if (NULL != jteap->body)
+			Jim_DecrRefCount(interp, jteap->body);
+
+		jteap->event = n->value;
+
+		Jim_Obj *o;
+		Jim_GetOpt_Obj(goi, &o);
+		jteap->body = Jim_DuplicateObj(goi->interp, o);
+		Jim_IncrRefCount(jteap->body);
+
+		if (!found)
+		{
+			/* add to head of event list */
+			jteap->next = tap->event_action;
+			tap->event_action = jteap;
+		}
+	}
+	else if (found)
+	{
+		Jim_SetResult(goi->interp,
+			Jim_DuplicateObj(goi->interp, jteap->body));
+	}
+	return JIM_OK;
+}
 
+static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, struct jtag_tap * tap)
+{
 	/* parse config or cget options */
-	while (goi->argc > 0) {
+	while (goi->argc > 0)
+	{
 		Jim_SetEmptyResult (goi->interp);
 
-		e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
-		if (e != JIM_OK) {
+		Jim_Nvp *n;
+		int e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
+		if (e != JIM_OK)
+		{
 			Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
 			return e;
 		}
 
-		switch (n->value) {
-			case JCFG_EVENT:
-				if (goi->argc == 0) {
-					Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
-					return JIM_ERR;
-				}
-
-				e = Jim_GetOpt_Nvp(goi, nvp_jtag_tap_event, &n);
-				if (e != JIM_OK) {
-					Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
-					return e;
-				}
-
-				if (goi->isconfigure) {
-					if (goi->argc != 1) {
-						Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
-						return JIM_ERR;
-					}
-				} else {
-					if (goi->argc != 0) {
-						Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
-						return JIM_ERR;
-					}
-				}
-
-				{
-					struct jtag_tap_event_action *jteap;
-
-					jteap = tap->event_action;
-					/* replace existing? */
-					while (jteap) {
-						if (jteap->event == (enum jtag_event)n->value) {
-							break;
-						}
-						jteap = jteap->next;
-					}
-
-					if (goi->isconfigure) {
-						bool replace = true;
-						if (jteap == NULL) {
-							/* create new */
-							jteap = calloc(1, sizeof (*jteap));
-							replace = false;
-						}
-						jteap->event = n->value;
-						Jim_GetOpt_Obj(goi, &o);
-						if (jteap->body) {
-							Jim_DecrRefCount(interp, jteap->body);
-						}
-						jteap->body = Jim_DuplicateObj(goi->interp, o);
-						Jim_IncrRefCount(jteap->body);
-
-						if (!replace)
-						{
-							/* add to head of event list */
-							jteap->next = tap->event_action;
-							tap->event_action = jteap;
-						}
-						Jim_SetEmptyResult(goi->interp);
-					} else {
-						/* get */
-						if (jteap == NULL) {
-							Jim_SetEmptyResult(goi->interp);
-						} else {
-							Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
-						}
-					}
-				}
-				/* loop for more */
-				break;
+		switch (n->value)
+		{
+		case JCFG_EVENT:
+			e = jtag_tap_configure_event(goi, tap);
+			if (e != JIM_OK)
+				return e;
+			break;
+		default:
+			Jim_SetResult_sprintf(goi->interp, "unknown event: %s", n->name);
+			return JIM_ERR;
 		}
-	} /* while (goi->argc) */
+	}
 
 	return JIM_OK;
 }

commit 4ff5eda576d75ee57ba448d2136867c791d215a8
Author: Zachary T Welch <zw...@su...>
Date:   Thu Nov 26 11:00:03 2009 -0800

    improve jtag_tap_handle_event indentation
    
    Use 'continue' to reduce identation levels and superfluous logic.

diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index 929c784..8371967 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -571,29 +571,36 @@ static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e)
 {
 	struct jtag_tap_event_action * jteap;
 
-	for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next) {
-		if (jteap->event == e) {
-			LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
-					tap->dotted_name,
-					e,
-					Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
-					Jim_GetString(jteap->body, NULL));
-			if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
-				Jim_PrintErrorMessage(interp);
-			} else switch (e) {
-			case JTAG_TAP_EVENT_ENABLE:
-			case JTAG_TAP_EVENT_DISABLE:
-				/* NOTE:  we currently assume the handlers
-				 * can't fail.  Right here is where we should
-				 * really be verifying the scan chains ...
-				 */
-				tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
-				LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
-					tap->enabled ? "enabled" : "disabled");
-				break;
-			default:
-				break;
-			}
+	for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next)
+	{
+		if (jteap->event != e)
+			continue;
+
+		Jim_Nvp *nvp = Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e);
+		LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
+				tap->dotted_name, e, nvp->name,
+				Jim_GetString(jteap->body, NULL));
+
+		if (Jim_EvalObj(interp, jteap->body) != JIM_OK)
+		{
+			Jim_PrintErrorMessage(interp);
+			continue;
+		}
+
+		switch (e)
+		{
+		case JTAG_TAP_EVENT_ENABLE:
+		case JTAG_TAP_EVENT_DISABLE:
+			/* NOTE:  we currently assume the handlers
+			 * can't fail.  Right here is where we should
+			 * really be verifying the scan chains ...
+			 */
+			tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
+			LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
+				tap->enabled ? "enabled" : "disabled");
+			break;
+		default:
+			break;
 		}
 	}
 }

commit 0377e5b54d6db196cfeeaaa70824c581317e2290
Author: Zachary T Welch <zw...@su...>
Date:   Thu Nov 26 08:19:40 2009 -0800

    begin moving JTAG jim handlers/helpers
    
    Moves the tertiary jim handlers and required static helpers to the top
    of tcl.c, defining them in a new registration array that is chained in
    both the top-level context and under the jtag command.  The top-level
    commands can be removed at some point in the future to reduce clutter.

diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index e7a0f67..929c784 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -51,6 +51,238 @@ static const Jim_Nvp nvp_jtag_tap_event[] = {
 
 extern struct jtag_interface *jtag_interface;
 
+static bool scan_is_safe(tap_state_t state)
+{
+	switch (state)
+	{
+	case TAP_RESET:
+	case TAP_IDLE:
+	case TAP_DRPAUSE:
+	case TAP_IRPAUSE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
+{
+	int retval;
+	struct scan_field *fields;
+	int num_fields;
+	int field_count = 0;
+	int i, e;
+	struct jtag_tap *tap;
+	tap_state_t endstate;
+
+	/* args[1] = device
+	 * args[2] = num_bits
+	 * args[3] = hex string
+	 * ... repeat num bits and hex string ...
+	 *
+	 * .. optionally:
+	*     args[N-2] = "-endstate"
+	 *     args[N-1] = statename
+	 */
+	if ((argc < 4) || ((argc % 2) != 0))
+	{
+		Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
+		return JIM_ERR;
+	}
+
+	endstate = TAP_IDLE;
+
+	script_debug(interp, "drscan", argc, args);
+
+	/* validate arguments as numbers */
+	e = JIM_OK;
+	for (i = 2; i < argc; i += 2)
+	{
+		long bits;
+		const char *cp;
+
+		e = Jim_GetLong(interp, args[i], &bits);
+		/* If valid - try next arg */
+		if (e == JIM_OK) {
+			continue;
+		}
+
+		/* Not valid.. are we at the end? */
+		if (((i + 2) != argc)) {
+			/* nope, then error */
+			return e;
+		}
+
+		/* it could be: "-endstate FOO"
+		 * e.g. DRPAUSE so we can issue more instructions
+		 * before entering RUN/IDLE and executing them.
+		 */
+
+		/* get arg as a string. */
+		cp = Jim_GetString(args[i], NULL);
+		/* is it the magic? */
+		if (0 == strcmp("-endstate", cp)) {
+			/* is the statename valid? */
+			cp = Jim_GetString(args[i + 1], NULL);
+
+			/* see if it is a valid state name */
+			endstate = tap_state_by_name(cp);
+			if (endstate < 0) {
+				/* update the error message */
+				Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
+			} else {
+				if (!scan_is_safe(endstate))
+					LOG_WARNING("drscan with unsafe "
+							"endstate \"%s\"", cp);
+
+				/* valid - so clear the error */
+				e = JIM_OK;
+				/* and remove the last 2 args */
+				argc -= 2;
+			}
+		}
+
+		/* Still an error? */
+		if (e != JIM_OK) {
+			return e; /* too bad */
+		}
+	} /* validate args */
+
+	tap = jtag_tap_by_jim_obj(interp, args[1]);
+	if (tap == NULL) {
+		return JIM_ERR;
+	}
+
+	num_fields = (argc-2)/2;
+	fields = malloc(sizeof(struct scan_field) * num_fields);
+	for (i = 2; i < argc; i += 2)
+	{
+		long bits;
+		int len;
+		const char *str;
+
+		Jim_GetLong(interp, args[i], &bits);
+		str = Jim_GetString(args[i + 1], &len);
+
+		fields[field_count].tap = tap;
+		fields[field_count].num_bits = bits;
+		fields[field_count].out_value = malloc(DIV_ROUND_UP(bits, 8));
+		str_to_buf(str, len, fields[field_count].out_value, bits, 0);
+		fields[field_count].in_value = fields[field_count].out_value;
+		field_count++;
+	}
+
+	jtag_add_dr_scan(num_fields, fields, endstate);
+
+	retval = jtag_execute_queue();
+	if (retval != ERROR_OK)
+	{
+		Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
+		return JIM_ERR;
+	}
+
+	field_count = 0;
+	Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
+	for (i = 2; i < argc; i += 2)
+	{
+		long bits;
+		char *str;
+
+		Jim_GetLong(interp, args[i], &bits);
+		str = buf_to_str(fields[field_count].in_value, bits, 16);
+		free(fields[field_count].out_value);
+
+		Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
+		free(str);
+		field_count++;
+	}
+
+	Jim_SetResult(interp, list);
+
+	free(fields);
+
+	return JIM_OK;
+}
+
+
+static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
+{
+	tap_state_t states[8];
+
+	if ((argc < 2) || ((size_t)argc > (ARRAY_SIZE(states) + 1)))
+	{
+		Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
+		return JIM_ERR;
+	}
+
+	script_debug(interp, "pathmove", argc, args);
+
+	int i;
+	for (i = 0; i < argc-1; i++)
+	{
+		const char *cp;
+		cp = Jim_GetString(args[i + 1], NULL);
+		states[i] = tap_state_by_name(cp);
+		if (states[i] < 0)
+		{
+			/* update the error message */
+			Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
+			return JIM_ERR;
+		}
+	}
+
+	if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
+	{
+		Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
+		return JIM_ERR;
+	}
+
+	jtag_add_pathmove(argc-2, states + 1);
+
+	if (jtag_execute_queue()!= ERROR_OK)
+	{
+		Jim_SetResultString(interp, "pathmove: failed",-1);
+		return JIM_ERR;
+	}
+
+	return JIM_OK;
+}
+
+
+static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
+{
+	script_debug(interp, "flush_count", argc, args);
+
+	Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
+
+	return JIM_OK;
+}
+
+static const struct command_registration jtag_command_handlers_to_move[] = {
+	{
+		.name = "drscan",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &Jim_Command_drscan,
+		.help = "execute DR scan <device> "
+			"<num_bits> <value> <num_bits1> <value2> ...",
+	},
+	{
+		.name = "flush_count",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &Jim_Command_flush_count,
+		.help = "returns number of times the JTAG queue has been flushed",
+	},
+	{
+		.name = "pathmove",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &Jim_Command_pathmove,
+		.usage = "<state1>,<state2>,<state3>... ",
+		.help = "move JTAG to state1 then to state2, state3, etc.",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
+
 enum jtag_tap_cfg_param {
 	JCFG_EVENT
 };
@@ -598,6 +830,9 @@ static const struct command_registration jtag_subcommand_handlers[] = {
 		.jim_handler = &jim_jtag_names,
 		.help = "Returns list of all JTAG tap names",
 	},
+	{
+		.chain = jtag_command_handlers_to_move,
+	},
 	COMMAND_REGISTRATION_DONE
 };
 
@@ -1095,20 +1330,6 @@ COMMAND_HANDLER(handle_runtest_command)
  * Not surprisingly, this is the same constraint as SVF; the "irscan"
  * and "drscan" commands are a write-only subset of what SVF provides.
  */
-static bool scan_is_safe(tap_state_t state)
-{
-	switch (state)
-	{
-	case TAP_RESET:
-	case TAP_IDLE:
-	case TAP_DRPAUSE:
-	case TAP_IRPAUSE:
-		return true;
-	default:
-		return false;
-	}
-}
-
 
 COMMAND_HANDLER(handle_irscan_command)
 {
@@ -1191,199 +1412,6 @@ error_return:
 	return retval;
 }
 
-static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
-{
-	int retval;
-	struct scan_field *fields;
-	int num_fields;
-	int field_count = 0;
-	int i, e;
-	struct jtag_tap *tap;
-	tap_state_t endstate;
-
-	/* args[1] = device
-	 * args[2] = num_bits
-	 * args[3] = hex string
-	 * ... repeat num bits and hex string ...
-	 *
-	 * .. optionally:
-	*     args[N-2] = "-endstate"
-	 *     args[N-1] = statename
-	 */
-	if ((argc < 4) || ((argc % 2) != 0))
-	{
-		Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
-		return JIM_ERR;
-	}
-
-	endstate = TAP_IDLE;
-
-	script_debug(interp, "drscan", argc, args);
-
-	/* validate arguments as numbers */
-	e = JIM_OK;
-	for (i = 2; i < argc; i += 2)
-	{
-		long bits;
-		const char *cp;
-
-		e = Jim_GetLong(interp, args[i], &bits);
-		/* If valid - try next arg */
-		if (e == JIM_OK) {
-			continue;
-		}
-
-		/* Not valid.. are we at the end? */
-		if (((i + 2) != argc)) {
-			/* nope, then error */
-			return e;
-		}
-
-		/* it could be: "-endstate FOO"
-		 * e.g. DRPAUSE so we can issue more instructions
-		 * before entering RUN/IDLE and executing them.
-		 */
-
-		/* get arg as a string. */
-		cp = Jim_GetString(args[i], NULL);
-		/* is it the magic? */
-		if (0 == strcmp("-endstate", cp)) {
-			/* is the statename valid? */
-			cp = Jim_GetString(args[i + 1], NULL);
-
-			/* see if it is a valid state name */
-			endstate = tap_state_by_name(cp);
-			if (endstate < 0) {
-				/* update the error message */
-				Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
-			} else {
-				if (!scan_is_safe(endstate))
-					LOG_WARNING("drscan with unsafe "
-							"endstate \"%s\"", cp);
-
-				/* valid - so clear the error */
-				e = JIM_OK;
-				/* and remove the last 2 args */
-				argc -= 2;
-			}
-		}
-
-		/* Still an error? */
-		if (e != JIM_OK) {
-			return e; /* too bad */
-		}
-	} /* validate args */
-
-	tap = jtag_tap_by_jim_obj(interp, args[1]);
-	if (tap == NULL) {
-		return JIM_ERR;
-	}
-
-	num_fields = (argc-2)/2;
-	fields = malloc(sizeof(struct scan_field) * num_fields);
-	for (i = 2; i < argc; i += 2)
-	{
-		long bits;
-		int len;
-		const char *str;
-
-		Jim_GetLong(interp, args[i], &bits);
-		str = Jim_GetString(args[i + 1], &len);
-
-		fields[field_count].tap = tap;
-		fields[field_count].num_bits = bits;
-		fields[field_count].out_value = malloc(DIV_ROUND_UP(bits, 8));
-		str_to_buf(str, len, fields[field_count].out_value, bits, 0);
-		fields[field_count].in_value = fields[field_count].out_value;
-		field_count++;
-	}
-
-	jtag_add_dr_scan(num_fields, fields, endstate);
-
-	retval = jtag_execute_queue();
-	if (retval != ERROR_OK)
-	{
-		Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
-		return JIM_ERR;
-	}
-
-	field_count = 0;
-	Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
-	for (i = 2; i < argc; i += 2)
-	{
-		long bits;
-		char *str;
-
-		Jim_GetLong(interp, args[i], &bits);
-		str = buf_to_str(fields[field_count].in_value, bits, 16);
-		free(fields[field_count].out_value);
-
-		Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
-		free(str);
-		field_count++;
-	}
-
-	Jim_SetResult(interp, list);
-
-	free(fields);
-
-	return JIM_OK;
-}
-
-
-static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
-{
-	tap_state_t states[8];
-
-	if ((argc < 2) || ((size_t)argc > (ARRAY_SIZE(states) + 1)))
-	{
-		Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
-		return JIM_ERR;
-	}
-
-	script_debug(interp, "pathmove", argc, args);
-
-	int i;
-	for (i = 0; i < argc-1; i++)
-	{
-		const char *cp;
-		cp = Jim_GetString(args[i + 1], NULL);
-		states[i] = tap_state_by_name(cp);
-		if (states[i] < 0)
-		{
-			/* update the error message */
-			Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
-			return JIM_ERR;
-		}
-	}
-
-	if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
-	{
-		Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
-		return JIM_ERR;
-	}
-
-	jtag_add_pathmove(argc-2, states + 1);
-
-	if (jtag_execute_queue()!= ERROR_OK)
-	{
-		Jim_SetResultString(interp, "pathmove: failed",-1);
-		return JIM_ERR;
-	}
-
-	return JIM_OK;
-}
-
-
-static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
-{
-	script_debug(interp, "flush_count", argc, args);
-
-	Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
-
-	return JIM_OK;
-}
-
 
 COMMAND_HANDLER(handle_verify_ircapture_command)
 {
@@ -1560,7 +1588,6 @@ static const struct command_registration jtag_command_handlers[] = {
 		.help = "choose short(default) or long tms_sequence",
 		.usage = "<short | long>",
 	},
-	// jim commands
 	{
 		.name = "jtag",
 		.mode = COMMAND_ANY,
@@ -1569,28 +1596,10 @@ static const struct command_registration jtag_command_handlers[] = {
 		.chain = jtag_subcommand_handlers,
 	},
 	{
-		.name = "drscan",
-		.mode = COMMAND_EXEC,
-		.jim_handler = &Jim_Command_drscan,
-		.help = "execute DR scan <device> "
-			"<num_bits> <value> <num_bits...
 
[truncated message content]