X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fhelper%2Fcommand.c;h=119862284d3fa0d3ffbddc06bd30fab7c36d06bf;hp=386572ed94d7b5f989cf8d7405b02d5a717fca79;hb=526fe3d83e118d87af34353a7140c02f3f1a3c19;hpb=dc796a209113c3fdc27de0211edcaa67faed7b5f

diff --git a/src/helper/command.c b/src/helper/command.c
index 386572ed94..119862284d 100644
--- a/src/helper/command.c
+++ b/src/helper/command.c
@@ -2,6 +2,9 @@
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
+ *   Copyright (C) 2007,2008 Øyvind Harboe                                      *
+ *   oyvind.harboe@zylin.com                                               *
+ *                                                                         *
  *   part of this file is taken from libcli (libcli.sourceforge.net)       *
  *   Copyright (C) David Parrish (david@dparrish.com)                      *
  *                                                                         *
@@ -25,8 +28,9 @@
 #endif
 
 #include "replacements.h"
-
+#include "target.h"
 #include "command.h"
+#include "configuration.h"
 
 #include "log.h"
 #include "time_support.h"
@@ -37,64 +41,102 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <errno.h>
 
 int fast_and_dangerous = 0;
-
-void command_print_help_line(command_context_t* context, struct command_s *command, int indent);
+Jim_Interp *interp = NULL;
 
 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
-/* forward declaration of jim_command */
-extern int jim_command(command_context_t *context, char *line);
+int run_command(command_context_t *context, command_t *c, char *words[], int num_words);
 
-int build_unique_lengths(command_context_t *context, command_t *commands)
+static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string)
+{		
+	Jim_Obj *tclOutput=(Jim_Obj *)privData;
+
+	Jim_AppendString(interp, tclOutput, string, strlen(string));
+}
+
+extern command_context_t *global_cmd_ctx;
+
+
+static int script_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	command_t *c, *p;
+	/* the private data is stashed in the interp structure */
+	command_t *c;
+	command_context_t *context;
+	int retval;
+	int i;
+	int nwords;
+	char **words;
 
-	/* iterate through all commands */
-	for (c = commands; c; c = c->next)
+	target_call_timer_callbacks_now();
+	LOG_USER_N("%s", ""); /* Keep GDB connection alive*/ 
+	
+	c = interp->cmdPrivData;
+	LOG_DEBUG("script_command - %s", c->name);
+
+	words = malloc(sizeof(char *) * argc);
+	for (i = 0; i < argc; i++)
 	{
-		/* find out how many characters are required to uniquely identify a command */
-		for (c->unique_len = 1; c->unique_len <= strlen(c->name); c->unique_len++)
+		int len;
+		const char *w=Jim_GetString(argv[i], &len);
+		if (*w=='#')
 		{
-			int foundmatch = 0;
-			
-			/* for every command, see if the current length is enough */
-			for (p = commands; p; p = p->next)
-			{
-				/* ignore the command itself */
-				if (c == p)
-					continue;
-				
-				/* compare commands up to the current length */
-				if (strncmp(p->name, c->name, c->unique_len) == 0)
-					foundmatch++;
-			}
-			
-			/* when none of the commands matched, we've found the minimum length required */
-			if (!foundmatch)
-				break;
+			/* hit an end of line comment */
+			break;
 		}
-		
-		/* if the current command has children, build the unique lengths for them */
-		if (c->children)
-			build_unique_lengths(context, c->children);
+		words[i] = strdup(w);
+		if (words[i] == NULL) 
+		{
+			return JIM_ERR;
+		}
+		LOG_DEBUG("script_command - %s, argv[%u]=%s", c->name, i, words[i]);
+	}
+	nwords = i;
+
+	/* grab the command context from the associated data */
+	context = Jim_GetAssocData(interp, "context");
+	if (context == NULL)
+	{
+		/* Tcl can invoke commands directly instead of via command_run_line(). This would
+		 * happen when the Jim Tcl interpreter is provided by eCos.
+		 */
+		context = global_cmd_ctx;
 	}
 	
-	return ERROR_OK;
-}
+	/* capture log output and return it */
+	Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
+	/* a garbage collect can happen, so we need a reference count to this object */
+	Jim_IncrRefCount(tclOutput);
+	
+	log_add_callback(tcl_output, tclOutput);
+	
+	retval = run_command(context, c, words, nwords);
+	
+	log_remove_callback(tcl_output, tclOutput);
 
