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
41 #include "configuration.h"
43 #include "time_support.h"
44 #include "jim-eventloop.h"
47 Jim_Interp
*interp
= NULL
;
49 static int run_command(struct command_context
*context
,
50 struct command
*c
, const char *words
[], unsigned num_words
);
52 static void tcl_output(void *privData
, const char *file
, unsigned line
,
53 const char *function
, const char *string
)
55 Jim_Obj
*tclOutput
= (Jim_Obj
*)privData
;
56 Jim_AppendString(interp
, tclOutput
, string
, strlen(string
));
59 static Jim_Obj
*command_log_capture_start(Jim_Interp
*interp
)
61 /* capture log output and return it. A garbage collect can
62 * happen, so we need a reference count to this object */
63 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
64 if (NULL
== tclOutput
)
66 Jim_IncrRefCount(tclOutput
);
67 log_add_callback(tcl_output
, tclOutput
);
71 static void command_log_capture_finish(Jim_Interp
*interp
, Jim_Obj
*tclOutput
)
73 log_remove_callback(tcl_output
, tclOutput
);
74 Jim_SetResult(interp
, tclOutput
);
75 Jim_DecrRefCount(interp
, tclOutput
);
78 static int command_retval_set(Jim_Interp
*interp
, int retval
)
80 int *return_retval
= Jim_GetAssocData(interp
, "retval");
81 if (return_retval
!= NULL
)
82 *return_retval
= retval
;
84 return (retval
== ERROR_OK
) ? JIM_OK
: JIM_ERR
;
87 extern struct command_context
*global_cmd_ctx
;
89 void script_debug(Jim_Interp
*interp
, const char *name
,
90 unsigned argc
, Jim_Obj
*const *argv
)
92 LOG_DEBUG("command - %s", name
);
93 for (unsigned i
= 0; i
< argc
; i
++)
96 const char *w
= Jim_GetString(argv
[i
], &len
);
98 /* end of line comment? */
102 LOG_DEBUG("%s - argv[%d]=%s", name
, i
, w
);
106 static void script_command_args_free(const char **words
, unsigned nwords
)
108 for (unsigned i
= 0; i
< nwords
; i
++)
109 free((void *)words
[i
]);
112 static const char **script_command_args_alloc(
113 unsigned argc
, Jim_Obj
*const *argv
, unsigned *nwords
)
115 const char **words
= malloc(argc
* sizeof(char *));
120 for (i
= 0; i
< argc
; i
++)
123 const char *w
= Jim_GetString(argv
[i
], &len
);
124 /* a comment may end the line early */
128 words
[i
] = strdup(w
);
129 if (words
[i
] == NULL
)
131 script_command_args_free(words
, i
);
139 static struct command_context
*current_command_context(void)
141 /* grab the command context from the associated data */
142 struct command_context
*cmd_ctx
= Jim_GetAssocData(interp
, "context");
145 /* Tcl can invoke commands directly instead of via command_run_line(). This would
146 * happen when the Jim Tcl interpreter is provided by eCos.
148 cmd_ctx
= global_cmd_ctx
;
153 static int script_command(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
155 /* the private data is stashed in the interp structure */
157 struct command
*c
= interp
->cmdPrivData
;
160 target_call_timer_callbacks_now();
161 LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
163 script_debug(interp
, c
->name
, argc
, argv
);
166 const char **words
= script_command_args_alloc(argc
, argv
, &nwords
);
170 Jim_Obj
*tclOutput
= command_log_capture_start(interp
);
172 struct command_context
*cmd_ctx
= current_command_context();
173 int retval
= run_command(cmd_ctx
, c
, (const char **)words
, nwords
);
175 command_log_capture_finish(interp
, tclOutput
);
176 script_command_args_free(words
, nwords
);
177 return command_retval_set(interp
, retval
);
180 /* nice short description of source file */
181 #define __THIS__FILE__ "command.c"
184 * Find a command by name from a list of commands.
185 * @returns Returns the named command if it exists in the list.
186 * Returns NULL otherwise.
188 static struct command
*command_find(struct command
*head
, const char *name
)
190 for (struct command
*cc
= head
; cc
; cc
= cc
->next
)
192 if (strcmp(cc
->name
, name
) == 0)
197 struct command
*command_find_in_context(struct command_context
*cmd_ctx
,
200 return command_find(cmd_ctx
->commands
, name
);
202 struct command
*command_find_in_parent(struct command
*parent
,
205 return command_find(parent
->children
, name
);
209 * Add the command into the linked list, sorted by name.
210 * @param head Address to head of command list pointer, which may be
211 * updated if @c c gets inserted at the beginning of the list.
212 * @param c The command to add to the list pointed to by @c head.
214 static void command_add_child(struct command
**head
, struct command
*c
)
223 while ((*head
)->next
&& (strcmp(c
->name
, (*head
)->name
) > 0))
224 head
= &(*head
)->next
;
226 if (strcmp(c
->name
, (*head
)->name
) > 0) {
227 c
->next
= (*head
)->next
;
235 static struct command
**command_list_for_parent(
236 struct command_context
*cmd_ctx
, struct command
*parent
)
238 return parent
? &parent
->children
: &cmd_ctx
->commands
;
241 static struct command
*command_new(struct command_context
*cmd_ctx
,
242 struct command
*parent
, const struct command_registration
*cr
)
246 struct command
*c
= malloc(sizeof(struct command
));
247 memset(c
, 0, sizeof(struct command
));
249 c
->name
= strdup(cr
->name
);
251 c
->help
= strdup(cr
->help
);
253 c
->usage
= strdup(cr
->usage
);
255 c
->handler
= cr
->handler
;
256 c
->jim_handler
= cr
->jim_handler
;
257 c
->jim_handler_data
= cr
->jim_handler_data
;
260 command_add_child(command_list_for_parent(cmd_ctx
, parent
), c
);
264 static void command_free(struct command
*c
)
266 /// @todo if command has a handler, unregister its jim command!
268 while (NULL
!= c
->children
)
270 struct command
*tmp
= c
->children
;
271 c
->children
= tmp
->next
;
278 free((void*)c
->help
);
280 free((void*)c
->usage
);
284 static int register_command_handler(struct command
*c
)
286 int retval
= -ENOMEM
;
287 const char *full_name
= command_name(c
, '_');
288 if (NULL
== full_name
)
291 const char *ocd_name
= alloc_printf("ocd_%s", full_name
);
292 if (NULL
== full_name
)
295 Jim_CreateCommand(interp
, ocd_name
, script_command
, c
, NULL
);
296 free((void *)ocd_name
);
298 /* we now need to add an overrideable proc */
299 const char *override_name
= alloc_printf("proc %s {args} {"
300 "if {[catch {eval ocd_%s $args}] == 0} "
301 "{return \"\"} else {return -code error}}",
302 full_name
, full_name
);
303 if (NULL
== full_name
)
306 Jim_Eval_Named(interp
, override_name
, __THIS__FILE__
, __LINE__
);
307 free((void *)override_name
);
312 free((void *)full_name
);
316 struct command
* register_command(struct command_context
*context
,
317 struct command
*parent
, const struct command_registration
*cr
)
319 if (!context
|| !cr
->name
)
322 const char *name
= cr
->name
;
323 struct command
**head
= command_list_for_parent(context
, parent
);
324 struct command
*c
= command_find(*head
, name
);
327 LOG_ERROR("command '%s' is already registered in '%s' context",
328 name
, parent
? parent
->name
: "<global>");
332 c
= command_new(context
, parent
, cr
);
336 if (NULL
!= c
->handler
)
338 int retval
= register_command_handler(c
);
339 if (ERROR_OK
!= retval
)
341 unregister_command(context
, parent
, name
);
346 if (NULL
!= cr
->jim_handler
&& NULL
== parent
)
347 Jim_CreateCommand(interp
, cr
->name
, cr
->jim_handler
, cr
->jim_handler_data
, NULL
);
352 int register_commands(struct command_context
*cmd_ctx
, struct command
*parent
,
353 const struct command_registration
*cmds
)
355 int retval
= ERROR_OK
;
357 for (i
= 0; cmds
[i
].name
|| cmds
[i
].chain
; i
++)
359 const struct command_registration
*cr
= cmds
+ i
;
361 struct command
*c
= NULL
;
362 if (NULL
!= cr
->name
)
364 c
= register_command(cmd_ctx
, parent
, cr
);
371 if (NULL
!= cr
->chain
)
373 struct command
*p
= c
? : parent
;
374 retval
= register_commands(cmd_ctx
, p
, cr
->chain
);
375 if (ERROR_OK
!= retval
)
379 if (ERROR_OK
!= retval
)
381 for (unsigned j
= 0; j
< i
; j
++)
382 unregister_command(cmd_ctx
, parent
, cmds
[j
].name
);
387 int unregister_all_commands(struct command_context
*context
,
388 struct command
*parent
)
393 struct command
**head
= command_list_for_parent(context
, parent
);
394 while (NULL
!= *head
)
396 struct command
*tmp
= *head
;
404 int unregister_command(struct command_context
*context
,
405 struct command
*parent
, const char *name
)
407 if ((!context
) || (!name
))
408 return ERROR_INVALID_ARGUMENTS
;
410 struct command
*p
= NULL
;
411 struct command
**head
= command_list_for_parent(context
, parent
);
412 for (struct command
*c
= *head
; NULL
!= c
; p
= c
, c
= c
->next
)
414 if (strcmp(name
, c
->name
) != 0)
429 void command_output_text(struct command_context
*context
, const char *data
)
431 if (context
&& context
->output_handler
&& data
) {
432 context
->output_handler(context
, data
);
436 void command_print_sameline(struct command_context
*context
, const char *format
, ...)
441 va_start(ap
, format
);
443 string
= alloc_vprintf(format
, ap
);
446 /* we want this collected in the log + we also want to pick it up as a tcl return
449 * The latter bit isn't precisely neat, but will do for now.
451 LOG_USER_N("%s", string
);
452 /* We already printed it above */
453 /* command_output_text(context, string); */
460 void command_print(struct command_context
*context
, const char *format
, ...)
465 va_start(ap
, format
);
467 string
= alloc_vprintf(format
, ap
);
470 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
471 /* we want this collected in the log + we also want to pick it up as a tcl return
474 * The latter bit isn't precisely neat, but will do for now.
476 LOG_USER_N("%s", string
);
477 /* We already printed it above */
478 /* command_output_text(context, string); */
485 static char *__command_name(struct command
*c
, char delim
, unsigned extra
)
488 unsigned len
= strlen(c
->name
);
489 if (NULL
== c
->parent
) {
490 // allocate enough for the name, child names, and '\0'
491 name
= malloc(len
+ extra
+ 1);
492 strcpy(name
, c
->name
);
494 // parent's extra must include both the space and name
495 name
= __command_name(c
->parent
, delim
, 1 + len
+ extra
);
496 char dstr
[2] = { delim
, 0 };
498 strcat(name
, c
->name
);
502 char *command_name(struct command
*c
, char delim
)
504 return __command_name(c
, delim
, 0);
507 static int run_command(struct command_context
*context
,
508 struct command
*c
, const char *words
[], unsigned num_words
)
510 if (!((context
->mode
== COMMAND_CONFIG
) || (c
->mode
== COMMAND_ANY
) || (c
->mode
== context
->mode
)))
512 /* Config commands can not run after the config stage */
513 LOG_ERROR("Command '%s' only runs during configuration stage", c
->name
);
517 struct command_invocation cmd
= {
520 .argc
= num_words
- 1,
523 int retval
= c
->handler(&cmd
);
524 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
)
526 /* Print help for command */
527 char *full_name
= command_name(c
, ' ');
528 if (NULL
!= full_name
) {
529 command_run_linef(context
, "help %s", full_name
);
534 else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
536 /* just fall through for a shutdown request */
538 else if (retval
!= ERROR_OK
)
540 /* we do not print out an error message because the command *should*
541 * have printed out an error
543 LOG_DEBUG("Command failed with error code %d", retval
);
549 int command_run_line(struct command_context
*context
, char *line
)
551 /* all the parent commands have been registered with the interpreter
552 * so, can just evaluate the line as a script and check for
555 /* run the line thru a script engine */
556 int retval
= ERROR_FAIL
;
558 /* Beware! This code needs to be reentrant. It is also possible
559 * for OpenOCD commands to be invoked directly from Tcl. This would
560 * happen when the Jim Tcl interpreter is provided by eCos for
563 Jim_DeleteAssocData(interp
, "context");
564 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
565 if (retcode
== JIM_OK
)
567 /* associated the return value */
568 Jim_DeleteAssocData(interp
, "retval");
569 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
570 if (retcode
== JIM_OK
)
572 retcode
= Jim_Eval_Named(interp
, line
, __THIS__FILE__
, __LINE__
);
574 Jim_DeleteAssocData(interp
, "retval");
576 Jim_DeleteAssocData(interp
, "context");
578 if (retcode
== JIM_ERR
) {
579 if (retval
!= ERROR_COMMAND_CLOSE_CONNECTION
)
581 /* We do not print the connection closed error message */
582 Jim_PrintErrorMessage(interp
);
584 if (retval
== ERROR_OK
)
586 /* It wasn't a low level OpenOCD command that failed */
590 } else if (retcode
== JIM_EXIT
) {
592 /* exit(Jim_GetExitCode(interp)); */
597 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
602 for (i
= 0; i
< reslen
; i
+= 256)
608 strncpy(buff
, result
+ i
, chunk
);
610 LOG_USER_N("%s", buff
);
612 LOG_USER_N("%s", "\n");
619 int command_run_linef(struct command_context
*context
, const char *format
, ...)
621 int retval
= ERROR_FAIL
;
624 va_start(ap
, format
);
625 string
= alloc_vprintf(format
, ap
);
628 retval
= command_run_line(context
, string
);
634 void command_set_output_handler(struct command_context
* context
,
635 command_output_handler_t output_handler
, void *priv
)
637 context
->output_handler
= output_handler
;
638 context
->output_handler_priv
= priv
;
641 struct command_context
* copy_command_context(struct command_context
* context
)
643 struct command_context
* copy_context
= malloc(sizeof(struct command_context
));
645 *copy_context
= *context
;
650 int command_done(struct command_context
*context
)
658 /* find full path to file */
659 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
663 const char *file
= Jim_GetString(argv
[1], NULL
);
664 char *full_path
= find_file(file
);
665 if (full_path
== NULL
)
667 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
670 Jim_SetResult(interp
, result
);
674 static int jim_echo(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
678 const char *str
= Jim_GetString(argv
[1], NULL
);
683 static size_t openocd_jim_fwrite(const void *_ptr
, size_t size
, size_t n
, void *cookie
)
689 /* make it a char easier to read code */
693 if (ptr
== NULL
|| interp
== NULL
|| nbytes
== 0) {
697 /* do we have to chunk it? */
698 if (ptr
[nbytes
] == 0)
700 /* no it is a C style string */
701 LOG_USER_N("%s", ptr
);
704 /* GRR we must chunk - not null terminated */
714 memcpy(chunk
, ptr
, x
);
718 LOG_USER_N("%s", chunk
);
726 static size_t openocd_jim_fread(void *ptr
, size_t size
, size_t n
, void *cookie
)
728 /* TCL wants to read... tell him no */
732 static int openocd_jim_vfprintf(void *cookie
, const char *fmt
, va_list ap
)
743 cp
= alloc_vprintf(fmt
, ap
);
746 LOG_USER_N("%s", cp
);
753 static int openocd_jim_fflush(void *cookie
)
755 /* nothing to flush */
759 static char* openocd_jim_fgets(char *s
, int size
, void *cookie
)
766 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
771 Jim_Obj
*tclOutput
= command_log_capture_start(interp
);
773 const char *str
= Jim_GetString(argv
[1], NULL
);
774 int retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
776 command_log_capture_finish(interp
, tclOutput
);
781 static COMMAND_HELPER(command_help_find
, struct command
*head
,
782 struct command
**out
)
785 return ERROR_INVALID_ARGUMENTS
;
786 *out
= command_find(head
, CMD_ARGV
[0]);
788 return ERROR_INVALID_ARGUMENTS
;
792 return CALL_COMMAND_HANDLER(command_help_find
, (*out
)->children
, out
);
795 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
798 static COMMAND_HELPER(command_help_show_list
, struct command
*head
, unsigned n
,
801 for (struct command
*c
= head
; NULL
!= c
; c
= c
->next
)
802 CALL_COMMAND_HANDLER(command_help_show
, c
, n
, show_help
);
806 #define HELP_LINE_WIDTH(_n) (int)(76 - (2 * _n))
808 static void command_help_show_indent(unsigned n
)
810 for (unsigned i
= 0; i
< n
; i
++)
813 static void command_help_show_wrap(const char *str
, unsigned n
, unsigned n2
)
815 const char *cp
= str
, *last
= str
;
818 const char *next
= last
;
823 } while (*next
!= ' ' && *next
!= '\t' && *next
!= '\0');
824 } while ((next
- last
< HELP_LINE_WIDTH(n
)) && *next
!= '\0');
825 if (next
- last
< HELP_LINE_WIDTH(n
))
827 command_help_show_indent(n
);
828 LOG_USER_N("%.*s", (int)(cp
- last
), last
);
834 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
837 command_help_show_indent(n
);
838 LOG_USER_N("%s", command_name(c
, ' '));
841 command_help_show_wrap(c
->usage
, 0, n
+ 5);
845 if (show_help
&& c
->help
)
846 command_help_show_wrap(c
->help
, n
+ 3, n
+ 3);
850 return CALL_COMMAND_HANDLER(command_help_show_list
,
851 c
->children
, n
, show_help
);
853 COMMAND_HANDLER(handle_help_command
)
855 bool full
= strcmp(CMD_NAME
, "help") == 0;
857 struct command
*c
= CMD_CTX
->commands
;
860 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0, full
);
862 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
863 if (ERROR_OK
!= retval
)
866 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0, full
);
869 static int command_unknown_find(unsigned argc
, Jim_Obj
*const *argv
,
870 struct command
*head
, struct command
**out
)
874 struct command
*c
= command_find(head
, Jim_GetString(argv
[0], NULL
));
878 return command_unknown_find(--argc
, ++argv
, (*out
)->children
, out
);
881 static int command_unknown(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
883 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
884 script_debug(interp
, cmd_name
, argc
- 1, argv
+ 1);
886 struct command_context
*cmd_ctx
= current_command_context();
887 struct command
*c
= cmd_ctx
->commands
;
888 int remaining
= command_unknown_find(argc
- 1, argv
+ 1, c
, &c
);
889 // if nothing could be consumed, then it's really an unknown command
890 if (remaining
== argc
- 1)
892 const char *cmd
= Jim_GetString(argv
[1], NULL
);
893 LOG_ERROR("Unknown command:\n %s", cmd
);
898 Jim_Obj
*const *start
;
900 if (c
->handler
|| c
->jim_handler
)
902 // include the command name in the list
903 count
= remaining
+ 1;
904 start
= argv
+ (argc
- remaining
- 1);
908 c
= command_find(cmd_ctx
->commands
, "help");
911 LOG_ERROR("unknown command, but help is missing too");
914 count
= argc
- remaining
;
918 // pass the command through to the intended handler
921 interp
->cmdPrivData
= c
->jim_handler_data
;
922 return (*c
->jim_handler
)(interp
, count
, start
);
926 const char **words
= script_command_args_alloc(count
, start
, &nwords
);
930 Jim_Obj
*tclOutput
= command_log_capture_start(interp
);
932 int retval
= run_command(cmd_ctx
, c
, words
, nwords
);
934 command_log_capture_finish(interp
, tclOutput
);
935 script_command_args_free(words
, nwords
);
937 if (!found
&& ERROR_OK
== retval
)
940 return command_retval_set(interp
, retval
);
943 int help_add_command(struct command_context
*cmd_ctx
, struct command
*parent
,
944 const char *cmd_name
, const char *help_text
, const char *usage
)
946 struct command
**head
= command_list_for_parent(cmd_ctx
, parent
);
947 struct command
*nc
= command_find(*head
, cmd_name
);
950 // add a new command with help text
951 struct command_registration cr
= {
957 nc
= register_command(cmd_ctx
, parent
, &cr
);
960 LOG_ERROR("failed to add '%s' help text", cmd_name
);
963 LOG_DEBUG("added '%s' help text", cmd_name
);
968 bool replaced
= false;
971 free((void *)nc
->help
);
974 nc
->help
= strdup(help_text
);
976 LOG_INFO("replaced existing '%s' help", cmd_name
);
978 LOG_DEBUG("added '%s' help text", cmd_name
);
982 bool replaced
= false;
985 free((void *)nc
->usage
);
988 nc
->usage
= strdup(usage
);
990 LOG_INFO("replaced existing '%s' usage", cmd_name
);
992 LOG_DEBUG("added '%s' usage text", cmd_name
);
997 COMMAND_HANDLER(handle_help_add_command
)
1001 LOG_ERROR("%s: insufficient arguments", CMD_NAME
);
1002 return ERROR_INVALID_ARGUMENTS
;
1005 // save help text and remove it from argument list
1006 const char *str
= CMD_ARGV
[--CMD_ARGC
];
1007 const char *help
= !strcmp(CMD_NAME
, "add_help_text") ? str
: NULL
;
1008 const char *usage
= !strcmp(CMD_NAME
, "add_usage_text") ? str
: NULL
;
1009 if (!help
&& !usage
)
1011 LOG_ERROR("command name '%s' is unknown", CMD_NAME
);
1012 return ERROR_INVALID_ARGUMENTS
;
1014 // likewise for the leaf command name
1015 const char *cmd_name
= CMD_ARGV
[--CMD_ARGC
];
1017 struct command
*c
= NULL
;
1020 c
= CMD_CTX
->commands
;
1021 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
1022 if (ERROR_OK
!= retval
)
1025 return help_add_command(CMD_CTX
, c
, cmd_name
, help
, usage
);
1028 /* sleep command sleeps for <n> miliseconds
1029 * this is useful in target startup scripts
1031 COMMAND_HANDLER(handle_sleep_command
)
1036 if (strcmp(CMD_ARGV
[1], "busy") == 0)
1039 return ERROR_COMMAND_SYNTAX_ERROR
;
1041 else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
1042 return ERROR_COMMAND_SYNTAX_ERROR
;
1044 unsigned long duration
= 0;
1045 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
1046 if (ERROR_OK
!= retval
)
1051 long long then
= timeval_ms();
1052 while (timeval_ms() - then
< (long long)duration
)
1054 target_call_timer_callbacks_now();
1059 busy_sleep(duration
);
1064 static const struct command_registration command_builtin_handlers
[] = {
1066 .name
= "add_help_text",
1067 .handler
= &handle_help_add_command
,
1068 .mode
= COMMAND_ANY
,
1069 .help
= "add new command help text",
1070 .usage
= "<command> [...] <help_text>]",
1073 .name
= "add_usage_text",
1074 .handler
= &handle_help_add_command
,
1075 .mode
= COMMAND_ANY
,
1076 .help
= "add new command usage text",
1077 .usage
= "<command> [...] <usage_text>]",
1081 .handler
= &handle_sleep_command
,
1082 .mode
= COMMAND_ANY
,
1083 .help
= "sleep for n milliseconds. "
1084 "\"busy\" will busy wait",
1085 .usage
= "<n> [busy]",
1089 .handler
= &handle_help_command
,
1090 .mode
= COMMAND_ANY
,
1091 .help
= "show full command help",
1092 .usage
= "[<command> ...]",
1096 .handler
= &handle_help_command
,
1097 .mode
= COMMAND_ANY
,
1098 .help
= "show basic command usage",
1099 .usage
= "[<command> ...]",
1101 COMMAND_REGISTRATION_DONE
1104 struct command_context
* command_init(const char *startup_tcl
)
1106 struct command_context
* context
= malloc(sizeof(struct command_context
));
1109 context
->mode
= COMMAND_EXEC
;
1110 context
->commands
= NULL
;
1111 context
->current_target
= 0;
1112 context
->output_handler
= NULL
;
1113 context
->output_handler_priv
= NULL
;
1115 #if !BUILD_ECOSBOARD
1117 /* Create an interpreter */
1118 interp
= Jim_CreateInterp();
1119 /* Add all the Jim core commands */
1120 Jim_RegisterCoreCommands(interp
);
1123 #if defined(_MSC_VER)
1124 /* WinXX - is generic, the forward
1125 * looking problem is this:
1127 * "win32" or "win64"
1129 * "winxx" is generic.
1132 #elif defined(__linux__)
1134 #elif defined(__DARWIN__)
1136 #elif defined(__CYGWIN__)
1138 #elif defined(__MINGW32__)
1140 #elif defined(__ECOS)
1143 #warn unrecognized host OS...
1146 Jim_SetGlobalVariableStr(interp
, "ocd_HOSTOS",
1147 Jim_NewStringObj(interp
, HostOs
, strlen(HostOs
)));
1149 Jim_CreateCommand(interp
, "unknown", &command_unknown
, NULL
, NULL
);
1150 Jim_CreateCommand(interp
, "ocd_find", jim_find
, NULL
, NULL
);
1151 Jim_CreateCommand(interp
, "echo", jim_echo
, NULL
, NULL
);
1152 Jim_CreateCommand(interp
, "capture", jim_capture
, NULL
, NULL
);
1154 /* Set Jim's STDIO */
1155 interp
->cookie_stdin
= interp
;
1156 interp
->cookie_stdout
= interp
;
1157 interp
->cookie_stderr
= interp
;
1158 interp
->cb_fwrite
= openocd_jim_fwrite
;
1159 interp
->cb_fread
= openocd_jim_fread
;
1160 interp
->cb_vfprintf
= openocd_jim_vfprintf
;
1161 interp
->cb_fflush
= openocd_jim_fflush
;
1162 interp
->cb_fgets
= openocd_jim_fgets
;
1164 register_commands(context
, NULL
, command_builtin_handlers
);
1166 #if !BUILD_ECOSBOARD
1167 Jim_EventLoopOnLoad(interp
);
1169 Jim_SetAssocData(interp
, "context", NULL
, context
);
1170 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl",1) == JIM_ERR
)
1172 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1173 Jim_PrintErrorMessage(interp
);
1176 Jim_DeleteAssocData(interp
, "context");
1181 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
1184 return ERROR_INVALID_ARGUMENTS
;
1186 cmd_ctx
->mode
= mode
;
1190 void process_jim_events(void)
1192 #if !BUILD_ECOSBOARD
1193 static int recursion
= 0;
1198 Jim_ProcessEvents (interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
1204 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1205 int parse##name(const char *str, type *ul) \
1209 LOG_ERROR("Invalid command argument"); \
1210 return ERROR_COMMAND_ARGUMENT_INVALID; \
1213 *ul = func(str, &end, 0); \
1216 LOG_ERROR("Invalid command argument"); \
1217 return ERROR_COMMAND_ARGUMENT_INVALID; \
1219 if ((max == *ul) && (ERANGE == errno)) \
1221 LOG_ERROR("Argument overflow"); \
1222 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1224 if (min && (min == *ul) && (ERANGE == errno)) \
1226 LOG_ERROR("Argument underflow"); \
1227 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1231 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long , strtoul
, 0, ULONG_MAX
)
1232 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1233 DEFINE_PARSE_NUM_TYPE(_long
, long , strtol
, LONG_MIN
, LONG_MAX
)
1234 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1236 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1237 int parse##name(const char *str, type *ul) \
1240 int retval = parse##funcname(str, &n); \
1241 if (ERROR_OK != retval) \
1244 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1246 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1251 #define DEFINE_PARSE_ULONG(name, type, min, max) \
1252 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong)
1253 DEFINE_PARSE_ULONG(_uint
, unsigned, 0, UINT_MAX
)
1254 DEFINE_PARSE_ULONG(_u32
, uint32_t, 0, UINT32_MAX
)
1255 DEFINE_PARSE_ULONG(_u16
, uint16_t, 0, UINT16_MAX
)
1256 DEFINE_PARSE_ULONG(_u8
, uint8_t, 0, UINT8_MAX
)
1258 #define DEFINE_PARSE_LONG(name, type, min, max) \
1259 DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long)
1260 DEFINE_PARSE_LONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1261 DEFINE_PARSE_LONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1262 DEFINE_PARSE_LONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1263 DEFINE_PARSE_LONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1265 static int command_parse_bool(const char *in
, bool *out
,
1266 const char *on
, const char *off
)
1268 if (strcasecmp(in
, on
) == 0)
1270 else if (strcasecmp(in
, off
) == 0)
1273 return ERROR_COMMAND_SYNTAX_ERROR
;
1277 int command_parse_bool_arg(const char *in
, bool *out
)
1279 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1281 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1283 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1285 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1287 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1289 return ERROR_INVALID_ARGUMENTS
;
1292 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1296 const char *in
= CMD_ARGV
[0];
1297 if (command_parse_bool_arg(in
, out
) != ERROR_OK
)
1299 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1300 return ERROR_INVALID_ARGUMENTS
;
1305 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1308 return ERROR_INVALID_ARGUMENTS
;
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)