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

diff --git a/src/helper/command.c b/src/helper/command.c
index d31c3588c2..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,14 +41,16 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <unistd.h>
-
-#include <openocd_tcl.h>
+#include <errno.h>
 
 int fast_and_dangerous = 0;
-extern command_context_t *active_cmd_ctx;
+Jim_Interp *interp = NULL;
 
 int handle_sleep_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);
+
+int run_command(command_context_t *context, command_t *c, char *words[], int num_words);
+
 static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string)
 {		
 	Jim_Obj *tclOutput=(Jim_Obj *)privData;
@@ -52,12 +58,15 @@ static void tcl_output(void *privData, const char *file, int line, const char *f
 	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)
 {
 	/* the private data is stashed in the interp structure */
 	command_t *c;
 	command_context_t *context;
-	int *retval;
+	int retval;
 	int i;
 	int nwords;
 	char **words;
@@ -68,41 +77,61 @@ static int script_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	c = interp->cmdPrivData;
 	LOG_DEBUG("script_command - %s", c->name);
 
-	nwords = argc;
-	words = malloc(sizeof(char *) * nwords);
-	for (i = 0; i < nwords; i++)
+	words = malloc(sizeof(char *) * argc);
+	for (i = 0; i < argc; i++)
 	{
 		int len;
-
-		words[i] = strdup(Jim_GetString(argv[i], &len));
+		const char *w=Jim_GetString(argv[i], &len);
+		if (*w=='#')
+		{
+			/* hit an end of line comment */
+			break;
+		}
+		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");
-	retval = Jim_GetAssocData(interp, "retval"); 
-	if (context != NULL && retval != NULL)
+	if (context == NULL)
 	{
-		/* capture log output and return it */
-		Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
-		log_add_callback(tcl_output, tclOutput);
-		
-		*retval = run_command(context, c, words, nwords);
-		
-		log_remove_callback(tcl_output, tclOutput);
-		Jim_SetResult(interp, tclOutput);
-		
+		/* 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;
 	}
+	
+	/* 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);
+
+	/* 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);
 
-	return (*retval==ERROR_OK)?JIM_OK:JIM_ERR;
+	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)
@@ -174,10 +203,14 @@ command_t* register_command(command_context_t *context, command_t *parent, char
 		t2="_";
 	}
 	t3=c->name;
-	const char *full_name=alloc_printf("%s%s%s", t1, t2, t3);
+	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);
@@ -207,7 +240,6 @@ int unregister_all_commands(command_context_t *context)
 	if (context == NULL)
 		return ERROR_OK;
 	
-	
 	while(NULL != context->commands)
 	{
 		c = context->commands;
@@ -277,7 +309,6 @@ int unregister_command(command_context_t *context, char *name)
 	return ERROR_OK;
 }
 
-
 void command_output_text(command_context_t *context, const char *data)
 {
 	if( context && context->output_handler && data  ){
@@ -295,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);
 	}
 
@@ -313,7 +351,14 @@ 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);
 	}
 
@@ -326,6 +371,7 @@ int run_command(command_context_t *context, command_t *c, char *words[], int num
 	if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) ))
 	{
 		/* Config commands can not run after the config stage */
+		LOG_ERROR("Illegal mode for command");
 		return ERROR_FAIL;
 	}
 	
@@ -367,24 +413,40 @@ int command_run_line(command_context_t *context, char *line)
 	 * results
 	 */
 	/* run the line thru a script engine */
-	int retval;
+	int retval=ERROR_FAIL;
 	int retcode;
-
-	Jim_DeleteAssocData(interp, "context"); /* remove existing */
+	/* 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_FAIL;
-
-	/* associated the return value */
-	retval = ERROR_OK;
-	Jim_DeleteAssocData(interp, "retval"); /* remove existing */
-	retcode = Jim_SetAssocData(interp, "retval", NULL, &retval);
-	if (retcode != JIM_OK)
-		return ERROR_FAIL;
-
-	retcode = Jim_Eval(interp, line);	
+	if (retcode == JIM_OK)
+	{
+		/* 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");
+	}
 	if (retcode == JIM_ERR) {
-		Jim_PrintErrorMessage(interp);
+		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)); */
@@ -412,7 +474,6 @@ int command_run_line(command_context_t *context, char *line)
 	return retval;
 }
 
-
 int command_run_linef(command_context_t *context, char *format, ...)
 {
 	int retval=ERROR_FAIL;
@@ -428,8 +489,6 @@ int command_run_linef(command_context_t *context, char *format, ...)
 	return retval;
 }
 
-
-
 void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
 {
 	context->output_handler = output_handler;
@@ -453,16 +512,155 @@ int command_done(command_context_t *context)
 	return ERROR_OK;
 }
 
+/* find full path to file */
+static int jim_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	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;
+}
+
+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;
+}
+
+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;
+	}
+
+	/* 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;
+		}
+		/* copy it */
+		memcpy(chunk, ptr, x);
+		/* terminate it */
+		chunk[n] = 0;
+		/* output it */
+		LOG_USER_N("%s", chunk);
+		ptr += x;
+		nbytes -= x;
+	}
+	
+	return n;
+}
+
+static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie)
+{
+	/* TCL wants to read... tell him no */
+	return 0;
+}
+
+static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap)
+{
+	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;
+}
+
+static int openocd_jim_fflush(void *cookie)
+{
+	/* nothing to flush */
+	return 0;
+}
+
+static char* openocd_jim_fgets(char *s, int size, void *cookie)
+{
+	/* 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;
 	
+	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");
 	
@@ -506,3 +704,23 @@ int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
 	
 	return ERROR_OK;
 }
+
+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)
+{
+	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);
+}