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
)
334 int retval
= ERROR_OK
;
336 for (i
= 0; cmds
[i
].name
|| cmds
[i
].chain
; i
++)
338 const struct command_registration
*cr
= cmds
+ i
;
340 struct command
*c
= NULL
;
341 if (NULL
!= cr
->name
)
343 c
= register_command(cmd_ctx
, parent
, cr
);
350 if (NULL
!= cr
->chain
)
352 struct command
*p
= c
? : parent
;
353 retval
= register_commands(cmd_ctx
, p
, cr
->chain
);
354 if (ERROR_OK
!= retval
)
358 if (ERROR_OK
!= retval
)
360 for (unsigned j
= 0; j
< i
; j
++)
361 unregister_command(cmd_ctx
, parent
, cmds
[j
].name
);
366 int unregister_all_commands(struct command_context
*context
,
367 struct command
*parent
)
372 struct command
**head
= command_list_for_parent(context
, parent
);
373 while (NULL
!= *head
)
375 struct command
*tmp
= *head
;
383 int unregister_command(struct command_context
*context
,
384 struct command
*parent
, const char *name
)
386 if ((!context
) || (!name
))
387 return ERROR_INVALID_ARGUMENTS
;
389 struct command
*p
= NULL
;
390 struct command
**head
= command_list_for_parent(context
, parent
);
391 for (struct command
*c
= *head
; NULL
!= c
; p
= c
, c
= c
->next
)
393 if (strcmp(name
, c
->name
) != 0)
408 void command_output_text(struct command_context
*context
, const char *data
)
410 if (context
&& context
->output_handler
&& data
) {
411 context
->output_handler(context
, data
);
415 void command_print_sameline(struct command_context
*context
, const char *format
, ...)
420 va_start(ap
, format
);
422 string
= alloc_vprintf(format
, ap
);
425 /* we want this collected in the log + we also want to pick it up as a tcl return
428 * The latter bit isn't precisely neat, but will do for now.
430 LOG_USER_N("%s", string
);
431 /* We already printed it above */
432 /* command_output_text(context, string); */
439 void command_print(struct command_context
*context
, const char *format
, ...)
444 va_start(ap
, format
);
446 string
= alloc_vprintf(format
, ap
);
449 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
450 /* we want this collected in the log + we also want to pick it up as a tcl return
453 * The latter bit isn't precisely neat, but will do for now.
455 LOG_USER_N("%s", string
);
456 /* We already printed it above */
457 /* command_output_text(context, string); */
464 static char *__command_name(struct command
*c
, char delim
, unsigned extra
)
467 unsigned len
= strlen(c
->name
);
468 if (NULL
== c
->parent
) {
469 // allocate enough for the name, child names, and '\0'
470 name
= malloc(len
+ extra
+ 1);
471 strcpy(name
, c
->name
);
473 // parent's extra must include both the space and name
474 name
= __command_name(c
->parent
, delim
, 1 + len
+ extra
);
475 char dstr
[2] = { delim
, 0 };
477 strcat(name
, c
->name
);
481 char *command_name(struct command
*c
, char delim
)
483 return __command_name(c
, delim
, 0);
486 static int run_command(struct command_context
*context
,
487 struct command
*c
, const char *words
[], unsigned num_words
)
489 if (!((context
->mode
== COMMAND_CONFIG
) || (c
->mode
== COMMAND_ANY
) || (c
->mode
== context
->mode
)))
491 /* Config commands can not run after the config stage */
492 LOG_ERROR("Command '%s' only runs during configuration stage", c
->name
);
496 struct command_invocation cmd
= {
499 .argc
= num_words
- 1,
502 int retval
= c
->handler(&cmd
);
503 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
)
505 /* Print help for command */
506 char *full_name
= command_name(c
, ' ');
507 if (NULL
!= full_name
) {
508 command_run_linef(context
, "help %s", full_name
);
513 else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
515 /* just fall through for a shutdown request */
517 else if (retval
!= ERROR_OK
)
519 /* we do not print out an error message because the command *should*
520 * have printed out an error
522 LOG_DEBUG("Command failed with error code %d", retval
);
528 int command_run_line(struct command_context
*context
, char *line
)
530 /* all the parent commands have been registered with the interpreter
531 * so, can just evaluate the line as a script and check for
534 /* run the line thru a script engine */
535 int retval
= ERROR_FAIL
;
537 /* Beware! This code needs to be reentrant. It is also possible
538 * for OpenOCD commands to be invoked directly from Tcl. This would
539 * happen when the Jim Tcl interpreter is provided by eCos for
542 Jim_DeleteAssocData(interp
, "context");
543 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
544 if (retcode
== JIM_OK
)
546 /* associated the return value */
547 Jim_DeleteAssocData(interp
, "retval");
548 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
549 if (retcode
== JIM_OK
)
551 retcode
= Jim_Eval_Named(interp
, line
, __THIS__FILE__
, __LINE__
);
553 Jim_DeleteAssocData(interp
, "retval");
555 Jim_DeleteAssocData(interp
, "context");
557 if (retcode
== JIM_ERR
) {
558 if (retval
!= ERROR_COMMAND_CLOSE_CONNECTION
)
560 /* We do not print the connection closed error message */
561 Jim_PrintErrorMessage(interp
);
563 if (retval
== ERROR_OK
)
565 /* It wasn't a low level OpenOCD command that failed */
569 } else if (retcode
== JIM_EXIT
) {
571 /* exit(Jim_GetExitCode(interp)); */
576 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
581 for (i
= 0; i
< reslen
; i
+= 256)
587 strncpy(buff
, result
+ i
, chunk
);
589 LOG_USER_N("%s", buff
);
591 LOG_USER_N("%s", "\n");
598 int command_run_linef(struct command_context
*context
, const char *format
, ...)
600 int retval
= ERROR_FAIL
;
603 va_start(ap
, format
);
604 string
= alloc_vprintf(format
, ap
);
607 retval
= command_run_line(context
, string
);
613 void command_set_output_handler(struct command_context
* context
,
614 command_output_handler_t output_handler
, void *priv
)
616 context
->output_handler
= output_handler
;
617 context
->output_handler_priv
= priv
;
620 struct command_context
* copy_command_context(struct command_context
* context
)
622 struct command_context
* copy_context
= malloc(sizeof(struct command_context
));
624 *copy_context
= *context
;
629 int command_done(struct command_context
*context
)
637 /* find full path to file */
638 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
642 const char *file
= Jim_GetString(argv
[1], NULL
);
643 char *full_path
= find_file(file
);
644 if (full_path
== NULL
)
646 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
649 Jim_SetResult(interp
, result
);
653 static int jim_echo(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
657 const char *str
= Jim_GetString(argv
[1], NULL
);
662 static size_t openocd_jim_fwrite(const void *_ptr
, size_t size
, size_t n
, void *cookie
)
668 /* make it a char easier to read code */
672 if (ptr
== NULL
|| interp
== NULL
|| nbytes
== 0) {
676 /* do we have to chunk it? */
677 if (ptr
[nbytes
] == 0)
679 /* no it is a C style string */
680 LOG_USER_N("%s", ptr
);
683 /* GRR we must chunk - not null terminated */
693 memcpy(chunk
, ptr
, x
);
697 LOG_USER_N("%s", chunk
);
705 static size_t openocd_jim_fread(void *ptr
, size_t size
, size_t n
, void *cookie
)
707 /* TCL wants to read... tell him no */
711 static int openocd_jim_vfprintf(void *cookie
, const char *fmt
, va_list ap
)
722 cp
= alloc_vprintf(fmt
, ap
);
725 LOG_USER_N("%s", cp
);
732 static int openocd_jim_fflush(void *cookie
)
734 /* nothing to flush */
738 static char* openocd_jim_fgets(char *s
, int size
, void *cookie
)
745 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
750 const char *str
= Jim_GetString(argv
[1], NULL
);
752 /* capture log output and return it */
753 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
754 /* a garbage collect can happen, so we need a reference count to this object */
755 Jim_IncrRefCount(tclOutput
);
757 log_add_callback(tcl_output
, tclOutput
);
759 retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
761 log_remove_callback(tcl_output
, tclOutput
);
763 /* We dump output into this local variable */
764 Jim_SetResult(interp
, tclOutput
);
765 Jim_DecrRefCount(interp
, tclOutput
);
770 static COMMAND_HELPER(command_help_find
, struct command
*head
,
771 struct command
**out
)
774 return ERROR_INVALID_ARGUMENTS
;
775 *out
= command_find(head
, CMD_ARGV
[0]);
777 return ERROR_INVALID_ARGUMENTS
;
781 return CALL_COMMAND_HANDLER(command_help_find
, (*out
)->children
, out
);
784 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
787 static COMMAND_HELPER(command_help_show_list
, struct command
*head
, unsigned n
,
790 for (struct command
*c
= head
; NULL
!= c
; c
= c
->next
)
791 CALL_COMMAND_HANDLER(command_help_show
, c
, n
, show_help
);
794 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
,
797 const char *usage
= c
->usage
? : "";
798 const char *help
= "";
799 const char *sep
= "";
800 if (show_help
&& c
->help
)
802 help
= c
->help
? : "";
803 sep
= c
->usage
? " | " : "";
805 command_run_linef(CMD_CTX
, "cmd_help {%s} {%s%s%s} %d",
806 command_name(c
, ' '), usage
, sep
, help
, n
);
811 return CALL_COMMAND_HANDLER(command_help_show_list
,
812 c
->children
, n
, show_help
);
814 COMMAND_HANDLER(handle_help_command
)
816 struct command
*c
= CMD_CTX
->commands
;
819 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0, true);
821 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
822 if (ERROR_OK
!= retval
)
825 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0, true);
828 COMMAND_HANDLER(handle_usage_command
)
830 struct command
*c
= CMD_CTX
->commands
;
833 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0, false);
835 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
836 if (ERROR_OK
!= retval
)
839 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0, false);
843 int help_add_command(struct command_context
*cmd_ctx
, struct command
*parent
,
844 const char *cmd_name
, const char *help_text
, const char *usage
)
846 struct command
**head
= command_list_for_parent(cmd_ctx
, parent
);
847 struct command
*nc
= command_find(*head
, cmd_name
);
850 // add a new command with help text
851 struct command_registration cr
= {
857 nc
= register_command(cmd_ctx
, parent
, &cr
);
860 LOG_ERROR("failed to add '%s' help text", cmd_name
);
863 LOG_DEBUG("added '%s' help text", cmd_name
);
867 bool replaced
= false;
870 free((void *)nc
->help
);
873 nc
->help
= strdup(help_text
);
876 LOG_INFO("replaced existing '%s' help", cmd_name
);
878 LOG_DEBUG("added '%s' help text", cmd_name
);
883 COMMAND_HANDLER(handle_help_add_command
)
887 LOG_ERROR("%s: insufficient arguments", CMD_NAME
);
888 return ERROR_INVALID_ARGUMENTS
;
891 // save help text and remove it from argument list
892 const char *help_text
= CMD_ARGV
[--CMD_ARGC
];
893 // likewise for the leaf command name
894 const char *cmd_name
= CMD_ARGV
[--CMD_ARGC
];
896 struct command
*c
= NULL
;
899 c
= CMD_CTX
->commands
;
900 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
901 if (ERROR_OK
!= retval
)
904 return help_add_command(CMD_CTX
, c
, cmd_name
, help_text
, NULL
);
907 /* sleep command sleeps for <n> miliseconds
908 * this is useful in target startup scripts
910 COMMAND_HANDLER(handle_sleep_command
)
915 if (strcmp(CMD_ARGV
[1], "busy") == 0)
918 return ERROR_COMMAND_SYNTAX_ERROR
;
920 else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
921 return ERROR_COMMAND_SYNTAX_ERROR
;
923 unsigned long duration
= 0;
924 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
925 if (ERROR_OK
!= retval
)
930 long long then
= timeval_ms();
931 while (timeval_ms() - then
< (long long)duration
)
933 target_call_timer_callbacks_now();
938 busy_sleep(duration
);
943 static const struct command_registration command_builtin_handlers
[] = {
945 .name
= "add_help_text",
946 .handler
= &handle_help_add_command
,
948 .help
= "add new command help text",
949 .usage
= "<command> [...] <help_text>]",
953 .handler
= &handle_sleep_command
,
955 .help
= "sleep for n milliseconds. "
956 "\"busy\" will busy wait",
957 .usage
= "<n> [busy]",
961 .handler
= &handle_help_command
,
963 .help
= "show built-in command help",
964 .usage
= "[<command_name> ...]",
968 .handler
= &handle_usage_command
,
970 .help
= "show command usage",
971 .usage
= "[<command_name> ...]",
973 COMMAND_REGISTRATION_DONE
976 struct command_context
* command_init(const char *startup_tcl
)
978 struct command_context
* context
= malloc(sizeof(struct command_context
));
981 context
->mode
= COMMAND_EXEC
;
982 context
->commands
= NULL
;
983 context
->current_target
= 0;
984 context
->output_handler
= NULL
;
985 context
->output_handler_priv
= NULL
;
989 /* Create an interpreter */
990 interp
= Jim_CreateInterp();
991 /* Add all the Jim core commands */
992 Jim_RegisterCoreCommands(interp
);
995 #if defined(_MSC_VER)
996 /* WinXX - is generic, the forward
997 * looking problem is this:
1001 * "winxx" is generic.
1004 #elif defined(__linux__)
1006 #elif defined(__DARWIN__)
1008 #elif defined(__CYGWIN__)
1010 #elif defined(__MINGW32__)
1012 #elif defined(__ECOS)
1015 #warn unrecognized host OS...
1018 Jim_SetGlobalVariableStr(interp
, "ocd_HOSTOS",
1019 Jim_NewStringObj(interp
, HostOs
, strlen(HostOs
)));
1021 Jim_CreateCommand(interp
, "ocd_find", jim_find
, NULL
, NULL
);
1022 Jim_CreateCommand(interp
, "echo", jim_echo
, NULL
, NULL
);
1023 Jim_CreateCommand(interp
, "capture", jim_capture
, NULL
, NULL
);
1025 /* Set Jim's STDIO */
1026 interp
->cookie_stdin
= interp
;
1027 interp
->cookie_stdout
= interp
;
1028 interp
->cookie_stderr
= interp
;
1029 interp
->cb_fwrite
= openocd_jim_fwrite
;
1030 interp
->cb_fread
= openocd_jim_fread
;
1031 interp
->cb_vfprintf
= openocd_jim_vfprintf
;
1032 interp
->cb_fflush
= openocd_jim_fflush
;
1033 interp
->cb_fgets
= openocd_jim_fgets
;
1035 register_commands(context
, NULL
, command_builtin_handlers
);
1037 #if !BUILD_ECOSBOARD
1038 Jim_EventLoopOnLoad(interp
);
1040 Jim_SetAssocData(interp
, "context", NULL
, context
);
1041 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl",1) == JIM_ERR
)
1043 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
1044 Jim_PrintErrorMessage(interp
);
1047 Jim_DeleteAssocData(interp
, "context");
1052 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
1055 return ERROR_INVALID_ARGUMENTS
;
1057 cmd_ctx
->mode
= mode
;
1061 void process_jim_events(void)
1063 #if !BUILD_ECOSBOARD
1064 static int recursion
= 0;
1069 Jim_ProcessEvents (interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
1075 void register_jim(struct command_context
*cmd_ctx
, const char *name
,
1076 Jim_CmdProc cmd
, const char *help
)
1078 Jim_CreateCommand(interp
, name
, cmd
, NULL
, NULL
);
1080 Jim_Obj
*cmd_list
= Jim_NewListObj(interp
, NULL
, 0);
1081 Jim_ListAppendElement(interp
, cmd_list
,
1082 Jim_NewStringObj(interp
, name
, -1));
1084 help_add_command(cmd_ctx
, NULL
, name
, help
, NULL
);
1087 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
1088 int parse##name(const char *str, type *ul) \
1092 LOG_ERROR("Invalid command argument"); \
1093 return ERROR_COMMAND_ARGUMENT_INVALID; \
1096 *ul = func(str, &end, 0); \
1099 LOG_ERROR("Invalid command argument"); \
1100 return ERROR_COMMAND_ARGUMENT_INVALID; \
1102 if ((max == *ul) && (ERANGE == errno)) \
1104 LOG_ERROR("Argument overflow"); \
1105 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1107 if (min && (min == *ul) && (ERANGE == errno)) \
1109 LOG_ERROR("Argument underflow"); \
1110 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1114 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long , strtoul
, 0, ULONG_MAX
)
1115 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1116 DEFINE_PARSE_NUM_TYPE(_long
, long , strtol
, LONG_MIN
, LONG_MAX
)
1117 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1119 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1120 int parse##name(const char *str, type *ul) \
1123 int retval = parse##funcname(str, &n); \
1124 if (ERROR_OK != retval) \
1127 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1129 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1134 #define DEFINE_PARSE_ULONG(name, type, min, max) \
1135 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong)
1136 DEFINE_PARSE_ULONG(_uint
, unsigned, 0, UINT_MAX
)
1137 DEFINE_PARSE_ULONG(_u32
, uint32_t, 0, UINT32_MAX
)
1138 DEFINE_PARSE_ULONG(_u16
, uint16_t, 0, UINT16_MAX
)
1139 DEFINE_PARSE_ULONG(_u8
, uint8_t, 0, UINT8_MAX
)
1141 #define DEFINE_PARSE_LONG(name, type, min, max) \
1142 DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long)
1143 DEFINE_PARSE_LONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1144 DEFINE_PARSE_LONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1145 DEFINE_PARSE_LONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1146 DEFINE_PARSE_LONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1148 static int command_parse_bool(const char *in
, bool *out
,
1149 const char *on
, const char *off
)
1151 if (strcasecmp(in
, on
) == 0)
1153 else if (strcasecmp(in
, off
) == 0)
1156 return ERROR_COMMAND_SYNTAX_ERROR
;
1160 int command_parse_bool_arg(const char *in
, bool *out
)
1162 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1164 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1166 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1168 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1170 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1172 return ERROR_INVALID_ARGUMENTS
;
1175 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1179 const char *in
= CMD_ARGV
[0];
1180 if (command_parse_bool_arg(in
, out
) != ERROR_OK
)
1182 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1183 return ERROR_INVALID_ARGUMENTS
;
1188 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1191 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)