-/* Avoid evaluating this each time we add a command. Reduces overhead from O(n^2) to O(n). 
- * Makes a difference on ARM7 types machines and is not observable on GHz machines.
- */
-static int unique_length_dirty = 1; 
+	/* We dump output into this local variable */
+	Jim_SetResult(interp, tclOutput);
+	Jim_DecrRefCount(interp, tclOutput);
+
+	for (i = 0; i < nwords; i++)
+		free(words[i]);
+	free(words);
+
+	int *return_retval = Jim_GetAssocData(interp, "retval");
+	if (return_retval != NULL)
+	{
+		*return_retval = retval;
+	}
+	
+	return (retval==ERROR_OK)?JIM_OK:JIM_ERR;
+}
 
 command_t* register_command(command_context_t *context, command_t *parent, char *name, int (*handler)(struct command_context_s *context, char* name, char** args, int argc), enum command_mode mode, char *help)
 {
 	command_t *c, *p;
-	unique_length_dirty = 1;
 	
 	if (!context || !name)
 		return NULL;
@@ -106,11 +148,8 @@ command_t* register_command(command_context_t *context, command_t *parent, char
 	c->children = NULL;
 	c->handler = handler;
 	c->mode = mode;
-	if (help)
-		c->help = strdup(help);
-	else
-		c->help = NULL;
-	c->unique_len = 0;
+	if (!help)
+		help="";
 	c->next = NULL;
 	
 	/* place command in tree */
@@ -143,6 +182,54 @@ command_t* register_command(command_context_t *context, command_t *parent, char
 		}
 	}
 	
+	/* just a placeholder, no handler */
+	if (c->handler==NULL)
+		return c;
+
+	/* If this is a two level command, e.g. "flash banks", then the
+	 * "unknown" proc in startup.tcl must redirect to  this command.
+	 * 
+	 * "flash banks" is translated by "unknown" to "flash_banks"
+	 * if such a proc exists
+	 */
+	/* Print help for command */
+	const char *t1="";
+	const char *t2="";
+	const char *t3="";
+	/* maximum of two levels :-) */
+	if (c->parent!=NULL)
+	{
+		t1=c->parent->name;
+		t2="_";
+	}
+	t3=c->name;
+	const char *full_name=alloc_printf("ocd_%s%s%s", t1, t2, t3);
+	Jim_CreateCommand(interp, full_name, script_command, c, NULL);
+	free((void *)full_name);
+	
+	/* we now need to add an overrideable proc */
+	const char *override_name=alloc_printf("proc %s%s%s {args} {eval \"ocd_%s%s%s $args\";return \"\"}", t1, t2, t3, t1, t2, t3);
+	Jim_Eval(interp, override_name);	
+	free((void *)override_name);
+	
+	/* accumulate help text in Tcl helptext list.  */
+    Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
+    if (Jim_IsShared(helptext))
+        helptext = Jim_DuplicateObj(interp, helptext);
+	Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
+	
+	Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
+
+	/* maximum of two levels :-) */
+	if (c->parent!=NULL)
+	{
+		Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, c->parent->name, -1));
+	} 
+	Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, c->name, -1));
+	
+	Jim_ListAppendElement(interp, cmd_entry, cmd_list);
+	Jim_ListAppendElement(interp, cmd_entry, Jim_NewStringObj(interp, help, -1));
+	Jim_ListAppendElement(interp, helptext, cmd_entry);
 	return c;
 }
 
@@ -150,12 +237,9 @@ int unregister_all_commands(command_context_t *context)
 {
 	command_t *c, *c2;
 	
-	unique_length_dirty = 1;
-	
 	if (context == NULL)
 		return ERROR_OK;
 	
-	
 	while(NULL != context->commands)
 	{
 		c = context->commands;
@@ -166,8 +250,6 @@ int unregister_all_commands(command_context_t *context)
 			c->children = c->children->next;
 			free(c2->name);
 			c2->name = NULL;
-			free(c2->help);
-			c2->help = NULL;
 			free(c2);
 			c2 = NULL;
 		}
@@ -176,8 +258,6 @@ int unregister_all_commands(command_context_t *context)
 		
 		free(c->name);
 		c->name = NULL;
-		free(c->help);
-		c->help = NULL;
 		free(c);
 		c = NULL;		
 	}
