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 extern struct command_context
*global_cmd_ctx
;
61 void script_debug(Jim_Interp
*interp
, const char *name
,
62 unsigned argc
, Jim_Obj
*const *argv
)
64 LOG_DEBUG("command - %s", name
);
65 for (unsigned i
= 0; i
< argc
; i
++)
68 const char *w
= Jim_GetString(argv
[i
], &len
);
70 /* end of line comment? */
74 LOG_DEBUG("%s - argv[%d]=%s", name
, i
, w
);
78 static void script_command_args_free(const char **words
, unsigned nwords
)
80 for (unsigned i
= 0; i
< nwords
; i
++)
81 free((void *)words
[i
]);
84 static const char **script_command_args_alloc(
85 unsigned argc
, Jim_Obj
*const *argv
, unsigned *nwords
)
87 const char **words
= malloc(argc
* sizeof(char *));
92 for (i
= 0; i
< argc
; i
++)
95 const char *w
= Jim_GetString(argv
[i
], &len
);
96 /* a comment may end the line early */
100 words
[i
] = strdup(w
);
101 if (words
[i
] == NULL
)
103 script_command_args_free(words
, i
);
111 static int script_command(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
113 /* the private data is stashed in the interp structure */
115 struct command_context
*context
;
118 /* DANGER!!!! be careful what we invoke here, since interp->cmdPrivData might
119 * get overwritten by running other Jim commands! Treat it as an
120 * emphemeral global variable that is used in lieu of an argument
121 * to the fn and fish it out manually.
123 c
= interp
->cmdPrivData
;
126 LOG_ERROR("BUG: interp->cmdPrivData == NULL");
129 target_call_timer_callbacks_now();
130 LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
132 script_debug(interp
, c
->name
, argc
, argv
);
135 const char **words
= script_command_args_alloc(argc
, argv
, &nwords
);
139 /* grab the command context from the associated data */
140 context
= Jim_GetAssocData(interp
, "context");
143 /* Tcl can invoke commands directly instead of via command_run_line(). This would
144 * happen when the Jim Tcl interpreter is provided by eCos.
146 context
= global_cmd_ctx
;
149 /* capture log output and return it */
150 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
151 /* a garbage collect can happen, so we need a reference count to this object */
152 Jim_IncrRefCount(tclOutput
);
154 log_add_callback(tcl_output
, tclOutput
);
156 retval
= run_command(context
, c
, (const char **)words
, nwords
);
158 log_remove_callback(tcl_output
, tclOutput
);
160 /* We dump output into this local variable */
161 Jim_SetResult(interp
, tclOutput
);
162 Jim_DecrRefCount(interp
, tclOutput
);
164 script_command_args_free(words
, nwords
);
166 int *return_retval
= Jim_GetAssocData(interp
, "retval");
167 if (return_retval
!= NULL
)
169 *return_retval
= retval
;
172 return (retval
== ERROR_OK
)?JIM_OK
:JIM_ERR
;
175 /* nice short description of source file */
176 #define __THIS__FILE__ "command.c"
179 * Find a command by name from a list of commands.
180 * @returns Returns the named command if it exists in the list.
181 * Returns NULL otherwise.
183 static struct command
*command_find(struct command
*head
, const char *name
)
185 for (struct command
*cc
= head
; cc
; cc
= cc
->next
)
187 if (strcmp(cc
->name
, name
) == 0)
194 * Add the command into the linked list, sorted by name.
195 * @param head Address to head of command list pointer, which may be
196 * updated if @c c gets inserted at the beginning of the list.
197 * @param c The command to add to the list pointed to by @c head.
199 static void command_add_child(struct command
**head
, struct command
*c
)
208 while ((*head
)->next
&& (strcmp(c
->name
, (*head
)->name
) > 0))
209 head
= &(*head
)->next
;
211 if (strcmp(c
->name
, (*head
)->name
) > 0) {
212 c
->next
= (*head
)->next
;
220 static struct command
**command_list_for_parent(
221 struct command_context
*cmd_ctx
, struct command
*parent
)
223 return parent
? &parent
->children
: &cmd_ctx
->commands
;
226 static struct command
*command_new(struct command_context
*cmd_ctx
,
227 struct command
*parent
, const char *name
,
228 command_handler_t handler
, enum command_mode mode
,
229 const char *help
, const char *usage
)
233 struct command
*c
= malloc(sizeof(struct command
));
234 memset(c
, 0, sizeof(struct command
));
236 c
->name
= strdup(name
);
238 c
->help
= strdup(help
);
240 c
->usage
= strdup(usage
);
242 c
->handler
= handler
;
245 command_add_child(command_list_for_parent(cmd_ctx
, parent
), c
);
249 static void command_free(struct command
*c
)
251 /// @todo if command has a handler, unregister its jim command!
253 while (NULL
!= c
->children
)
255 struct command
*tmp
= c
->children
;
256 c
->children
= tmp
->next
;
263 free((void*)c
->help
);
265 free((void*)c
->usage
);
269 static int register_command_handler(struct command
*c
)
271 int retval
= -ENOMEM
;
272 const char *full_name
= command_name(c
, '_');
273 if (NULL
== full_name
)
276 const char *ocd_name
= alloc_printf("ocd_%s", full_name
);
277 if (NULL
== full_name
)
280 Jim_CreateCommand(interp
, ocd_name
, script_command
, c
, NULL
);
281 free((void *)ocd_name
);
283 /* we now need to add an overrideable proc */
284 const char *override_name
= alloc_printf("proc %s {args} {"
285 "if {[catch {eval ocd_%s $args}] == 0} "
286 "{return \"\"} else {return -code error}}",
287 full_name
, full_name
);
288 if (NULL
== full_name
)
291 Jim_Eval_Named(interp
, override_name
, __THIS__FILE__
, __LINE__
);
292 free((void *)override_name
);
297 free((void *)full_name
);
301 struct command
* register_command(struct command_context
*context
,
302 struct command
*parent
, const struct command_registration
*cr
)
304 if (!context
|| !cr
->name
)
307 const char *name
= cr
->name
;
308 struct command
**head
= command_list_for_parent(context
, parent
);
309 struct command
*c
= command_find(*head
, name
);
312 LOG_ERROR("command '%s' is already registered in '%s' context",
313 name
, parent
? parent
->name
: "<global>");
317 c
= command_new(context
, parent
, name
, cr
->handler
, cr
->mode
, cr
->help
, cr
->usage
);
318 /* if allocation failed or it is a placeholder (no handler), we're done */
319 if (NULL
== c
|| NULL
== c
->handler
)
322 int retval
= register_command_handler(c
);
323 if (ERROR_OK
!= retval
)
325 unregister_command(context
, parent
, name
);
331 int register_commands(struct command_context
*cmd_ctx
, struct command
*parent
,
332 const struct command_registration
*cmds
)
335 for (i
= 0; cmds
[i
].name
; i
++)
337 struct command
*c
= register_command(cmd_ctx
, parent
, cmds
+ i
);
341 for (unsigned j
= 0; j
< i
; j
++)
342 unregister_command(cmd_ctx
, parent
, cmds
[j
].name
);
348 int unregister_all_commands(struct command_context
*context
,
349 struct command
*parent
)
354 struct command
**head
= command_list_for_parent(context
, parent
);
355 while (NULL
!= *head
)
357 struct command
*tmp
= *head
;
365 int unregister_command(struct command_context
*context
,
366 struct command
*parent
, const char *name
)
368 if ((!context
) || (!name
))
369 return ERROR_INVALID_ARGUMENTS
;
371 struct command
*p
= NULL
;
372 struct command
**head
= command_list_for_parent(context
, parent
);
373 for (struct command
*c
= *head
; NULL
!= c
; p
= c
, c
= c
->next
)
375 if (strcmp(name
, c
->name
) != 0)
390 void command_output_text(struct command_context
*context
, const char *data
)
392 if (context
&& context
->output_handler
&& data
) {
393 context
->output_handler(context
, data
);
397 void command_print_sameline(struct command_context
*context
, const char *format
, ...)
402 va_start(ap
, format
);
404 string
= alloc_vprintf(format
, ap
);
407 /* we want this collected in the log + we also want to pick it up as a tcl return
410 * The latter bit isn't precisely neat, but will do for now.
412 LOG_USER_N("%s", string
);
413 /* We already printed it above */
414 /* command_output_text(context, string); */
421 void command_print(struct command_context
*context
, const char *format
, ...)
426 va_start(ap
, format
);
428 string
= alloc_vprintf(format
, ap
);
431 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
432 /* we want this collected in the log + we also want to pick it up as a tcl return
435 * The latter bit isn't precisely neat, but will do for now.
437 LOG_USER_N("%s", string
);
438 /* We already printed it above */
439 /* command_output_text(context, string); */
446 static char *__command_name(struct command
*c
, char delim
, unsigned extra
)
449 unsigned len
= strlen(c
->name
);
450 if (NULL
== c
->parent
) {
451 // allocate enough for the name, child names, and '\0'
452 name
= malloc(len
+ extra
+ 1);
453 strcpy(name
, c
->name
);
455 // parent's extra must include both the space and name
456 name
= __command_name(c
->parent
, delim
, 1 + len
+ extra
);
457 char dstr
[2] = { delim
, 0 };
459 strcat(name
, c
->name
);
463 char *command_name(struct command
*c
, char delim
)
465 return __command_name(c
, delim
, 0);
468 static int run_command(struct command_context
*context
,
469 struct command
*c
, const char *words
[], unsigned num_words
)
471 if (!((context
->mode
== COMMAND_CONFIG
) || (c
->mode
== COMMAND_ANY
) || (c
->mode
== context
->mode
)))
473 /* Config commands can not run after the config stage */
474 LOG_ERROR("Command '%s' only runs during configuration stage", c
->name
);
478 struct command_invocation cmd
= {
481 .argc
= num_words
- 1,
484 int retval
= c
->handler(&cmd
);
485 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
)
487 /* Print help for command */
488 char *full_name
= command_name(c
, ' ');
489 if (NULL
!= full_name
) {
490 command_run_linef(context
, "help %s", full_name
);
495 else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
497 /* just fall through for a shutdown request */
499 else if (retval
!= ERROR_OK
)
501 /* we do not print out an error message because the command *should*
502 * have printed out an error
504 LOG_DEBUG("Command failed with error code %d", retval
);
510 int command_run_line(struct command_context
*context
, char *line
)
512 /* all the parent commands have been registered with the interpreter
513 * so, can just evaluate the line as a script and check for
516 /* run the line thru a script engine */
517 int retval
= ERROR_FAIL
;
519 /* Beware! This code needs to be reentrant. It is also possible
520 * for OpenOCD commands to be invoked directly from Tcl. This would
521 * happen when the Jim Tcl interpreter is provided by eCos for
524 Jim_DeleteAssocData(interp
, "context");
525 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
526 if (retcode
== JIM_OK
)
528 /* associated the return value */
529 Jim_DeleteAssocData(interp
, "retval");
530 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
531 if (retcode
== JIM_OK
)
533 retcode
= Jim_Eval_Named(interp
, line
, __THIS__FILE__
, __LINE__
);
535 Jim_DeleteAssocData(interp
, "retval");
537 Jim_DeleteAssocData(interp
, "context");
539 if (retcode
== JIM_ERR
) {
540 if (retval
!= ERROR_COMMAND_CLOSE_CONNECTION
)
542 /* We do not print the connection closed error message */
543 Jim_PrintErrorMessage(interp
);
545 if (retval
== ERROR_OK
)
547 /* It wasn't a low level OpenOCD command that failed */
551 } else if (retcode
== JIM_EXIT
) {
553 /* exit(Jim_GetExitCode(interp)); */
558 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
563 for (i
= 0; i
< reslen
; i
+= 256)
569 strncpy(buff
, result
+ i
, chunk
);
571 LOG_USER_N("%s", buff
);
573 LOG_USER_N("%s", "\n");
580 int command_run_linef(struct command_context
*context
, const char *format
, ...)
582 int retval
= ERROR_FAIL
;
585 va_start(ap
, format
);
586 string
= alloc_vprintf(format
, ap
);
589 retval
= command_run_line(context
, string
);
595 void command_set_output_handler(struct command_context
* context
,
596 command_output_handler_t output_handler
, void *priv
)
598 context
->output_handler
= output_handler
;
599 context
->output_handler_priv
= priv
;
602 struct command_context
* copy_command_context(struct command_context
* context
)
604 struct command_context
* copy_context
= malloc(sizeof(struct command_context
));
606 *copy_context
= *context
;
611 int command_done(struct command_context
*context
)
619 /* find full path to file */
620 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
624 const char *file
= Jim_GetString(argv
[1], NULL
);
625 char *full_path
= find_file(file
);
626 if (full_path
== NULL
)
628 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
631 Jim_SetResult(interp
, result
);
635 static int jim_echo(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
639 const char *str
= Jim_GetString(argv
[1], NULL
);
644 static size_t openocd_jim_fwrite(const void *_ptr
, size_t size
, size_t n
, void *cookie
)
650 /* make it a char easier to read code */
654 if (ptr
== NULL
|| interp
== NULL
|| nbytes
== 0) {
658 /* do we have to chunk it? */
659 if (ptr
[nbytes
] == 0)
661 /* no it is a C style string */
662 LOG_USER_N("%s", ptr
);
665 /* GRR we must chunk - not null terminated */
675 memcpy(chunk
, ptr
, x
);
679 LOG_USER_N("%s", chunk
);
687 static size_t openocd_jim_fread(void *ptr
, size_t size
, size_t n
, void *cookie
)
689 /* TCL wants to read... tell him no */
693 static int openocd_jim_vfprintf(void *cookie
, const char *fmt
, va_list ap
)
704 cp
= alloc_vprintf(fmt
, ap
);
707 LOG_USER_N("%s", cp
);
714 static int openocd_jim_fflush(void *cookie
)
716 /* nothing to flush */
720 static char* openocd_jim_fgets(char *s
, int size
, void *cookie
)
727 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
732 const char *str
= Jim_GetString(argv
[1], NULL
);
734 /* capture log output and return it */
735 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
736 /* a garbage collect can happen, so we need a reference count to this object */
737 Jim_IncrRefCount(tclOutput
);
739 log_add_callback(tcl_output
, tclOutput
);
741 retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
743 log_remove_callback(tcl_output
, tclOutput
);
745 /* We dump output into this local variable */
746 Jim_SetResult(interp
, tclOutput
);
747 Jim_DecrRefCount(interp
, tclOutput
);
752 static COMMAND_HELPER(command_help_find
, struct command
*head
,
753 struct command
**out
)
756 return ERROR_INVALID_ARGUMENTS
;
757 *out
= command_find(head
, CMD_ARGV
[0]);
759 return ERROR_INVALID_ARGUMENTS
;
763 return CALL_COMMAND_HANDLER(command_help_find
, (*out
)->children
, out
);
766 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
769 static COMMAND_HELPER(command_help_show_list
, struct command
*head
, unsigned n
,
772 for (struct command
*c
= head
; NULL
!= c
; c
= c
->next
)
773 CALL_COMMAND_HANDLER(command_help_show
, c
, n
, show_help
);
776 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
779 const char *usage
= c
->usage
? : "";
780 const char *help
= "";
781 const char *sep
= "";
782 if (show_help
&& c
->help
)
784 help
= c
->help
? : "";
785 sep
= c
->usage
? " | " : "";
787 command_run_linef(CMD_CTX
, "cmd_help {%s} {%s%s%s} %d",
788 command_name(c
, ' '), usage
, sep
, help
, n
);
793 return CALL_COMMAND_HANDLER(command_help_show_list
,
794 c
->children
, n
, show_help
);
796 COMMAND_HANDLER(handle_help_command
)
798 struct command
*c
= CMD_CTX
->commands
;
801 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0, true);
803 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
804 if (ERROR_OK
!= retval
)
807 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0, true);
810 COMMAND_HANDLER(handle_usage_command
)
812 struct command
*c
= CMD_CTX
->commands
;
815 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0, false);
817 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
818 if (ERROR_OK
!= retval
)
821 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0, false);
825 int help_add_command(struct command_context
*cmd_ctx
, struct command
*parent
,
826 const char *cmd_name
, const char *help_text
, const char *usage
)
828 struct command
**head
= command_list_for_parent(cmd_ctx
, parent
);
829 struct command
*nc
= command_find(*head
, cmd_name
);
832 // add a new command with help text
833 struct command_registration cr
= {
839 nc
= register_command(cmd_ctx
, parent
, &cr
);
842 LOG_ERROR("failed to add '%s' help text", cmd_name
);
845 LOG_DEBUG("added '%s' help text", cmd_name
);
849 bool replaced
= false;
852 free((void *)nc
->help
);
855 nc
->help
= strdup(help_text
);
858 LOG_INFO("replaced existing '%s' help", cmd_name
);
860 LOG_DEBUG("added '%s' help text", cmd_name
);
865 COMMAND_HANDLER(handle_help_add_command
)
869 LOG_ERROR("%s: insufficient arguments", CMD_NAME
);
870 return ERROR_INVALID_ARGUMENTS
;
873 // save help text and remove it from argument list
874 const char *help_text
= CMD_ARGV
[--CMD_ARGC
];
875 // likewise for the leaf command name
876 const char *cmd_name
= CMD_ARGV
[--CMD_ARGC
];
878 struct command
*c
= NULL
;
881 c
= CMD_CTX
->commands
;
882 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
883 if (ERROR_OK
!= retval
)
886 return help_add_command(CMD_CTX
, c
, cmd_name
, help_text
, NULL
);
889 /* sleep command sleeps for <n> miliseconds
890 * this is useful in target startup scripts
892 COMMAND_HANDLER(handle_sleep_command
)
897 if (strcmp(CMD_ARGV
[1], "busy") == 0)
900 return ERROR_COMMAND_SYNTAX_ERROR
;
902 else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
903 return ERROR_COMMAND_SYNTAX_ERROR
;
905 unsigned long duration
= 0;
906 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
907 if (ERROR_OK
!= retval
)
912 long long then
= timeval_ms();
913 while (timeval_ms() - then
< (long long)duration
)
915 target_call_timer_callbacks_now();
920 busy_sleep(duration
);
925 static const struct command_registration command_builtin_handlers
[] = {
927 .name
= "add_help_text",
928 .handler
= &handle_help_add_command
,
930 .help
= "add new command help text",
931 .usage
= "<command> [...] <help_text>]",
935 .handler
= &handle_sleep_command
,
937 .help
= "sleep for n milliseconds. "
938 "\"busy\" will busy wait",
939 .usage
= "<n> [busy]",
943 .handler
= &handle_help_command
,
945 .help
= "show built-in command help",
946 .usage
= "[<command_name> ...]",
950 .handler
= &handle_usage_command
,
952 .help
= "show command usage",
953 .usage
= "[<command_name> ...]",
955 COMMAND_REGISTRATION_DONE
958 struct command_context
* command_init(const char *startup_tcl
)
960 struct command_context
* context
= malloc(sizeof(struct command_context
));
963 context
->mode
= COMMAND_EXEC
;
964 context
->commands
= NULL
;
965 context
->current_target
= 0;
966 context
->output_handler
= NULL
;
967 context
->output_handler_priv
= NULL
;
971 /* Create an interpreter */
972 interp
= Jim_CreateInterp();
973 /* Add all the Jim core commands */
974 Jim_RegisterCoreCommands(interp
);
977 #if defined(_MSC_VER)
978 /* WinXX - is generic, the forward
979 * looking problem is this:
983 * "winxx" is generic.
986 #elif defined(__linux__)
988 #elif defined(__DARWIN__)
990 #elif defined(__CYGWIN__)
992 #elif defined(__MINGW32__)
994 #elif defined(__ECOS)
997 #warn unrecognized host OS...
1000 Jim_SetGlobalVariableStr(interp
, "ocd_HOSTOS",
1001 Jim_NewStringObj(interp
, HostOs
, strlen(HostOs
)));
1003 Jim_CreateCommand(interp
, "ocd_find", jim_find
, NULL
, NULL
);
1004 Jim_CreateCommand(interp
, "echo", jim_echo
, NULL
, NULL
);
1005 Jim_CreateCommand(interp
, "capture", jim_capture
, NULL
, NULL
);
1007 /* Set Jim's STDIO */
1008 interp
->cookie_stdin
= interp
;
1009 interp
->cookie_stdout
= interp
;
1010 interp
->cookie_stderr
= interp
;
1011 interp
->cb_fwrite
= openocd_jim_fwrite
;
1012 interp
->cb_fread
= openocd_jim_fread
;
1013 interp
->cb_vfprintf
= openocd_jim_vfprintf
;
1014 interp
->cb_fflush
= openocd_jim_fflush
;
1015 interp
->cb_fgets
= openocd_jim_fgets
;
1017 register_commands(context
, NULL
, command_builtin_handlers
);
1019 #if !BUILD_ECOSBOARD
1020 Jim_EventLoopOnLoad(interp
);
1022 Jim_SetAssocData(interp
, "context", NULL
, context
);
1023 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl",1) == JIM_ERR
)
1025 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1026 Jim_PrintErrorMessage(interp
);
1029 Jim_DeleteAssocData(interp
, "context");
1034 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
1037 return ERROR_INVALID_ARGUMENTS
;
1039 cmd_ctx
->mode
= mode
;
1043 void process_jim_events(void)
1045 #if !BUILD_ECOSBOARD
1046 static int recursion
= 0;
1051 Jim_ProcessEvents (interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
1057 void register_jim(struct command_context
*cmd_ctx
, const char *name
,
1058 Jim_CmdProc cmd
, const char *help
)
1060 Jim_CreateCommand(interp
, name
, cmd
, NULL
, NULL
);
1062 Jim_Obj
*cmd_list
= Jim_NewListObj(interp
, NULL
, 0);
1063 Jim_ListAppendElement(interp
, cmd_list
,
1064 Jim_NewStringObj(interp
, name
, -1));
1066 help_add_command(cmd_ctx
, NULL
, name
, help
, NULL
);
1069 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1070 int parse##name(const char *str, type *ul) \
1074 LOG_ERROR("Invalid command argument"); \
1075 return ERROR_COMMAND_ARGUMENT_INVALID; \
1078 *ul = func(str, &end, 0); \
1081 LOG_ERROR("Invalid command argument"); \
1082 return ERROR_COMMAND_ARGUMENT_INVALID; \
1084 if ((max == *ul) && (ERANGE == errno)) \
1086 LOG_ERROR("Argument overflow"); \
1087 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1089 if (min && (min == *ul) && (ERANGE == errno)) \
1091 LOG_ERROR("Argument underflow"); \
1092 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1096 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long , strtoul
, 0, ULONG_MAX
)
1097 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1098 DEFINE_PARSE_NUM_TYPE(_long
, long , strtol
, LONG_MIN
, LONG_MAX
)
1099 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1101 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1102 int parse##name(const char *str, type *ul) \
1105 int retval = parse##funcname(str, &n); \
1106 if (ERROR_OK != retval) \
1109 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1111 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1116 #define DEFINE_PARSE_ULONG(name, type, min, max) \
1117 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong)
1118 DEFINE_PARSE_ULONG(_uint
, unsigned, 0, UINT_MAX
)
1119 DEFINE_PARSE_ULONG(_u32
, uint32_t, 0, UINT32_MAX
)
1120 DEFINE_PARSE_ULONG(_u16
, uint16_t, 0, UINT16_MAX
)
1121 DEFINE_PARSE_ULONG(_u8
, uint8_t, 0, UINT8_MAX
)
1123 #define DEFINE_PARSE_LONG(name, type, min, max) \
1124 DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long)
1125 DEFINE_PARSE_LONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1126 DEFINE_PARSE_LONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1127 DEFINE_PARSE_LONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1128 DEFINE_PARSE_LONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1130 static int command_parse_bool(const char *in
, bool *out
,
1131 const char *on
, const char *off
)
1133 if (strcasecmp(in
, on
) == 0)
1135 else if (strcasecmp(in
, off
) == 0)
1138 return ERROR_COMMAND_SYNTAX_ERROR
;
1142 int command_parse_bool_arg(const char *in
, bool *out
)
1144 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1146 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1148 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1150 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1152 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1154 return ERROR_INVALID_ARGUMENTS
;
1157 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1161 const char *in
= CMD_ARGV
[0];
1162 if (command_parse_bool_arg(in
, out
) != ERROR_OK
)
1164 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1165 return ERROR_INVALID_ARGUMENTS
;
1170 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1173 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)