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>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer in the documentation and/or other materials
20 * provided with the distribution.
22 * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
23 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
24 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
27 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
33 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * The views and conclusions contained in the software and documentation
36 * are those of the authors and should not be interpreted as representing
37 * official policies, either expressed or implied, of the Jim Tcl Project.
40 #include "jimautoconf.h"
42 #include <jim-eventloop.h>
46 #include <sys/types.h>
51 #if defined(__MINGW32__)
56 #ifdef HAVE_SYS_SELECT_H
57 #include <sys/select.h>
61 /* XXX: Implement this in terms of select() or nanosleep() */
62 #define msleep(MS) sleep((MS) / 1000)
63 #warning "sub-second sleep not supported"
65 #define msleep(MS) sleep((MS) / 1000); usleep(((MS) % 1000) * 1000);
71 /* File event structure */
72 typedef struct Jim_FileEvent
75 int mask
; /* one of JIM_EVENT_(READABLE|WRITABLE|EXCEPTION) */
76 Jim_FileProc
*fileProc
;
77 Jim_EventFinalizerProc
*finalizerProc
;
79 struct Jim_FileEvent
*next
;
82 /* Time event structure */
83 typedef struct Jim_TimeEvent
85 jim_wide id
; /* time event identifier. */
86 long initialms
; /* initial relative timer value */
87 jim_wide when
; /* milliseconds */
88 Jim_TimeProc
*timeProc
;
89 Jim_EventFinalizerProc
*finalizerProc
;
91 struct Jim_TimeEvent
*next
;
94 /* Per-interp stucture containing the state of the event loop */
95 typedef struct Jim_EventLoop
97 Jim_FileEvent
*fileEventHead
;
98 Jim_TimeEvent
*timeEventHead
;
99 jim_wide timeEventNextId
; /* highest event id created, starting at 1 */
101 int suppress_bgerror
; /* bgerror returned break, so don't call it again */
104 static void JimAfterTimeHandler(Jim_Interp
*interp
, void *clientData
);
105 static void JimAfterTimeEventFinalizer(Jim_Interp
*interp
, void *clientData
);
107 int Jim_EvalObjBackground(Jim_Interp
*interp
, Jim_Obj
*scriptObjPtr
)
109 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
110 Jim_CallFrame
*savedFramePtr
;
113 savedFramePtr
= interp
->framePtr
;
114 interp
->framePtr
= interp
->topFramePtr
;
115 retval
= Jim_EvalObj(interp
, scriptObjPtr
);
116 interp
->framePtr
= savedFramePtr
;
117 /* Try to report the error (if any) via the bgerror proc */
118 if (retval
!= JIM_OK
&& !eventLoop
->suppress_bgerror
) {
122 objv
[0] = Jim_NewStringObj(interp
, "bgerror", -1);
123 objv
[1] = Jim_GetResult(interp
);
124 Jim_IncrRefCount(objv
[0]);
125 Jim_IncrRefCount(objv
[1]);
126 if (Jim_GetCommand(interp
, objv
[0], JIM_NONE
) == NULL
|| (rc
= Jim_EvalObjVector(interp
, 2, objv
)) != JIM_OK
) {
127 if (rc
== JIM_BREAK
) {
128 /* No more bgerror calls */
129 eventLoop
->suppress_bgerror
++;
132 /* Report the error to stderr. */
133 Jim_MakeErrorMessage(interp
);
134 fprintf(stderr
, "%s\n", Jim_String(Jim_GetResult(interp
)));
135 /* And reset the result */
136 Jim_SetResultString(interp
, "", -1);
139 Jim_DecrRefCount(interp
, objv
[0]);
140 Jim_DecrRefCount(interp
, objv
[1]);
146 void Jim_CreateFileHandler(Jim_Interp
*interp
, int fd
, int mask
,
147 Jim_FileProc
* proc
, void *clientData
, Jim_EventFinalizerProc
* finalizerProc
)
150 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
152 fe
= Jim_Alloc(sizeof(*fe
));
156 fe
->finalizerProc
= finalizerProc
;
157 fe
->clientData
= clientData
;
158 fe
->next
= eventLoop
->fileEventHead
;
159 eventLoop
->fileEventHead
= fe
;
163 * Removes all event handlers for 'handle' that match 'mask'.
165 void Jim_DeleteFileHandler(Jim_Interp
*interp
, int fd
, int mask
)
167 Jim_FileEvent
*fe
, *next
, *prev
= NULL
;
168 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
170 for (fe
= eventLoop
->fileEventHead
; fe
; fe
= next
) {
172 if (fe
->fd
== fd
&& (fe
->mask
& mask
)) {
173 /* Remove this entry from the list */
175 eventLoop
->fileEventHead
= next
;
178 if (fe
->finalizerProc
)
179 fe
->finalizerProc(interp
, fe
->clientData
);
188 * Returns the time since interp creation in milliseconds.
190 static jim_wide
JimGetTime(Jim_EventLoop
*eventLoop
)
194 gettimeofday(&tv
, NULL
);
196 return (jim_wide
)(tv
.tv_sec
- eventLoop
->timeBase
) * 1000 + tv
.tv_usec
/ 1000;
199 jim_wide
Jim_CreateTimeHandler(Jim_Interp
*interp
, jim_wide milliseconds
,
200 Jim_TimeProc
* proc
, void *clientData
, Jim_EventFinalizerProc
* finalizerProc
)
202 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
203 jim_wide id
= ++eventLoop
->timeEventNextId
;
204 Jim_TimeEvent
*te
, *e
, *prev
;
206 te
= Jim_Alloc(sizeof(*te
));
208 te
->initialms
= milliseconds
;
209 te
->when
= JimGetTime(eventLoop
) + milliseconds
;
211 te
->finalizerProc
= finalizerProc
;
212 te
->clientData
= clientData
;
214 /* Add to the appropriate place in the list */
216 for (e
= eventLoop
->timeEventHead
; e
; e
= e
->next
) {
217 if (te
->when
< e
->when
) {
223 te
->next
= prev
->next
;
227 te
->next
= eventLoop
->timeEventHead
;
228 eventLoop
->timeEventHead
= te
;
234 static jim_wide
JimParseAfterId(Jim_Obj
*idObj
)
236 const char *tok
= Jim_String(idObj
);
239 if (strncmp(tok
, "after#", 6) == 0 && Jim_StringToWide(tok
+ 6, &id
, 10) == JIM_OK
) {
240 /* Got an event by id */
246 static jim_wide
JimFindAfterByScript(Jim_EventLoop
*eventLoop
, Jim_Obj
*scriptObj
)
250 for (te
= eventLoop
->timeEventHead
; te
; te
= te
->next
) {
251 /* Is this an 'after' event? */
252 if (te
->timeProc
== JimAfterTimeHandler
) {
253 if (Jim_StringEqObj(scriptObj
, te
->clientData
)) {
258 return -1; /* NO event with the specified ID found */
261 static Jim_TimeEvent
*JimFindTimeHandlerById(Jim_EventLoop
*eventLoop
, jim_wide id
)
265 for (te
= eventLoop
->timeEventHead
; te
; te
= te
->next
) {
273 static Jim_TimeEvent
*Jim_RemoveTimeHandler(Jim_EventLoop
*eventLoop
, jim_wide id
)
275 Jim_TimeEvent
*te
, *prev
= NULL
;
277 for (te
= eventLoop
->timeEventHead
; te
; te
= te
->next
) {
280 eventLoop
->timeEventHead
= te
->next
;
282 prev
->next
= te
->next
;
290 static void Jim_FreeTimeHandler(Jim_Interp
*interp
, Jim_TimeEvent
*te
)
292 if (te
->finalizerProc
)
293 te
->finalizerProc(interp
, te
->clientData
);
297 jim_wide
Jim_DeleteTimeHandler(Jim_Interp
*interp
, jim_wide id
)
300 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
302 if (id
> eventLoop
->timeEventNextId
) {
303 return -2; /* wrong event ID */
306 te
= Jim_RemoveTimeHandler(eventLoop
, id
);
310 remain
= te
->when
- JimGetTime(eventLoop
);
311 remain
= (remain
< 0) ? 0 : remain
;
313 Jim_FreeTimeHandler(interp
, te
);
316 return -1; /* NO event with the specified ID found */
319 /* --- POSIX version of Jim_ProcessEvents, for now the only available --- */
321 /* Process every pending time event, then every pending file event
322 * (that may be registered by time event callbacks just processed).
323 * The behaviour depends upon the setting of flags:
325 * If flags is 0, the function does nothing and returns.
326 * if flags has JIM_ALL_EVENTS set, all event types are processed.
327 * if flags has JIM_FILE_EVENTS set, file events are processed.
328 * if flags has JIM_TIME_EVENTS set, time events are processed.
329 * if flags has JIM_DONT_WAIT set, the function returns as soon as all
330 * the events that are possible to process without waiting are processed.
332 * Returns the number of events processed or -1 if
333 * there are no matching handlers, or -2 on error.
335 int Jim_ProcessEvents(Jim_Interp
*interp
, int flags
)
337 jim_wide sleep_ms
= -1;
339 Jim_EventLoop
*eventLoop
= Jim_GetAssocData(interp
, "eventloop");
340 Jim_FileEvent
*fe
= eventLoop
->fileEventHead
;
344 if ((flags
& JIM_FILE_EVENTS
) == 0 || fe
== NULL
) {
346 if ((flags
& JIM_TIME_EVENTS
) == 0 || eventLoop
->timeEventHead
== NULL
) {
352 /* Note that we want call select() even if there are no
353 * file events to process as long as we want to process time
354 * events, in order to sleep until the next time event is ready
357 if (flags
& JIM_DONT_WAIT
) {
361 else if (flags
& JIM_TIME_EVENTS
) {
362 /* The nearest timer is always at the head of the list */
363 if (eventLoop
->timeEventHead
) {
364 Jim_TimeEvent
*shortest
= eventLoop
->timeEventHead
;
366 /* Calculate the time missing for the nearest
368 sleep_ms
= shortest
->when
- JimGetTime(eventLoop
);
380 if (flags
& JIM_FILE_EVENTS
) {
382 struct timeval tv
, *tvp
= NULL
;
383 fd_set rfds
, wfds
, efds
;
390 /* Check file events */
392 if (fe
->mask
& JIM_EVENT_READABLE
)
393 FD_SET(fe
->fd
, &rfds
);
394 if (fe
->mask
& JIM_EVENT_WRITABLE
)
395 FD_SET(fe
->fd
, &wfds
);
396 if (fe
->mask
& JIM_EVENT_EXCEPTION
)
397 FD_SET(fe
->fd
, &efds
);
405 tvp
->tv_sec
= sleep_ms
/ 1000;
406 tvp
->tv_usec
= 1000 * (sleep_ms
% 1000);
409 retval
= select(maxfd
+ 1, &rfds
, &wfds
, &efds
, tvp
);
412 if (errno
== EINVAL
) {
413 /* This can happen on mingw32 if a non-socket filehandle is passed */
414 Jim_SetResultString(interp
, "non-waitable filehandle", -1);
418 else if (retval
> 0) {
419 fe
= eventLoop
->fileEventHead
;
424 if ((fe
->mask
& JIM_EVENT_READABLE
) && FD_ISSET(fd
, &rfds
))
425 mask
|= JIM_EVENT_READABLE
;
426 if (fe
->mask
& JIM_EVENT_WRITABLE
&& FD_ISSET(fd
, &wfds
))
427 mask
|= JIM_EVENT_WRITABLE
;
428 if (fe
->mask
& JIM_EVENT_EXCEPTION
&& FD_ISSET(fd
, &efds
))
429 mask
|= JIM_EVENT_EXCEPTION
;
432 if (fe
->fileProc(interp
, fe
->clientData
, mask
) != JIM_OK
) {
433 /* Remove the element on handler error */
434 Jim_DeleteFileHandler(interp
, fd
, mask
);
435 /* At this point fe is no longer valid - it will be assigned below */
438 /* After an event is processed our file event list
439 * may no longer be the same, so what we do
440 * is to clear the bit for this file descriptor and
441 * restart again from the head. */
445 fe
= eventLoop
->fileEventHead
;
459 /* Check time events */
460 te
= eventLoop
->timeEventHead
;
461 maxId
= eventLoop
->timeEventNextId
;
465 if (te
->id
> maxId
) {
469 if (JimGetTime(eventLoop
) >= te
->when
) {
471 /* Remove from the list before executing */
472 Jim_RemoveTimeHandler(eventLoop
, id
);
473 te
->timeProc(interp
, te
->clientData
);
474 /* After an event is processed our time event list may
475 * no longer be the same, so we restart from head.
476 * Still we make sure to don't process events registered
477 * by event handlers itself in order to don't loop forever
478 * even in case an [after 0] that continuously register
479 * itself. To do so we saved the max ID we want to handle. */
480 Jim_FreeTimeHandler(interp
, te
);
482 te
= eventLoop
->timeEventHead
;
493 /* ---------------------------------------------------------------------- */
495 static void JimELAssocDataDeleProc(Jim_Interp
*interp
, void *data
)
500 Jim_EventLoop
*eventLoop
= data
;
502 fe
= eventLoop
->fileEventHead
;
505 if (fe
->finalizerProc
)
506 fe
->finalizerProc(interp
, fe
->clientData
);
511 te
= eventLoop
->timeEventHead
;
514 if (te
->finalizerProc
)
515 te
->finalizerProc(interp
, te
->clientData
);
522 static int JimELVwaitCommand(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
524 Jim_EventLoop
*eventLoop
= Jim_CmdPrivData(interp
);
529 Jim_WrongNumArgs(interp
, 1, argv
, "name");
533 oldValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
535 Jim_IncrRefCount(oldValue
);
538 /* If a result was left, it is an error */
539 if (Jim_Length(Jim_GetResult(interp
))) {
544 eventLoop
->suppress_bgerror
= 0;
546 while ((rc
= Jim_ProcessEvents(interp
, JIM_ALL_EVENTS
)) >= 0) {
548 currValue
= Jim_GetGlobalVariable(interp
, argv
[1], JIM_NONE
);
549 /* Stop the loop if the vwait-ed variable changed value,
550 * or if was unset and now is set (or the contrary)
551 * or if a signal was caught
553 if ((oldValue
&& !currValue
) ||
554 (!oldValue
&& currValue
) ||
555 (oldValue
&& currValue
&& !Jim_StringEqObj(oldValue
, currValue
)) ||
556 Jim_CheckSignal(interp
)) {
561 Jim_DecrRefCount(interp
, oldValue
);
567 Jim_SetEmptyResult(interp
);
571 static int JimELUpdateCommand(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
573 Jim_EventLoop
*eventLoop
= Jim_CmdPrivData(interp
);
574 static const char * const options
[] = {
577 enum { UPDATE_IDLE
, UPDATE_NONE
};
578 int option
= UPDATE_NONE
;
579 int flags
= JIM_TIME_EVENTS
;
582 flags
= JIM_ALL_EVENTS
;
584 else if (argc
> 2 || Jim_GetEnum(interp
, argv
[1], options
, &option
, NULL
, JIM_ERRMSG
| JIM_ENUM_ABBREV
) != JIM_OK
) {
585 Jim_WrongNumArgs(interp
, 1, argv
, "?idletasks?");
589 eventLoop
->suppress_bgerror
= 0;
591 while (Jim_ProcessEvents(interp
, flags
| JIM_DONT_WAIT
) > 0) {
597 static void JimAfterTimeHandler(Jim_Interp
*interp
, void *clientData
)
599 Jim_Obj
*objPtr
= clientData
;
601 Jim_EvalObjBackground(interp
, objPtr
);
604 static void JimAfterTimeEventFinalizer(Jim_Interp
*interp
, void *clientData
)
606 Jim_Obj
*objPtr
= clientData
;
608 Jim_DecrRefCount(interp
, objPtr
);
611 static int JimELAfterCommand(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
613 Jim_EventLoop
*eventLoop
= Jim_CmdPrivData(interp
);
615 Jim_Obj
*objPtr
, *idObjPtr
;
616 static const char * const options
[] = {
617 "cancel", "info", "idle", NULL
620 { AFTER_CANCEL
, AFTER_INFO
, AFTER_IDLE
, AFTER_RESTART
, AFTER_EXPIRE
, AFTER_CREATE
};
621 int option
= AFTER_CREATE
;
624 Jim_WrongNumArgs(interp
, 1, argv
, "option ?arg ...?");
627 if (Jim_GetWide(interp
, argv
[1], &ms
) != JIM_OK
) {
628 if (Jim_GetEnum(interp
, argv
[1], options
, &option
, "argument", JIM_ERRMSG
) != JIM_OK
) {
631 Jim_SetEmptyResult(interp
);
633 else if (argc
== 2) {
642 Jim_WrongNumArgs(interp
, 2, argv
, "script ?script ...?");
647 Jim_Obj
*scriptObj
= Jim_ConcatObj(interp
, argc
- 2, argv
+ 2);
648 Jim_IncrRefCount(scriptObj
);
649 id
= Jim_CreateTimeHandler(interp
, ms
, JimAfterTimeHandler
, scriptObj
,
650 JimAfterTimeEventFinalizer
);
651 objPtr
= Jim_NewStringObj(interp
, NULL
, 0);
652 Jim_AppendString(interp
, objPtr
, "after#", -1);
653 idObjPtr
= Jim_NewIntObj(interp
, id
);
654 Jim_IncrRefCount(idObjPtr
);
655 Jim_AppendObj(interp
, objPtr
, idObjPtr
);
656 Jim_DecrRefCount(interp
, idObjPtr
);
657 Jim_SetResult(interp
, objPtr
);
662 Jim_WrongNumArgs(interp
, 2, argv
, "id|command");
668 id
= JimParseAfterId(argv
[2]);
670 /* Not an event id, so search by script */
671 Jim_Obj
*scriptObj
= Jim_ConcatObj(interp
, argc
- 2, argv
+ 2);
672 id
= JimFindAfterByScript(eventLoop
, scriptObj
);
673 Jim_FreeNewObj(interp
, scriptObj
);
679 remain
= Jim_DeleteTimeHandler(interp
, id
);
681 Jim_SetResultInt(interp
, remain
);
688 Jim_TimeEvent
*te
= eventLoop
->timeEventHead
;
689 Jim_Obj
*listObj
= Jim_NewListObj(interp
, NULL
, 0);
691 const char *fmt
= "after#%" JIM_WIDE_MODIFIER
;
694 snprintf(buf
, sizeof(buf
), fmt
, te
->id
);
695 Jim_ListAppendElement(interp
, listObj
, Jim_NewStringObj(interp
, buf
, -1));
698 Jim_SetResult(interp
, listObj
);
700 else if (argc
== 3) {
701 id
= JimParseAfterId(argv
[2]);
703 Jim_TimeEvent
*e
= JimFindTimeHandlerById(eventLoop
, id
);
704 if (e
&& e
->timeProc
== JimAfterTimeHandler
) {
705 Jim_Obj
*listObj
= Jim_NewListObj(interp
, NULL
, 0);
706 Jim_ListAppendElement(interp
, listObj
, e
->clientData
);
707 Jim_ListAppendElement(interp
, listObj
, Jim_NewStringObj(interp
, e
->initialms
? "timer" : "idle", -1));
708 Jim_SetResult(interp
, listObj
);
712 Jim_SetResultFormatted(interp
, "event \"%#s\" doesn't exist", argv
[2]);
716 Jim_WrongNumArgs(interp
, 2, argv
, "?id?");
724 int Jim_eventloopInit(Jim_Interp
*interp
)
726 Jim_EventLoop
*eventLoop
;
728 if (Jim_PackageProvide(interp
, "eventloop", "1.0", JIM_ERRMSG
))
731 eventLoop
= Jim_Alloc(sizeof(*eventLoop
));
732 memset(eventLoop
, 0, sizeof(*eventLoop
));
734 Jim_SetAssocData(interp
, "eventloop", JimELAssocDataDeleProc
, eventLoop
);
736 Jim_CreateCommand(interp
, "vwait", JimELVwaitCommand
, eventLoop
, NULL
);
737 Jim_CreateCommand(interp
, "update", JimELUpdateCommand
, eventLoop
, NULL
);
738 Jim_CreateCommand(interp
, "after", JimELAfterCommand
, eventLoop
, NULL
);