@@ -189,8 +269,6 @@ int unregister_command(command_context_t *context, char *name)
 {
 	command_t *c, *p = NULL, *c2;
 	
-	unique_length_dirty = 1;
-	
 	if ((!context) || (!name))
 		return ERROR_INVALID_ARGUMENTS;
 	
@@ -215,16 +293,12 @@ int unregister_command(command_context_t *context, char *name)
 				for (c2 = c->children; c2; c2 = c2->next)
 				{
 					free(c2->name);
-					if (c2->help)
-						free(c2->help);
 					free(c2);
 				}
 			}
 			
 			/* delete command */
 			free(c->name);
-			if (c->help)
-				free(c->help);
 			free(c);
 		}
 		
@@ -235,74 +309,11 @@ int unregister_command(command_context_t *context, char *name)
 	return ERROR_OK;
 }
 
-int parse_line(char *line, char *words[], int max_words)
+void command_output_text(command_context_t *context, const char *data)
 {
-	int nwords = 0;
-	char *p = line;
-	char *word_start = line;
-	int inquote = 0;
-
-	while (nwords < max_words - 1)
-	{
-		/* check if we reached
-		 * a terminating NUL
-		 * a matching closing quote character " or '
-		 * we're inside a word but not a quote, and the current character is whitespace
-		 */
-		if (!*p || *p == inquote || (word_start && !inquote && isspace(*p)))
-		{
-			/* we're inside a word or quote, and reached its end*/
-			if (word_start)
-			{
-				int len;
-				char *word_end=p;
-				
-				/* This will handle extra whitespace within quotes */
-				while (isspace(*word_start)&&(word_start<word_end))
-					word_start++;
-				while (isspace(*(word_end-1))&&(word_start<word_end))
-					word_end--;
-				len = word_end - word_start;
-				
-				if (len>0)
-				{
-					/* copy the word */
-					memcpy(words[nwords] = malloc(len + 1), word_start, len);
-					/* add terminating NUL */
-					words[nwords++][len] = 0;
-				}
-			}
-			/* we're done parsing the line */
-			if (!*p)
-				break;
-
-			/* skip over trailing quote or whitespace*/
-			if (inquote || isspace(*p))
-				p++;
-			while (isspace(*p))
-				p++;
-			
-			inquote = 0;
-			word_start = 0;
-		}
-		else if (*p == '"' || *p == '\'')
-		{
-			/* we've reached the beginning of a quote */
-			inquote = *p++;
-			word_start = p;
-		}
-		else
-		{
-			/* we've reached the beginning of a new word */
-			if (!word_start)
-				word_start = p;
-			
-			/* normal character, skip */
-			p++;
-		}
+	if( context && context->output_handler && data  ){
+		context->output_handler( context, data );
 	}
-	
-	return nwords;
 }
 
 void command_print_n(command_context_t *context, char *format, ...)
@@ -315,7 +326,14 @@ void command_print_n(command_context_t *context, char *format, ...)
 	string = alloc_vprintf(format, ap);
 	if (string != NULL)
 	{
-		context->output_handler(context, string);
+		/* we want this collected in the log + we also want to pick it up as a tcl return
+		 * value.
+		 * 
+		 * The latter bit isn't precisely neat, but will do for now.
+		 */
+		LOG_USER_N("%s", string);
+		// We already printed it above
+		//command_output_text(context, string);
 		free(string);
 	}
 
@@ -333,75 +351,45 @@ void command_print(command_context_t *context, char *format, ...)
 	if (string != NULL)
 	{
 		strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
-		context->output_handler(context, string);
+		/* we want this collected in the log + we also want to pick it up as a tcl return
+		 * value.
+		 * 
+		 * The latter bit isn't precisely neat, but will do for now.
+		 */
+		LOG_USER_N("%s", string);
+		// We already printed it above
+		//command_output_text(context, string);
 		free(string);
 	}
 
 	va_end(ap);
 }
 
