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>
56 #include <cyg/jimtcl/jim.h>
57 #include <cyg/jimtcl/jim-eventloop.h>
60 #include "jim-eventloop.h"
63 /* File event structure */
64 typedef struct Jim_FileEvent
{
66 int mask
; /* one of JIM_EVENT_(READABLE | WRITABLE | EXCEPTION) */
67 Jim_FileProc
*fileProc
;
68 Jim_EventFinalizerProc
*finalizerProc
;
70 struct Jim_FileEvent
*next
;
73 /* Time event structure */
74 typedef struct Jim_TimeEvent
{
75 jim_wide id
; /* time event identifier. */
76 int mode
; /* restart, repetitive .. UK */
77 long initialms
; /* initial relativ timer value UK */
78 long when_sec
; /* seconds */
79 long when_ms
; /* milliseconds */
80 Jim_TimeProc
*timeProc
;
81 Jim_EventFinalizerProc
*finalizerProc
;
83 struct Jim_TimeEvent
*next
;
86 /* Per-interp stucture containing the state of the event loop */
87 typedef struct Jim_EventLoop
{
88 jim_wide timeEventNextId
;
89 Jim_FileEvent
*fileEventHead
;
90 Jim_TimeEvent
*timeEventHead
;
93 static void Jim_CreateFileHandler(Jim_Interp
*interp
, void *handle
, int mask
,
94 Jim_FileProc
*proc
, void *clientData
,
95 Jim_EventFinalizerProc
*finalizerProc
)
98 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
100 // fprintf(stderr,"rein\n");
101 fe
= Jim_Alloc(sizeof(*fe
));
105 fe
->finalizerProc
= finalizerProc
;
106 fe
->clientData
= clientData
;
107 fe
->next
= eventLoop
->fileEventHead
;
108 eventLoop
->fileEventHead
= fe
;
109 // fprintf(stderr,"raus\n");
112 static void Jim_DeleteFileHandler(Jim_Interp
*interp
, void *handle
)
114 Jim_FileEvent
*fe
, *prev
= NULL
;
115 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
117 fe
= eventLoop
->fileEventHead
;
119 if (fe
->handle
== handle
) {
121 eventLoop
->fileEventHead
= fe
->next
;
123 prev
->next
= fe
->next
;
124 if (fe
->finalizerProc
)
125 fe
->finalizerProc(interp
, fe
->clientData
);
134 /* That's another part of this extension that needs to be ported
136 static void JimGetTime(long *seconds
, long *milliseconds
)
140 gettimeofday(&tv
, NULL
);
141 *seconds
= tv
.tv_sec
;
142 *milliseconds
= tv
.tv_usec
/1000;
145 static jim_wide
Jim_CreateTimeHandler(Jim_Interp
*interp
, jim_wide milliseconds
,
146 Jim_TimeProc
*proc
, void *clientData
,
147 Jim_EventFinalizerProc
*finalizerProc
)
149 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
150 jim_wide id
= eventLoop
->timeEventNextId
++;
152 long cur_sec
, cur_ms
;
154 JimGetTime(&cur_sec
, &cur_ms
);
156 te
= Jim_Alloc(sizeof(*te
));
159 te
->initialms
= milliseconds
;
160 te
->when_sec
= cur_sec
+ milliseconds
/1000;
161 te
->when_ms
= cur_ms
+ milliseconds
%1000;
162 if (te
->when_ms
>= 1000) {
167 te
->finalizerProc
= finalizerProc
;
168 te
->clientData
= clientData
;
169 te
->next
= eventLoop
->timeEventHead
;
170 eventLoop
->timeEventHead
= te
;
174 static jim_wide
Jim_DeleteTimeHandler(Jim_Interp
*interp
, jim_wide id
)
176 Jim_TimeEvent
*te
, *prev
= NULL
;
177 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
178 long cur_sec
, cur_ms
;
181 JimGetTime(&cur_sec
, &cur_ms
);
183 te
= eventLoop
->timeEventHead
;
184 if (id
>= eventLoop
->timeEventNextId
)
185 return -2; /* wrong event ID */
188 remain
= (te
->when_sec
- cur_sec
) * 1000;
189 remain
+= (te
->when_ms
- cur_ms
) ;
190 remain
= (remain
< 0) ? 0 : remain
;
193 eventLoop
->timeEventHead
= te
->next
;
195 prev
->next
= te
->next
;
196 if (te
->finalizerProc
)
197 te
->finalizerProc(interp
, te
->clientData
);
204 return -1; /* NO event with the specified ID found */
207 /* Search the first timer to fire.
208 * This operation is useful to know how many time the select can be
209 * put in sleep without to delay any event.
210 * If there are no timers NULL is returned. */
211 static Jim_TimeEvent
*JimSearchNearestTimer(Jim_EventLoop
*eventLoop
)
213 Jim_TimeEvent
*te
= eventLoop
->timeEventHead
;
214 Jim_TimeEvent
*nearest
= NULL
;
217 if (!nearest
|| te
->when_sec
< nearest
->when_sec
||
218 (te
->when_sec
== nearest
->when_sec
&&
219 te
->when_ms
< nearest
->when_ms
))
226 /* --- POSIX version of Jim_ProcessEvents, for now the only available --- */
227 #define JIM_FILE_EVENTS 1
228 #define JIM_TIME_EVENTS 2
229 #define JIM_ALL_EVENTS (JIM_FILE_EVENTS | JIM_TIME_EVENTS)
230 #define JIM_DONT_WAIT 4
232 /* Process every pending time event, then every pending file event
233 * (that may be registered by time event callbacks just processed).
234 * Without special flags the function sleeps until some file event
235 * fires, or when the next time event occurrs (if any).
237 * If flags is 0, the function does nothing and returns.
238 * if flags has JIM_ALL_EVENTS set, all the kind of events are processed.
239 * if flags has JIM_FILE_EVENTS set, file events are processed.
240 * if flags has JIM_TIME_EVENTS set, time events are processed.
241 * if flags has JIM_DONT_WAIT set the function returns ASAP until all
242 * the events that's possible to process without to wait are processed.
244 * The function returns the number of events processed. */
245 int Jim_ProcessEvents(Jim_Interp
*interp
, int flags
)
247 int maxfd
= 0, numfd
= 0, processed
= 0;
248 fd_set rfds
, wfds
, efds
;
249 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
250 Jim_FileEvent
*fe
= eventLoop
->fileEventHead
;
259 /* Check file events */
261 int fd
= fileno((FILE*)fe
->handle
);
263 if (fe
->mask
& JIM_EVENT_READABLE
)
265 if (fe
->mask
& JIM_EVENT_WRITABLE
) FD_SET(fd
, &wfds
);
266 if (fe
->mask
& JIM_EVENT_EXCEPTION
) FD_SET(fd
, &efds
);
267 if (maxfd
< fd
) maxfd
= fd
;
271 /* Note that we want call select() even if there are no
272 * file events to process as long as we want to process time
273 * events, in order to sleep until the next time event is ready
275 if (numfd
|| ((flags
& JIM_TIME_EVENTS
) && !(flags
& JIM_DONT_WAIT
))) {
277 Jim_TimeEvent
*shortest
;
278 struct timeval tv
, *tvp
;
281 shortest
= JimSearchNearestTimer(eventLoop
);
283 long now_sec
, now_ms
;
285 /* Calculate the time missing for the nearest
287 JimGetTime(&now_sec
, &now_ms
);
289 dt
= 1000 * (shortest
->when_sec
- now_sec
);
290 dt
+= (shortest
->when_ms
- now_ms
);
294 tvp
->tv_sec
= dt
/ 1000;
295 tvp
->tv_usec
= dt
% 1000;
296 // fprintf(stderr,"Next %d.% 8d\n",(int)tvp->tv_sec,(int)tvp->tv_usec);
298 tvp
= NULL
; /* wait forever */
299 // fprintf(stderr,"No Event\n");
302 retval
= select(maxfd
+ 1, &rfds
, &wfds
, &efds
, tvp
);
305 case EINTR
: fprintf(stderr
,"select EINTR\n"); break;
306 case EINVAL
: fprintf(stderr
,"select EINVAL\n"); break;
307 case ENOMEM
: fprintf(stderr
,"select ENOMEM\n"); break;
309 } else if (retval
> 0) {
310 fe
= eventLoop
->fileEventHead
;
312 int fd
= fileno((FILE*)fe
->handle
);
314 // fprintf(stderr,"fd: %d mask: %02x \n",fd,fe->mask);
316 if ((fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) ||
317 (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
)) ||
318 (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
)))
322 if (fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) {
323 mask
|= JIM_EVENT_READABLE
;
324 if ((fe
->mask
& JIM_EVENT_FEOF
) && feof((FILE *)fe
->handle
))
325 mask
|= JIM_EVENT_FEOF
;
327 if (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
))
328 mask
|= JIM_EVENT_WRITABLE
;
329 if (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
))
330 mask
|= JIM_EVENT_EXCEPTION
;
331 if (fe
->fileProc(interp
, fe
->clientData
, mask
) == JIM_ERR
) {
332 /* Remove the element on handler error */
333 Jim_DeleteFileHandler(interp
, fe
->handle
);
336 /* After an event is processed our file event list
337 * may no longer be the same, so what we do
338 * is to clear the bit for this file descriptor and
339 * restart again from the head. */
340 fe
= eventLoop
->fileEventHead
;
350 /* Check time events */
351 te
= eventLoop
->timeEventHead
;
352 maxId
= eventLoop
->timeEventNextId
-1;
354 long now_sec
, now_ms
;
357 if (te
->id
> maxId
) {
361 JimGetTime(&now_sec
, &now_ms
);
362 if (now_sec
> te
->when_sec
||
363 (now_sec
== te
->when_sec
&& now_ms
>= te
->when_ms
))
366 te
->timeProc(interp
, te
->clientData
);
367 /* After an event is processed our time event list may
368 * no longer be the same, so we restart from head.
369 * Still we make sure to don't process events registered
370 * by event handlers itself in order to don't loop forever
371 * even in case an [after 0] that continuously register
372 * itself. To do so we saved the max ID we want to handle. */
373 Jim_DeleteTimeHandler(interp
, id
);
374 te
= eventLoop
->timeEventHead
;
382 /* ---------------------------------------------------------------------- */
384 static void JimELAssocDataDeleProc(Jim_Interp
*interp
, void *data
)
389 Jim_EventLoop
*eventLoop
= data
;
391 fe
= eventLoop
->fileEventHead
;
394 if (fe
->finalizerProc
)
395 fe
->finalizerProc(interp
, fe
->clientData
);
400 te
= eventLoop
->timeEventHead
;
403 if (te
->finalizerProc
)
404 te
->finalizerProc(interp
, te
->clientData
);
411 static int JimELVwaitCommand(Jim_Interp
*interp
, int argc
,
412 Jim_Obj
*const *argv
)
417 Jim_WrongNumArgs(interp
, 1, argv
, "name");
420 oldValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
421 if (oldValue
) Jim_IncrRefCount(oldValue
);
425 Jim_ProcessEvents(interp
, JIM_ALL_EVENTS
);
426 currValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
427 /* Stop the loop if the vwait-ed variable changed value,
428 * or if was unset and now is set (or the contrary). */
429 if ((oldValue
&& !currValue
) ||
430 (!oldValue
&& currValue
) ||
431 (oldValue
&& currValue
&&
432 !Jim_StringEqObj(oldValue
, currValue
, JIM_CASESENS
)))
435 if (oldValue
) Jim_DecrRefCount(interp
, oldValue
);
439 static void JimAfterTimeHandler(Jim_Interp
*interp
, void *clientData
)
441 Jim_Obj
*objPtr
= clientData
;
443 Jim_EvalObjBackground(interp
, objPtr
);
446 static void JimAfterTimeEventFinalizer(Jim_Interp
*interp
, void *clientData
)
448 Jim_Obj
*objPtr
= clientData
;
450 Jim_DecrRefCount(interp
, objPtr
);
453 static int JimELAfterCommand(Jim_Interp
*interp
, int argc
,
454 Jim_Obj
*const *argv
)
457 Jim_Obj
*objPtr
, *idObjPtr
;
458 const char *options
[] = {
459 "info", "cancel", "restart", "expire", NULL
461 enum {INFO
, CANCEL
, RESTART
, EXPIRE
, CREATE
};
462 int option
= CREATE
;
465 Jim_WrongNumArgs(interp
, 1, argv
, "<after milliseconds> script");
468 if (Jim_GetWide(interp
, argv
[1], &ms
) != JIM_OK
)
469 if (Jim_GetEnum(interp
, argv
[1], options
, &option
, "after options",
470 JIM_ERRMSG
) != JIM_OK
)
474 Jim_IncrRefCount(argv
[2]);
475 id
= Jim_CreateTimeHandler(interp
, ms
, JimAfterTimeHandler
, argv
[2],
476 JimAfterTimeEventFinalizer
);
477 objPtr
= Jim_NewStringObj(interp
, NULL
, 0);
478 Jim_AppendString(interp
, objPtr
, "after#", -1);
479 idObjPtr
= Jim_NewIntObj(interp
, id
);
480 Jim_IncrRefCount(idObjPtr
);
481 Jim_AppendObj(interp
, objPtr
, idObjPtr
);
482 Jim_DecrRefCount(interp
, idObjPtr
);
483 Jim_SetResult(interp
, objPtr
);
489 const char *tok
= Jim_GetString(argv
[2], &tlen
);
490 if (sscanf(tok
,"after#%" JIM_WIDE_MODIFIER
, &id
) == 1) {
491 remain
= Jim_DeleteTimeHandler(interp
, id
);
493 Jim_SetResult(interp
, Jim_NewIntObj(interp
, remain
));
497 Jim_SetResultString(interp
, "invalid event" , -1);
501 fprintf(stderr
,"unserviced option to after %d\n",option
);
506 /* This extension is not dynamically loaded, instead it's linked statically,
507 which is why we shouldn't use the unspecific 'Jim_OnLoad' name */
508 int Jim_EventLoopOnLoad(Jim_Interp
*interp
)
510 Jim_EventLoop
*eventLoop
;
512 Jim_InitExtension(interp
);
513 if (Jim_PackageProvide(interp
, "eventloop", "1.0", JIM_ERRMSG
) != JIM_OK
)
516 eventLoop
= Jim_Alloc(sizeof(*eventLoop
));
517 eventLoop
->fileEventHead
= NULL
;
518 eventLoop
->timeEventHead
= NULL
;
519 eventLoop
->timeEventNextId
= 1;
520 Jim_SetAssocData(interp
, "eventloop", JimELAssocDataDeleProc
, eventLoop
);
522 Jim_CreateCommand(interp
, "vwait", JimELVwaitCommand
, NULL
, NULL
);
523 Jim_CreateCommand(interp
, "after", JimELAfterCommand
, NULL
, NULL
);
525 /* Export events API */
526 Jim_RegisterApi(interp
, "Jim_CreateFileHandler", Jim_CreateFileHandler
);
527 Jim_RegisterApi(interp
, "Jim_DeleteFileHandler", Jim_DeleteFileHandler
);
528 Jim_RegisterApi(interp
, "Jim_CreateTimeHandler", Jim_CreateTimeHandler
);
529 Jim_RegisterApi(interp
, "Jim_DeleteTimeHandler", Jim_DeleteTimeHandler
);
530 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)