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
,
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
->handler
= handler
;
243 command_add_child(command_list_for_parent(cmd_ctx
, parent
), c
);
247 static void command_free(struct command
*c
)
249 /// @todo if command has a handler, unregister its jim command!
251 while (NULL
!= c
->children
)
253 struct command
*tmp
= c
->children
;
254 c
->children
= tmp
->next
;
261 free((void*)c
->help
);
265 struct command
* register_command(struct command_context
*context
,
266 struct command
*parent
, const struct command_registration
*cr
)
268 if (!context
|| !cr
->name
)
271 const char *name
= cr
->name
;
272 struct command
**head
= command_list_for_parent(context
, parent
);
273 struct command
*c
= command_find(*head
, name
);
276 LOG_ERROR("command '%s' is already registered in '%s' context",
277 name
, parent
? parent
->name
: "<global>");
281 c
= command_new(context
, parent
, name
, cr
->handler
, cr
->mode
, cr
->help
);
282 /* if allocation failed or it is a placeholder (no handler), we're done */
283 if (NULL
== c
|| NULL
== c
->handler
)
286 const char *full_name
= command_name(c
, '_');
288 const char *ocd_name
= alloc_printf("ocd_%s", full_name
);
289 Jim_CreateCommand(interp
, ocd_name
, script_command
, c
, NULL
);
290 free((void *)ocd_name
);
292 /* we now need to add an overrideable proc */
293 const char *override_name
= alloc_printf("proc %s {args} {"
294 "if {[catch {eval ocd_%s $args}] == 0} "
295 "{return \"\"} else {return -code error}}",
296 full_name
, full_name
);
297 Jim_Eval_Named(interp
, override_name
, __THIS__FILE__
, __LINE__
);
298 free((void *)override_name
);
300 free((void *)full_name
);
305 int register_commands(struct command_context
*cmd_ctx
, struct command
*parent
,
306 const struct command_registration
*cmds
)
309 for (i
= 0; cmds
[i
].name
; i
++)
311 struct command
*c
= register_command(cmd_ctx
, parent
, cmds
+ i
);
315 for (unsigned j
= 0; j
< i
; j
++)
316 unregister_command(cmd_ctx
, parent
, cmds
[j
].name
);
322 int unregister_all_commands(struct command_context
*context
,
323 struct command
*parent
)
328 struct command
**head
= command_list_for_parent(context
, parent
);
329 while (NULL
!= *head
)
331 struct command
*tmp
= *head
;
339 int unregister_command(struct command_context
*context
,
340 struct command
*parent
, const char *name
)
342 if ((!context
) || (!name
))
343 return ERROR_INVALID_ARGUMENTS
;
345 struct command
*p
= NULL
;
346 struct command
**head
= command_list_for_parent(context
, parent
);
347 for (struct command
*c
= *head
; NULL
!= c
; p
= c
, c
= c
->next
)
349 if (strcmp(name
, c
->name
) != 0)
364 void command_output_text(struct command_context
*context
, const char *data
)
366 if (context
&& context
->output_handler
&& data
) {
367 context
->output_handler(context
, data
);
371 void command_print_sameline(struct command_context
*context
, const char *format
, ...)
376 va_start(ap
, format
);
378 string
= alloc_vprintf(format
, ap
);
381 /* we want this collected in the log + we also want to pick it up as a tcl return
384 * The latter bit isn't precisely neat, but will do for now.
386 LOG_USER_N("%s", string
);
387 /* We already printed it above */
388 /* command_output_text(context, string); */
395 void command_print(struct command_context
*context
, const char *format
, ...)
400 va_start(ap
, format
);
402 string
= alloc_vprintf(format
, ap
);
405 strcat(string
, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
406 /* we want this collected in the log + we also want to pick it up as a tcl return
409 * The latter bit isn't precisely neat, but will do for now.
411 LOG_USER_N("%s", string
);
412 /* We already printed it above */
413 /* command_output_text(context, string); */
420 static char *__command_name(struct command
*c
, char delim
, unsigned extra
)
423 unsigned len
= strlen(c
->name
);
424 if (NULL
== c
->parent
) {
425 // allocate enough for the name, child names, and '\0'
426 name
= malloc(len
+ extra
+ 1);
427 strcpy(name
, c
->name
);
429 // parent's extra must include both the space and name
430 name
= __command_name(c
->parent
, delim
, 1 + len
+ extra
);
431 char dstr
[2] = { delim
, 0 };
433 strcat(name
, c
->name
);
437 char *command_name(struct command
*c
, char delim
)
439 return __command_name(c
, delim
, 0);
442 static int run_command(struct command_context
*context
,
443 struct command
*c
, const char *words
[], unsigned num_words
)
445 if (!((context
->mode
== COMMAND_CONFIG
) || (c
->mode
== COMMAND_ANY
) || (c
->mode
== context
->mode
)))
447 /* Config commands can not run after the config stage */
448 LOG_ERROR("Command '%s' only runs during configuration stage", c
->name
);
452 struct command_invocation cmd
= {
455 .argc
= num_words
- 1,
458 int retval
= c
->handler(&cmd
);
459 if (retval
== ERROR_COMMAND_SYNTAX_ERROR
)
461 /* Print help for command */
462 char *full_name
= command_name(c
, ' ');
463 if (NULL
!= full_name
) {
464 command_run_linef(context
, "help %s", full_name
);
469 else if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
471 /* just fall through for a shutdown request */
473 else if (retval
!= ERROR_OK
)
475 /* we do not print out an error message because the command *should*
476 * have printed out an error
478 LOG_DEBUG("Command failed with error code %d", retval
);
484 int command_run_line(struct command_context
*context
, char *line
)
486 /* all the parent commands have been registered with the interpreter
487 * so, can just evaluate the line as a script and check for
490 /* run the line thru a script engine */
491 int retval
= ERROR_FAIL
;
493 /* Beware! This code needs to be reentrant. It is also possible
494 * for OpenOCD commands to be invoked directly from Tcl. This would
495 * happen when the Jim Tcl interpreter is provided by eCos for
498 Jim_DeleteAssocData(interp
, "context");
499 retcode
= Jim_SetAssocData(interp
, "context", NULL
, context
);
500 if (retcode
== JIM_OK
)
502 /* associated the return value */
503 Jim_DeleteAssocData(interp
, "retval");
504 retcode
= Jim_SetAssocData(interp
, "retval", NULL
, &retval
);
505 if (retcode
== JIM_OK
)
507 retcode
= Jim_Eval_Named(interp
, line
, __THIS__FILE__
, __LINE__
);
509 Jim_DeleteAssocData(interp
, "retval");
511 Jim_DeleteAssocData(interp
, "context");
513 if (retcode
== JIM_ERR
) {
514 if (retval
!= ERROR_COMMAND_CLOSE_CONNECTION
)
516 /* We do not print the connection closed error message */
517 Jim_PrintErrorMessage(interp
);
519 if (retval
== ERROR_OK
)
521 /* It wasn't a low level OpenOCD command that failed */
525 } else if (retcode
== JIM_EXIT
) {
527 /* exit(Jim_GetExitCode(interp)); */
532 result
= Jim_GetString(Jim_GetResult(interp
), &reslen
);
537 for (i
= 0; i
< reslen
; i
+= 256)
543 strncpy(buff
, result
+ i
, chunk
);
545 LOG_USER_N("%s", buff
);
547 LOG_USER_N("%s", "\n");
554 int command_run_linef(struct command_context
*context
, const char *format
, ...)
556 int retval
= ERROR_FAIL
;
559 va_start(ap
, format
);
560 string
= alloc_vprintf(format
, ap
);
563 retval
= command_run_line(context
, string
);
569 void command_set_output_handler(struct command_context
* context
,
570 command_output_handler_t output_handler
, void *priv
)
572 context
->output_handler
= output_handler
;
573 context
->output_handler_priv
= priv
;
576 struct command_context
* copy_command_context(struct command_context
* context
)
578 struct command_context
* copy_context
= malloc(sizeof(struct command_context
));
580 *copy_context
= *context
;
585 int command_done(struct command_context
*context
)
593 /* find full path to file */
594 static int jim_find(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
598 const char *file
= Jim_GetString(argv
[1], NULL
);
599 char *full_path
= find_file(file
);
600 if (full_path
== NULL
)
602 Jim_Obj
*result
= Jim_NewStringObj(interp
, full_path
, strlen(full_path
));
605 Jim_SetResult(interp
, result
);
609 static int jim_echo(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
613 const char *str
= Jim_GetString(argv
[1], NULL
);
618 static size_t openocd_jim_fwrite(const void *_ptr
, size_t size
, size_t n
, void *cookie
)
624 /* make it a char easier to read code */
628 if (ptr
== NULL
|| interp
== NULL
|| nbytes
== 0) {
632 /* do we have to chunk it? */
633 if (ptr
[nbytes
] == 0)
635 /* no it is a C style string */
636 LOG_USER_N("%s", ptr
);
639 /* GRR we must chunk - not null terminated */
649 memcpy(chunk
, ptr
, x
);
653 LOG_USER_N("%s", chunk
);
661 static size_t openocd_jim_fread(void *ptr
, size_t size
, size_t n
, void *cookie
)
663 /* TCL wants to read... tell him no */
667 static int openocd_jim_vfprintf(void *cookie
, const char *fmt
, va_list ap
)
678 cp
= alloc_vprintf(fmt
, ap
);
681 LOG_USER_N("%s", cp
);
688 static int openocd_jim_fflush(void *cookie
)
690 /* nothing to flush */
694 static char* openocd_jim_fgets(char *s
, int size
, void *cookie
)
701 static int jim_capture(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
706 const char *str
= Jim_GetString(argv
[1], NULL
);
708 /* capture log output and return it */
709 Jim_Obj
*tclOutput
= Jim_NewStringObj(interp
, "", 0);
710 /* a garbage collect can happen, so we need a reference count to this object */
711 Jim_IncrRefCount(tclOutput
);
713 log_add_callback(tcl_output
, tclOutput
);
715 retcode
= Jim_Eval_Named(interp
, str
, __THIS__FILE__
, __LINE__
);
717 log_remove_callback(tcl_output
, tclOutput
);
719 /* We dump output into this local variable */
720 Jim_SetResult(interp
, tclOutput
);
721 Jim_DecrRefCount(interp
, tclOutput
);
726 static COMMAND_HELPER(command_help_find
, struct command
*head
,
727 struct command
**out
)
730 return ERROR_INVALID_ARGUMENTS
;
731 *out
= command_find(head
, CMD_ARGV
[0]);
733 return ERROR_INVALID_ARGUMENTS
;
737 return CALL_COMMAND_HANDLER(command_help_find
, (*out
)->children
, out
);
740 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
);
742 static COMMAND_HELPER(command_help_show_list
, struct command
*head
, unsigned n
)
744 for (struct command
*c
= head
; NULL
!= c
; c
= c
->next
)
745 CALL_COMMAND_HANDLER(command_help_show
, c
, n
);
748 static COMMAND_HELPER(command_help_show
, struct command
*c
, unsigned n
)
750 command_run_linef(CMD_CTX
, "cmd_help {%s} {%s} %d", command_name(c
, ' '),
751 c
->help
? : "no help available", n
);
756 return CALL_COMMAND_HANDLER(command_help_show_list
, c
->children
, n
);
758 COMMAND_HANDLER(handle_help_command
)
760 struct command
*c
= CMD_CTX
->commands
;
763 return CALL_COMMAND_HANDLER(command_help_show_list
, c
, 0);
765 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
766 if (ERROR_OK
!= retval
)
769 return CALL_COMMAND_HANDLER(command_help_show
, c
, 0);
773 int help_add_command(struct command_context
*cmd_ctx
, struct command
*parent
,
774 const char *cmd_name
, const char *help_text
)
776 struct command
**head
= command_list_for_parent(cmd_ctx
, parent
);
777 struct command
*nc
= command_find(*head
, cmd_name
);
780 // add a new command with help text
781 struct command_registration cr
= {
786 nc
= register_command(cmd_ctx
, parent
, &cr
);
789 LOG_ERROR("failed to add '%s' help text", cmd_name
);
792 LOG_DEBUG("added '%s' help text", cmd_name
);
796 bool replaced
= false;
799 free((void *)nc
->help
);
802 nc
->help
= strdup(help_text
);
805 LOG_INFO("replaced existing '%s' help", cmd_name
);
807 LOG_DEBUG("added '%s' help text", cmd_name
);
812 COMMAND_HANDLER(handle_help_add_command
)
816 LOG_ERROR("%s: insufficient arguments", CMD_NAME
);
817 return ERROR_INVALID_ARGUMENTS
;
820 // save help text and remove it from argument list
821 const char *help_text
= CMD_ARGV
[--CMD_ARGC
];
822 // likewise for the leaf command name
823 const char *cmd_name
= CMD_ARGV
[--CMD_ARGC
];
825 struct command
*c
= NULL
;
828 c
= CMD_CTX
->commands
;
829 int retval
= CALL_COMMAND_HANDLER(command_help_find
, c
, &c
);
830 if (ERROR_OK
!= retval
)
833 return help_add_command(CMD_CTX
, c
, cmd_name
, help_text
);
836 /* sleep command sleeps for <n> miliseconds
837 * this is useful in target startup scripts
839 COMMAND_HANDLER(handle_sleep_command
)
844 if (strcmp(CMD_ARGV
[1], "busy") == 0)
847 return ERROR_COMMAND_SYNTAX_ERROR
;
849 else if (CMD_ARGC
< 1 || CMD_ARGC
> 2)
850 return ERROR_COMMAND_SYNTAX_ERROR
;
852 unsigned long duration
= 0;
853 int retval
= parse_ulong(CMD_ARGV
[0], &duration
);
854 if (ERROR_OK
!= retval
)
859 long long then
= timeval_ms();
860 while (timeval_ms() - then
< (long long)duration
)
862 target_call_timer_callbacks_now();
867 busy_sleep(duration
);
872 struct command_context
* command_init(const char *startup_tcl
)
874 struct command_context
* context
= malloc(sizeof(struct command_context
));
877 context
->mode
= COMMAND_EXEC
;
878 context
->commands
= NULL
;
879 context
->current_target
= 0;
880 context
->output_handler
= NULL
;
881 context
->output_handler_priv
= NULL
;
885 /* Create an interpreter */
886 interp
= Jim_CreateInterp();
887 /* Add all the Jim core commands */
888 Jim_RegisterCoreCommands(interp
);
891 #if defined(_MSC_VER)
892 /* WinXX - is generic, the forward
893 * looking problem is this:
897 * "winxx" is generic.
900 #elif defined(__linux__)
902 #elif defined(__DARWIN__)
904 #elif defined(__CYGWIN__)
906 #elif defined(__MINGW32__)
908 #elif defined(__ECOS)
911 #warn unrecognized host OS...
914 Jim_SetGlobalVariableStr(interp
, "ocd_HOSTOS",
915 Jim_NewStringObj(interp
, HostOs
, strlen(HostOs
)));
917 Jim_CreateCommand(interp
, "ocd_find", jim_find
, NULL
, NULL
);
918 Jim_CreateCommand(interp
, "echo", jim_echo
, NULL
, NULL
);
919 Jim_CreateCommand(interp
, "capture", jim_capture
, NULL
, NULL
);
921 /* Set Jim's STDIO */
922 interp
->cookie_stdin
= interp
;
923 interp
->cookie_stdout
= interp
;
924 interp
->cookie_stderr
= interp
;
925 interp
->cb_fwrite
= openocd_jim_fwrite
;
926 interp
->cb_fread
= openocd_jim_fread
;
927 interp
->cb_vfprintf
= openocd_jim_vfprintf
;
928 interp
->cb_fflush
= openocd_jim_fflush
;
929 interp
->cb_fgets
= openocd_jim_fgets
;
931 COMMAND_REGISTER(context
, NULL
, "add_help_text",
932 handle_help_add_command
, COMMAND_ANY
,
933 "<command> [...] <help_text>] - "
934 "add new command help text");
937 Jim_EventLoopOnLoad(interp
);
939 Jim_SetAssocData(interp
, "context", NULL
, context
);
940 if (Jim_Eval_Named(interp
, startup_tcl
, "embedded:startup.tcl",1) == JIM_ERR
)
942 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD)");
943 Jim_PrintErrorMessage(interp
);
946 Jim_DeleteAssocData(interp
, "context");
948 COMMAND_REGISTER(context
, NULL
, "sleep",
949 handle_sleep_command
, COMMAND_ANY
,
950 "<n> [busy] - sleep for n milliseconds. "
951 "\"busy\" means busy wait");
953 COMMAND_REGISTER(context
, NULL
, "help",
954 &handle_help_command
, COMMAND_ANY
,
955 "[<command_name> ...] - show built-in command help");
960 int command_context_mode(struct command_context
*cmd_ctx
, enum command_mode mode
)
963 return ERROR_INVALID_ARGUMENTS
;
965 cmd_ctx
->mode
= mode
;
969 void process_jim_events(void)
972 static int recursion
= 0;
977 Jim_ProcessEvents (interp
, JIM_ALL_EVENTS
| JIM_DONT_WAIT
);
983 void register_jim(struct command_context
*cmd_ctx
, const char *name
,
984 Jim_CmdProc cmd
, const char *help
)
986 Jim_CreateCommand(interp
, name
, cmd
, NULL
, NULL
);
988 Jim_Obj
*cmd_list
= Jim_NewListObj(interp
, NULL
, 0);
989 Jim_ListAppendElement(interp
, cmd_list
,
990 Jim_NewStringObj(interp
, name
, -1));
992 help_add_command(cmd_ctx
, NULL
, name
, help
);
995 #define DEFINE_PARSE_NUM_TYPE(name, type, func, min, max) \
996 int parse##name(const char *str, type *ul) \
1000 LOG_ERROR("Invalid command argument"); \
1001 return ERROR_COMMAND_ARGUMENT_INVALID; \
1004 *ul = func(str, &end, 0); \
1007 LOG_ERROR("Invalid command argument"); \
1008 return ERROR_COMMAND_ARGUMENT_INVALID; \
1010 if ((max == *ul) && (ERANGE == errno)) \
1012 LOG_ERROR("Argument overflow"); \
1013 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1015 if (min && (min == *ul) && (ERANGE == errno)) \
1017 LOG_ERROR("Argument underflow"); \
1018 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1022 DEFINE_PARSE_NUM_TYPE(_ulong
, unsigned long , strtoul
, 0, ULONG_MAX
)
1023 DEFINE_PARSE_NUM_TYPE(_ullong
, unsigned long long, strtoull
, 0, ULLONG_MAX
)
1024 DEFINE_PARSE_NUM_TYPE(_long
, long , strtol
, LONG_MIN
, LONG_MAX
)
1025 DEFINE_PARSE_NUM_TYPE(_llong
, long long, strtoll
, LLONG_MIN
, LLONG_MAX
)
1027 #define DEFINE_PARSE_WRAPPER(name, type, min, max, functype, funcname) \
1028 int parse##name(const char *str, type *ul) \
1031 int retval = parse##funcname(str, &n); \
1032 if (ERROR_OK != retval) \
1035 return ERROR_COMMAND_ARGUMENT_OVERFLOW; \
1037 return ERROR_COMMAND_ARGUMENT_UNDERFLOW; \
1042 #define DEFINE_PARSE_ULONG(name, type, min, max) \
1043 DEFINE_PARSE_WRAPPER(name, type, min, max, unsigned long, _ulong)
1044 DEFINE_PARSE_ULONG(_uint
, unsigned, 0, UINT_MAX
)
1045 DEFINE_PARSE_ULONG(_u32
, uint32_t, 0, UINT32_MAX
)
1046 DEFINE_PARSE_ULONG(_u16
, uint16_t, 0, UINT16_MAX
)
1047 DEFINE_PARSE_ULONG(_u8
, uint8_t, 0, UINT8_MAX
)
1049 #define DEFINE_PARSE_LONG(name, type, min, max) \
1050 DEFINE_PARSE_WRAPPER(name, type, min, max, long, _long)
1051 DEFINE_PARSE_LONG(_int
, int, n
< INT_MIN
, INT_MAX
)
1052 DEFINE_PARSE_LONG(_s32
, int32_t, n
< INT32_MIN
, INT32_MAX
)
1053 DEFINE_PARSE_LONG(_s16
, int16_t, n
< INT16_MIN
, INT16_MAX
)
1054 DEFINE_PARSE_LONG(_s8
, int8_t, n
< INT8_MIN
, INT8_MAX
)
1056 static int command_parse_bool(const char *in
, bool *out
,
1057 const char *on
, const char *off
)
1059 if (strcasecmp(in
, on
) == 0)
1061 else if (strcasecmp(in
, off
) == 0)
1064 return ERROR_COMMAND_SYNTAX_ERROR
;
1068 int command_parse_bool_arg(const char *in
, bool *out
)
1070 if (command_parse_bool(in
, out
, "on", "off") == ERROR_OK
)
1072 if (command_parse_bool(in
, out
, "enable", "disable") == ERROR_OK
)
1074 if (command_parse_bool(in
, out
, "true", "false") == ERROR_OK
)
1076 if (command_parse_bool(in
, out
, "yes", "no") == ERROR_OK
)
1078 if (command_parse_bool(in
, out
, "1", "0") == ERROR_OK
)
1080 return ERROR_INVALID_ARGUMENTS
;
1083 COMMAND_HELPER(handle_command_parse_bool
, bool *out
, const char *label
)
1087 const char *in
= CMD_ARGV
[0];
1088 if (command_parse_bool_arg(in
, out
) != ERROR_OK
)
1090 LOG_ERROR("%s: argument '%s' is not valid", CMD_NAME
, in
);
1091 return ERROR_INVALID_ARGUMENTS
;
1096 LOG_INFO("%s is %s", label
, *out
? "enabled" : "disabled");
1099 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)