-command_t *find_command(command_context_t *context, command_t *commands, char *words[], int num_words, int start_word, int *new_start_word)
-{
-	command_t *c;
-	
-	if (unique_length_dirty)
-	{
-		unique_length_dirty = 0;
-		/* update unique lengths */
-		build_unique_lengths(context, context->commands);
-	}
-	
-	for (c = commands; c; c = c->next)
-	{
-		if (strncasecmp(c->name, words[start_word], c->unique_len))
-			continue;
-
-		if (strncasecmp(c->name, words[start_word], strlen(words[start_word])))
-			continue;
-		
-		if ((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) )
-		{
-			if (!c->children)
-			{
-				if (!c->handler)
-				{
-					return NULL;
-				}
-				else
-				{
-					*new_start_word=start_word;
-					return c;
-				}
-			}
-			else
-			{
-				if (start_word == num_words - 1)
-				{
-					return NULL;
-				}
-				return find_command(context, c->children, words, num_words, start_word + 1, new_start_word);
-			}
-		}
-	}
-	return NULL;
-}
-
-int find_and_run_command(command_context_t *context, command_t *commands, char *words[], int num_words)
+int run_command(command_context_t *context, command_t *c, char *words[], int num_words)
 {
 	int start_word=0;
-	command_t *c;
-	c=find_command(context, commands, words, num_words, start_word, &start_word);
-	if (c==NULL)
+	if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) ))
 	{
-		command_print(context, "Command %s not found", words[start_word]);
-		return ERROR_COMMAND_SYNTAX_ERROR;
+		/* Config commands can not run after the config stage */
+		LOG_ERROR("Illegal mode for command");
+		return ERROR_FAIL;
 	}
 	
 	int retval = c->handler(context, c->name, words + start_word + 1, num_words - start_word - 1);
 	if (retval == ERROR_COMMAND_SYNTAX_ERROR)
 	{
-		command_print(context, "Syntax error:");
-		command_print_help_line(context, c, 0);
+		/* Print help for command */
+		const char *t1="";
+		const char *t2="";
+		const char *t3="";
+		/* maximum of two levels :-) */
+		if (c->parent!=NULL)
+		{
+			t1=c->parent->name;
+			t2=" ";
+		}
+		t3=c->name;
+		command_run_linef(context, "help {%s%s%s}", t1, t2, t3);
 	}
 	else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
 	{
@@ -414,128 +402,75 @@ int find_and_run_command(command_context_t *context, command_t *commands, char *
 		 */
 		LOG_DEBUG("Command failed with error code %d", retval); 
 	}
-	return retval; 
-}
-
-int command_run_line_internal_op(command_context_t *context, char *line, int run)
-{
-	LOG_USER_N("%s", ""); /* Keep GDB connection alive*/ 
-	
-	int nwords;
-	char *words[128] = {0};
-	int retval;
-	int i;
-
-	/* skip preceding whitespace */
-	while (isspace(*line))
-		line++;
-	
-	/* empty line, ignore */
-	if (!*line)
-		return ERROR_OK;
-	
-	/* ignore comments */
-	if (*line && (line[0] == '#'))
-		return ERROR_OK;
-	
-	LOG_DEBUG("%s", line);
-
-	nwords = parse_line(line, words, sizeof(words) / sizeof(words[0]));
-	
-	if (nwords > 0)
-		if (run)
-		{
-			retval = find_and_run_command(context, context->commands, words, nwords);
-		} else
-		{
-			int t;
-			return (find_command(context, context->commands, words, nwords, 0, &t)!=NULL)?ERROR_OK:ERROR_FAIL;
-		}
-	else
-		return ERROR_INVALID_ARGUMENTS;
-	
-	for (i = 0; i < nwords; i++)
-		free(words[i]);
 	
-	return retval;
-}
-
-int command_run_line_internal(command_context_t *context, char *line)
-{
-	return command_run_line_internal_op(context, line, 1);
+	return retval; 
 }
 
 int command_run_line(command_context_t *context, char *line)
 {
-	if ((!context) || (!line))
-		return ERROR_INVALID_ARGUMENTS;
-
-	if (command_run_line_internal_op(context, line, 0)!=ERROR_OK)
-	{
-		/* If we can't find a command, then try the interpreter. 
-		 * If there is no interpreter implemented, then this will
-		 * simply print a syntax error.
-		 * 
-		 * These hooks were left in to reduce patch size for 
-		 * wip to add scripting language.
-		 */
-		return jim_command(context, line);
-	}
-
-	return command_run_line_internal(context, line);
-}
-
-int command_run_file(command_context_t *context, FILE *file, enum command_mode mode)
-{
-	int retval = ERROR_OK;
-	int old_command_mode;
-	char *buffer=malloc(4096);
-	if (buffer==NULL)
+	/* all the parent commands have been registered with the interpreter
+	 * so, can just evaluate the line as a script and check for
+	 * results
+	 */
+	/* run the line thru a script engine */
+	int retval=ERROR_FAIL;
+	int retcode;
+	/* Beware! This code needs to be reentrant. It is also possible
+	 * for OpenOCD commands to be invoked directly from Tcl. This would
+	 * happen when the Jim Tcl interpreter is provided by eCos for
+	 * instance.
+	 */
+	Jim_DeleteAssocData(interp, "context");
+	retcode = Jim_SetAssocData(interp, "context", NULL, context);
+	if (retcode == JIM_OK)
 	{
-		return ERROR_INVALID_ARGUMENTS;
+		/* associated the return value */
+		Jim_DeleteAssocData(interp, "retval");
+		retcode = Jim_SetAssocData(interp, "retval", NULL, &retval);
+		if (retcode == JIM_OK)
+		{
+			retcode = Jim_Eval(interp, line);
+			
+			Jim_DeleteAssocData(interp, "retval");
+		}	
+		Jim_DeleteAssocData(interp, "context");
 	}
-	
-	old_command_mode = context->mode;
-	context->mode = mode;
-	
-	while (fgets(buffer, 4096, file))
-	{
-		char *p;
-		char *cmd, *end;
-		
-		/* stop processing line after a comment (#, !) or a LF, CR were encountered */
-		if ((p = strpbrk(buffer, "#!\r\n")))
-			*p = 0;
-
-		/* skip over leading whitespace */
-		cmd = buffer;
-		while (isspace(*cmd))
-			cmd++;
-
-		/* empty (all whitespace) line? */
-		if (!*cmd)
-			continue;
-		
-		/* search the end of the current line, ignore trailing whitespace */
-		for (p = end = cmd; *p; p++)
-			if (!isspace(*p))
-				end = p;
-		
-		/* terminate end */
-		*++end = 0;
-		if (strcasecmp(cmd, "quit") == 0)
-			break;
-
-		/* run line */
-		if ((retval = command_run_line(context, cmd)) == ERROR_COMMAND_CLOSE_CONNECTION)
-			break;
+	if (retcode == JIM_ERR) {
+		if (retval!=ERROR_COMMAND_CLOSE_CONNECTION)
+		{
+			/* We do not print the connection closed error message */
+			Jim_PrintErrorMessage(interp);
+		}
+		if (retval==ERROR_OK)
+		{
+			/* It wasn't a low level OpenOCD command that failed */
+			return ERROR_FAIL; 
+		}
+		return retval;
+	} else if (retcode == JIM_EXIT) {
+		/* ignore. */
+		/* exit(Jim_GetExitCode(interp)); */
+	} else {
+		const char *result;
+		int reslen;
+
+		result = Jim_GetString(Jim_GetResult(interp), &reslen);
+		if (reslen) {
+			int i;
+			char buff[256+1];
+			for (i = 0; i < reslen; i += 256)
+			{
+				int chunk;
+				chunk = reslen - i;
+				if (chunk > 256)
+					chunk = 256;
+				strncpy(buff, result+i, chunk);
+				buff[chunk] = 0; 
+				LOG_USER_N("%s", buff);
+			}
+			LOG_USER_N("%s", "\n");
+		}
 	}
-	
-	context->mode = old_command_mode;
-
-	
-	free(buffer);
-	
 	return retval;
 }
 
@@ -554,121 +489,196 @@ int command_run_linef(command_context_t *context, char *format, ...)
 	return retval;
 }
 
