X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fhelper%2Fcommand.c;h=d29b6ec327a00a30f7d47baf898ba9f5503924f3;hp=e30e2d38833876f86de279da7be4f3a807401b3f;hb=841721929a63bb77379b1598d91ed85b85021734;hpb=97c4be68a05d8ac42a79f0311b4ee4f5aab9dc62 diff --git a/src/helper/command.c b/src/helper/command.c index e30e2d3883..d29b6ec327 100644 --- a/src/helper/command.c +++ b/src/helper/command.c @@ -2,6 +2,12 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * + * Copyright (C) 2007,2008 Øyvind Harboe * + * oyvind.harboe@zylin.com * + * * + * Copyright (C) 2008, Duane Ellis * + * openocd@duaneeellis.com * + * * * part of this file is taken from libcli (libcli.sourceforge.net) * * Copyright (C) David Parrish (david@dparrish.com) * * * @@ -24,95 +30,158 @@ #include "config.h" #endif -#include "replacements.h" +#if !BUILD_ECOSBOARD +/* see Embedder-HOWTO.txt in Jim Tcl project hosted on BerliOS*/ +#define JIM_EMBEDDED +#endif +// @todo the inclusion of target.h here is a layering violation +#include "target.h" #include "command.h" - +#include "configuration.h" #include "log.h" #include "time_support.h" +#include "jim-eventloop.h" -#include -#include -#include -#include -#include -#include int fast_and_dangerous = 0; +Jim_Interp *interp = NULL; -void command_print_help_line(command_context_t* context, struct command_s *command, int indent); +int run_command(command_context_t *context, command_t *c, char *words[], int num_words); -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); +static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string) +{ + Jim_Obj *tclOutput = (Jim_Obj *)privData; -/* forward declaration of jim_command */ -extern int jim_command(command_context_t *context, char *line); + Jim_AppendString(interp, tclOutput, string, strlen(string)); +} + +extern command_context_t *global_cmd_ctx; -int build_unique_lengths(command_context_t *context, command_t *commands) +void script_debug(Jim_Interp *interp, const char *name, int argc, Jim_Obj *const *argv) { - command_t *c, *p; + int i; - /* iterate through all commands */ - for (c = commands; c; c = c->next) + LOG_DEBUG("command - %s", name); + for (i = 0; i < argc; i++) { + int len; + const char *w = Jim_GetString(argv[i], &len); + + /* end of line comment? */ + if (*w == '#') + break; + + LOG_DEBUG("%s - argv[%d]=%s", name, i, w); + } +} + +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 i; + int nwords; + char **words; + + /* DANGER!!!! be careful what we invoke here, since interp->cmdPrivData might + * get overwritten by running other Jim commands! Treat it as an + * emphemeral global variable that is used in lieu of an argument + * to the fn and fish it out manually. + */ + c = interp->cmdPrivData; + if (c == NULL) { - /* 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++) + LOG_ERROR("BUG: interp->cmdPrivData == NULL"); + return JIM_ERR; + } + target_call_timer_callbacks_now(); + LOG_USER_N("%s", ""); /* Keep GDB connection alive*/ + + script_debug(interp, c->name, argc, argv); + + words = malloc(sizeof(char *) * argc); + for (i = 0; i < argc; i++) + { + 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; + } + words[i] = strdup(w); + if (words[i] == NULL) + { + int j; + for (j = 0; j < i; j++) + free(words[j]); + free(words); + return JIM_ERR; } - - /* if the current command has children, build the unique lengths for them */ - if (c->children) - build_unique_lengths(context, c->children); } - - return ERROR_OK; + 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; + } + + /* 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); + + int *return_retval = Jim_GetAssocData(interp, "retval"); + if (return_retval != NULL) + { + *return_retval = retval; + } + + return (retval == ERROR_OK)?JIM_OK:JIM_ERR; } -/* 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; +/* nice short description of source file */ +#define __THIS__FILE__ "command.c" 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; - + c = malloc(sizeof(command_t)); - + c->name = strdup(name); c->parent = parent; 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 */ if (parent) { @@ -142,60 +211,101 @@ command_t* register_command(command_context_t *context, command_t *parent, char context->commands = c; } } - + + /* 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} {if {[catch {eval ocd_%s%s%s $args}]==0} {return \"\"} else { return -code error }", t1, t2, t3, t1, t2, t3); + Jim_Eval_Named(interp, override_name, __THIS__FILE__, __LINE__); + 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; } 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) + + while (NULL != context->commands) { c = context->commands; - - while(NULL != c->children) + + while (NULL != c->children) { c2 = c->children; c->children = c->children->next; free(c2->name); c2->name = NULL; - free(c2->help); - c2->help = NULL; free(c2); c2 = NULL; } - + context->commands = context->commands->next; - + free(c->name); c->name = NULL; - free(c->help); - c->help = NULL; free(c); - c = NULL; + c = NULL; } - + return ERROR_OK; } 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; - + /* find command */ - for (c = context->commands; c; c = c->next) + c = context->commands; + + while (NULL != c) { if (strcmp(name, c->name) == 0) { @@ -206,130 +316,69 @@ int unregister_command(command_context_t *context, char *name) } else { + /* first element in command list */ context->commands = c->next; } - + /* unregister children */ - if (c->children) + while (NULL != c->children) { - for (c2 = c->children; c2; c2 = c2->next) - { - free(c2->name); - if (c2->help) - free(c2->help); - free(c2); - } + c2 = c->children; + c->children = c->children->next; + free(c2->name); + c2->name = NULL; + free(c2); + c2 = NULL; } - + /* delete command */ free(c->name); - if (c->help) - free(c->help); + c->name = NULL; free(c); + c = NULL; + return ERROR_OK; } - + /* remember the last command for unlinking */ p = c; + c = c->next; } - - return ERROR_OK; -} -int parse_line(char *line, char *words[], int max_words) -{ - 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_start0) - { - /* 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++; - } - } - - return nwords; + return ERROR_OK; } void command_output_text(command_context_t *context, const char *data) { - if( context && context->output_handler && data ){ - context->output_handler( context, data ); + if (context && context->output_handler && data) { + context->output_handler(context, data); } } -void command_print_n(command_context_t *context, char *format, ...) +void command_print_sameline(command_context_t *context, const char *format, ...) { char *string; - + va_list ap; va_start(ap, 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); } va_end(ap); } -void command_print(command_context_t *context, char *format, ...) +void command_print(command_context_t *context, const char *format, ...) { char *string; @@ -340,75 +389,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) +int run_command(command_context_t *context, command_t *c, char *words[], int num_words) { - command_t *c; - - if (unique_length_dirty) + int start_word = 0; + if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode))) { - unique_length_dirty = 0; - /* update unique lengths */ - build_unique_lengths(context, context->commands); + /* Config commands can not run after the config stage */ + LOG_ERROR("Command '%s' only runs during configuration stage", c->name); + return ERROR_FAIL; } - - 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 start_word=0; - command_t *c; - c=find_command(context, commands, words, num_words, start_word, &start_word); - if (c==NULL) - { - command_print(context, "Command %s not found", words[start_word]); - return ERROR_COMMAND_SYNTAX_ERROR; - } - 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) { @@ -419,316 +438,493 @@ int find_and_run_command(command_context_t *context, command_t *commands, char * /* we do not print out an error message because the command *should* * have printed out an error */ - LOG_DEBUG("Command failed with error code %d", retval); + LOG_DEBUG("Command failed with error code %d", retval); } - return retval; + + return retval; } -int command_run_line_internal_op(command_context_t *context, char *line, int run) +int command_run_line(command_context_t *context, char *line) { - 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; - - if (run) + /* 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) { - LOG_DEBUG("%s", line); - } + /* associated the return value */ + Jim_DeleteAssocData(interp, "retval"); + retcode = Jim_SetAssocData(interp, "retval", NULL, &retval); + if (retcode == JIM_OK) + { + retcode = Jim_Eval_Named(interp, line, __THIS__FILE__, __LINE__); - nwords = parse_line(line, words, sizeof(words) / sizeof(words[0])); - - if (nwords > 0) - { - if (run) + Jim_DeleteAssocData(interp, "retval"); + } + Jim_DeleteAssocData(interp, "context"); + } + if (retcode == JIM_ERR) { + if (retval != ERROR_COMMAND_CLOSE_CONNECTION) { - retval = find_and_run_command(context, context->commands, words, nwords); - } else + /* We do not print the connection closed error message */ + Jim_PrintErrorMessage(interp); + } + if (retval == ERROR_OK) { - int t; - return (find_command(context, context->commands, words, nwords, 0, &t)!=NULL)?ERROR_OK:ERROR_FAIL; + /* 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 > 0) + { + 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"); } + retval = ERROR_OK; } - 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) +int command_run_linef(command_context_t *context, const char *format, ...) +{ + int retval = ERROR_FAIL; + char *string; + va_list ap; + va_start(ap, format); + string = alloc_vprintf(format, ap); + if (string != NULL) + { + retval = command_run_line(context, string); + } + va_end(ap); + return retval; +} + +void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv) { - return command_run_line_internal_op(context, line, 1); + context->output_handler = output_handler; + context->output_handler_priv = priv; } -int command_run_line(command_context_t *context, char *line) +command_context_t* copy_command_context(command_context_t* context) { - if ((!context) || (!line)) - return ERROR_INVALID_ARGUMENTS; + command_context_t* copy_context = malloc(sizeof(command_context_t)); - 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); - } + *copy_context = *context; - return command_run_line_internal(context, line); + return copy_context; } -int command_run_file(command_context_t *context, FILE *file, enum command_mode mode) +int command_done(command_context_t *context) { - int retval = ERROR_OK; - int old_command_mode; - char *buffer=malloc(4096); - if (buffer==NULL) - { - return ERROR_INVALID_ARGUMENTS; - } - - 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; + free(context); + context = NULL; - /* run line */ - if ((retval = command_run_line(context, cmd)) == ERROR_COMMAND_CLOSE_CONNECTION) - break; - } - - context->mode = old_command_mode; + return ERROR_OK; +} - - free(buffer); - - return retval; +/* 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; } -int command_run_linef(command_context_t *context, char *format, ...) +static int jim_echo(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - int retval=ERROR_FAIL; - char *string; - va_list ap; - va_start(ap, format); - string = alloc_vprintf(format, ap); - if (string!=NULL) - { - retval=command_run_line(context, string); - } - va_end(ap); - return retval; + if (argc != 2) + return JIM_ERR; + const char *str = Jim_GetString(argv[1], NULL); + LOG_USER("%s", str); + return JIM_OK; } -void command_print_help_line(command_context_t* context, struct command_s *command, int indent) +static size_t openocd_jim_fwrite(const void *_ptr, size_t size, size_t n, void *cookie) { - 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); - - if (indent) - strncat(name_buf, indent_text, 64); - - command_print(context, "%20s\t%s", name_buf, help, indent); - - if (command->children) + 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) { - for (c = command->children; c; c = c->next) - { - command_print_help_line(context, c, indent + 1); + /* 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; } - free(indent_text); + + return n; } -int command_print_help_match(command_context_t* context, command_t* c_first, char* name, char** args, int argc) +static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie) { - command_t * c; - - for (c = c_first; c; c = c->next) - { - if (argc > 0) - { - if (strncasecmp(c->name, args[0], c->unique_len)) - continue; + /* TCL wants to read... tell him no */ + return 0; +} - if (strncasecmp(c->name, args[0], strlen(args[0]))) - continue; +static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap) +{ + char *cp; + int n; + Jim_Interp *interp; - if (argc > 1) - { - command_print_help_match(context, c->children, name, args + 1, argc - 1); - continue; - } - } + n = -1; + interp = cookie; + if (interp == NULL) + return n; - command_print_help_line(context, c, 0); + cp = alloc_vprintf(fmt, ap); + if (cp) + { + LOG_USER_N("%s", cp); + n = strlen(cp); + free(cp); } - - return ERROR_OK; + return n; } -int command_print_help(command_context_t* context, char* name, char** args, int argc) +static int openocd_jim_fflush(void *cookie) { - return command_print_help_match(context, context->commands, name, args, argc); + /* nothing to flush */ + 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 char* openocd_jim_fgets(char *s, int size, void *cookie) { - context->output_handler = output_handler; - context->output_handler_priv = priv; + /* not supported */ + errno = ENOTSUP; + return NULL; } -command_context_t* copy_command_context(command_context_t* context) +static int jim_capture(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - command_context_t* copy_context = malloc(sizeof(command_context_t)); + if (argc != 2) + return JIM_ERR; + int retcode; + const char *str = Jim_GetString(argv[1], NULL); - *copy_context = *context; - - return copy_context; + /* 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); + + retcode = Jim_Eval_Named(interp, str, __THIS__FILE__, __LINE__); + + log_remove_callback(tcl_output, tclOutput); + + /* We dump output into this local variable */ + Jim_SetResult(interp, tclOutput); + Jim_DecrRefCount(interp, tclOutput); + + return retcode; } -int command_done(command_context_t *context) +/* sleep command sleeps for miliseconds + * this is useful in target startup scripts + */ +static int handle_sleep_command(struct command_context_s *cmd_ctx, + char *cmd, char **args, int argc) { - free(context); - context = NULL; - + bool busy = false; + if (argc == 2) + { + if (strcmp(args[1], "busy") == 0) + busy = true; + else + return ERROR_COMMAND_SYNTAX_ERROR; + } + else if (argc < 1 || argc > 2) + return ERROR_COMMAND_SYNTAX_ERROR; + + unsigned long duration = 0; + int retval = parse_ulong(args[0], &duration); + if (ERROR_OK != retval) + return retval; + + if (!busy) + { + long long then = timeval_ms(); + while (timeval_ms() - then < (long long)duration) + { + target_call_timer_callbacks_now(); + usleep(1000); + } + } + else + busy_sleep(duration); + return ERROR_OK; } +static int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc != 1) + return ERROR_COMMAND_SYNTAX_ERROR; + + fast_and_dangerous = strcmp("enable", args[0]) == 0; + + return ERROR_OK; +} + + command_context_t* command_init() { command_context_t* context = malloc(sizeof(command_context_t)); - + extern const char startup_tcl[]; + const char *HostOs; + context->mode = COMMAND_EXEC; context->commands = NULL; context->current_target = 0; context->output_handler = NULL; context->output_handler_priv = NULL; - - register_command(context, NULL, "help", command_print_help, - COMMAND_EXEC, "display this help"); - - register_command(context, NULL, "sleep", handle_sleep_command, - COMMAND_ANY, "sleep for milliseconds"); - - register_command(context, NULL, "time", handle_time_command, - COMMAND_ANY, "time - execute and print time it took"); - - register_command(context, NULL, "fast", handle_fast_command, - COMMAND_ANY, "fast - place at beginning of config files. Sets defaults to fast and dangerous."); - - return context; -} -/* sleep command sleeps for miliseconds - * this is useful in target startup scripts - */ -int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - unsigned long duration = 0; - - if (argc == 1) +#if !BUILD_ECOSBOARD + Jim_InitEmbedded(); + /* Create an interpreter */ + interp = Jim_CreateInterp(); + /* Add all the Jim core commands */ + Jim_RegisterCoreCommands(interp); +#endif + +#if defined(_MSC_VER) + /* WinXX - is generic, the forward + * looking problem is this: + * + * "win32" or "win64" + * + * "winxx" is generic. + */ + HostOs = "winxx"; +#elif defined(__linux__) + HostOs = "linux"; +#elif defined(__DARWIN__) + HostOs = "darwin"; +#elif defined(__CYGWIN__) + HostOs = "cygwin"; +#elif defined(__MINGW32__) + HostOs = "mingw32"; +#else +#warn unrecognized host OS... + HostOs = "other"; +#endif + Jim_SetGlobalVariableStr(interp, "ocd_HOSTOS", + Jim_NewStringObj(interp, HostOs , strlen(HostOs))); + + Jim_CreateCommand(interp, "ocd_find", jim_find, NULL, NULL); + Jim_CreateCommand(interp, "echo", jim_echo, NULL, NULL); + Jim_CreateCommand(interp, "capture", jim_capture, 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; + +#if !BUILD_ECOSBOARD + Jim_EventLoopOnLoad(interp); +#endif + if (Jim_Eval_Named(interp, startup_tcl, "embedded:startup.tcl",1) == JIM_ERR) { - duration = strtoul(args[0], NULL, 0); - usleep(duration * 1000); + LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)"); + Jim_PrintErrorMessage(interp); + exit(-1); } - return ERROR_OK; + register_command(context, NULL, "sleep", + handle_sleep_command, COMMAND_ANY, + " [busy] - sleep for n milliseconds. " + "\"busy\" means busy wait"); + register_command(context, NULL, "fast", + handle_fast_command, COMMAND_ANY, + "fast - place at beginning of " + "config files. Sets defaults to fast and dangerous."); + + return context; } -int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +int command_context_mode(command_context_t *cmd_ctx, enum command_mode mode) { - if (argc!=1) - return ERROR_COMMAND_SYNTAX_ERROR; - - fast_and_dangerous = strcmp("enable", args[0])==0; - + if (!cmd_ctx) + return ERROR_INVALID_ARGUMENTS; + + cmd_ctx->mode = mode; return ERROR_OK; } +void process_jim_events(void) +{ +#if !BUILD_ECOSBOARD + static int recursion = 0; + + if (!recursion) + { + recursion++; + Jim_ProcessEvents (interp, JIM_ALL_EVENTS | JIM_DONT_WAIT); + recursion--; + } +#endif +} -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); + Jim_CreateCommand(interp, name, cmd, NULL, NULL); - return retval; + /* 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); } + +/* return global variable long value or 0 upon failure */ +long jim_global_long(const char *variable) +{ + Jim_Obj *objPtr = Jim_GetGlobalVariableStr(interp, variable, JIM_ERRMSG); + long t; + if (Jim_GetLong(interp, objPtr, &t) == JIM_OK) + { + return t; + } + return 0; +} + +#define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \ + int parse##name(const char *str, type *ul) \ + { \ + if (!*str) \ + { \ + LOG_ERROR("Invalid command argument"); \ + return ERROR_COMMAND_ARGUMENT_INVALID; \ + } \ + char *end; \ + *ul = func(str, &end, 0); \ + if (*end) \ + { \ + LOG_ERROR("Invalid command argument"); \ + return ERROR_COMMAND_ARGUMENT_INVALID; \ + } \ + if ((max == *ul) && (ERANGE == errno)) \ + { \ + LOG_ERROR("Argument overflow"); \ + return ERROR_COMMAND_ARGUMENT_OVERFLOW; \ + } \ + if (min && (min == *ul) && (ERANGE == errno)) \ + { \ + LOG_ERROR("Argument underflow"); \ + return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \ + } \ + return ERROR_OK; \ + } +DEFINE_PARSE_NUM_TYPE(_ulong, unsigned long , strtoul, 0, ULONG_MAX) +DEFINE_PARSE_NUM_TYPE(_ullong, unsigned long long, strtoull, 0, ULLONG_MAX) +DEFINE_PARSE_NUM_TYPE(_long, long , strtol, LONG_MIN, LONG_MAX) +DEFINE_PARSE_NUM_TYPE(_llong, long long, strtoll, LLONG_MIN, LLONG_MAX) + +#define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \ + int parse##name(const char *str, type *ul) \ + { \ + functype n; \ + int retval = parse##funcname(str, &n); \ + if (ERROR_OK != retval) \ + return retval; \ + if (n > max) \ + return ERROR_COMMAND_ARGUMENT_OVERFLOW; \ + if (min) \ + return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \ + *ul = n; \ + return ERROR_OK; \ + } + +#define DEFINE_PARSE_ULONG(name, type, min, max) \ + DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong) +DEFINE_PARSE_ULONG(_uint, unsigned, 0, UINT_MAX) +DEFINE_PARSE_ULONG(_u32, uint32_t, 0, UINT32_MAX) +DEFINE_PARSE_ULONG(_u16, uint16_t, 0, UINT16_MAX) +DEFINE_PARSE_ULONG(_u8, uint8_t, 0, UINT8_MAX) + +#define DEFINE_PARSE_LONG(name, type, min, max) \ + DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long) +DEFINE_PARSE_LONG(_int, int, n < INT_MIN, INT_MAX) +DEFINE_PARSE_LONG(_s32, int32_t, n < INT32_MIN, INT32_MAX) +DEFINE_PARSE_LONG(_s16, int16_t, n < INT16_MIN, INT16_MAX) +DEFINE_PARSE_LONG(_s8, int8_t, n < INT8_MIN, INT8_MAX)