1 /* Jim - A small embeddable Tcl interpreter
3 * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
4 * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
5 * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net>
6 * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
7 * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
8 * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
9 * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
25 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
26 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
27 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28 * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
29 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
35 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 * The views and conclusions contained in the software and documentation
38 * are those of the authors and should not be interpreted as representing
39 * official policies, either expressed or implied, of the Jim Tcl Project.
43 * - to really use flags in Jim_ProcessEvents()
44 * - more complete [after] command with [after info] and other subcommands.
52 #define __JIM_EVENTLOOP_CORE__
54 #include <pkgconf/jimtcl.h>
57 #include <cyg/jimtcl/jim.h>
58 #include <cyg/jimtcl/jim-eventloop.h>
61 #include "jim-eventloop.h"
64 #include "replacements.h"
69 /* File event structure */
70 typedef struct Jim_FileEvent
{
72 int mask
; /* one of JIM_EVENT_(READABLE|WRITABLE|EXCEPTION) */
73 Jim_FileProc
*fileProc
;
74 Jim_EventFinalizerProc
*finalizerProc
;
76 struct Jim_FileEvent
*next
;
79 /* Time event structure */
80 typedef struct Jim_TimeEvent
{
81 jim_wide id
; /* time event identifier. */
82 int mode
; /* restart, repetitive .. UK */
83 long initialms
; /* initial relativ timer value UK */
84 long when_sec
; /* seconds */
85 long when_ms
; /* milliseconds */
86 Jim_TimeProc
*timeProc
;
87 Jim_EventFinalizerProc
*finalizerProc
;
89 struct Jim_TimeEvent
*next
;
92 /* Per-interp stucture containing the state of the event loop */
93 typedef struct Jim_EventLoop
{
94 jim_wide timeEventNextId
;
95 Jim_FileEvent
*fileEventHead
;
96 Jim_TimeEvent
*timeEventHead
;
99 void Jim_CreateFileHandler(Jim_Interp
*interp
, void *handle
, int mask
,
100 Jim_FileProc
*proc
, void *clientData
,
101 Jim_EventFinalizerProc
*finalizerProc
)
104 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
106 // fprintf(stderr,"rein\n");
107 fe
= Jim_Alloc(sizeof(*fe
));
111 fe
->finalizerProc
= finalizerProc
;
112 fe
->clientData
= clientData
;
113 fe
->next
= eventLoop
->fileEventHead
;
114 eventLoop
->fileEventHead
= fe
;
115 // fprintf(stderr,"raus\n");
118 void Jim_DeleteFileHandler(Jim_Interp
*interp
, void *handle
)
120 Jim_FileEvent
*fe
, *prev
= NULL
;
121 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
123 fe
= eventLoop
->fileEventHead
;
125 if (fe
->handle
== handle
) {
127 eventLoop
->fileEventHead
= fe
->next
;
129 prev
->next
= fe
->next
;
130 if (fe
->finalizerProc
)
131 fe
->finalizerProc(interp
, fe
->clientData
);
140 // The same for signals.
141 void Jim_CreateSignalHandler(Jim_Interp
*interp
, int signum
,
142 Jim_FileProc
*proc
, void *clientData
,
143 Jim_EventFinalizerProc
*finalizerProc
)
146 void Jim_DeleteSignalHandler(Jim_Interp
*interp
, int signum
)
150 /* That's another part of this extension that needs to be ported
152 static void JimGetTime(long *seconds
, long *milliseconds
)
156 gettimeofday(&tv
, NULL
);
157 *seconds
= tv
.tv_sec
;
158 *milliseconds
= tv
.tv_usec
/1000;
161 jim_wide
Jim_CreateTimeHandler(Jim_Interp
*interp
, jim_wide milliseconds
,
162 Jim_TimeProc
*proc
, void *clientData
,
163 Jim_EventFinalizerProc
*finalizerProc
)
165 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
166 jim_wide id
= eventLoop
->timeEventNextId
++;
168 long cur_sec
, cur_ms
;
170 JimGetTime(&cur_sec
, &cur_ms
);
172 te
= Jim_Alloc(sizeof(*te
));
175 te
->initialms
= milliseconds
;
176 te
->when_sec
= cur_sec
+ milliseconds
/1000;
177 te
->when_ms
= cur_ms
+ milliseconds
%1000;
178 if (te
->when_ms
>= 1000) {
183 te
->finalizerProc
= finalizerProc
;
184 te
->clientData
= clientData
;
185 te
->next
= eventLoop
->timeEventHead
;
186 eventLoop
->timeEventHead
= te
;
190 jim_wide
Jim_DeleteTimeHandler(Jim_Interp
*interp
, jim_wide id
)
192 Jim_TimeEvent
*te
, *prev
= NULL
;
193 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
194 long cur_sec
, cur_ms
;
197 JimGetTime(&cur_sec
, &cur_ms
);
199 te
= eventLoop
->timeEventHead
;
200 if (id
>= eventLoop
->timeEventNextId
)
201 return -2; /* wrong event ID */
204 remain
= (te
->when_sec
- cur_sec
) * 1000;
205 remain
+= (te
->when_ms
- cur_ms
) ;
206 remain
= (remain
< 0) ? 0 : remain
;
209 eventLoop
->timeEventHead
= te
->next
;
211 prev
->next
= te
->next
;
212 if (te
->finalizerProc
)
213 te
->finalizerProc(interp
, te
->clientData
);
220 return -1; /* NO event with the specified ID found */
223 /* Search the first timer to fire.
224 * This operation is useful to know how many time the select can be
225 * put in sleep without to delay any event.
226 * If there are no timers NULL is returned. */
227 static Jim_TimeEvent
*JimSearchNearestTimer(Jim_EventLoop
*eventLoop
)
229 Jim_TimeEvent
*te
= eventLoop
->timeEventHead
;
230 Jim_TimeEvent
*nearest
= NULL
;
233 if (!nearest
|| te
->when_sec
< nearest
->when_sec
||
234 (te
->when_sec
== nearest
->when_sec
&&
235 te
->when_ms
< nearest
->when_ms
))
242 /* --- POSIX version of Jim_ProcessEvents, for now the only available --- */
243 #define JIM_FILE_EVENTS 1
244 #define JIM_TIME_EVENTS 2
245 #define JIM_ALL_EVENTS (JIM_FILE_EVENTS|JIM_TIME_EVENTS)
246 #define JIM_DONT_WAIT 4
248 /* Process every pending time event, then every pending file event
249 * (that may be registered by time event callbacks just processed).
250 * Without special flags the function sleeps until some file event
251 * fires, or when the next time event occurrs (if any).
253 * If flags is 0, the function does nothing and returns.
254 * if flags has JIM_ALL_EVENTS set, all the kind of events are processed.
255 * if flags has JIM_FILE_EVENTS set, file events are processed.
256 * if flags has JIM_TIME_EVENTS set, time events are processed.
257 * if flags has JIM_DONT_WAIT set the function returns ASAP until all
258 * the events that's possible to process without to wait are processed.
260 * The function returns the number of events processed. */
261 int Jim_ProcessEvents(Jim_Interp
*interp
, int flags
)
263 int maxfd
= 0, numfd
= 0, processed
= 0;
264 fd_set rfds
, wfds
, efds
;
265 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
266 Jim_FileEvent
*fe
= eventLoop
->fileEventHead
;
275 /* Check file events */
277 int fd
= fileno((FILE*)fe
->handle
);
279 if (fe
->mask
& JIM_EVENT_READABLE
)
281 if (fe
->mask
& JIM_EVENT_WRITABLE
) FD_SET(fd
, &wfds
);
282 if (fe
->mask
& JIM_EVENT_EXCEPTION
) FD_SET(fd
, &efds
);
283 if (maxfd
< fd
) maxfd
= fd
;
287 /* Note that we want call select() even if there are no
288 * file events to process as long as we want to process time
289 * events, in order to sleep until the next time event is ready
291 if (numfd
|| ((flags
& JIM_TIME_EVENTS
) && !(flags
& JIM_DONT_WAIT
))) {
293 Jim_TimeEvent
*shortest
;
294 struct timeval tv
, *tvp
;
297 shortest
= JimSearchNearestTimer(eventLoop
);
299 long now_sec
, now_ms
;
301 /* Calculate the time missing for the nearest
303 JimGetTime(&now_sec
, &now_ms
);
305 dt
= 1000 * (shortest
->when_sec
- now_sec
);
306 dt
+= ( shortest
->when_ms
- now_ms
);
310 tvp
->tv_sec
= dt
/ 1000;
311 tvp
->tv_usec
= dt
% 1000;
312 // fprintf(stderr,"Next %d.% 8d\n",(int)tvp->tv_sec,(int)tvp->tv_usec);
314 tvp
= NULL
; /* wait forever */
315 // fprintf(stderr,"No Event\n");
318 retval
= select(maxfd
+1, &rfds
, &wfds
, &efds
, tvp
);
321 case EINTR
: fprintf(stderr
,"select EINTR\n"); break;
322 case EINVAL
: fprintf(stderr
,"select EINVAL\n"); break;
323 case ENOMEM
: fprintf(stderr
,"select ENOMEM\n"); break;
325 } else if (retval
> 0) {
326 fe
= eventLoop
->fileEventHead
;
328 int fd
= fileno((FILE*)fe
->handle
);
330 // fprintf(stderr,"fd: %d mask: %02x \n",fd,fe->mask);
332 if ((fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) ||
333 (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
)) ||
334 (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
)))
338 if (fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) {
339 mask
|= JIM_EVENT_READABLE
;
340 if ((fe
->mask
& JIM_EVENT_FEOF
) && feof((FILE *)fe
->handle
))
341 mask
|= JIM_EVENT_FEOF
;
343 if (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
))
344 mask
|= JIM_EVENT_WRITABLE
;
345 if (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
))
346 mask
|= JIM_EVENT_EXCEPTION
;
347 if (fe
->fileProc(interp
, fe
->clientData
, mask
) == JIM_ERR
) {
348 /* Remove the element on handler error */
349 Jim_DeleteFileHandler(interp
, fe
->handle
);
352 /* After an event is processed our file event list
353 * may no longer be the same, so what we do
354 * is to clear the bit for this file descriptor and
355 * restart again from the head. */
356 fe
= eventLoop
->fileEventHead
;
366 /* Check time events */
367 te
= eventLoop
->timeEventHead
;
368 maxId
= eventLoop
->timeEventNextId
-1;
370 long now_sec
, now_ms
;
373 if (te
->id
> maxId
) {
377 JimGetTime(&now_sec
, &now_ms
);
378 if (now_sec
> te
->when_sec
||
379 (now_sec
== te
->when_sec
&& now_ms
>= te
->when_ms
))
382 te
->timeProc(interp
, te
->clientData
);
383 /* After an event is processed our time event list may
384 * no longer be the same, so we restart from head.
385 * Still we make sure to don't process events registered
386 * by event handlers itself in order to don't loop forever
387 * even in case an [after 0] that continuously register
388 * itself. To do so we saved the max ID we want to handle. */
389 Jim_DeleteTimeHandler(interp
, id
);
390 te
= eventLoop
->timeEventHead
;
398 /* ---------------------------------------------------------------------- */
400 void JimELAssocDataDeleProc(Jim_Interp
*interp
, void *data
)
405 Jim_EventLoop
*eventLoop
= data
;
407 fe
= eventLoop
->fileEventHead
;
410 if (fe
->finalizerProc
)
411 fe
->finalizerProc(interp
, fe
->clientData
);
416 te
= eventLoop
->timeEventHead
;
419 if (te
->finalizerProc
)
420 te
->finalizerProc(interp
, te
->clientData
);
427 static int JimELVwaitCommand(Jim_Interp
*interp
, int argc
,
428 Jim_Obj
*const *argv
)
433 Jim_WrongNumArgs(interp
, 1, argv
, "name");
436 oldValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
437 if (oldValue
) Jim_IncrRefCount(oldValue
);
441 Jim_ProcessEvents(interp
, JIM_ALL_EVENTS
);
442 currValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
443 /* Stop the loop if the vwait-ed variable changed value,
444 * or if was unset and now is set (or the contrary). */
445 if ((oldValue
&& !currValue
) ||
446 (!oldValue
&& currValue
) ||
447 (oldValue
&& currValue
&&
448 !Jim_StringEqObj(oldValue
, currValue
, JIM_CASESENS
)))
451 if (oldValue
) Jim_DecrRefCount(interp
, oldValue
);
455 void JimAfterTimeHandler(Jim_Interp
*interp
, void *clientData
)
457 Jim_Obj
*objPtr
= clientData
;
459 Jim_EvalObjBackground(interp
, objPtr
);
462 void JimAfterTimeEventFinalizer(Jim_Interp
*interp
, void *clientData
)
464 Jim_Obj
*objPtr
= clientData
;
466 Jim_DecrRefCount(interp
, objPtr
);
469 static int JimELAfterCommand(Jim_Interp
*interp
, int argc
,
470 Jim_Obj
*const *argv
)
473 Jim_Obj
*objPtr
, *idObjPtr
;
474 const char *options
[] = {
475 "info", "cancel", "restart", "expire", NULL
477 enum {INFO
, CANCEL
, RESTART
, EXPIRE
, CREATE
};
478 int option
= CREATE
;
481 Jim_WrongNumArgs(interp
, 1, argv
, "<after milliseconds> script");
484 if (Jim_GetWide(interp
, argv
[1], &ms
) != JIM_OK
)
485 if (Jim_GetEnum(interp
, argv
[1], options
, &option
, "after options",
486 JIM_ERRMSG
) != JIM_OK
)
490 Jim_IncrRefCount(argv
[2]);
491 id
= Jim_CreateTimeHandler(interp
, ms
, JimAfterTimeHandler
, argv
[2],
492 JimAfterTimeEventFinalizer
);
493 objPtr
= Jim_NewStringObj(interp
, NULL
, 0);
494 Jim_AppendString(interp
, objPtr
, "after#", -1);
495 idObjPtr
= Jim_NewIntObj(interp
, id
);
496 Jim_IncrRefCount(idObjPtr
);
497 Jim_AppendObj(interp
, objPtr
, idObjPtr
);
498 Jim_DecrRefCount(interp
, idObjPtr
);
499 Jim_SetResult(interp
, objPtr
);
505 const char *tok
= Jim_GetString(argv
[2], &tlen
);
506 if ( sscanf(tok
,"after#%lld",&id
) == 1) {
507 remain
= Jim_DeleteTimeHandler(interp
, id
);
509 Jim_SetResult(interp
, Jim_NewIntObj(interp
, remain
));
513 Jim_SetResultString(interp
, "invalid event" , -1);
517 fprintf(stderr
,"unserviced option to after %d\n",option
);
522 /* This extension is not dynamically loaded, instead it's linked statically,
523 which is why we shouldn't use the unspecific 'Jim_OnLoad' name */
524 int Jim_EventLoopOnLoad(Jim_Interp
*interp
)
526 Jim_EventLoop
*eventLoop
;
528 Jim_InitExtension(interp
);
529 if (Jim_PackageProvide(interp
, "eventloop", "1.0", JIM_ERRMSG
) != JIM_OK
)
532 eventLoop
= Jim_Alloc(sizeof(*eventLoop
));
533 eventLoop
->fileEventHead
= NULL
;
534 eventLoop
->timeEventHead
= NULL
;
535 eventLoop
->timeEventNextId
= 1;
536 Jim_SetAssocData(interp
, "eventloop", JimELAssocDataDeleProc
, eventLoop
);
538 Jim_CreateCommand(interp
, "vwait", JimELVwaitCommand
, NULL
, NULL
);
539 Jim_CreateCommand(interp
, "after", JimELAfterCommand
, NULL
, NULL
);
541 /* Export events API */
542 Jim_RegisterApi(interp
, "Jim_CreateFileHandler", Jim_CreateFileHandler
);
543 Jim_RegisterApi(interp
, "Jim_DeleteFileHandler", Jim_DeleteFileHandler
);
544 Jim_RegisterApi(interp
, "Jim_CreateTimeHandler", Jim_CreateTimeHandler
);
545 Jim_RegisterApi(interp
, "Jim_DeleteTimeHandler", Jim_DeleteTimeHandler
);
546 Jim_RegisterApi(interp
, "Jim_ProcessEvents", Jim_ProcessEvents
);
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)