-void command_print_help_line(command_context_t* context, struct command_s *command, int indent)
+void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
 {
-	command_t *c;
-	char *indent_text=malloc(indent + 2);
-	
-	char *help = "no help available";
-	char name_buf[64];
-	
-	if (indent)
-	{
-	    indent_text[0] = ' ';
-	    memset(indent_text + 1, '-', indent);
-	    indent_text[indent + 1] = 0;
-	}
-	
-	if (command->help)
-		help = command->help;
-		
-	snprintf(name_buf, 64, command->name);
+	context->output_handler = output_handler;
+	context->output_handler_priv = priv;
+}
+
+command_context_t* copy_command_context(command_context_t* context)
+{
+	command_context_t* copy_context = malloc(sizeof(command_context_t));
+
+	*copy_context = *context;
 
-	if (indent)
-	    strncat(name_buf, indent_text, 64);
+	return copy_context;
+}
 
-	command_print(context, "%20s\t%s", name_buf, help, indent);
+int command_done(command_context_t *context)
+{
+	free(context);
+	context = NULL;
 	
-	if (command->children)
-	{
-		for (c = command->children; c; c = c->next)
-		{
-			command_print_help_line(context, c, indent + 1);
-		}
-	}
-	free(indent_text);
+	return ERROR_OK;
 }
 
