]> git.sur5r.net Git - openocd/blob - src/helper/command.c
e1751d4fedda0381128a99f6a372e401111f9bfa
[openocd] / src / helper / command.c
1 /***************************************************************************
2  *   Copyright (C) 2005 by Dominic Rath                                    *
3  *   Dominic.Rath@gmx.de                                                   *
4  *                                                                         *
5  *   Copyright (C) 2007,2008 Ã˜yvind Harboe                                 *
6  *   oyvind.harboe@zylin.com                                               *
7  *                                                                         *
8  *   Copyright (C) 2008, Duane Ellis                                       *
9  *   openocd@duaneeellis.com                                               *
10  *                                                                         *
11  *   part of this file is taken from libcli (libcli.sourceforge.net)       *
12  *   Copyright (C) David Parrish (david@dparrish.com)                      *
13  *                                                                         *
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.                                   *
18  *                                                                         *
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.                          *
23  *                                                                         *
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  ***************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "replacements.h"
34 #include "target.h"
35 #include "command.h"
36 #include "configuration.h"
37
38 #include "log.h"
39 #include "time_support.h"
40 #include "jim-eventloop.h"
41
42 #include <stdlib.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <stdarg.h>
46 #include <stdio.h>
47 #include <unistd.h>
48 #include <errno.h>
49
50 int fast_and_dangerous = 0;
51 Jim_Interp *interp = NULL;
52
53 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55
56 int run_command(command_context_t *context, command_t *c, char *words[], int num_words);
57
58 static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string)
59 {
60         Jim_Obj *tclOutput=(Jim_Obj *)privData;
61
62         Jim_AppendString(interp, tclOutput, string, strlen(string));
63 }
64
65 extern command_context_t *global_cmd_ctx;
66
67 static int script_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
68 {
69         /* the private data is stashed in the interp structure */
70         command_t *c;
71         command_context_t *context;
72         int retval;
73         int i;
74         int nwords;
75         char **words;
76
77         /* DANGER!!!! be careful what we invoke here, since interp->cmdPrivData might
78          * get overwritten by running other Jim commands! Treat it as an
79          * emphemeral global variable that is used in lieu of an argument
80          * to the fn and fish it out manually.
81          */
82         c = interp->cmdPrivData;
83         if (c==NULL)
84         {
85                 LOG_ERROR("BUG: interp->cmdPrivData==NULL");
86                 return JIM_ERR;
87         }
88         target_call_timer_callbacks_now();
89         LOG_USER_N("%s", ""); /* Keep GDB connection alive*/
90
91         LOG_DEBUG("script_command - %s", c->name);
92
93         words = malloc(sizeof(char *) * argc);
94         for (i = 0; i < argc; i++)
95         {
96                 int len;
97                 const char *w=Jim_GetString(argv[i], &len);
98                 if (*w=='#')
99                 {
100                         /* hit an end of line comment */
101                         break;
102                 }
103                 words[i] = strdup(w);
104                 if (words[i] == NULL)
105                 {
106                         return JIM_ERR;
107                 }
108                 LOG_DEBUG("script_command - %s, argv[%u]=%s", c->name, i, words[i]);
109         }
110         nwords = i;
111
112         /* grab the command context from the associated data */
113         context = Jim_GetAssocData(interp, "context");
114         if (context == NULL)
115         {
116                 /* Tcl can invoke commands directly instead of via command_run_line(). This would
117                  * happen when the Jim Tcl interpreter is provided by eCos.
118                  */
119                 context = global_cmd_ctx;
120         }
121
122         /* capture log output and return it */
123         Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
124         /* a garbage collect can happen, so we need a reference count to this object */
125         Jim_IncrRefCount(tclOutput);
126
127         log_add_callback(tcl_output, tclOutput);
128
129         retval = run_command(context, c, words, nwords);
130
131         log_remove_callback(tcl_output, tclOutput);
132
133         /* We dump output into this local variable */
134         Jim_SetResult(interp, tclOutput);
135         Jim_DecrRefCount(interp, tclOutput);
136
137         for (i = 0; i < nwords; i++)
138                 free(words[i]);
139         free(words);
140
141         int *return_retval = Jim_GetAssocData(interp, "retval");
142         if (return_retval != NULL)
143         {
144                 *return_retval = retval;
145         }
146
147         return (retval==ERROR_OK)?JIM_OK:JIM_ERR;
148 }
149
150 /* nice short description of source file */
151 #define __THIS__FILE__ "command.c"
152
153 command_t* register_command(command_context_t *context, command_t *parent, char *name, int (*handler)(struct command_context_s *context, char* name, char** args, int argc), enum command_mode mode, char *help)
154 {
155         command_t *c, *p;
156
157         if (!context || !name)
158                 return NULL;
159
160         c = malloc(sizeof(command_t));
161
162         c->name = strdup(name);
163         c->parent = parent;
164         c->children = NULL;
165         c->handler = handler;
166         c->mode = mode;
167         if (!help)
168                 help="";
169         c->next = NULL;
170
171         /* place command in tree */
172         if (parent)
173         {
174                 if (parent->children)
175                 {
176                         /* find last child */
177                         for (p = parent->children; p && p->next; p = p->next);
178                         if (p)
179                                 p->next = c;
180                 }
181                 else
182                 {
183                         parent->children = c;
184                 }
185         }
186         else
187         {
188                 if (context->commands)
189                 {
190                         /* find last command */
191                         for (p = context->commands; p && p->next; p = p->next);
192                         if (p)
193                                 p->next = c;
194                 }
195                 else
196                 {
197                         context->commands = c;
198                 }
199         }
200
201         /* just a placeholder, no handler */
202         if (c->handler==NULL)
203                 return c;
204
205         /* If this is a two level command, e.g. "flash banks", then the
206          * "unknown" proc in startup.tcl must redirect to  this command.
207          *
208          * "flash banks" is translated by "unknown" to "flash_banks"
209          * if such a proc exists
210          */
211         /* Print help for command */
212         const char *t1="";
213         const char *t2="";
214         const char *t3="";
215         /* maximum of two levels :-) */
216         if (c->parent!=NULL)
217         {
218                 t1=c->parent->name;
219                 t2="_";
220         }
221         t3=c->name;
222         const char *full_name=alloc_printf("ocd_%s%s%s", t1, t2, t3);
223         Jim_CreateCommand(interp, full_name, script_command, c, NULL);
224         free((void *)full_name);
225
226         /* we now need to add an overrideable proc */
227         const char *override_name=alloc_printf("proc %s%s%s {args} {if {[catch {eval \"ocd_%s%s%s $args\"}]==0} {return \"\"} else { return -code error }", t1, t2, t3, t1, t2, t3);
228         Jim_Eval_Named(interp, override_name, __THIS__FILE__, __LINE__ );
229         free((void *)override_name);
230
231         /* accumulate help text in Tcl helptext list.  */
232         Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
233         if (Jim_IsShared(helptext))
234                 helptext = Jim_DuplicateObj(interp, helptext);
235         Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
236
237         Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
238
239         /* maximum of two levels :-) */
240         if (c->parent!=NULL)
241         {
242                 Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, c->parent->name, -1));
243         }
244         Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, c->name, -1));
245
246         Jim_ListAppendElement(interp, cmd_entry, cmd_list);
247         Jim_ListAppendElement(interp, cmd_entry, Jim_NewStringObj(interp, help, -1));
248         Jim_ListAppendElement(interp, helptext, cmd_entry);
249         return c;
250 }
251
252 int unregister_all_commands(command_context_t *context)
253 {
254         command_t *c, *c2;
255
256         if (context == NULL)
257                 return ERROR_OK;
258
259         while(NULL != context->commands)
260         {
261                 c = context->commands;
262
263                 while(NULL != c->children)
264                 {
265                         c2 = c->children;
266                         c->children = c->children->next;
267                         free(c2->name);
268                         c2->name = NULL;
269                         free(c2);
270                         c2 = NULL;
271                 }
272
273                 context->commands = context->commands->next;
274
275                 free(c->name);
276                 c->name = NULL;
277                 free(c);
278                 c = NULL;
279         }
280
281         return ERROR_OK;
282 }
283
284 int unregister_command(command_context_t *context, char *name)
285 {
286         command_t *c, *p = NULL, *c2;
287
288         if ((!context) || (!name))
289                 return ERROR_INVALID_ARGUMENTS;
290
291         /* find command */
292         c = context->commands;
293
294         while(NULL != c)
295         {
296                 if (strcmp(name, c->name) == 0)
297                 {
298                         /* unlink command */
299                         if (p)
300                         {
301                                 p->next = c->next;
302                         }
303                         else
304                         {
305                                 /* first element in command list */
306                                 context->commands = c->next;
307                         }
308
309                         /* unregister children */
310                         while(NULL != c->children)
311                         {
312                                 c2 = c->children;
313                                 c->children = c->children->next;
314                                 free(c2->name);
315                                 c2->name = NULL;
316                                 free(c2);
317                                 c2 = NULL;
318                         }
319
320                         /* delete command */
321                         free(c->name);
322                         c->name = NULL;
323                         free(c);
324                         c = NULL;
325                         return ERROR_OK;
326                 }
327
328                 /* remember the last command for unlinking */
329                 p = c;
330                 c = c->next;
331         }
332
333         return ERROR_OK;
334 }
335
336 void command_output_text(command_context_t *context, const char *data)
337 {
338         if( context && context->output_handler && data  ){
339                 context->output_handler( context, data );
340         }
341 }
342
343 void command_print_n(command_context_t *context, char *format, ...)
344 {
345         char *string;
346
347         va_list ap;
348         va_start(ap, format);
349
350         string = alloc_vprintf(format, ap);
351         if (string != NULL)
352         {
353                 /* we want this collected in the log + we also want to pick it up as a tcl return
354                  * value.
355                  *
356                  * The latter bit isn't precisely neat, but will do for now.
357                  */
358                 LOG_USER_N("%s", string);
359                 /* We already printed it above */
360                 /* command_output_text(context, string); */
361                 free(string);
362         }
363
364         va_end(ap);
365 }
366
367 void command_print(command_context_t *context, char *format, ...)
368 {
369         char *string;
370
371         va_list ap;
372         va_start(ap, format);
373
374         string = alloc_vprintf(format, ap);
375         if (string != NULL)
376         {
377                 strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one char longer */
378                 /* we want this collected in the log + we also want to pick it up as a tcl return
379                  * value.
380                  *
381                  * The latter bit isn't precisely neat, but will do for now.
382                  */
383                 LOG_USER_N("%s", string);
384                 /* We already printed it above */
385                 /* command_output_text(context, string); */
386                 free(string);
387         }
388
389         va_end(ap);
390 }
391
392 int run_command(command_context_t *context, command_t *c, char *words[], int num_words)
393 {
394         int start_word=0;
395         if (!((context->mode == COMMAND_CONFIG) || (c->mode == COMMAND_ANY) || (c->mode == context->mode) ))
396         {
397                 /* Config commands can not run after the config stage */
398                 LOG_ERROR("Illegal mode for command");
399                 return ERROR_FAIL;
400         }
401
402         int retval = c->handler(context, c->name, words + start_word + 1, num_words - start_word - 1);
403         if (retval == ERROR_COMMAND_SYNTAX_ERROR)
404         {
405                 /* Print help for command */
406                 const char *t1="";
407                 const char *t2="";
408                 const char *t3="";
409                 /* maximum of two levels :-) */
410                 if (c->parent!=NULL)
411                 {
412                         t1=c->parent->name;
413                         t2=" ";
414                 }
415                 t3=c->name;
416                 command_run_linef(context, "help {%s%s%s}", t1, t2, t3);
417         }
418         else if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
419         {
420                 /* just fall through for a shutdown request */
421         }
422         else if (retval != ERROR_OK)
423         {
424                 /* we do not print out an error message because the command *should*
425                  * have printed out an error
426                  */
427                 LOG_DEBUG("Command failed with error code %d", retval);
428         }
429
430         return retval;
431 }
432
433 int command_run_line(command_context_t *context, char *line)
434 {
435         /* all the parent commands have been registered with the interpreter
436          * so, can just evaluate the line as a script and check for
437          * results
438          */
439         /* run the line thru a script engine */
440         int retval=ERROR_FAIL;
441         int retcode;
442         /* Beware! This code needs to be reentrant. It is also possible
443          * for OpenOCD commands to be invoked directly from Tcl. This would
444          * happen when the Jim Tcl interpreter is provided by eCos for
445          * instance.
446          */
447         Jim_DeleteAssocData(interp, "context");
448         retcode = Jim_SetAssocData(interp, "context", NULL, context);
449         if (retcode == JIM_OK)
450         {
451                 /* associated the return value */
452                 Jim_DeleteAssocData(interp, "retval");
453                 retcode = Jim_SetAssocData(interp, "retval", NULL, &retval);
454                 if (retcode == JIM_OK)
455                 {
456                         retcode = Jim_Eval_Named(interp, line, __THIS__FILE__, __LINE__ );
457
458                         Jim_DeleteAssocData(interp, "retval");
459                 }
460                 Jim_DeleteAssocData(interp, "context");
461         }
462         if (retcode == JIM_ERR) {
463                 if (retval!=ERROR_COMMAND_CLOSE_CONNECTION)
464                 {
465                         /* We do not print the connection closed error message */
466                         Jim_PrintErrorMessage(interp);
467                 }
468                 if (retval==ERROR_OK)
469                 {
470                         /* It wasn't a low level OpenOCD command that failed */
471                         return ERROR_FAIL;
472                 }
473                 return retval;
474         } else if (retcode == JIM_EXIT) {
475                 /* ignore. */
476                 /* exit(Jim_GetExitCode(interp)); */
477         } else {
478                 const char *result;
479                 int reslen;
480
481                 result = Jim_GetString(Jim_GetResult(interp), &reslen);
482                 int i;
483                 char buff[256+1];
484                 for (i = 0; i < reslen; i += 256)
485                 {
486                         int chunk;
487                         chunk = reslen - i;
488                         if (chunk > 256)
489                                 chunk = 256;
490                         strncpy(buff, result+i, chunk);
491                         buff[chunk] = 0;
492                         LOG_USER_N("%s", buff);
493                 }
494                 LOG_USER_N("%s", "\n");
495                 retval=ERROR_OK;
496         }
497         return retval;
498 }
499
500 int command_run_linef(command_context_t *context, char *format, ...)
501 {
502         int retval=ERROR_FAIL;
503         char *string;
504         va_list ap;
505         va_start(ap, format);
506         string = alloc_vprintf(format, ap);
507         if (string!=NULL)
508         {
509                 retval=command_run_line(context, string);
510         }
511         va_end(ap);
512         return retval;
513 }
514
515 void command_set_output_handler(command_context_t* context, int (*output_handler)(struct command_context_s *context, const char* line), void *priv)
516 {
517         context->output_handler = output_handler;
518         context->output_handler_priv = priv;
519 }
520
521 command_context_t* copy_command_context(command_context_t* context)
522 {
523         command_context_t* copy_context = malloc(sizeof(command_context_t));
524
525         *copy_context = *context;
526
527         return copy_context;
528 }
529
530 int command_done(command_context_t *context)
531 {
532         free(context);
533         context = NULL;
534
535         return ERROR_OK;
536 }
537
538 /* find full path to file */
539 static int jim_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
540 {
541         if (argc != 2)
542                 return JIM_ERR;
543         const char *file = Jim_GetString(argv[1], NULL);
544         char *full_path = find_file(file);
545         if (full_path == NULL)
546                 return JIM_ERR;
547         Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path));
548         free(full_path);
549
550         Jim_SetResult(interp, result);
551         return JIM_OK;
552 }
553
554 static int jim_echo(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
555 {
556         if (argc != 2)
557                 return JIM_ERR;
558         const char *str = Jim_GetString(argv[1], NULL);
559         LOG_USER("%s", str);
560         return JIM_OK;
561 }
562
563 static size_t openocd_jim_fwrite(const void *_ptr, size_t size, size_t n, void *cookie)
564 {
565         size_t nbytes;
566         const char *ptr;
567         Jim_Interp *interp;
568
569         /* make it a char easier to read code */
570         ptr = _ptr;
571         interp = cookie;
572         nbytes = size * n;
573         if (ptr == NULL || interp == NULL || nbytes == 0) {
574                 return 0;
575         }
576
577         /* do we have to chunk it? */
578         if (ptr[nbytes] == 0)
579         {
580                 /* no it is a C style string */
581                 LOG_USER_N("%s", ptr);
582                 return strlen(ptr);
583         }
584         /* GRR we must chunk - not null terminated */
585         while (nbytes) {
586                 char chunk[128+1];
587                 int x;
588
589                 x = nbytes;
590                 if (x > 128) {
591                         x = 128;
592                 }
593                 /* copy it */
594                 memcpy(chunk, ptr, x);
595                 /* terminate it */
596                 chunk[n] = 0;
597                 /* output it */
598                 LOG_USER_N("%s", chunk);
599                 ptr += x;
600                 nbytes -= x;
601         }
602
603         return n;
604 }
605
606 static size_t openocd_jim_fread(void *ptr, size_t size, size_t n, void *cookie)
607 {
608         /* TCL wants to read... tell him no */
609         return 0;
610 }
611
612 static int openocd_jim_vfprintf(void *cookie, const char *fmt, va_list ap)
613 {
614         char *cp;
615         int n;
616         Jim_Interp *interp;
617
618         n = -1;
619         interp = cookie;
620         if (interp == NULL)
621                 return n;
622
623         cp = alloc_vprintf(fmt, ap);
624         if (cp)
625         {
626                 LOG_USER_N("%s", cp);
627                 n = strlen(cp);
628                 free(cp);
629         }
630         return n;
631 }
632
633 static int openocd_jim_fflush(void *cookie)
634 {
635         /* nothing to flush */
636         return 0;
637 }
638
639 static char* openocd_jim_fgets(char *s, int size, void *cookie)
640 {
641         /* not supported */
642         errno = ENOTSUP;
643         return NULL;
644 }
645
646 static int jim_capture(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
647 {
648         if (argc != 2)
649                 return JIM_ERR;
650         int retcode;
651         const char *str = Jim_GetString(argv[1], NULL);
652
653         /* capture log output and return it */
654         Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
655         /* a garbage collect can happen, so we need a reference count to this object */
656         Jim_IncrRefCount(tclOutput);
657
658         log_add_callback(tcl_output, tclOutput);
659
660         retcode = Jim_Eval_Named(interp, str, __THIS__FILE__, __LINE__ );
661
662         log_remove_callback(tcl_output, tclOutput);
663
664         /* We dump output into this local variable */
665         Jim_SetResult(interp, tclOutput);
666         Jim_DecrRefCount(interp, tclOutput);
667
668         return retcode;
669 }
670
671 command_context_t* command_init()
672 {
673         command_context_t* context = malloc(sizeof(command_context_t));
674         extern const char startup_tcl[];
675         const char *HostOs;
676
677         context->mode = COMMAND_EXEC;
678         context->commands = NULL;
679         context->current_target = 0;
680         context->output_handler = NULL;
681         context->output_handler_priv = NULL;
682
683 #ifdef JIM_EMBEDDED
684         Jim_InitEmbedded();
685         /* Create an interpreter */
686         interp = Jim_CreateInterp();
687         /* Add all the Jim core commands */
688         Jim_RegisterCoreCommands(interp);
689 #endif
690
691 #if defined( _MSC_VER )
692         /* WinXX - is generic, the forward
693          * looking problem is this:
694          * 
695          *   "win32" or "win64"
696          *
697          * "winxx" is generic.
698          */
699         HostOs = "winxx";
700 #elif defined( __LINUX__)
701         HostOs = "linux";
702 #elif defined( __DARWIN__ )
703         HostOs = "darwin";
704 #elif defined( __CYGWIN__ )
705         HostOs = "cygwin";
706 #elif defined( __MINGW32__ )
707         HostOs = "mingw32";
708 #else
709         HostOs = "other";
710 #endif
711         Jim_SetGlobalVariableStr( interp, "ocd_HOSTOS", Jim_NewStringObj( interp, HostOs , strlen(HostOs)) );
712
713         Jim_CreateCommand(interp, "ocd_find", jim_find, NULL, NULL);
714         Jim_CreateCommand(interp, "echo", jim_echo, NULL, NULL);
715         Jim_CreateCommand(interp, "capture", jim_capture, NULL, NULL);
716
717         /* Set Jim's STDIO */
718         interp->cookie_stdin = interp;
719         interp->cookie_stdout = interp;
720         interp->cookie_stderr = interp;
721         interp->cb_fwrite = openocd_jim_fwrite;
722         interp->cb_fread = openocd_jim_fread ;
723         interp->cb_vfprintf = openocd_jim_vfprintf;
724         interp->cb_fflush = openocd_jim_fflush;
725         interp->cb_fgets = openocd_jim_fgets;
726
727         add_default_dirs();
728
729 #ifdef JIM_EMBEDDED
730         Jim_EventLoopOnLoad(interp);
731 #endif
732         if (Jim_Eval_Named(interp, startup_tcl, "embedded:startup.tcl",1)==JIM_ERR)
733         {
734                 LOG_ERROR("Failed to run startup.tcl (embedded into OpenOCD compile time)");
735                 Jim_PrintErrorMessage(interp);
736                 exit(-1);
737         }
738
739         register_command(context, NULL, "sleep", handle_sleep_command,
740                                          COMMAND_ANY, "<n> [busy] - sleep for n milliseconds. \"busy\" means busy wait");
741
742         register_command(context, NULL, "fast", handle_fast_command,
743                                          COMMAND_ANY, "fast <enable/disable> - place at beginning of config files. Sets defaults to fast and dangerous.");
744
745         return context;
746 }
747
748 int command_context_mode(command_context_t *cmd_ctx, enum command_mode mode)
749 {
750         if (!cmd_ctx)
751                 return ERROR_INVALID_ARGUMENTS;
752
753         cmd_ctx->mode = mode;
754         return ERROR_OK;
755 }
756
757 /* sleep command sleeps for <n> miliseconds
758  * this is useful in target startup scripts
759  */
760 int handle_sleep_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
761 {
762         unsigned long duration = 0;
763         int busy = 0;
764
765         if (argc==1)
766         {
767
768         } else if (argc==2)
769         {
770                 if (strcmp(args[1], "busy")!=0)
771                         return ERROR_COMMAND_SYNTAX_ERROR;
772                 busy = 1;
773         } else
774         {
775                 return ERROR_COMMAND_SYNTAX_ERROR;
776         }
777
778         duration = strtoul(args[0], NULL, 0);
779
780         if (busy)
781         {
782                 busy_sleep(duration);
783         } else
784         {
785                 long long then=timeval_ms();
786                 while ((timeval_ms()-then)<(long long)duration)
787                 {
788                         target_call_timer_callbacks_now();
789                         usleep(1000);
790                 }
791         }
792
793         return ERROR_OK;
794 }
795
796 int handle_fast_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
797 {
798         if (argc!=1)
799                 return ERROR_COMMAND_SYNTAX_ERROR;
800
801         fast_and_dangerous = strcmp("enable", args[0])==0;
802
803         return ERROR_OK;
804 }
805
806 void process_jim_events(void)
807 {
808 #ifdef JIM_EMBEDDED
809         static int recursion = 0;
810
811         if (!recursion)
812         {
813                 recursion++;
814                 Jim_ProcessEvents (interp, JIM_ALL_EVENTS|JIM_DONT_WAIT);
815                 recursion--;
816         }
817 #endif
818 }
819
820 void register_jim(struct command_context_s *cmd_ctx, const char *name, int (*cmd)(Jim_Interp *interp, int argc, Jim_Obj *const *argv), const char *help)
821 {
822         Jim_CreateCommand(interp, name, cmd, NULL, NULL);
823
824         /* FIX!!! it would be prettier to invoke add_help_text...
825          * accumulate help text in Tcl helptext list.  */
826         Jim_Obj *helptext=Jim_GetGlobalVariableStr(interp, "ocd_helptext", JIM_ERRMSG);
827         if (Jim_IsShared(helptext))
828                 helptext = Jim_DuplicateObj(interp, helptext);
829
830         Jim_Obj *cmd_entry=Jim_NewListObj(interp, NULL, 0);
831
832         Jim_Obj *cmd_list=Jim_NewListObj(interp, NULL, 0);
833         Jim_ListAppendElement(interp, cmd_list, Jim_NewStringObj(interp, name, -1));
834
835         Jim_ListAppendElement(interp, cmd_entry, cmd_list);
836         Jim_ListAppendElement(interp, cmd_entry, Jim_NewStringObj(interp, help, -1));
837         Jim_ListAppendElement(interp, helptext, cmd_entry);
838 }
839
840 /* return global variable long value or 0 upon failure */
841 long jim_global_long(const char *variable)
842 {
843         Jim_Obj *objPtr=Jim_GetGlobalVariableStr(interp, variable, JIM_ERRMSG);
844         long t;
845         if (Jim_GetLong(interp, objPtr, &t)==JIM_OK)
846         {
847                 return t;
848         }
849         return 0;
850 }