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, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
34 /* see Embedder-HOWTO.txt in Jim Tcl project hosted on BerliOS*/
38 // @todo the inclusion of target.h here is a layering violation
39 #include <jtag/jtag.h>
40 #include <target/target.h>
42 #include "configuration.h"
44 #include "time_support.h"
45 #include "jim-eventloop.h"
48 /* nice short description of source file */
49 #define __THIS__FILE__ "command.c"
52 static int run_command(struct command_context
*context
,
53 struct command
*c
, const char *words
[], unsigned num_words
);
55 struct log_capture_state
{
60 static void tcl_output(void *privData
, const char *file
, unsigned line
,
61 const char *function
, const char *string
)
63 struct log_capture_state
*state
= (struct log_capture_state
*)privData
;
64 Jim_AppendString(state
->interp
, state
->output
, string
, strlen(string
));
67 static struct log_capture_state
*command_log_capture_start(Jim_Interp
*interp
)
69 /* capture log output and return it. A garbage collect can
70 * happen, so we need a reference count to this object */
71 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
72 if (NULL
== tclOutput
)
75 struct log_capture_state
*state
= malloc(sizeof(*state
));
79 state
->interp
= interp
;
80 Jim_IncrRefCount(tclOutput
);
81 state
->output
= tclOutput
;
83 log_add_callback(tcl_output
, state
);
88 /* Classic openocd commands provide progress output which we
89 * will capture and return as a Tcl return value.
91 * However, if a non-openocd command has been invoked, then it
92 * makes sense to return the tcl return value from that command.
94 * The tcl return value is empty for openocd commands that provide
97 * Therefore we set the tcl return value only if we actually
100 static void command_log_capture_finish(struct log_capture_state
*state
)
105 log_remove_callback(tcl_output
, state
);
108 Jim_GetString(state
->output
, &length
);
112 Jim_SetResult(state
->interp
, state
->output
);
115 /* No output captured, use tcl return value (which could
118 Jim_DecrRefCount(state
->interp
, state
->output
);
123 static int command_retval_set(Jim_Interp
*interp
, int retval
)
125 int *return_retval
= Jim_GetAssocData(interp
, "retval");
126 if (return_retval
!= NULL
)
127 *return_retval
= retval
;
129 return (retval
== ERROR_OK
) ? JIM_OK
: JIM_ERR
;
132 extern struct command_context
*global_cmd_ctx
;
134 /* dump a single line to the log for the command.
135 * Do nothing in case we are not at debug level 3 */
136 void script_debug(Jim_Interp
*interp
, const char *name
,
137 unsigned argc
, Jim_Obj
*const *argv
)
139 if (debug_level
< LOG_LVL_DEBUG
)
142 char * dbg
= alloc_printf("command - %s", name
);
143 for (unsigned i
= 0; i
< argc
; i
++)
146 const char *w
= Jim_GetString(argv
[i
], &len
);
147 char * t
= alloc_printf("%s %s", dbg
, w
);
151 LOG_DEBUG("%s", dbg
);
155 static void script_command_args_free(const char **words
, unsigned nwords
)
157 for (unsigned i
= 0; i
< nwords
; i
++)
158 free((void *)words
[i
]);
161 static const char **script_command_args_alloc(
162 unsigned argc
, Jim_Obj
*const *argv
, unsigned *nwords
)
164 const char **words
= malloc(argc
* sizeof(char *));
169 for (i
= 0; i
< argc
; i
++)
172 const char *w
= Jim_GetString(argv
[i
], &len
);
173 words
[i
] = strdup(w
);
174 if (words
[i
] == NULL
)
176 script_command_args_free(words
, i
);
184 struct command_context
*current_command_context(Jim_Interp
*interp
)
186 /* grab the command context from the associated data */
187 struct command_context
*cmd_ctx
= Jim_GetAssocData(interp
, "context");
190 /* Tcl can invoke commands directly instead of via command_run_line(). This would
191 * happen when the Jim Tcl interpreter is provided by eCos or if we are running
192 * commands in a startup script.
194 * A telnet or gdb server would provide a non-default command context to
195 * handle piping of error output, have a separate current target, etc.
197 cmd_ctx
= global_cmd_ctx
;
202 static int script_command_run(Jim_Interp
*interp
,
203 int argc
, Jim_Obj
*const *argv
, struct command
*c
, bool capture
)
205 target_call_timer_callbacks_now();
206 LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
209 const char **words
= script_command_args_alloc(argc
, argv
, &nwords
);
213 struct log_capture_state
*state
= NULL
;
215 state
= command_log_capture_start(interp
);
217 struct command_context
*cmd_ctx
= current_command_context(interp
);
218 int retval
= run_command(cmd_ctx
, c
, (const char **)words
, nwords
);
220 command_log_capture_finish(state
);
222 script_command_args_free(words
, nwords
);
223 return command_retval_set(interp
, retval
);
226 static int script_command(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
228 /* the private data is stashed in the interp structure */
230 struct command
*c
= interp
->cmdPrivData
;
232 script_debug(interp
, c
->name
, argc
, argv
);
233 return script_command_run(interp
, argc
, argv
, c
, true);
236 static struct command
*command_root(struct command
*c
)
238 while (NULL
!= c
->parent
)
244 * Find a command by name from a list of commands.
245 * @returns Returns the named command if it exists in the list.
246 * Returns NULL otherwise.
248 static struct command
*command_find(struct command
*head
, const char *name
)
250 for (struct command
*cc
= head
; cc
; cc
= cc
->next
)
252 if (strcmp(cc
->name
, name
) == 0)
257 struct command
*command_find_in_context(struct command_context
*cmd_ctx
,
260 return command_find(cmd_ctx
->commands
, name
);
262 struct command
*command_find_in_parent(struct command
*parent
,
265 return command_find(parent
->children
, name
);
269 * Add the command into the linked list, sorted by name.
270 * @param head Address to head of command list pointer, which may be
271 * updated if @c c gets inserted at the beginning of the list.
272 * @param c The command to add to the list pointed to by @c head.
274 static void command_add_child(struct command
**head
, struct command
*c
)
283 while ((*head
)->next
&& (strcmp(c
->name
, (*head
)->name
) > 0))
284 head
= &(*head
)->next
;
286 if (strcmp(c
->name
, (*head
)->name
) > 0) {
287 c
->next
= (*head
)->next
;
295 static struct command
**command_list_for_parent(
296 struct command_context
*cmd_ctx
, struct command
*parent
)
298 return parent
? &parent
->children
: &cmd_ctx
->commands
;
301 static void command_free(struct command
*c
)
303 /// @todo if command has a handler, unregister its jim command!
305 while (NULL
!= c
->children
)
307 struct command
*tmp
= c
->children
;
308 c
->children
= tmp
->next
;
313 free((void *)c
->name
);
315 free((void*)c
->help
);
317 free((void*)c
->usage
);
321 static struct command
*command_new(struct command_context
*cmd_ctx
,
322 struct command
*parent
, const struct command_registration
*cr
)
327 If it is a non-jim command with no .usage specified,
330 strlen(.usage) == 0 means that the command takes no
333 if ((cr
->jim_handler
== NULL
) &&
334 (cr
->usage
== NULL
)) {
335 LOG_DEBUG("BUG: command '%s%s%s' does not have the "
336 "'.usage' field filled out",
337 parent
&& parent
->name
? parent
->name
: "",
338 parent
&& parent
->name
? " " : "",
342 struct command
*c
= calloc(1, sizeof(struct command
));
346 c
->name
= strdup(cr
->name
);
348 c
->help
= strdup(cr
->help
);
350 c
->usage
= strdup(cr
->usage
);
352 if (!c
->name
|| (cr
->help
&& !c
->help
) || (cr
->usage
&& !c
->usage
))
353 goto command_new_error
;
356 c
->handler
= cr
->handler
;
357 c
->jim_handler
= cr
->jim_handler
;
358 c
->jim_handler_data
= cr
->jim_handler_data
;
361 command_add_child(command_list_for_parent(cmd_ctx
, parent
), c
);
370 static int command_unknown(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
372 static int register_command_handler(struct command_context
*cmd_ctx
,
375 Jim_Interp
*interp
= cmd_ctx
->interp
;
376 const char *ocd_name
= alloc_printf("ocd_%s", c
->name
);
377 if (NULL
== ocd_name
)
380 LOG_DEBUG("registering '%s'...", ocd_name
);
382 Jim_CmdProc func
= c
->handler
? &script_command
: &command_unknown
;
383 int retval
= Jim_CreateCommand(interp
, ocd_name
, func
, c
, NULL
);
384 free((void *)ocd_name
);
385 if (JIM_OK
!= retval
)
388 /* we now need to add an overrideable proc */
389 const char *override_name
= alloc_printf(
390 "proc %s {args} {eval ocd_bouncer %s $args}",
392 if (NULL
== override_name
)
395 retval
= Jim_Eval_Named(interp
, override_name
, 0, 0);
396 free((void *)override_name
);
401 struct command
* register_command(struct command_context
*context
,
402 struct command
*parent
, const struct command_registration
*cr
)
404 if (!context
|| !cr
->name
)
407 const char *name
= cr
->name
;
408 struct command
**head
= command_list_for_parent(context
, parent
);
409 struct command
*c
= command_find(*head
, name
);
412 /* TODO: originally we treated attempting to register a cmd twice as an error
413 * Sometimes we need this behaviour, such as with flash banks.
414 * http://www.mail-archive.com/openocd-development@lists.berlios.de/msg11152.html */
415 LOG_DEBUG("command '%s' is already registered in '%s' context",
416 name
, parent
? parent
->name
: "<global>");
420 c
= command_new(context
, parent
, cr
);
424 int retval
= ERROR_OK
;
425 if (NULL
!= cr
->jim_handler
&& NULL
== parent
)
427 retval
= Jim_CreateCommand(context
->interp
, cr
->name
,
428 cr
->jim_handler
, cr
->jim_handler_data
, NULL
);
430 else if (NULL
!= cr
->handler
|| NULL
!= parent
)
431 retval
= register_command_handler(context
, command_root(c
));
433 if (ERROR_OK
!= retval
)
435 unregister_command(context
, parent
, name
);
441 int register_commands(struct command_context
*cmd_ctx
, struct command
*parent
,
442 const struct command_registration
*cmds
)
444 int retval
= ERROR_OK
;
446 for (i
= 0; cmds
[i
].name
|| cmds
[i
].chain
; i
++)
448 const struct command_registration
*cr
= cmds
+ i
;
450 struct command
*c
= NULL
;
451 if (NULL
!= cr
->name
)
453 c
= register_command(cmd_ctx
, parent
, cr
);
460 if (NULL
!= cr
->chain
)
462 struct command
*p
= c
? : parent
;
463 retval
= register_commands(cmd_ctx
, p
, cr
->chain
);
464 if (ERROR_OK
!= retval
)
468 if (ERROR_OK
!= retval
)
470 for (unsigned j
= 0; j
< i
; j
++)
471 unregister_command(cmd_ctx
, parent
, cmds
[j
].name
);
476 int unregister_all_commands(struct command_context
*context
,
477 struct command
*parent
)
482 struct command
**head
= command_list_for_parent(context
, parent
);
483 while (NULL
!= *head
)
485 struct command
*tmp
= *head
;
493 int unregister_command(struct command_context
*context
,
494 struct command
*parent
, const char *name
)
496 if ((!context
) || (!name
))
497 return ERROR_COMMAND_SYNTAX_ERROR
;
499 struct command
*p
= NULL
;
500 struct command
**head
= command_list_for_parent(context
, parent
);
501 for (struct command
*c
= *head
; NULL
!= c
; p
= c
, c
= c
->next
)
503 if (strcmp(name
, c
->name
) != 0)
518 void command_set_handler_data(struct command
*c
, void *p
)
520 if (NULL
!= c
->handler
|| NULL
!= c
->jim_handler
)
521 c
->jim_handler_data
= p
;
522 for (struct command
*cc
= c
->children
; NULL
!= cc
; cc
= cc
->next
)
523 command_set_handler_data(cc
, p
);
526 void command_output_text(struct command_context
*context
, const char *data
)
528 if (context
&& context
->output_handler
&& data
) {
529 context
->output_handler(context
, data
);
533 void command_print_sameline(struct command_context
*context
, const char *format
, ...)
538 va_start(ap
, format
);
540 string
= alloc_vprintf(format
, ap
);
543 /* we want this collected in the log + we also want to pick it up as a tcl return
546 * The latter bit isn't precisely neat, but will do for now.
548 LOG_USER_N("%s", string
);
549 /* We already printed it above */
550 /* command_output_text(context, string); */
557 void command_print(struct command_context
*context
, const char *format
, ...)
562 va_start(ap
, format
);
564 string
= alloc_vprintf(format
, ap
);
567 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
568 /* we want this collected in the log + we also want to pick it up as a tcl return
571 * The latter bit isn't precisely neat, but will do for now.
573 LOG_USER_N("%s", string
);
574 /* We already printed it above */
575 /* command_output_text(context, string); */
582 static char *__command_name(struct command
*c
, char delim
, unsigned extra
)
585 unsigned len
= strlen(c
->name
);
586 if (NULL
== c
->parent
) {
587 // allocate enough for the name, child names, and '\0'
588 name
= malloc(len
+ extra
+ 1);
589 strcpy(name
, c
->name
);
591 // parent's extra must include both the space and name
592 name
= __command_name(c
->parent
, delim
, 1 + len
+ extra
);
593 char dstr
[2] = { delim
, 0 };
595 strcat(name
, c
->name
);
599 char *command_name(struct command
*c
, char delim
)
601 return __command_name(c
, delim
, 0);
604 static bool command_can_run(struct command_context
*cmd_ctx
, struct command
*c
)
606 return c
->mode
== COMMAND_ANY
|| c
->mode
== cmd_ctx
->mode
;
609 static int run_command(struct command_context
*context
,
610 struct command
*c
, const char *words
[], unsigned num_words
)
612 if (!command_can_run(context
, c
))
614 /* Many commands may be run only before/after 'init' */
617 case COMMAND_CONFIG
: when
= "before"; break;
618 case COMMAND_EXEC
: when
= "after"; break;
619 // handle the impossible with humor; it guarantees a bug report!
620 default: when
= "if Cthulhu is summoned by"; break;
622 LOG_ERROR("The '%s' command must be used %s 'init'.",
627 struct command_invocation cmd
= {
631 .argc
= num_words
- 1,
634 int retval
= c
->handler(&cmd
);
635 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
)
637 /* Print help for command */
638 char *full_name
= command_name(c
, ' ');
639 if (NULL
!= full_name
) {
640 command_run_linef(context
, "usage %s", full_name
);
645 else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
647 /* just fall through for a shutdown request */
649 else if (retval
!= ERROR_OK
)
651 /* we do not print out an error message because the command *should*
652 * have printed out an error
654 LOG_DEBUG("Command failed with error code %d", retval
);
660 int command_run_line(struct command_context
*context
, char *line
)
662 /* all the parent commands have been registered with the interpreter
663 * so, can just evaluate the line as a script and check for
666 /* run the line thru a script engine */
667 int retval
= ERROR_FAIL
;
669 /* Beware! This code needs to be reentrant. It is also possible
670 * for OpenOCD commands to be invoked directly from Tcl. This would
671 * happen when the Jim Tcl interpreter is provided by eCos for
674 Jim_Interp
*interp
= context
->interp
;
675 Jim_DeleteAssocData(interp
, "context");
676 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
677 if (retcode
== JIM_OK
)
679 /* associated the return value */
680 Jim_DeleteAssocData(interp
, "retval");
681 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
682 if (retcode
== JIM_OK
)
684 retcode
= Jim_Eval_Named(interp
, line
, 0, 0);
686 Jim_DeleteAssocData(interp
, "retval");
688 Jim_DeleteAssocData(interp
, "context");
690 if (retcode
== JIM_ERR
) {
691 if (retval
!= ERROR_COMMAND_CLOSE_CONNECTION
)
693 /* We do not print the connection closed error message */
694 Jim_MakeErrorMessage(interp
);
695 LOG_USER("%s", Jim_GetString(Jim_GetResult(interp
), NULL
));
697 if (retval
== ERROR_OK
)
699 /* It wasn't a low level OpenOCD command that failed */
703 } else if (retcode
== JIM_EXIT
) {
705 /* exit(Jim_GetExitCode(interp)); */
710 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
715 for (i
= 0; i
< reslen
; i
+= 256)
721 strncpy(buff
, result
+ i
, chunk
);
723 LOG_USER_N("%s", buff
);
732 int command_run_linef(struct command_context
*context
, const char *format
, ...)
734 int retval
= ERROR_FAIL
;
737 va_start(ap
, format
);
738 string
= alloc_vprintf(format
, ap
);
741 retval
= command_run_line(context
, string
);
748 void command_set_output_handler(struct command_context
* context
,
749 command_output_handler_t output_handler
, void *priv
)
751 context
->output_handler
= output_handler
;
752 context
->output_handler_priv
= priv
;
755 struct command_context
* copy_command_context(struct command_context
* context
)
757 struct command_context
* copy_context
= malloc(sizeof(struct command_context
));
759 *copy_context
= *context
;
764 void command_done(struct command_context
*cmd_ctx
)
772 /* find full path to file */
773 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
777 const char *file
= Jim_GetString(argv
[1], NULL
);
778 char *full_path
= find_file(file
);
779 if (full_path
== NULL
)
781 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
784 Jim_SetResult(interp
, result
);
788 COMMAND_HANDLER(jim_echo
)
790 if (CMD_ARGC
== 2 && !strcmp(CMD_ARGV
[0], "-n"))
792 LOG_USER_N("%s", CMD_ARGV
[1]);
797 LOG_USER("%s", CMD_ARGV
[0]);
801 /* Capture progress output and return as tcl return value. If the
802 * progress output was empty, return tcl return value.
804 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
809 struct log_capture_state
*state
= command_log_capture_start(interp
);
811 /* disable polling during capture. This avoids capturing output
814 * This is necessary in order to avoid accidentially getting a non-empty
815 * string for tcl fn's.
817 bool save_poll
= jtag_poll_get_enabled();
819 jtag_poll_set_enabled(false);
821 const char *str
= Jim_GetString(argv
[1], NULL
);
822 int retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
824 jtag_poll_set_enabled(save_poll
);
826 command_log_capture_finish(state
);
831 static COMMAND_HELPER(command_help_find
, struct command
*head
,
832 struct command
**out
)
835 return ERROR_COMMAND_SYNTAX_ERROR
;
836 *out
= command_find(head
, CMD_ARGV
[0]);
837 if (NULL
== *out
&& strncmp(CMD_ARGV
[0], "ocd_", 4) == 0)
838 *out
= command_find(head
, CMD_ARGV
[0] + 4);
840 return ERROR_COMMAND_SYNTAX_ERROR
;
844 return CALL_COMMAND_HANDLER(command_help_find
, (*out
)->children
, out
);
847 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
848 bool show_help
, const char *match
);
850 static COMMAND_HELPER(command_help_show_list
, struct command
*head
, unsigned n
,
851 bool show_help
, const char *match
)
853 for (struct command
*c
= head
; NULL
!= c
; c
= c
->next
)
854 CALL_COMMAND_HANDLER(command_help_show
, c
, n
, show_help
, match
);
858 #define HELP_LINE_WIDTH(_n) (int)(76 - (2 * _n))
860 static void command_help_show_indent(unsigned n
)
862 for (unsigned i
= 0; i
< n
; i
++)
865 static void command_help_show_wrap(const char *str
, unsigned n
, unsigned n2
)
867 const char *cp
= str
, *last
= str
;
870 const char *next
= last
;
875 } while (*next
!= ' ' && *next
!= '\t' && *next
!= '\0');
876 } while ((next
- last
< HELP_LINE_WIDTH(n
)) && *next
!= '\0');
877 if (next
- last
< HELP_LINE_WIDTH(n
))
879 command_help_show_indent(n
);
880 LOG_USER("%.*s", (int)(cp
- last
), last
);
885 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
886 bool show_help
, const char *match
)
888 char *cmd_name
= command_name(c
, ' ');
889 if (NULL
== cmd_name
)
892 /* If the match string occurs anywhere, we print out
893 * stuff for this command. */
894 bool is_match
= (strstr(cmd_name
, match
) != NULL
) ||
895 ((c
->usage
!= NULL
) && (strstr(c
->usage
, match
) != NULL
)) ||
896 ((c
->help
!= NULL
) && (strstr(c
->help
, match
) != NULL
));
900 command_help_show_indent(n
);
901 LOG_USER_N("%s", cmd_name
);
909 command_help_show_wrap(c
->usage
, 0, n
+ 5);
915 if (is_match
&& show_help
)
919 /* Normal commands are runtime-only; highlight exceptions */
920 if (c
->mode
!= COMMAND_EXEC
) {
921 const char *stage_msg
= "";
925 stage_msg
= " (configuration command)";
928 stage_msg
= " (command valid any time)";
931 stage_msg
= " (?mode error?)";
934 msg
= alloc_printf("%s%s", c
->help
? : "", stage_msg
);
936 msg
= alloc_printf("%s", c
->help
? : "");
940 command_help_show_wrap(msg
, n
+ 3, n
+ 3);
947 LOG_ERROR("command recursion exceeded");
951 return CALL_COMMAND_HANDLER(command_help_show_list
,
952 c
->children
, n
, show_help
, match
);
954 COMMAND_HANDLER(handle_help_command
)
956 bool full
= strcmp(CMD_NAME
, "help") == 0;
958 struct command
*c
= CMD_CTX
->commands
;
963 else if (CMD_ARGC
>= 1) {
966 for (i
= 0; i
< CMD_ARGC
; ++i
) {
970 match
= alloc_printf("%s %s", match
,
974 LOG_ERROR("unable to build "
979 match
= alloc_printf("%s", CMD_ARGV
[i
]);
981 LOG_ERROR("unable to build "
988 return ERROR_COMMAND_SYNTAX_ERROR
;
990 retval
= CALL_COMMAND_HANDLER(command_help_show_list
,
998 static int command_unknown_find(unsigned argc
, Jim_Obj
*const *argv
,
999 struct command
*head
, struct command
**out
, bool top_level
)
1003 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
1004 struct command
*c
= command_find(head
, cmd_name
);
1005 if (NULL
== c
&& top_level
&& strncmp(cmd_name
, "ocd_", 4) == 0)
1006 c
= command_find(head
, cmd_name
+ 4);
1010 return command_unknown_find(--argc
, ++argv
, (*out
)->children
, out
, false);
1014 static int command_unknown(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1016 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
1017 if (strcmp(cmd_name
, "unknown") == 0)
1024 script_debug(interp
, cmd_name
, argc
, argv
);
1026 struct command_context
*cmd_ctx
= current_command_context(interp
);
1027 struct command
*c
= cmd_ctx
->commands
;
1028 int remaining
= command_unknown_find(argc
, argv
, c
, &c
, true);
1029 // if nothing could be consumed, then it's really an unknown command
1030 if (remaining
== argc
)
1032 const char *cmd
= Jim_GetString(argv
[0], NULL
);
1033 LOG_ERROR("Unknown command:\n %s", cmd
);
1038 Jim_Obj
*const *start
;
1040 if (c
->handler
|| c
->jim_handler
)
1042 // include the command name in the list
1043 count
= remaining
+ 1;
1044 start
= argv
+ (argc
- remaining
- 1);
1048 c
= command_find(cmd_ctx
->commands
, "usage");
1051 LOG_ERROR("unknown command, but usage is missing too");
1054 count
= argc
- remaining
;
1058 // pass the command through to the intended handler
1061 interp
->cmdPrivData
= c
->jim_handler_data
;
1062 return (*c
->jim_handler
)(interp
, count
, start
);
1065 return script_command_run(interp
, count
, start
, c
, found
);
1068 static int jim_command_mode(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1070 struct command_context
*cmd_ctx
= current_command_context(interp
);
1071 enum command_mode mode
;
1075 struct command
*c
= cmd_ctx
->commands
;
1076 int remaining
= command_unknown_find(argc
- 1, argv
+ 1, c
, &c
, true);
1077 // if nothing could be consumed, then it's an unknown command
1078 if (remaining
== argc
- 1)
1080 Jim_SetResultString(interp
, "unknown", -1);
1086 mode
= cmd_ctx
->mode
;
1088 const char *mode_str
;
1090 case COMMAND_ANY
: mode_str
= "any"; break;
1091 case COMMAND_CONFIG
: mode_str
= "config"; break;
1092 case COMMAND_EXEC
: mode_str
= "exec"; break;
1093 default: mode_str
= "unknown"; break;
1095 Jim_SetResultString(interp
, mode_str
, -1);
1099 static int jim_command_type(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1104 struct command_context
*cmd_ctx
= current_command_context(interp
);
1105 struct command
*c
= cmd_ctx
->commands
;
1106 int remaining
= command_unknown_find(argc
- 1, argv
+ 1, c
, &c
, true);
1107 // if nothing could be consumed, then it's an unknown command
1108 if (remaining
== argc
- 1)
1110 Jim_SetResultString(interp
, "unknown", -1);
1115 Jim_SetResultString(interp
, "native", -1);
1116 else if (c
->handler
)
1117 Jim_SetResultString(interp
, "simple", -1);
1119 Jim_SetResultString(interp
, "group", -1);
1124 int help_add_command(struct command_context
*cmd_ctx
, struct command
*parent
,
1125 const char *cmd_name
, const char *help_text
, const char *usage
)
1127 struct command
**head
= command_list_for_parent(cmd_ctx
, parent
);
1128 struct command
*nc
= command_find(*head
, cmd_name
);
1131 // add a new command with help text
1132 struct command_registration cr
= {
1134 .mode
= COMMAND_ANY
,
1138 nc
= register_command(cmd_ctx
, parent
, &cr
);
1141 LOG_ERROR("failed to add '%s' help text", cmd_name
);
1144 LOG_DEBUG("added '%s' help text", cmd_name
);
1149 bool replaced
= false;
1152 free((void *)nc
->help
);
1155 nc
->help
= strdup(help_text
);
1157 LOG_INFO("replaced existing '%s' help", cmd_name
);
1159 LOG_DEBUG("added '%s' help text", cmd_name
);
1163 bool replaced
= false;
1166 free((void *)nc
->usage
);
1169 nc
->usage
= strdup(usage
);
1171 LOG_INFO("replaced existing '%s' usage", cmd_name
);
1173 LOG_DEBUG("added '%s' usage text", cmd_name
);
1178 COMMAND_HANDLER(handle_help_add_command
)
1182 LOG_ERROR("%s: insufficient arguments", CMD_NAME
);
1183 return ERROR_COMMAND_SYNTAX_ERROR
;
1186 // save help text and remove it from argument list
1187 const char *str
= CMD_ARGV
[--CMD_ARGC
];
1188 const char *help
= !strcmp(CMD_NAME
, "add_help_text") ? str
: NULL
;
1189 const char *usage
= !strcmp(CMD_NAME
, "add_usage_text") ? str
: NULL
;
1190 if (!help
&& !usage
)
1192 LOG_ERROR("command name '%s' is unknown", CMD_NAME
);
1193 return ERROR_COMMAND_SYNTAX_ERROR
;
1195 // likewise for the leaf command name
1196 const char *cmd_name
= CMD_ARGV
[--CMD_ARGC
];
1198 struct command
*c
= NULL
;
1201 c
= CMD_CTX
->commands
;
1202 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
1203 if (ERROR_OK
!= retval
)
1206 return help_add_command(CMD_CTX
, c
, cmd_name
, help
, usage
);
1209 /* sleep command sleeps for <n> milliseconds
1210 * this is useful in target startup scripts
1212 COMMAND_HANDLER(handle_sleep_command
)
1217 if (strcmp(CMD_ARGV
[1], "busy") == 0)
1220 return ERROR_COMMAND_SYNTAX_ERROR
;
1222 else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
1223 return ERROR_COMMAND_SYNTAX_ERROR
;
1225 unsigned long duration
= 0;
1226 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
1227 if (ERROR_OK
!= retval
)
1232 long long then
= timeval_ms();
1233 while (timeval_ms() - then
< (long long)duration
)
1235 target_call_timer_callbacks_now();
1240 busy_sleep(duration
);
1245 static const struct command_registration command_subcommand_handlers
[] = {
1248 .mode
= COMMAND_ANY
,
1249 .jim_handler
= jim_command_mode
,
1250 .usage
= "[command_name ...]",
1251 .help
= "Returns the command modes allowed by a command:"
1252 "'any', 'config', or 'exec'. If no command is"
1253 "specified, returns the current command mode. "
1254 "Returns 'unknown' if an unknown command is given. "
1255 "Command can be multiple tokens.",
1259 .mode
= COMMAND_ANY
,
1260 .jim_handler
= jim_command_type
,
1261 .usage
= "command_name [...]",
1262 .help
= "Returns the type of built-in command:"
1263 "'native', 'simple', 'group', or 'unknown'. "
1264 "Command can be multiple tokens.",
1266 COMMAND_REGISTRATION_DONE
1269 static const struct command_registration command_builtin_handlers
[] = {
1272 .handler
= jim_echo
,
1273 .mode
= COMMAND_ANY
,
1274 .help
= "Logs a message at \"user\" priority. "
1275 "Output message to stdout. "
1276 "Option \"-n\" suppresses trailing newline",
1277 .usage
= "[-n] string",
1280 .name
= "add_help_text",
1281 .handler
= handle_help_add_command
,
1282 .mode
= COMMAND_ANY
,
1283 .help
= "Add new command help text; "
1284 "Command can be multiple tokens.",
1285 .usage
= "command_name helptext_string",
1288 .name
= "add_usage_text",
1289 .handler
= handle_help_add_command
,
1290 .mode
= COMMAND_ANY
,
1291 .help
= "Add new command usage text; "
1292 "command can be multiple tokens.",
1293 .usage
= "command_name usage_string",
1297 .handler
= handle_sleep_command
,
1298 .mode
= COMMAND_ANY
,
1299 .help
= "Sleep for specified number of milliseconds. "
1300 "\"busy\" will busy wait instead (avoid this).",
1301 .usage
= "milliseconds ['busy']",
1305 .handler
= handle_help_command
,
1306 .mode
= COMMAND_ANY
,
1307 .help
= "Show full command help; "
1308 "command can be multiple tokens.",
1309 .usage
= "[command_name]",
1313 .handler
= handle_help_command
,
1314 .mode
= COMMAND_ANY
,
1315 .help
= "Show basic command usage; "
1316 "command can be multiple tokens.",
1317 .usage
= "[command_name]",
1322 .help
= "core command group (introspection)",
1323 .chain
= command_subcommand_handlers
,
1325 COMMAND_REGISTRATION_DONE
1328 struct command_context
* command_init(const char *startup_tcl
, Jim_Interp
*interp
)
1330 struct command_context
* context
= malloc(sizeof(struct command_context
));
1333 context
->mode
= COMMAND_EXEC
;
1334 context
->commands
= NULL
;
1335 context
->current_target
= 0;
1336 context
->output_handler
= NULL
;
1337 context
->output_handler_priv
= NULL
;
1339 #if !BUILD_ECOSBOARD
1340 /* Create a jim interpreter if we were not handed one */
1343 /* Create an interpreter */
1344 interp
= Jim_CreateInterp();
1345 /* Add all the Jim core commands */
1346 Jim_RegisterCoreCommands(interp
);
1347 Jim_InitStaticExtensions(interp
);
1350 context
->interp
= interp
;
1352 /* Stick to lowercase for HostOS strings. */
1353 #if defined(_MSC_VER)
1354 /* WinXX - is generic, the forward
1355 * looking problem is this:
1357 * "win32" or "win64"
1359 * "winxx" is generic.
1362 #elif defined(__linux__)
1364 #elif defined(__APPLE__) || defined(__DARWIN__)
1366 #elif defined(__CYGWIN__)
1368 #elif defined(__MINGW32__)
1370 #elif defined(__ECOS)
1372 #elif defined(__FreeBSD__)
1375 #warning "Unrecognized host OS..."
1378 Jim_SetGlobalVariableStr(interp
, "ocd_HOSTOS",
1379 Jim_NewStringObj(interp
, HostOs
, strlen(HostOs
)));
1381 Jim_CreateCommand(interp
, "ocd_find", jim_find
, NULL
, NULL
);
1382 Jim_CreateCommand(interp
, "capture", jim_capture
, NULL
, NULL
);
1384 register_commands(context
, NULL
, command_builtin_handlers
);
1386 Jim_SetAssocData(interp
, "context", NULL
, context
);
1387 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl",1) == JIM_ERR
)
1389 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1390 Jim_MakeErrorMessage(interp
);
1391 LOG_USER_N("%s", Jim_GetString(Jim_GetResult(interp
), NULL
));
1394 Jim_DeleteAssocData(interp
, "context");
1399 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
1402 return ERROR_COMMAND_SYNTAX_ERROR
;
1404 cmd_ctx
->mode
= mode
;
1408 void process_jim_events(struct command_context
*cmd_ctx
)
1410 #if !BUILD_ECOSBOARD
1411 static int recursion
= 0;
1416 Jim_ProcessEvents(cmd_ctx
->interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
1421 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1422 int parse##name(const char *str, type *ul) \
1426 LOG_ERROR("Invalid command argument"); \
1427 return ERROR_COMMAND_ARGUMENT_INVALID; \
1430 *ul = func(str, &end, 0); \
1433 LOG_ERROR("Invalid command argument"); \
1434 return ERROR_COMMAND_ARGUMENT_INVALID; \
1436 if ((max == *ul) && (ERANGE == errno)) \
1438 LOG_ERROR("Argument overflow"); \
1439 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1441 if (min && (min == *ul) && (ERANGE == errno)) \
1443 LOG_ERROR("Argument underflow"); \
1444 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1448 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long , strtoul
, 0, ULONG_MAX
)
1449 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1450 DEFINE_PARSE_NUM_TYPE(_long
, long , strtol
, LONG_MIN
, LONG_MAX
)
1451 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1453 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1454 int parse##name(const char *str, type *ul) \
1457 int retval = parse##funcname(str, &n); \
1458 if (ERROR_OK != retval) \
1461 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1463 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1468 #define DEFINE_PARSE_ULONG(name, type, min, max) \
1469 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong)
1470 DEFINE_PARSE_ULONG(_uint
, unsigned, 0, UINT_MAX
)
1471 DEFINE_PARSE_ULONG(_u32
, uint32_t, 0, UINT32_MAX
)
1472 DEFINE_PARSE_ULONG(_u16
, uint16_t, 0, UINT16_MAX
)
1473 DEFINE_PARSE_ULONG(_u8
, uint8_t, 0, UINT8_MAX
)
1475 #define DEFINE_PARSE_LONG(name, type, min, max) \
1476 DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long)
1477 DEFINE_PARSE_LONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1478 DEFINE_PARSE_LONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1479 DEFINE_PARSE_LONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1480 DEFINE_PARSE_LONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1482 static int command_parse_bool(const char *in
, bool *out
,
1483 const char *on
, const char *off
)
1485 if (strcasecmp(in
, on
) == 0)
1487 else if (strcasecmp(in
, off
) == 0)
1490 return ERROR_COMMAND_SYNTAX_ERROR
;
1494 int command_parse_bool_arg(const char *in
, bool *out
)
1496 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1498 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1500 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1502 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1504 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1506 return ERROR_COMMAND_SYNTAX_ERROR
;
1509 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1513 const char *in
= CMD_ARGV
[0];
1514 if (command_parse_bool_arg(in
, out
) != ERROR_OK
)
1516 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1517 return ERROR_COMMAND_SYNTAX_ERROR
;
1522 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1525 return ERROR_COMMAND_SYNTAX_ERROR
;