-int command_print_help_match(command_context_t* context, command_t* c_first, char* name, char** args, int argc)
+/* find full path to file */
+static int jim_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	command_t * c;
+	if (argc != 2)
+		return JIM_ERR;
+	const char *file = Jim_GetString(argv[1], NULL);
+	char *full_path = find_file(file);
+	if (full_path == NULL)
+		return JIM_ERR;
+	Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path));
+	free(full_path);
+	
+	Jim_SetResult(interp, result);
+	return JIM_OK;
+}
 
-	for (c = c_first; c; c = c->next)
-	{
-		if (argc > 0)
-		{
-			if (strncasecmp(c->name, args[0], c->unique_len))
-				continue;
+static int jim_echo(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 2)
+		return JIM_ERR;
+	const char *str = Jim_GetString(argv[1], NULL);
+	LOG_USER("%s", str);
+	return JIM_OK;
+}
 
-			if (strncasecmp(c->name, args[0], strlen(args[0])))
-				continue;
+static size_t openocd_jim_fwrite(const void *_ptr, size_t size, size_t n, void *cookie)
+{
+	size_t nbytes;
+	const char *ptr;
+	Jim_Interp *interp;
+
+	/* make it a char easier to read code */
+	ptr = _ptr;
+	interp = cookie;
+	nbytes = size * n;
+	if (ptr == NULL || interp == NULL || nbytes == 0) {
+		return 0;
+	}
 
-			if (argc > 1)
-			{
-				command_print_help_match(context, c->children, name, args + 1, argc - 1);
-				continue;
-			}
+	/* do we have to chunk it? */
+	if (ptr[nbytes] == 0)
+	{
+		/* no it is a C style string */
+		LOG_USER_N("%s", ptr);
+		return strlen(ptr);
+	}
+	/* GRR we must chunk - not null terminated */
+	while (nbytes) {
+		char chunk[128+1];
+		int x;
+
+		x = nbytes;
+		if (x > 128) {
+			x = 128;
 		}
-
-		command_print_help_line(context, c, 0);
+		/* copy it */
+		memcpy(chunk, ptr, x);
+		/* terminate it */
+		chunk[n] = 0;
+		/* output it */
+		LOG_USER_N("%s", chunk);
+		ptr += x;
+		nbytes -= x;
 	}
 	
-	return ERROR_OK;
+	return n;
 }
 
-int command_print_help(command_context_t* context, char* name, char** args, int argc)
+static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie)
 {
-    return command_print_help_match(context, context->commands, name, args, argc);
+	/* TCL wants to read... tell him no */
+	return 0;
 }
 
-void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
+static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap)
 {
-	context->output_handler = output_handler;
-	context->output_handler_priv = priv;
+	char *cp;
+	int n;
+	Jim_Interp *interp;
+
+	n = -1;
+	interp = cookie;
+	if (interp == NULL)
+		return n;
+
+	cp = alloc_vprintf(fmt, ap);
+	if (cp)
+	{
+		LOG_USER_N("%s", cp);
+		n = strlen(cp);
+		free(cp);
+	}
+	return n;
 }
 
-command_context_t* copy_command_context(command_context_t* context)
+static int openocd_jim_fflush(void *cookie)
 {
-	command_context_t* copy_context = malloc(sizeof(command_context_t));
-
-	*copy_context = *context;
-	
-	return copy_context;
+	/* nothing to flush */
+	return 0;
 }
 
