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.
49 #define __JIM_EVENTLOOP_CORE__
51 #include <pkgconf/jimtcl.h>
54 #include <cyg/jimtcl/jim.h>
55 #include <cyg/jimtcl/jim-eventloop.h>
58 #include "jim-eventloop.h"
63 #include <sys/types.h>
65 #include <sys/select.h>
70 /* File event structure */
71 typedef struct Jim_FileEvent
{
73 int mask
; /* one of JIM_EVENT_(READABLE|WRITABLE|EXCEPTION) */
74 Jim_FileProc
*fileProc
;
75 Jim_EventFinalizerProc
*finalizerProc
;
77 struct Jim_FileEvent
*next
;
80 /* Time event structure */
81 typedef struct Jim_TimeEvent
{
82 jim_wide id
; /* time event identifier. */
83 int mode
; /* restart, repetitive .. UK */
84 long initialms
; /* initial relativ timer value UK */
85 long when_sec
; /* seconds */
86 long when_ms
; /* milliseconds */
87 Jim_TimeProc
*timeProc
;
88 Jim_EventFinalizerProc
*finalizerProc
;
90 struct Jim_TimeEvent
*next
;
93 /* Per-interp stucture containing the state of the event loop */
94 typedef struct Jim_EventLoop
{
95 jim_wide timeEventNextId
;
96 Jim_FileEvent
*fileEventHead
;
97 Jim_TimeEvent
*timeEventHead
;
100 void Jim_CreateFileHandler(Jim_Interp
*interp
, void *handle
, int mask
,
101 Jim_FileProc
*proc
, void *clientData
,
102 Jim_EventFinalizerProc
*finalizerProc
)
105 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
107 // fprintf(stderr,"rein\n");
108 fe
= Jim_Alloc(sizeof(*fe
));
112 fe
->finalizerProc
= finalizerProc
;
113 fe
->clientData
= clientData
;
114 fe
->next
= eventLoop
->fileEventHead
;
115 eventLoop
->fileEventHead
= fe
;
116 // fprintf(stderr,"raus\n");
119 void Jim_DeleteFileHandler(Jim_Interp
*interp
, void *handle
)
121 Jim_FileEvent
*fe
, *prev
= NULL
;
122 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
124 fe
= eventLoop
->fileEventHead
;
126 if (fe
->handle
== handle
) {
128 eventLoop
->fileEventHead
= fe
->next
;
130 prev
->next
= fe
->next
;
131 if (fe
->finalizerProc
)
132 fe
->finalizerProc(interp
, fe
->clientData
);
141 // The same for signals.
142 void Jim_CreateSignalHandler(Jim_Interp
*interp
, int signum
,
143 Jim_FileProc
*proc
, void *clientData
,
144 Jim_EventFinalizerProc
*finalizerProc
)
147 void Jim_DeleteSignalHandler(Jim_Interp
*interp
, int signum
)
151 /* That's another part of this extension that needs to be ported
153 static void JimGetTime(long *seconds
, long *milliseconds
)
157 gettimeofday(&tv
, NULL
);
158 *seconds
= tv
.tv_sec
;
159 *milliseconds
= tv
.tv_usec
/1000;
162 jim_wide
Jim_CreateTimeHandler(Jim_Interp
*interp
, jim_wide milliseconds
,
163 Jim_TimeProc
*proc
, void *clientData
,
164 Jim_EventFinalizerProc
*finalizerProc
)
166 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
167 jim_wide id
= eventLoop
->timeEventNextId
++;
169 long cur_sec
, cur_ms
;
171 JimGetTime(&cur_sec
, &cur_ms
);
173 te
= Jim_Alloc(sizeof(*te
));
176 te
->initialms
= milliseconds
;
177 te
->when_sec
= cur_sec
+ milliseconds
/1000;
178 te
->when_ms
= cur_ms
+ milliseconds
%1000;
179 if (te
->when_ms
>= 1000) {
184 te
->finalizerProc
= finalizerProc
;
185 te
->clientData
= clientData
;
186 te
->next
= eventLoop
->timeEventHead
;
187 eventLoop
->timeEventHead
= te
;
191 jim_wide
Jim_DeleteTimeHandler(Jim_Interp
*interp
, jim_wide id
)
193 Jim_TimeEvent
*te
, *prev
= NULL
;
194 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
195 long cur_sec
, cur_ms
;
198 JimGetTime(&cur_sec
, &cur_ms
);
200 te
= eventLoop
->timeEventHead
;
201 if (id
>= eventLoop
->timeEventNextId
)
202 return -2; /* wrong event ID */
205 remain
= (te
->when_sec
- cur_sec
) * 1000;
206 remain
+= (te
->when_ms
- cur_ms
) ;
207 remain
= (remain
< 0) ? 0 : remain
;
210 eventLoop
->timeEventHead
= te
->next
;
212 prev
->next
= te
->next
;
213 if (te
->finalizerProc
)
214 te
->finalizerProc(interp
, te
->clientData
);
221 return -1; /* NO event with the specified ID found */
224 /* Search the first timer to fire.
225 * This operation is useful to know how many time the select can be
226 * put in sleep without to delay any event.
227 * If there are no timers NULL is returned. */
228 static Jim_TimeEvent
*JimSearchNearestTimer(Jim_EventLoop
*eventLoop
)
230 Jim_TimeEvent
*te
= eventLoop
->timeEventHead
;
231 Jim_TimeEvent
*nearest
= NULL
;
234 if (!nearest
|| te
->when_sec
< nearest
->when_sec
||
235 (te
->when_sec
== nearest
->when_sec
&&
236 te
->when_ms
< nearest
->when_ms
))
243 /* Process every pending time event, then every pending file event
244 * (that may be registered by time event callbacks just processed).
245 * Without special flags the function sleeps until some file event
246 * fires, or when the next time event occurrs (if any).
248 * If flags is 0, the function does nothing and returns.
249 * if flags has JIM_ALL_EVENTS set, all the kind of events are processed.
250 * if flags has JIM_FILE_EVENTS set, file events are processed.
251 * if flags has JIM_TIME_EVENTS set, time events are processed.
252 * if flags has JIM_DONT_WAIT set the function returns ASAP until all
253 * the events that's possible to process without to wait are processed.
255 * The function returns the number of events processed. */
256 int Jim_ProcessEvents(Jim_Interp
*interp
, int flags
)
258 int maxfd
= 0, numfd
= 0, processed
= 0;
259 fd_set rfds
, wfds
, efds
;
260 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
261 Jim_FileEvent
*fe
= eventLoop
->fileEventHead
;
270 /* Check file events */
272 int fd
= fileno(fe
->handle
);
274 if (fe
->mask
& JIM_EVENT_READABLE
)
276 if (fe
->mask
& JIM_EVENT_WRITABLE
) FD_SET(fd
, &wfds
);
277 if (fe
->mask
& JIM_EVENT_EXCEPTION
) FD_SET(fd
, &efds
);
278 if (maxfd
< fd
) maxfd
= fd
;
282 /* Note that we want call select() even if there are no
283 * file events to process as long as we want to process time
284 * events, in order to sleep until the next time event is ready
286 if (numfd
|| ((flags
& JIM_TIME_EVENTS
) && !(flags
& JIM_DONT_WAIT
))) {
288 Jim_TimeEvent
*shortest
;
289 struct timeval tv
, *tvp
;
292 shortest
= JimSearchNearestTimer(eventLoop
);
294 long now_sec
, now_ms
;
296 /* Calculate the time missing for the nearest
298 JimGetTime(&now_sec
, &now_ms
);
300 dt
= 1000 * (shortest
->when_sec
- now_sec
);
301 dt
+= ( shortest
->when_ms
- now_ms
);
305 tvp
->tv_sec
= dt
/ 1000;
306 tvp
->tv_usec
= dt
% 1000;
307 // fprintf(stderr,"Next %d.% 8d\n",(int)tvp->tv_sec,(int)tvp->tv_usec);
309 tvp
= NULL
; /* wait forever */
310 // fprintf(stderr,"No Event\n");
313 retval
= select(maxfd
+1, &rfds
, &wfds
, &efds
, tvp
);
316 case EINTR
: fprintf(stderr
,"select EINTR\n"); break;
317 case EINVAL
: fprintf(stderr
,"select EINVAL\n"); break;
318 case ENOMEM
: fprintf(stderr
,"select ENOMEM\n"); break;
320 } else if (retval
> 0) {
321 fe
= eventLoop
->fileEventHead
;
323 int fd
= fileno(fe
->handle
);
325 // fprintf(stderr,"fd: %d mask: %02x \n",fd,fe->mask);
327 if ((fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) ||
328 (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
)) ||
329 (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
)))
333 if (fe
->mask
& JIM_EVENT_READABLE
&& FD_ISSET(fd
, &rfds
)) {
334 mask
|= JIM_EVENT_READABLE
;
335 if ((fe
->mask
& JIM_EVENT_FEOF
) && feof((FILE *)fe
->handle
))
336 mask
|= JIM_EVENT_FEOF
;
338 if (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
))
339 mask
|= JIM_EVENT_WRITABLE
;
340 if (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
))
341 mask
|= JIM_EVENT_EXCEPTION
;
342 if (fe
->fileProc(interp
, fe
->clientData
, mask
) == JIM_ERR
) {
343 /* Remove the element on handler error */
344 Jim_DeleteFileHandler(interp
, fe
->handle
);
347 /* After an event is processed our file event list
348 * may no longer be the same, so what we do
349 * is to clear the bit for this file descriptor and
350 * restart again from the head. */
351 fe
= eventLoop
->fileEventHead
;
361 /* Check time events */
362 te
= eventLoop
->timeEventHead
;
363 maxId
= eventLoop
->timeEventNextId
-1;
365 long now_sec
, now_ms
;
368 if (te
->id
> maxId
) {
372 JimGetTime(&now_sec
, &now_ms
);
373 if (now_sec
> te
->when_sec
||
374 (now_sec
== te
->when_sec
&& now_ms
>= te
->when_ms
))
377 te
->timeProc(interp
, te
->clientData
);
378 /* After an event is processed our time event list may
379 * no longer be the same, so we restart from head.
380 * Still we make sure to don't process events registered
381 * by event handlers itself in order to don't loop forever
382 * even in case an [after 0] that continuously register
383 * itself. To do so we saved the max ID we want to handle. */
384 Jim_DeleteTimeHandler(interp
, id
);
385 te
= eventLoop
->timeEventHead
;
393 /* ---------------------------------------------------------------------- */
395 void JimELAssocDataDeleProc(Jim_Interp
*interp
, void *data
)
400 Jim_EventLoop
*eventLoop
= data
;
402 fe
= eventLoop
->fileEventHead
;
405 if (fe
->finalizerProc
)
406 fe
->finalizerProc(interp
, fe
->clientData
);
411 te
= eventLoop
->timeEventHead
;
414 if (te
->finalizerProc
)
415 te
->finalizerProc(interp
, te
->clientData
);
422 static int JimELVwaitCommand(Jim_Interp
*interp
, int argc
,
423 Jim_Obj
*const *argv
)
428 Jim_WrongNumArgs(interp
, 1, argv
, "name");
431 oldValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
432 if (oldValue
) Jim_IncrRefCount(oldValue
);
436 Jim_ProcessEvents(interp
, JIM_ALL_EVENTS
);
437 currValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
438 /* Stop the loop if the vwait-ed variable changed value,
439 * or if was unset and now is set (or the contrary). */
440 if ((oldValue
&& !currValue
) ||
441 (!oldValue
&& currValue
) ||
442 (oldValue
&& currValue
&&
443 !Jim_StringEqObj(oldValue
, currValue
, JIM_CASESENS
)))
446 if (oldValue
) Jim_DecrRefCount(interp
, oldValue
);
450 void JimAfterTimeHandler(Jim_Interp
*interp
, void *clientData
)
452 Jim_Obj
*objPtr
= clientData
;
454 Jim_EvalObjBackground(interp
, objPtr
);
457 void JimAfterTimeEventFinalizer(Jim_Interp
*interp
, void *clientData
)
459 Jim_Obj
*objPtr
= clientData
;
461 Jim_DecrRefCount(interp
, objPtr
);
464 static int JimELAfterCommand(Jim_Interp
*interp
, int argc
,
465 Jim_Obj
*const *argv
)
468 Jim_Obj
*objPtr
, *idObjPtr
;
469 const char *options
[] = {
470 "info", "cancel", "restart", "expire", NULL
472 enum {INFO
, CANCEL
, RESTART
, EXPIRE
, CREATE
};
473 int option
= CREATE
;
476 Jim_WrongNumArgs(interp
, 1, argv
, "<after milliseconds> script");
479 if (Jim_GetWide(interp
, argv
[1], &ms
) != JIM_OK
)
480 if (Jim_GetEnum(interp
, argv
[1], options
, &option
, "after options",
481 JIM_ERRMSG
) != JIM_OK
)
485 Jim_IncrRefCount(argv
[2]);
486 id
= Jim_CreateTimeHandler(interp
, ms
, JimAfterTimeHandler
, argv
[2],
487 JimAfterTimeEventFinalizer
);
488 objPtr
= Jim_NewStringObj(interp
, NULL
, 0);
489 Jim_AppendString(interp
, objPtr
, "after#", -1);
490 idObjPtr
= Jim_NewIntObj(interp
, id
);
491 Jim_IncrRefCount(idObjPtr
);
492 Jim_AppendObj(interp
, objPtr
, idObjPtr
);
493 Jim_DecrRefCount(interp
, idObjPtr
);
494 Jim_SetResult(interp
, objPtr
);
500 const char *tok
= Jim_GetString(argv
[2], &tlen
);
501 if ( sscanf(tok
,"after#%lld",&id
) == 1) {
502 remain
= Jim_DeleteTimeHandler(interp
, id
);
504 Jim_SetResult(interp
, Jim_NewIntObj(interp
, remain
));
508 Jim_SetResultString(interp
, "invalid event" , -1);
512 fprintf(stderr
,"unserviced option to after %d\n",option
);
517 /* This extension is not dynamically loaded, instead it's linked statically,
518 which is why we shouldn't use the unspecific 'Jim_OnLoad' name */
519 #define Jim_OnLoad Jim_EventLoopOnLoad
521 int Jim_OnLoad(Jim_Interp
*interp
)
523 Jim_EventLoop
*eventLoop
;
525 Jim_InitExtension(interp
);
526 if (Jim_PackageProvide(interp
, "eventloop", "1.0", JIM_ERRMSG
) != JIM_OK
)
529 eventLoop
= Jim_Alloc(sizeof(*eventLoop
));
530 eventLoop
->fileEventHead
= NULL
;
531 eventLoop
->timeEventHead
= NULL
;
532 eventLoop
->timeEventNextId
= 1;
533 Jim_SetAssocData(interp
, "eventloop", JimELAssocDataDeleProc
, eventLoop
);
535 Jim_CreateCommand(interp
, "vwait", JimELVwaitCommand
, NULL
, NULL
);
536 Jim_CreateCommand(interp
, "after", JimELAfterCommand
, NULL
, NULL
);
538 /* Export events API */
539 Jim_RegisterApi(interp
, "Jim_CreateFileHandler", Jim_CreateFileHandler
);
540 Jim_RegisterApi(interp
, "Jim_DeleteFileHandler", Jim_DeleteFileHandler
);
541 Jim_RegisterApi(interp
, "Jim_CreateTimeHandler", Jim_CreateTimeHandler
);
542 Jim_RegisterApi(interp
, "Jim_DeleteTimeHandler", Jim_DeleteTimeHandler
);
543 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)