1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008, Duane Ellis *
9 * openocd@duaneeellis.com *
11 * part of this file is taken from libcli (libcli.sourceforge.net) *
12 * Copyright (C) David Parrish (david@dparrish.com) *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
26 ***************************************************************************/
32 /* see Embedded-HOWTO.txt in Jim Tcl project hosted on BerliOS*/
35 /* @todo the inclusion of target.h here is a layering violation */
36 #include <jtag/jtag.h>
37 #include <target/target.h>
39 #include "configuration.h"
41 #include "time_support.h"
42 #include "jim-eventloop.h"
44 /* nice short description of source file */
45 #define __THIS__FILE__ "command.c"
47 struct log_capture_state
{
52 static int unregister_command(struct command_context
*context
,
53 const char *cmd_prefix
, const char *name
);
54 static int jim_command_dispatch(Jim_Interp
*interp
, int argc
, Jim_Obj
* const *argv
);
55 static int help_add_command(struct command_context
*cmd_ctx
,
56 const char *cmd_name
, const char *help_text
, const char *usage_text
);
57 static int help_del_command(struct command_context
*cmd_ctx
, const char *cmd_name
);
59 /* set of functions to wrap jimtcl internal data */
60 static inline bool jimcmd_is_proc(Jim_Cmd
*cmd
)
65 static inline bool jimcmd_is_ocd_command(Jim_Cmd
*cmd
)
67 return !cmd
->isproc
&& cmd
->u
.native
.cmdProc
== jim_command_dispatch
;
70 static inline void *jimcmd_privdata(Jim_Cmd
*cmd
)
72 return cmd
->isproc
? NULL
: cmd
->u
.native
.privData
;
75 static void tcl_output(void *privData
, const char *file
, unsigned line
,
76 const char *function
, const char *string
)
78 struct log_capture_state
*state
= privData
;
79 Jim_AppendString(state
->interp
, state
->output
, string
, strlen(string
));
82 static struct log_capture_state
*command_log_capture_start(Jim_Interp
*interp
)
84 /* capture log output and return it. A garbage collect can
85 * happen, so we need a reference count to this object */
86 Jim_Obj
*jim_output
= Jim_NewStringObj(interp
, "", 0);
90 Jim_IncrRefCount(jim_output
);
92 struct log_capture_state
*state
= malloc(sizeof(*state
));
94 LOG_ERROR("Out of memory");
95 Jim_DecrRefCount(interp
, jim_output
);
99 state
->interp
= interp
;
100 state
->output
= jim_output
;
102 log_add_callback(tcl_output
, state
);
107 /* Classic openocd commands provide progress output which we
108 * will capture and return as a Tcl return value.
110 * However, if a non-openocd command has been invoked, then it
111 * makes sense to return the tcl return value from that command.
113 * The tcl return value is empty for openocd commands that provide
116 * Therefore we set the tcl return value only if we actually
119 static void command_log_capture_finish(struct log_capture_state
*state
)
124 log_remove_callback(tcl_output
, state
);
127 Jim_GetString(state
->output
, &length
);
130 Jim_SetResult(state
->interp
, state
->output
);
132 /* No output captured, use tcl return value (which could
135 Jim_DecrRefCount(state
->interp
, state
->output
);
141 * FIXME: workaround for memory leak in jimtcl 0.80
142 * Jim API Jim_CreateCommand() converts the command name in a Jim object and
143 * does not free the object. Fixed for jimtcl 0.81 by e4416cf86f0b
144 * Use the internal jimtcl API Jim_CreateCommandObj, not exported by jim.h,
145 * and override the bugged API through preprocessor's macro.
146 * This workaround works only when jimtcl is compiled as OpenOCD submodule.
147 * If jimtcl is linked-in from a precompiled library, either static or dynamic,
148 * the symbol Jim_CreateCommandObj is not exported and the build will use the
150 * To be removed when OpenOCD will switch to jimtcl 0.81
152 #if JIM_VERSION == 80
153 static int workaround_createcommand(Jim_Interp
*interp
, const char *cmdName
,
154 Jim_CmdProc
*cmdProc
, void *privData
, Jim_DelCmdProc
*delProc
);
155 int Jim_CreateCommandObj(Jim_Interp
*interp
, Jim_Obj
*cmdNameObj
,
156 Jim_CmdProc
*cmdProc
, void *privData
, Jim_DelCmdProc
*delProc
)
157 __attribute__((weak
, alias("workaround_createcommand")));
158 static int workaround_createcommand(Jim_Interp
*interp
, const char *cmdName
,
159 Jim_CmdProc
*cmdProc
, void *privData
, Jim_DelCmdProc
*delProc
)
161 if ((void *)Jim_CreateCommandObj
== (void *)workaround_createcommand
)
162 return Jim_CreateCommand(interp
, cmdName
, cmdProc
, privData
, delProc
);
164 Jim_Obj
*cmd_name
= Jim_NewStringObj(interp
, cmdName
, -1);
165 Jim_IncrRefCount(cmd_name
);
166 int retval
= Jim_CreateCommandObj(interp
, cmd_name
, cmdProc
, privData
, delProc
);
167 Jim_DecrRefCount(interp
, cmd_name
);
170 #define Jim_CreateCommand workaround_createcommand
171 #endif /* JIM_VERSION == 80 */
172 /* FIXME: end of workaround for memory leak in jimtcl 0.80 */
174 static int command_retval_set(Jim_Interp
*interp
, int retval
)
176 int *return_retval
= Jim_GetAssocData(interp
, "retval");
177 if (return_retval
!= NULL
)
178 *return_retval
= retval
;
180 return (retval
== ERROR_OK
) ? JIM_OK
: retval
;
183 extern struct command_context
*global_cmd_ctx
;
185 /* dump a single line to the log for the command.
186 * Do nothing in case we are not at debug level 3 */
187 static void script_debug(Jim_Interp
*interp
, unsigned int argc
, Jim_Obj
* const *argv
)
189 if (debug_level
< LOG_LVL_DEBUG
)
192 char *dbg
= alloc_printf("command -");
193 for (unsigned i
= 0; i
< argc
; i
++) {
195 const char *w
= Jim_GetString(argv
[i
], &len
);
196 char *t
= alloc_printf("%s %s", dbg
, w
);
200 LOG_DEBUG("%s", dbg
);
204 static void script_command_args_free(char **words
, unsigned nwords
)
206 for (unsigned i
= 0; i
< nwords
; i
++)
211 static char **script_command_args_alloc(
212 unsigned argc
, Jim_Obj
* const *argv
, unsigned *nwords
)
214 char **words
= malloc(argc
* sizeof(char *));
219 for (i
= 0; i
< argc
; i
++) {
221 const char *w
= Jim_GetString(argv
[i
], &len
);
222 words
[i
] = strdup(w
);
223 if (words
[i
] == NULL
) {
224 script_command_args_free(words
, i
);
232 struct command_context
*current_command_context(Jim_Interp
*interp
)
234 /* grab the command context from the associated data */
235 struct command_context
*cmd_ctx
= Jim_GetAssocData(interp
, "context");
236 if (NULL
== cmd_ctx
) {
237 /* Tcl can invoke commands directly instead of via command_run_line(). This would
238 * happen when the Jim Tcl interpreter is provided by eCos or if we are running
239 * commands in a startup script.
241 * A telnet or gdb server would provide a non-default command context to
242 * handle piping of error output, have a separate current target, etc.
244 cmd_ctx
= global_cmd_ctx
;
250 * Find a openocd command from fullname.
251 * @returns Returns the named command if it is registred in interp.
252 * Returns NULL otherwise.
254 static struct command
*command_find_from_name(Jim_Interp
*interp
, const char *name
)
259 Jim_Obj
*jim_name
= Jim_NewStringObj(interp
, name
, -1);
260 Jim_IncrRefCount(jim_name
);
261 Jim_Cmd
*cmd
= Jim_GetCommand(interp
, jim_name
, JIM_NONE
);
262 Jim_DecrRefCount(interp
, jim_name
);
263 if (!cmd
|| jimcmd_is_proc(cmd
) || !jimcmd_is_ocd_command(cmd
))
266 return jimcmd_privdata(cmd
);
269 static struct command
*command_new(struct command_context
*cmd_ctx
,
270 const char *full_name
, const struct command_registration
*cr
)
275 * If it is a non-jim command with no .usage specified,
278 * strlen(.usage) == 0 means that the command takes no
281 if (!cr
->jim_handler
&& !cr
->usage
)
282 LOG_ERROR("BUG: command '%s' does not have the "
283 "'.usage' field filled out",
286 struct command
*c
= calloc(1, sizeof(struct command
));
290 c
->name
= strdup(cr
->name
);
296 c
->handler
= cr
->handler
;
297 c
->jim_handler
= cr
->jim_handler
;
300 if (cr
->help
|| cr
->usage
)
301 help_add_command(cmd_ctx
, full_name
, cr
->help
, cr
->usage
);
306 static void command_free(struct Jim_Interp
*interp
, void *priv
)
308 struct command
*c
= priv
;
314 static struct command
*register_command(struct command_context
*context
,
315 const char *cmd_prefix
, const struct command_registration
*cr
)
319 if (!context
|| !cr
->name
)
323 full_name
= alloc_printf("%s %s", cmd_prefix
, cr
->name
);
325 full_name
= strdup(cr
->name
);
329 struct command
*c
= command_find_from_name(context
->interp
, full_name
);
331 /* TODO: originally we treated attempting to register a cmd twice as an error
332 * Sometimes we need this behaviour, such as with flash banks.
333 * http://www.mail-archive.com/openocd-development@lists.berlios.de/msg11152.html */
334 LOG_DEBUG("command '%s' is already registered", full_name
);
339 c
= command_new(context
, full_name
, cr
);
345 LOG_DEBUG("registering '%s'...", full_name
);
346 int retval
= Jim_CreateCommand(context
->interp
, full_name
,
347 jim_command_dispatch
, c
, command_free
);
348 if (retval
!= JIM_OK
) {
349 command_run_linef(context
, "del_help_text {%s}", full_name
);
350 command_run_linef(context
, "del_usage_text {%s}", full_name
);
360 int __register_commands(struct command_context
*cmd_ctx
, const char *cmd_prefix
,
361 const struct command_registration
*cmds
, void *data
,
362 struct target
*override_target
)
364 int retval
= ERROR_OK
;
366 for (i
= 0; cmds
[i
].name
|| cmds
[i
].chain
; i
++) {
367 const struct command_registration
*cr
= cmds
+ i
;
369 struct command
*c
= NULL
;
370 if (NULL
!= cr
->name
) {
371 c
= register_command(cmd_ctx
, cmd_prefix
, cr
);
376 c
->jim_handler_data
= data
;
377 c
->jim_override_target
= override_target
;
379 if (NULL
!= cr
->chain
) {
382 char *new_prefix
= alloc_printf("%s %s", cmd_prefix
, cr
->name
);
387 retval
= __register_commands(cmd_ctx
, new_prefix
, cr
->chain
, data
, override_target
);
390 retval
= __register_commands(cmd_ctx
, cr
->name
, cr
->chain
, data
, override_target
);
393 retval
= __register_commands(cmd_ctx
, cmd_prefix
, cr
->chain
, data
, override_target
);
395 if (ERROR_OK
!= retval
)
399 if (ERROR_OK
!= retval
) {
400 for (unsigned j
= 0; j
< i
; j
++)
401 unregister_command(cmd_ctx
, cmd_prefix
, cmds
[j
].name
);
406 static __attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT
, 2, 3)))
407 int unregister_commands_match(struct command_context
*cmd_ctx
, const char *format
, ...)
409 Jim_Interp
*interp
= cmd_ctx
->interp
;
412 va_start(ap
, format
);
413 char *query
= alloc_vprintf(format
, ap
);
418 char *query_cmd
= alloc_printf("info commands {%s}", query
);
423 int retval
= Jim_EvalSource(interp
, __THIS__FILE__
, __LINE__
, query_cmd
);
425 if (retval
!= JIM_OK
)
428 Jim_Obj
*list
= Jim_GetResult(interp
);
429 Jim_IncrRefCount(list
);
431 int len
= Jim_ListLength(interp
, list
);
432 for (int i
= 0; i
< len
; i
++) {
433 Jim_Obj
*elem
= Jim_ListGetIndex(interp
, list
, i
);
434 Jim_IncrRefCount(elem
);
436 const char *name
= Jim_GetString(elem
, NULL
);
437 struct command
*c
= command_find_from_name(interp
, name
);
439 /* not openocd command */
440 Jim_DecrRefCount(interp
, elem
);
443 LOG_DEBUG("delete command \"%s\"", name
);
444 #if JIM_VERSION >= 80
445 Jim_DeleteCommand(interp
, elem
);
447 Jim_DeleteCommand(interp
, name
);
450 help_del_command(cmd_ctx
, name
);
452 Jim_DecrRefCount(interp
, elem
);
455 Jim_DecrRefCount(interp
, list
);
459 int unregister_all_commands(struct command_context
*context
,
460 const char *cmd_prefix
)
465 if (!cmd_prefix
|| !*cmd_prefix
)
466 return unregister_commands_match(context
, "*");
468 int retval
= unregister_commands_match(context
, "%s *", cmd_prefix
);
469 if (retval
!= ERROR_OK
)
472 return unregister_commands_match(context
, "%s", cmd_prefix
);
475 static int unregister_command(struct command_context
*context
,
476 const char *cmd_prefix
, const char *name
)
478 if (!context
|| !name
)
479 return ERROR_COMMAND_SYNTAX_ERROR
;
481 if (!cmd_prefix
|| !*cmd_prefix
)
482 return unregister_commands_match(context
, "%s", name
);
484 return unregister_commands_match(context
, "%s %s", cmd_prefix
, name
);
487 void command_output_text(struct command_context
*context
, const char *data
)
489 if (context
&& context
->output_handler
&& data
)
490 context
->output_handler(context
, data
);
493 void command_print_sameline(struct command_invocation
*cmd
, const char *format
, ...)
498 va_start(ap
, format
);
500 string
= alloc_vprintf(format
, ap
);
501 if (string
!= NULL
&& cmd
) {
502 /* we want this collected in the log + we also want to pick it up as a tcl return
505 * The latter bit isn't precisely neat, but will do for now.
507 Jim_AppendString(cmd
->ctx
->interp
, cmd
->output
, string
, -1);
508 /* We already printed it above
509 * command_output_text(context, string); */
516 void command_print(struct command_invocation
*cmd
, const char *format
, ...)
521 va_start(ap
, format
);
523 string
= alloc_vprintf(format
, ap
);
524 if (string
!= NULL
&& cmd
) {
525 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one
527 /* we want this collected in the log + we also want to pick it up as a tcl return
530 * The latter bit isn't precisely neat, but will do for now.
532 Jim_AppendString(cmd
->ctx
->interp
, cmd
->output
, string
, -1);
533 /* We already printed it above
534 * command_output_text(context, string); */
541 static bool command_can_run(struct command_context
*cmd_ctx
, struct command
*c
, const char *full_name
)
543 if (c
->mode
== COMMAND_ANY
|| c
->mode
== cmd_ctx
->mode
)
546 /* Many commands may be run only before/after 'init' */
555 /* handle the impossible with humor; it guarantees a bug report! */
557 when
= "if Cthulhu is summoned by";
560 LOG_ERROR("The '%s' command must be used %s 'init'.",
561 full_name
? full_name
: c
->name
, when
);
565 static int run_command(struct command_context
*context
,
566 struct command
*c
, const char **words
, unsigned num_words
)
568 struct command_invocation cmd
= {
572 .argc
= num_words
- 1,
576 cmd
.output
= Jim_NewEmptyStringObj(context
->interp
);
577 Jim_IncrRefCount(cmd
.output
);
579 int retval
= c
->handler(&cmd
);
580 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
) {
581 /* Print help for command */
582 command_run_linef(context
, "usage %s", words
[0]);
583 } else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
) {
584 /* just fall through for a shutdown request */
586 if (retval
!= ERROR_OK
)
587 LOG_DEBUG("Command '%s' failed with error code %d",
589 /* Use the command output as the Tcl result */
590 Jim_SetResult(context
->interp
, cmd
.output
);
592 Jim_DecrRefCount(context
->interp
, cmd
.output
);
597 int command_run_line(struct command_context
*context
, char *line
)
599 /* all the parent commands have been registered with the interpreter
600 * so, can just evaluate the line as a script and check for
603 /* run the line thru a script engine */
604 int retval
= ERROR_FAIL
;
606 /* Beware! This code needs to be reentrant. It is also possible
607 * for OpenOCD commands to be invoked directly from Tcl. This would
608 * happen when the Jim Tcl interpreter is provided by eCos for
611 struct target
*saved_target_override
= context
->current_target_override
;
612 context
->current_target_override
= NULL
;
614 Jim_Interp
*interp
= context
->interp
;
615 struct command_context
*old_context
= Jim_GetAssocData(interp
, "context");
616 Jim_DeleteAssocData(interp
, "context");
617 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
618 if (retcode
== JIM_OK
) {
619 /* associated the return value */
620 Jim_DeleteAssocData(interp
, "retval");
621 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
622 if (retcode
== JIM_OK
) {
623 retcode
= Jim_Eval_Named(interp
, line
, 0, 0);
625 Jim_DeleteAssocData(interp
, "retval");
627 Jim_DeleteAssocData(interp
, "context");
628 int inner_retcode
= Jim_SetAssocData(interp
, "context", NULL
, old_context
);
629 if (retcode
== JIM_OK
)
630 retcode
= inner_retcode
;
632 context
->current_target_override
= saved_target_override
;
633 if (retcode
== JIM_OK
) {
637 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
639 command_output_text(context
, result
);
640 command_output_text(context
, "\n");
643 } else if (retcode
== JIM_EXIT
) {
645 * exit(Jim_GetExitCode(interp)); */
646 } else if (retcode
== ERROR_COMMAND_CLOSE_CONNECTION
) {
649 Jim_MakeErrorMessage(interp
);
650 /* error is broadcast */
651 LOG_USER("%s", Jim_GetString(Jim_GetResult(interp
), NULL
));
653 if (retval
== ERROR_OK
) {
654 /* It wasn't a low level OpenOCD command that failed */
663 int command_run_linef(struct command_context
*context
, const char *format
, ...)
665 int retval
= ERROR_FAIL
;
668 va_start(ap
, format
);
669 string
= alloc_vprintf(format
, ap
);
670 if (string
!= NULL
) {
671 retval
= command_run_line(context
, string
);
678 void command_set_output_handler(struct command_context
*context
,
679 command_output_handler_t output_handler
, void *priv
)
681 context
->output_handler
= output_handler
;
682 context
->output_handler_priv
= priv
;
685 struct command_context
*copy_command_context(struct command_context
*context
)
687 struct command_context
*copy_context
= malloc(sizeof(struct command_context
));
689 *copy_context
= *context
;
694 void command_done(struct command_context
*cmd_ctx
)
702 /* find full path to file */
703 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
707 const char *file
= Jim_GetString(argv
[1], NULL
);
708 char *full_path
= find_file(file
);
709 if (full_path
== NULL
)
711 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
714 Jim_SetResult(interp
, result
);
718 COMMAND_HANDLER(jim_echo
)
720 if (CMD_ARGC
== 2 && !strcmp(CMD_ARGV
[0], "-n")) {
721 LOG_USER_N("%s", CMD_ARGV
[1]);
726 LOG_USER("%s", CMD_ARGV
[0]);
730 /* Capture progress output and return as tcl return value. If the
731 * progress output was empty, return tcl return value.
733 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
738 struct log_capture_state
*state
= command_log_capture_start(interp
);
740 /* disable polling during capture. This avoids capturing output
743 * This is necessary in order to avoid accidentally getting a non-empty
744 * string for tcl fn's.
746 bool save_poll
= jtag_poll_get_enabled();
748 jtag_poll_set_enabled(false);
750 const char *str
= Jim_GetString(argv
[1], NULL
);
751 int retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
753 jtag_poll_set_enabled(save_poll
);
755 command_log_capture_finish(state
);
767 static COMMAND_HELPER(command_help_show
, struct help_entry
*c
,
768 bool show_help
, const char *cmd_match
);
770 static COMMAND_HELPER(command_help_show_list
, bool show_help
, const char *cmd_match
)
772 struct help_entry
*entry
;
774 list_for_each_entry(entry
, CMD_CTX
->help_list
, lh
)
775 CALL_COMMAND_HANDLER(command_help_show
, entry
, show_help
, cmd_match
);
779 #define HELP_LINE_WIDTH(_n) (int)(76 - (2 * _n))
781 static void command_help_show_indent(unsigned n
)
783 for (unsigned i
= 0; i
< n
; i
++)
786 static void command_help_show_wrap(const char *str
, unsigned n
, unsigned n2
)
788 const char *cp
= str
, *last
= str
;
790 const char *next
= last
;
795 } while (*next
!= ' ' && *next
!= '\t' && *next
!= '\0');
796 } while ((next
- last
< HELP_LINE_WIDTH(n
)) && *next
!= '\0');
797 if (next
- last
< HELP_LINE_WIDTH(n
))
799 command_help_show_indent(n
);
800 LOG_USER("%.*s", (int)(cp
- last
), last
);
806 static COMMAND_HELPER(command_help_show
, struct help_entry
*c
,
807 bool show_help
, const char *cmd_match
)
810 for (const char *s
= strchr(c
->cmd_name
, ' '); s
; s
= strchr(s
+ 1, ' '))
813 /* If the match string occurs anywhere, we print out
814 * stuff for this command. */
815 bool is_match
= (strstr(c
->cmd_name
, cmd_match
) != NULL
) ||
816 ((c
->usage
!= NULL
) && (strstr(c
->usage
, cmd_match
) != NULL
)) ||
817 ((c
->help
!= NULL
) && (strstr(c
->help
, cmd_match
) != NULL
));
820 command_help_show_indent(n
);
821 LOG_USER_N("%s", c
->cmd_name
);
823 if (c
->usage
&& strlen(c
->usage
) > 0) {
825 command_help_show_wrap(c
->usage
, 0, n
+ 5);
830 if (is_match
&& show_help
) {
833 /* TODO: factorize jim_command_mode() to avoid running jim command here */
834 char *request
= alloc_printf("command mode %s", c
->cmd_name
);
836 LOG_ERROR("Out of memory");
839 int retval
= Jim_Eval(CMD_CTX
->interp
, request
);
841 enum command_mode mode
= COMMAND_UNKNOWN
;
842 if (retval
!= JIM_ERR
) {
843 const char *result
= Jim_GetString(Jim_GetResult(CMD_CTX
->interp
), NULL
);
844 if (!strcmp(result
, "any"))
846 else if (!strcmp(result
, "config"))
847 mode
= COMMAND_CONFIG
;
848 else if (!strcmp(result
, "exec"))
852 /* Normal commands are runtime-only; highlight exceptions */
853 if (mode
!= COMMAND_EXEC
) {
854 const char *stage_msg
= "";
858 stage_msg
= " (configuration command)";
861 stage_msg
= " (command valid any time)";
864 stage_msg
= " (?mode error?)";
867 msg
= alloc_printf("%s%s", c
->help
? : "", stage_msg
);
869 msg
= alloc_printf("%s", c
->help
? : "");
872 command_help_show_wrap(msg
, n
+ 3, n
+ 3);
881 COMMAND_HANDLER(handle_help_command
)
883 bool full
= strcmp(CMD_NAME
, "help") == 0;
888 cmd_match
= strdup("");
891 cmd_match
= strdup(CMD_ARGV
[0]);
893 for (unsigned int i
= 1; i
< CMD_ARGC
&& cmd_match
; ++i
) {
894 char *prev
= cmd_match
;
895 cmd_match
= alloc_printf("%s %s", prev
, CMD_ARGV
[i
]);
900 if (cmd_match
== NULL
) {
901 LOG_ERROR("unable to build search string");
904 retval
= CALL_COMMAND_HANDLER(command_help_show_list
, full
, cmd_match
);
910 static char *alloc_concatenate_strings(int argc
, Jim_Obj
* const *argv
)
917 all
= strdup(Jim_GetString(argv
[0], NULL
));
919 LOG_ERROR("Out of memory");
923 for (i
= 1; i
< argc
; ++i
) {
925 all
= alloc_printf("%s %s", all
, Jim_GetString(argv
[i
], NULL
));
928 LOG_ERROR("Out of memory");
936 static int exec_command(Jim_Interp
*interp
, struct command_context
*cmd_ctx
,
937 struct command
*c
, int argc
, Jim_Obj
* const *argv
)
940 return c
->jim_handler(interp
, argc
, argv
);
944 char **words
= script_command_args_alloc(argc
, argv
, &nwords
);
948 int retval
= run_command(cmd_ctx
, c
, (const char **)words
, nwords
);
949 script_command_args_free(words
, nwords
);
950 return command_retval_set(interp
, retval
);
953 static int jim_command_dispatch(Jim_Interp
*interp
, int argc
, Jim_Obj
* const *argv
)
955 script_debug(interp
, argc
, argv
);
957 /* check subcommands */
959 char *s
= alloc_printf("%s %s", Jim_GetString(argv
[0], NULL
), Jim_GetString(argv
[1], NULL
));
960 Jim_Obj
*js
= Jim_NewStringObj(interp
, s
, -1);
961 Jim_IncrRefCount(js
);
963 Jim_Cmd
*cmd
= Jim_GetCommand(interp
, js
, JIM_NONE
);
965 int retval
= Jim_EvalObjPrefix(interp
, js
, argc
- 2, argv
+ 2);
966 Jim_DecrRefCount(interp
, js
);
969 Jim_DecrRefCount(interp
, js
);
972 struct command
*c
= jim_to_command(interp
);
973 if (!c
->jim_handler
&& !c
->handler
) {
974 Jim_EvalObjPrefix(interp
, Jim_NewStringObj(interp
, "usage", -1), 1, argv
);
978 struct command_context
*cmd_ctx
= current_command_context(interp
);
980 if (!command_can_run(cmd_ctx
, c
, Jim_GetString(argv
[0], NULL
)))
983 target_call_timer_callbacks_now();
986 * Black magic of overridden current target:
987 * If the command we are going to handle has a target prefix,
988 * override the current target temporarily for the time
989 * of processing the command.
990 * current_target_override is used also for event handlers
991 * therefore we prevent touching it if command has no prefix.
992 * Previous override is saved and restored back to ensure
993 * correct work when jim_command_dispatch() is re-entered.
995 struct target
*saved_target_override
= cmd_ctx
->current_target_override
;
996 if (c
->jim_override_target
)
997 cmd_ctx
->current_target_override
= c
->jim_override_target
;
999 int retval
= exec_command(interp
, cmd_ctx
, c
, argc
, argv
);
1001 if (c
->jim_override_target
)
1002 cmd_ctx
->current_target_override
= saved_target_override
;
1007 static int jim_command_mode(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1009 struct command_context
*cmd_ctx
= current_command_context(interp
);
1010 enum command_mode mode
;
1013 char *full_name
= alloc_concatenate_strings(argc
- 1, argv
+ 1);
1016 Jim_Obj
*s
= Jim_NewStringObj(interp
, full_name
, -1);
1017 Jim_IncrRefCount(s
);
1018 Jim_Cmd
*cmd
= Jim_GetCommand(interp
, s
, JIM_NONE
);
1019 Jim_DecrRefCount(interp
, s
);
1021 if (!cmd
|| !(jimcmd_is_proc(cmd
) || jimcmd_is_ocd_command(cmd
))) {
1022 Jim_SetResultString(interp
, "unknown", -1);
1026 if (jimcmd_is_proc(cmd
)) {
1030 struct command
*c
= jimcmd_privdata(cmd
);
1035 mode
= cmd_ctx
->mode
;
1037 const char *mode_str
;
1042 case COMMAND_CONFIG
:
1043 mode_str
= "config";
1049 mode_str
= "unknown";
1052 Jim_SetResultString(interp
, mode_str
, -1);
1056 int help_del_all_commands(struct command_context
*cmd_ctx
)
1058 struct help_entry
*curr
, *n
;
1060 list_for_each_entry_safe(curr
, n
, cmd_ctx
->help_list
, lh
) {
1061 list_del(&curr
->lh
);
1062 free(curr
->cmd_name
);
1070 static int help_del_command(struct command_context
*cmd_ctx
, const char *cmd_name
)
1072 struct help_entry
*curr
;
1074 list_for_each_entry(curr
, cmd_ctx
->help_list
, lh
) {
1075 if (!strcmp(cmd_name
, curr
->cmd_name
)) {
1076 list_del(&curr
->lh
);
1077 free(curr
->cmd_name
);
1088 static int help_add_command(struct command_context
*cmd_ctx
,
1089 const char *cmd_name
, const char *help_text
, const char *usage_text
)
1091 int cmp
= -1; /* add after curr */
1092 struct help_entry
*curr
;
1094 list_for_each_entry_reverse(curr
, cmd_ctx
->help_list
, lh
) {
1095 cmp
= strcmp(cmd_name
, curr
->cmd_name
);
1100 struct help_entry
*entry
;
1102 entry
= calloc(1, sizeof(*entry
));
1104 LOG_ERROR("Out of memory");
1107 entry
->cmd_name
= strdup(cmd_name
);
1108 if (!entry
->cmd_name
) {
1109 LOG_ERROR("Out of memory");
1113 list_add(&entry
->lh
, &curr
->lh
);
1119 char *text
= strdup(help_text
);
1121 LOG_ERROR("Out of memory");
1129 char *text
= strdup(usage_text
);
1131 LOG_ERROR("Out of memory");
1135 entry
->usage
= text
;
1141 COMMAND_HANDLER(handle_help_add_command
)
1144 return ERROR_COMMAND_SYNTAX_ERROR
;
1146 const char *help
= !strcmp(CMD_NAME
, "add_help_text") ? CMD_ARGV
[1] : NULL
;
1147 const char *usage
= !strcmp(CMD_NAME
, "add_usage_text") ? CMD_ARGV
[1] : NULL
;
1148 if (!help
&& !usage
) {
1149 LOG_ERROR("command name '%s' is unknown", CMD_NAME
);
1150 return ERROR_COMMAND_SYNTAX_ERROR
;
1152 const char *cmd_name
= CMD_ARGV
[0];
1153 return help_add_command(CMD_CTX
, cmd_name
, help
, usage
);
1156 /* sleep command sleeps for <n> milliseconds
1157 * this is useful in target startup scripts
1159 COMMAND_HANDLER(handle_sleep_command
)
1162 if (CMD_ARGC
== 2) {
1163 if (strcmp(CMD_ARGV
[1], "busy") == 0)
1166 return ERROR_COMMAND_SYNTAX_ERROR
;
1167 } else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
1168 return ERROR_COMMAND_SYNTAX_ERROR
;
1170 unsigned long duration
= 0;
1171 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
1172 if (ERROR_OK
!= retval
)
1176 int64_t then
= timeval_ms();
1177 while (timeval_ms() - then
< (int64_t)duration
) {
1178 target_call_timer_callbacks_now();
1182 busy_sleep(duration
);
1187 static const struct command_registration command_subcommand_handlers
[] = {
1190 .mode
= COMMAND_ANY
,
1191 .jim_handler
= jim_command_mode
,
1192 .usage
= "[command_name ...]",
1193 .help
= "Returns the command modes allowed by a command: "
1194 "'any', 'config', or 'exec'. If no command is "
1195 "specified, returns the current command mode. "
1196 "Returns 'unknown' if an unknown command is given. "
1197 "Command can be multiple tokens.",
1199 COMMAND_REGISTRATION_DONE
1202 static const struct command_registration command_builtin_handlers
[] = {
1205 .mode
= COMMAND_ANY
,
1206 .jim_handler
= jim_find
,
1207 .help
= "find full path to file",
1212 .mode
= COMMAND_ANY
,
1213 .jim_handler
= jim_capture
,
1214 .help
= "Capture progress output and return as tcl return value. If the "
1215 "progress output was empty, return tcl return value.",
1220 .handler
= jim_echo
,
1221 .mode
= COMMAND_ANY
,
1222 .help
= "Logs a message at \"user\" priority. "
1223 "Output message to stdout. "
1224 "Option \"-n\" suppresses trailing newline",
1225 .usage
= "[-n] string",
1228 .name
= "add_help_text",
1229 .handler
= handle_help_add_command
,
1230 .mode
= COMMAND_ANY
,
1231 .help
= "Add new command help text; "
1232 "Command can be multiple tokens.",
1233 .usage
= "command_name helptext_string",
1236 .name
= "add_usage_text",
1237 .handler
= handle_help_add_command
,
1238 .mode
= COMMAND_ANY
,
1239 .help
= "Add new command usage text; "
1240 "command can be multiple tokens.",
1241 .usage
= "command_name usage_string",
1245 .handler
= handle_sleep_command
,
1246 .mode
= COMMAND_ANY
,
1247 .help
= "Sleep for specified number of milliseconds. "
1248 "\"busy\" will busy wait instead (avoid this).",
1249 .usage
= "milliseconds ['busy']",
1253 .handler
= handle_help_command
,
1254 .mode
= COMMAND_ANY
,
1255 .help
= "Show full command help; "
1256 "command can be multiple tokens.",
1257 .usage
= "[command_name]",
1261 .handler
= handle_help_command
,
1262 .mode
= COMMAND_ANY
,
1263 .help
= "Show basic command usage; "
1264 "command can be multiple tokens.",
1265 .usage
= "[command_name]",
1269 .mode
= COMMAND_ANY
,
1270 .help
= "core command group (introspection)",
1271 .chain
= command_subcommand_handlers
,
1274 COMMAND_REGISTRATION_DONE
1277 struct command_context
*command_init(const char *startup_tcl
, Jim_Interp
*interp
)
1279 struct command_context
*context
= calloc(1, sizeof(struct command_context
));
1281 context
->mode
= COMMAND_EXEC
;
1283 /* context can be duplicated. Put list head on separate mem-chunk to keep list consistent */
1284 context
->help_list
= malloc(sizeof(*context
->help_list
));
1285 INIT_LIST_HEAD(context
->help_list
);
1287 /* Create a jim interpreter if we were not handed one */
1288 if (interp
== NULL
) {
1289 /* Create an interpreter */
1290 interp
= Jim_CreateInterp();
1291 /* Add all the Jim core commands */
1292 Jim_RegisterCoreCommands(interp
);
1293 Jim_InitStaticExtensions(interp
);
1296 context
->interp
= interp
;
1298 register_commands(context
, NULL
, command_builtin_handlers
);
1300 Jim_SetAssocData(interp
, "context", NULL
, context
);
1301 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl", 1) == JIM_ERR
) {
1302 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1303 Jim_MakeErrorMessage(interp
);
1304 LOG_USER_N("%s", Jim_GetString(Jim_GetResult(interp
), NULL
));
1307 Jim_DeleteAssocData(interp
, "context");
1312 void command_exit(struct command_context
*context
)
1317 Jim_FreeInterp(context
->interp
);
1318 free(context
->help_list
);
1319 command_done(context
);
1322 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
1325 return ERROR_COMMAND_SYNTAX_ERROR
;
1327 cmd_ctx
->mode
= mode
;
1331 void process_jim_events(struct command_context
*cmd_ctx
)
1333 static int recursion
;
1338 Jim_ProcessEvents(cmd_ctx
->interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
1342 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1343 int parse ## name(const char *str, type * ul) \
1346 LOG_ERROR("Invalid command argument"); \
1347 return ERROR_COMMAND_ARGUMENT_INVALID; \
1351 *ul = func(str, &end, 0); \
1353 LOG_ERROR("Invalid command argument"); \
1354 return ERROR_COMMAND_ARGUMENT_INVALID; \
1356 if ((max == *ul) && (ERANGE == errno)) { \
1357 LOG_ERROR("Argument overflow"); \
1358 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1360 if (min && (min == *ul) && (ERANGE == errno)) { \
1361 LOG_ERROR("Argument underflow"); \
1362 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1366 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long, strtoul
, 0, ULONG_MAX
)
1367 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1368 DEFINE_PARSE_NUM_TYPE(_long
, long, strtol
, LONG_MIN
, LONG_MAX
)
1369 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1371 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1372 int parse ## name(const char *str, type * ul) \
1375 int retval = parse ## funcname(str, &n); \
1376 if (ERROR_OK != retval) \
1379 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1381 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1386 #define DEFINE_PARSE_ULONGLONG(name, type, min, max) \
1387 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long long, _ullong)
1388 DEFINE_PARSE_ULONGLONG(_uint
, unsigned, 0, UINT_MAX
)
1389 DEFINE_PARSE_ULONGLONG(_u64
, uint64_t, 0, UINT64_MAX
)
1390 DEFINE_PARSE_ULONGLONG(_u32
, uint32_t, 0, UINT32_MAX
)
1391 DEFINE_PARSE_ULONGLONG(_u16
, uint16_t, 0, UINT16_MAX
)
1392 DEFINE_PARSE_ULONGLONG(_u8
, uint8_t, 0, UINT8_MAX
)
1394 DEFINE_PARSE_ULONGLONG(_target_addr
, target_addr_t
, 0, TARGET_ADDR_MAX
)
1396 #define DEFINE_PARSE_LONGLONG(name, type, min, max) \
1397 DEFINE_PARSE_WRAPPER(name, type, min, max, long long, _llong)
1398 DEFINE_PARSE_LONGLONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1399 DEFINE_PARSE_LONGLONG(_s64
, int64_t, n
< INT64_MIN
, INT64_MAX
)
1400 DEFINE_PARSE_LONGLONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1401 DEFINE_PARSE_LONGLONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1402 DEFINE_PARSE_LONGLONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1404 static int command_parse_bool(const char *in
, bool *out
,
1405 const char *on
, const char *off
)
1407 if (strcasecmp(in
, on
) == 0)
1409 else if (strcasecmp(in
, off
) == 0)
1412 return ERROR_COMMAND_SYNTAX_ERROR
;
1416 int command_parse_bool_arg(const char *in
, bool *out
)
1418 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1420 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1422 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1424 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1426 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1428 return ERROR_COMMAND_SYNTAX_ERROR
;
1431 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1435 const char *in
= CMD_ARGV
[0];
1436 if (command_parse_bool_arg(in
, out
) != ERROR_OK
) {
1437 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1438 return ERROR_COMMAND_SYNTAX_ERROR
;
1443 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1446 return ERROR_COMMAND_SYNTAX_ERROR
;
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)