-int command_done(command_context_t *context)
+static char* openocd_jim_fgets(char *s, int size, void *cookie)
 {
-	free(context);
-	context = NULL;
-	
-	return ERROR_OK;
+	/* not supported */
+	errno = ENOTSUP;
+	return NULL;
 }
 
 command_context_t* command_init()
 {
 	command_context_t* context = malloc(sizeof(command_context_t));
-	
+	extern unsigned const char startup_tcl[];
+
 	context->mode = COMMAND_EXEC;
 	context->commands = NULL;
 	context->current_target = 0;
 	context->output_handler = NULL;
 	context->output_handler_priv = NULL;
+
+#ifdef JIM_EMBEDDED
+	Jim_InitEmbedded();
+	/* Create an interpreter */
+	interp = Jim_CreateInterp();
+	/* Add all the Jim core commands */
+	Jim_RegisterCoreCommands(interp);
+#endif
+
+	Jim_CreateCommand(interp, "ocd_find", jim_find, NULL, NULL);
+	Jim_CreateCommand(interp, "echo", jim_echo, NULL, NULL);
+
+	/* Set Jim's STDIO */
+	interp->cookie_stdin = interp;
+	interp->cookie_stdout = interp;
+	interp->cookie_stderr = interp;
+	interp->cb_fwrite = openocd_jim_fwrite;
+	interp->cb_fread = openocd_jim_fread ;
+	interp->cb_vfprintf = openocd_jim_vfprintf;
+	interp->cb_fflush = openocd_jim_fflush;
+	interp->cb_fgets = openocd_jim_fgets;
 	
-	register_command(context, NULL, "help", command_print_help,
-					 COMMAND_EXEC, "display this help");
-	
+	add_default_dirs();
+
+	if (Jim_Eval(interp, startup_tcl)==JIM_ERR)
+	{
+		LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD compile time)");
+		Jim_PrintErrorMessage(interp);
+		exit(-1);
+	}
+
 	register_command(context, NULL, "sleep", handle_sleep_command,
 					 COMMAND_ANY, "sleep for <n> milliseconds");
 	
-	register_command(context, NULL, "time", handle_time_command,
-					 COMMAND_ANY, "time <cmd + args> - execute <cmd + args> and print time it took");
-	
 	register_command(context, NULL, "fast", handle_fast_command,
 					 COMMAND_ANY, "fast <enable/disable> - place at beginning of config files. Sets defaults to fast and dangerous.");
 	
 	return context;
 }
 
+int command_context_mode(command_context_t *cmd_ctx, enum command_mode mode)
+{
+	if (!cmd_ctx)
+		return ERROR_INVALID_ARGUMENTS;
+
+	cmd_ctx->mode = mode;
+	return ERROR_OK;
+}
+
 /* sleep command sleeps for <n> miliseconds
  * this is useful in target startup scripts
  */
@@ -695,35 +705,22 @@ int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 	return ERROR_OK;
 }
 
-
-int handle_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+void register_jim(struct command_context_s *cmd_ctx, const char *name, int (*cmd)(Jim_Interp *interp, int argc, Jim_Obj *const *argv), const char *help)
 {
-	duration_t duration;
-	char *duration_text;
-	int retval;
-	float t;
-	
-	if (argc<1)
-		return ERROR_COMMAND_SYNTAX_ERROR;
-	
-	duration_start_measure(&duration);
-	
-	retval = find_and_run_command(cmd_ctx, cmd_ctx->commands, args, argc);
-	
-	duration_stop_measure(&duration, &duration_text);
-	
-	t=duration.duration.tv_sec;
-	t+=((float)duration.duration.tv_usec / 1000000.0);
-	command_print(cmd_ctx, "%s took %fs", args[0], t);
-	
-	free(duration_text);
-
-	return retval;
+	Jim_CreateCommand(interp, name, cmd, NULL, NULL);
+
+	/* FIX!!! it would be prettier to invoke add_help_text... 
+	   accumulate help text in Tcl helptext list.  */
+	Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
+	if (Jim_IsShared(helptext))
+		helptext = Jim_DuplicateObj(interp, helptext);
+    
+	Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
+	
+	Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
+	Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, name, -1));
+	
+	Jim_ListAppendElement(interp, cmd_entry, cmd_list);
+	Jim_ListAppendElement(interp, cmd_entry, Jim_NewStringObj(interp, help, -1));
+	Jim_ListAppendElement(interp, helptext, cmd_entry);
 }
-/*
- * Local Variables: **
- * tab-width: 4 **
- * c-basic-offset: 4 **
- * End: **
- */
-