* jim.c: reduce stack usage. Important for embedded devices without

	MMU.
	* jim.c, jim-aio.c, jim-eventloop.c, jim-eventloop.h: emergency repairs
	to make code compile with eCos after event loops was added. event loop
	stuff compiles under eCos at least, but this was not tested for regressions.

10 files changed, 801 insertions, 60 deletions

diff --git a/ChangeLog b/ChangeLog
index a523534..569693b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2008-07-23 oharboe
+
+	* jim.c: reduce stack usage. Important for embedded devices without
+	MMU.	
+	* jim.c, jim-aio.c, jim-eventloop.c, jim-eventloop.h: emergency repairs
+	to make code compile with eCos after event loops was added. event loop
+	stuff compiles under eCos at least, but this was not tested for regressions. 
+
 2008-07-21 oharboe
 
 	* src/jim.c: very slightly improved error messages.
diff --git a/ecos/language/tcl/jim/current/cdl/jimtcl.cdl b/ecos/language/tcl/jim/current/cdl/jimtcl.cdl
index 3d49a51..89953ce 100644
--- a/ecos/language/tcl/jim/current/cdl/jimtcl.cdl
+++ b/ecos/language/tcl/jim/current/cdl/jimtcl.cdl
@@ -51,7 +51,8 @@ cdl_package CYGPKG_JIMTCL {
     description   "Core Tcl implementation upon which commands pretinent to deeply embedded application can be added."

     include_dir   cyg/jimtcl

     include_files jim.h

-          compile       jim.c jim-aio.c

+    include_files jim-eventloop.h

+          compile       jim.c jim-aio.c jim-eventloop.c

        

               requires      CYGINT_ISO_STDIO_STREAMS

     requires      CYGINT_ISO_STDIO_FILEACCESS

diff --git a/ecos/language/tcl/jim/current/include/jim-eventloop.h b/ecos/language/tcl/jim/current/include/jim-eventloop.h
new file mode 100644
index 0000000..7506807
--- /dev/null
+++ b/ecos/language/tcl/jim/current/include/jim-eventloop.h
@@ -0,0 +1,114 @@
+/* Jim - A small embeddable Tcl interpreter

+ *

+ * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>

+ * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>

+ * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 

+ * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com

+ * Copyright 2008 Andrew Lunn <andrew@lunn.ch>

+ * Copyright 2008 Duane Ellis <openocd@duaneellis.com>

+ * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>

+ * 

+ * The FreeBSD license

+ * 

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above

+ *    copyright notice, this list of conditions and the following

+ *    disclaimer in the documentation and/or other materials

+ *    provided with the distribution.

+ * 

+ * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

+ * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ * 

+ * The views and conclusions contained in the software and documentation

+ * are those of the authors and should not be interpreted as representing

+ * official policies, either expressed or implied, of the Jim Tcl Project.

+ **/

+/* ------ USAGE -------

+ *

+ * In order to use this file from other extensions include it in every

+ * file where you need to call the eventloop API, also in the init

+ * function of your extension call Jim_ImportEventloopAPI(interp)

+ * after the Jim_InitExtension() call.

+ *

+ * See the UDP extension as example.

+ */

+

+

+#ifndef __JIM_EVENTLOOP_H__

+#define __JIM_EVENTLOOP_H__

+

+typedef int Jim_FileProc(Jim_Interp *interp, void *clientData, int mask);

+typedef int Jim_SignalProc(Jim_Interp *interp, void *clientData, void *msg);

+typedef void Jim_TimeProc(Jim_Interp *interp, void *clientData);

+typedef void Jim_EventFinalizerProc(Jim_Interp *interp, void *clientData);

+

+/* File event structure */

+#define JIM_EVENT_READABLE 1

+#define JIM_EVENT_WRITABLE 2

+#define JIM_EVENT_EXCEPTION 4

+#define JIM_EVENT_FEOF 8

+

+#ifndef __JIM_EVENTLOOP_CORE__

+# if defined JIM_EXTENSION || defined JIM_EMBEDDED

+#  define JIM_API(x) (*x)

+#  define JIM_STATIC

+# else

+#  define JIM_API(x) (*x)

+#  define JIM_STATIC extern

+# endif

+#else

+# define JIM_API(x) x

+# define JIM_STATIC static

+#endif /* __JIM_EVENTLOOP_CORE__ */

+

+JIM_STATIC void JIM_API(Jim_CreateFileHandler) (Jim_Interp *interp,

+        void *handle, int mask,

+        Jim_FileProc *proc, void *clientData,

+        Jim_EventFinalizerProc *finalizerProc);

+JIM_STATIC void JIM_API(Jim_DeleteFileHandler) (Jim_Interp *interp,

+        void *handle);

+JIM_STATIC jim_wide JIM_API(Jim_CreateTimeHandler) (Jim_Interp *interp,

+        jim_wide milliseconds,

+        Jim_TimeProc *proc, void *clientData,

+        Jim_EventFinalizerProc *finalizerProc);

+JIM_STATIC jim_wide JIM_API(Jim_DeleteTimeHandler) (Jim_Interp *interp, jim_wide id);

+JIM_STATIC int JIM_API(Jim_ProcessEvents) (Jim_Interp *interp, int flags);

+

+#undef JIM_STATIC

+#undef JIM_API

+

+#ifndef __JIM_EVENTLOOP_CORE__

+

+#define JIM_GET_API(name) \

+    Jim_GetApi(interp, "Jim_" #name, ((void *)&Jim_ ## name))

+

+#if defined(JIM_EXTENSION) || defined(JIM_EMBEDDED)

+/* This must be included "inline" inside the extension */

+static void Jim_ImportEventloopAPI(Jim_Interp *interp)

+{

+  JIM_GET_API(CreateFileHandler);

+  JIM_GET_API(DeleteFileHandler);

+  JIM_GET_API(CreateTimeHandler);

+  JIM_GET_API(DeleteTimeHandler);

+  JIM_GET_API(ProcessEvents);

+}

+#endif /* defined JIM_EXTENSION || defined JIM_EMBEDDED */

+#undef JIM_GET_API

+#endif /* __JIM_EVENTLOOP_CORE__ */

+

+#endif /* __JIM_EVENTLOOP_H__ */

diff --git a/ecos/language/tcl/jim/current/src/jim-aio.c b/ecos/language/tcl/jim/current/src/jim-aio.c
index 7e8aa9e..4eb5172 100644
--- a/ecos/language/tcl/jim/current/src/jim-aio.c
+++ b/ecos/language/tcl/jim/current/src/jim-aio.c
@@ -58,10 +58,11 @@
 #endif

 #ifdef __ECOS

 #include <cyg/jimtcl/jim.h>

+#include <cyg/jimtcl/jim-eventloop.h>

 #else

 #include "jim.h"

-#endif

 #include "jim-eventloop.h"

+#endif

 

 #define AIO_CMD_LEN 128

 #define AIO_BUF_LEN 1024

@@ -379,7 +380,8 @@ static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
         Jim_SetResult(interp, Jim_NewIntObj(interp, feof(af->fp)));

         return JIM_OK;

     } else if (option  == OPT_NDELAY) {

-	int fmode = af->flags;

+#ifdef O_NDELAY

+    	int fmode = af->flags;

 

         if (argc == 3) {

 		jim_wide wideValue;

@@ -397,6 +399,9 @@ static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
 	}

         Jim_SetResult(interp, Jim_NewIntObj(interp, (fmode & O_NONBLOCK)?1:0));

         return JIM_OK;

+#else

+        return JIM_ERR;

+#endif

     } else if   (  (option  == OPT_READABLE) 

 		|| (option  == OPT_WRITABLE) 

 		|| (option  == OPT_EXCEPTION) 

@@ -572,10 +577,8 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
 		SOCK_STREAM_CL, 

 		SOCK_STREAM_SERV 

     };

-    int modeLen;

     int socktype;

     int sock;

-    FILE *fsock;

     const char *hostportarg;

     int hostportlen;

     char a[0x20];

@@ -588,7 +591,6 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
     char* stport;

     unsigned int srcport;

     unsigned int port;

-    int elemcnt;

     struct sockaddr_in sa;

     struct hostent *he;

     int res;

@@ -618,10 +620,12 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
     srcport = atol(stsrcport);

     port = atol(stport);

     he = gethostbyname(sthost);

+    /* FIX!!!! this still results in null pointer exception here.  

     if (!he)

-	herror("gethostbyname");

+    	herror("gethostbyname");

     fprintf(stderr,"Official name is: %s\n", he->h_name);

     fprintf(stderr,"IP address: %s\n", inet_ntoa(*(struct in_addr*)he->h_addr));

+     */

 

     sock = socket(PF_INET,SOCK_STREAM,0);

     fprintf(stderr,"srcp: %x port: %x IP: %x sock: %d type: %d\n",srcport,port,he->h_addr,sock,socktype);

@@ -742,10 +746,10 @@ Jim_OnLoad(Jim_Interp *interp)
 Jim_AioInit(Jim_Interp *interp)

 #endif

 {

-    #ifndef JIM_STATICEXT

+#ifndef JIM_STATICEXT

     Jim_InitExtension(interp);

-    #endif

 	Jim_ImportEventloopAPI(interp);

+#endif

     if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG) != JIM_OK)

         return JIM_ERR;

     Jim_CreateCommand(interp, "aio.open", JimAioOpenCommand, NULL, NULL);

diff --git a/ecos/language/tcl/jim/current/src/jim-eventloop.c b/ecos/language/tcl/jim/current/src/jim-eventloop.c
new file mode 100644
index 0000000..d5fa57c
--- /dev/null
+++ b/ecos/language/tcl/jim/current/src/jim-eventloop.c
@@ -0,0 +1,547 @@
+/* Jim - A small embeddable Tcl interpreter

+ *

+ * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>

+ * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>

+ * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 

+ * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com

+ * Copyright 2008 Andrew Lunn <andrew@lunn.ch>

+ * Copyright 2008 Duane Ellis <openocd@duaneellis.com>

+ * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>

+ * 

+ * The FreeBSD license

+ * 

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above

+ *    copyright notice, this list of conditions and the following

+ *    disclaimer in the documentation and/or other materials

+ *    provided with the distribution.

+ * 

+ * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

+ * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ * 

+ * The views and conclusions contained in the software and documentation

+ * are those of the authors and should not be interpreted as representing

+ * official policies, either expressed or implied, of the Jim Tcl Project.

+ **/

+/* TODO:

+ *

+ *  - to really use flags in Jim_ProcessEvents()

+ *  - more complete [after] command with [after info] and other subcommands.

+ *  - Win32 port

+ */

+

+#define JIM_EXTENSION

+#define __JIM_EVENTLOOP_CORE__

+#ifdef __ECOS

+#include <pkgconf/jimtcl.h>

+#endif

+#ifdef __ECOS

+#include <cyg/jimtcl/jim.h>

+#include <cyg/jimtcl/jim-eventloop.h>

+#else

+#include "jim.h"

+#include "jim-eventloop.h"

+#endif

+

+/* POSIX includes */

+#include <sys/time.h>

+#include <sys/types.h>

+#include <unistd.h>

+#include <sys/select.h>

+#include <errno.h>

+	extern int errno;

+/* --- */

+

+/* File event structure */

+typedef struct Jim_FileEvent {

+    void *handle;

+    int mask; /* one of JIM_EVENT_(READABLE|WRITABLE|EXCEPTION) */

+    Jim_FileProc *fileProc;

+    Jim_EventFinalizerProc *finalizerProc;

+    void *clientData;

+    struct Jim_FileEvent *next;

+} Jim_FileEvent;

+

+/* Time event structure */

+typedef struct Jim_TimeEvent {

+    jim_wide id; /* time event identifier. */

+    int mode;	/* restart, repetitive .. UK */

+    long initialms; /* initial relativ timer value UK */

+    long when_sec; /* seconds */

+    long when_ms; /* milliseconds */

+    Jim_TimeProc *timeProc;

+    Jim_EventFinalizerProc *finalizerProc;

+    void *clientData;

+    struct Jim_TimeEvent *next;

+} Jim_TimeEvent;

+

+/* Per-interp stucture containing the state of the event loop */

+typedef struct Jim_EventLoop {

+    jim_wide timeEventNextId;

+    Jim_FileEvent *fileEventHead;

+    Jim_TimeEvent *timeEventHead;

+} Jim_EventLoop;

+

+void Jim_CreateFileHandler(Jim_Interp *interp, void *handle, int mask,

+        Jim_FileProc *proc, void *clientData,

+        Jim_EventFinalizerProc *finalizerProc)

+{

+    Jim_FileEvent *fe;

+    Jim_EventLoop *eventLoop = Jim_GetAssocData(interp, "eventloop");

+

+	// fprintf(stderr,"rein\n");

+    fe = Jim_Alloc(sizeof(*fe));

+    fe->handle = handle;

+    fe->mask = mask;

+    fe->fileProc = proc;

+    fe->finalizerProc = finalizerProc;

+    fe->clientData = clientData;

+    fe->next = eventLoop->fileEventHead;

+    eventLoop->fileEventHead = fe;

+	// fprintf(stderr,"raus\n");

+}

+

+void Jim_DeleteFileHandler(Jim_Interp *interp, void *handle)

+{

+    Jim_FileEvent *fe, *prev = NULL;

+    Jim_EventLoop *eventLoop = Jim_GetAssocData(interp, "eventloop");

+

+    fe = eventLoop->fileEventHead;

+    while(fe) {

+        if (fe->handle == handle) {

+            if (prev == NULL)

+                eventLoop->fileEventHead = fe->next;

+            else

+                prev->next = fe->next;

+            if (fe->finalizerProc)

+                fe->finalizerProc(interp, fe->clientData);

+            Jim_Free(fe);

+            return;

+        }

+        prev = fe;

+        fe = fe->next;

+    }

+}

+

+// The same for signals.

+void Jim_CreateSignalHandler(Jim_Interp *interp, int signum, 

+        Jim_FileProc *proc, void *clientData,

+        Jim_EventFinalizerProc *finalizerProc)

+{

+}

+void Jim_DeleteSignalHandler(Jim_Interp *interp, int signum) 

+{

+}

+

+/* That's another part of this extension that needs to be ported

+ * to WIN32. */

+static void JimGetTime(long *seconds, long *milliseconds)

+{

+    struct timeval tv;

+

+    gettimeofday(&tv, NULL);

+    *seconds = tv.tv_sec;

+    *milliseconds = tv.tv_usec/1000;

+}

+

+jim_wide Jim_CreateTimeHandler(Jim_Interp *interp, jim_wide milliseconds,

+        Jim_TimeProc *proc, void *clientData,

+        Jim_EventFinalizerProc *finalizerProc)

+{

+    Jim_EventLoop *eventLoop = Jim_GetAssocData(interp, "eventloop");

+    jim_wide id = eventLoop->timeEventNextId++;

+    Jim_TimeEvent *te;

+    long cur_sec, cur_ms;

+

+    JimGetTime(&cur_sec, &cur_ms);

+

+    te = Jim_Alloc(sizeof(*te));

+    te->id = id;

+    te->mode = 0;

+    te->initialms = milliseconds;

+    te->when_sec = cur_sec + milliseconds/1000;

+    te->when_ms = cur_ms + milliseconds%1000;

+    if (te->when_ms >= 1000) {

+        te->when_sec ++;

+        te->when_ms -= 1000;

+    }

+    te->timeProc = proc;

+    te->finalizerProc = finalizerProc;

+    te->clientData = clientData;

+    te->next = eventLoop->timeEventHead;

+    eventLoop->timeEventHead = te;

+    return id;

+}

+

+jim_wide Jim_DeleteTimeHandler(Jim_Interp *interp, jim_wide id)

+{

+    Jim_TimeEvent *te, *prev = NULL;

+    Jim_EventLoop *eventLoop = Jim_GetAssocData(interp, "eventloop");

+    long cur_sec, cur_ms;

+    jim_wide remain ;

+

+    JimGetTime(&cur_sec, &cur_ms);

+

+    te = eventLoop->timeEventHead;

+    if (id >= eventLoop->timeEventNextId) 

+    	return -2; /* wrong event ID */

+    while(te) {

+        if (te->id == id) {

+            remain  = (te->when_sec - cur_sec) * 1000;

+            remain += (te->when_ms  - cur_ms) ;

+	    remain = (remain < 0) ? 0 : remain ;

+

+            if (prev == NULL)

+                eventLoop->timeEventHead = te->next;

+            else

+                prev->next = te->next;

+            if (te->finalizerProc)

+                te->finalizerProc(interp, te->clientData);

+            Jim_Free(te);

+            return remain;

+        }

+        prev = te;

+        te = te->next;

+    }

+    return -1; /* NO event with the specified ID found */

+}

+

+/* Search the first timer to fire.

+ * This operation is useful to know how many time the select can be

+ * put in sleep without to delay any event.

+ * If there are no timers NULL is returned. */

+static Jim_TimeEvent *JimSearchNearestTimer(Jim_EventLoop *eventLoop)

+{

+    Jim_TimeEvent *te = eventLoop->timeEventHead;

+    Jim_TimeEvent *nearest = NULL;

+

+    while(te) {

+        if (!nearest || te->when_sec < nearest->when_sec ||

+                (te->when_sec == nearest->when_sec &&

+                 te->when_ms < nearest->when_ms))

+            nearest = te;

+        te = te->next;

+    }

+    return nearest;

+}

+

+/* --- POSIX version of Jim_ProcessEvents, for now the only available --- */

+#define JIM_FILE_EVENTS 1

+#define JIM_TIME_EVENTS 2

+#define JIM_ALL_EVENTS (JIM_FILE_EVENTS|JIM_TIME_EVENTS)

+#define JIM_DONT_WAIT 4

+

+/* Process every pending time event, then every pending file event

+ * (that may be registered by time event callbacks just processed).

+ * Without special flags the function sleeps until some file event

+ * fires, or when the next time event occurrs (if any).

+ *

+ * If flags is 0, the function does nothing and returns.

+ * if flags has JIM_ALL_EVENTS set, all the kind of events are processed.

+ * if flags has JIM_FILE_EVENTS set, file events are processed.

+ * if flags has JIM_TIME_EVENTS set, time events are processed.

+ * if flags has JIM_DONT_WAIT set the function returns ASAP until all

+ * the events that's possible to process without to wait are processed.

+ *

+ * The function returns the number of events processed. */

+int Jim_ProcessEvents(Jim_Interp *interp, int flags)

+{

+    int maxfd = 0, numfd = 0, processed = 0;

+    fd_set rfds, wfds, efds;

+    Jim_EventLoop *eventLoop = Jim_GetAssocData(interp, "eventloop");

+    Jim_FileEvent *fe = eventLoop->fileEventHead;

+    Jim_TimeEvent *te;

+    jim_wide maxId;

+    JIM_NOTUSED(flags);

+

+    FD_ZERO(&rfds);

+    FD_ZERO(&wfds);

+    FD_ZERO(&efds);

+

+    /* Check file events */

+    while (fe != NULL) {

+        int fd = fileno(fe->handle);

+

+        if (fe->mask & JIM_EVENT_READABLE) 

+		FD_SET(fd, &rfds);

+        if (fe->mask & JIM_EVENT_WRITABLE) FD_SET(fd, &wfds);

+        if (fe->mask & JIM_EVENT_EXCEPTION) FD_SET(fd, &efds);

+        if (maxfd < fd) maxfd = fd;

+        numfd++;

+        fe = fe->next;

+    }

+    /* Note that we want call select() even if there are no

+     * file events to process as long as we want to process time

+     * events, in order to sleep until the next time event is ready

+     * to fire. */

+    if (numfd || ((flags & JIM_TIME_EVENTS) && !(flags & JIM_DONT_WAIT))) {

+        int retval;

+        Jim_TimeEvent *shortest;

+        struct timeval tv, *tvp;

+	jim_wide dt;

+

+        shortest = JimSearchNearestTimer(eventLoop);

+        if (shortest) {

+            long now_sec, now_ms;

+

+            /* Calculate the time missing for the nearest

+             * timer to fire. */

+            JimGetTime(&now_sec, &now_ms);

+            tvp = &tv;

+	    dt   = 1000 * (shortest->when_sec - now_sec);

+	    dt  += ( shortest->when_ms  - now_ms);

+            if (dt < 0) {

+		dt = 1;

+	    }

+	    tvp->tv_sec  = dt / 1000;

+	    tvp->tv_usec = dt % 1000;

+	    // fprintf(stderr,"Next %d.% 8d\n",(int)tvp->tv_sec,(int)tvp->tv_usec);

+        } else {

+            tvp = NULL; /* wait forever */

+		// fprintf(stderr,"No Event\n");

+        }

+

+        retval = select(maxfd+1, &rfds, &wfds, &efds, tvp);

+        if (retval < 0) {

+	   switch (errno) {

+	       case EINTR:   fprintf(stderr,"select EINTR\n"); break;

+	       case EINVAL:  fprintf(stderr,"select EINVAL\n"); break;

+ 	       case ENOMEM:  fprintf(stderr,"select ENOMEM\n"); break;

+	   }

+	} else if (retval > 0) {

+            fe = eventLoop->fileEventHead;

+            while(fe != NULL) {

+                int fd = fileno(fe->handle);

+

+		// fprintf(stderr,"fd: %d mask: %02x \n",fd,fe->mask);

+

+                if ((fe->mask & JIM_EVENT_READABLE && FD_ISSET(fd, &rfds)) ||

+                    (fe->mask & JIM_EVENT_WRITABLE && FD_ISSET(fd, &wfds)) ||

+                    (fe->mask & JIM_EVENT_EXCEPTION && FD_ISSET(fd, &efds)))

+                {

+                    int mask = 0;

+

+                    if (fe->mask & JIM_EVENT_READABLE && FD_ISSET(fd, &rfds)) {

+                        mask |= JIM_EVENT_READABLE;

+			if ((fe->mask & JIM_EVENT_FEOF) && feof(fe->handle))

+				mask |= JIM_EVENT_FEOF;

+		    }

+                    if (fe->mask & JIM_EVENT_WRITABLE && FD_ISSET(fd, &wfds))

+                        mask |= JIM_EVENT_WRITABLE;

+                    if (fe->mask & JIM_EVENT_EXCEPTION && FD_ISSET(fd, &efds))

+                        mask |= JIM_EVENT_EXCEPTION;

+                    if (fe->fileProc(interp, fe->clientData, mask) == JIM_ERR) {

+                        /* Remove the element on handler error */

+                        Jim_DeleteFileHandler(interp, fe->handle);

+                    }

+                    processed++;

+                    /* After an event is processed our file event list

+                     * may no longer be the same, so what we do

+                     * is to clear the bit for this file descriptor and

+                     * restart again from the head. */

+                    fe = eventLoop->fileEventHead;

+                    FD_CLR(fd, &rfds);

+                    FD_CLR(fd, &wfds);

+                    FD_CLR(fd, &efds);

+                } else {

+                    fe = fe->next;

+                }

+            }

+        }

+    }

+    /* Check time events */

+    te = eventLoop->timeEventHead;

+    maxId = eventLoop->timeEventNextId-1;

+    while(te) {

+        long now_sec, now_ms;

+        jim_wide id;

+

+        if (te->id > maxId) {

+            te = te->next;

+            continue;

+        }

+        JimGetTime(&now_sec, &now_ms);

+        if (now_sec > te->when_sec ||

+            (now_sec == te->when_sec && now_ms >= te->when_ms))

+        {

+            id = te->id;

+            te->timeProc(interp, te->clientData);

+            /* After an event is processed our time event list may

+             * no longer be the same, so we restart from head.

+             * Still we make sure to don't process events registered

+             * by event handlers itself in order to don't loop forever

+             * even in case an [after 0] that continuously register

+             * itself. To do so we saved the max ID we want to handle. */

+            Jim_DeleteTimeHandler(interp, id);

+            te = eventLoop->timeEventHead;

+        } else {

+            te = te->next;

+        }

+    }

+

+    return processed;

+}

+/* ---------------------------------------------------------------------- */

+

+void JimELAssocDataDeleProc(Jim_Interp *interp, void *data)

+{

+    void *next;

+    Jim_FileEvent *fe;

+    Jim_TimeEvent *te;

+    Jim_EventLoop *eventLoop = data;

+

+    fe = eventLoop->fileEventHead;

+    while(fe) {

+        next = fe->next;

+        if (fe->finalizerProc)

+            fe->finalizerProc(interp, fe->clientData);

+        Jim_Free(fe);

+        fe = next;

+    }

+

+    te = eventLoop->timeEventHead;

+    while(te) {

+        next = te->next;

+        if (te->finalizerProc)

+            te->finalizerProc(interp, te->clientData);

+        Jim_Free(te);

+        te = next;

+    }

+    Jim_Free(data);

+}

+

+static int JimELVwaitCommand(Jim_Interp *interp, int argc, 

+        Jim_Obj *const *argv)

+{

+    Jim_Obj *oldValue;

+

+    if (argc != 2) {

+        Jim_WrongNumArgs(interp, 1, argv, "name");

+        return JIM_ERR;

+    }

+    oldValue = Jim_GetGlobalVariable(interp, argv[1], JIM_NONE);

+    if (oldValue) Jim_IncrRefCount(oldValue);

+    while (1) {

+        Jim_Obj *currValue;

+

+        Jim_ProcessEvents(interp, JIM_ALL_EVENTS);

+        currValue = Jim_GetGlobalVariable(interp, argv[1], JIM_NONE);

+        /* Stop the loop if the vwait-ed variable changed value,

+         * or if was unset and now is set (or the contrary). */

+        if ((oldValue && !currValue) ||

+            (!oldValue && currValue) ||

+            (oldValue && currValue &&

+             !Jim_StringEqObj(oldValue, currValue, JIM_CASESENS)))

+            break;

+    }

+    if (oldValue) Jim_DecrRefCount(interp, oldValue);

+    return JIM_OK;

+}

+

+void JimAfterTimeHandler(Jim_Interp *interp, void *clientData)

+{

+    Jim_Obj *objPtr = clientData;

+

+    Jim_EvalObjBackground(interp, objPtr);

+}

+

+void JimAfterTimeEventFinalizer(Jim_Interp *interp, void *clientData)

+{

+    Jim_Obj *objPtr = clientData;

+

+    Jim_DecrRefCount(interp, objPtr);

+}

+

+static int JimELAfterCommand(Jim_Interp *interp, int argc, 

+        Jim_Obj *const *argv)

+{

+    jim_wide ms, id;

+    Jim_Obj *objPtr, *idObjPtr;

+    const char *options[] = {

+	"info", "cancel", "restart", "expire", NULL

+    };

+    enum {INFO, CANCEL, RESTART, EXPIRE, CREATE };

+    int option = CREATE ;

+

+    if (argc < 3) {

+        Jim_WrongNumArgs(interp, 1, argv, "<after milliseconds> script");

+        return JIM_ERR;

+    }

+    if (Jim_GetWide(interp, argv[1], &ms) != JIM_OK)

+        if (Jim_GetEnum(interp, argv[1], options, &option, "after options",

+                    JIM_ERRMSG) != JIM_OK)

+            return JIM_ERR;

+    switch (option) {

+    case CREATE:

+        Jim_IncrRefCount(argv[2]);

+        id = Jim_CreateTimeHandler(interp, ms, JimAfterTimeHandler, argv[2],

+                JimAfterTimeEventFinalizer);

+        objPtr = Jim_NewStringObj(interp, NULL, 0);

+        Jim_AppendString(interp, objPtr, "after#", -1);

+        idObjPtr = Jim_NewIntObj(interp, id);

+        Jim_IncrRefCount(idObjPtr);

+        Jim_AppendObj(interp, objPtr, idObjPtr);

+        Jim_DecrRefCount(interp, idObjPtr);

+        Jim_SetResult(interp, objPtr);

+        return JIM_OK;

+    case CANCEL:

+	{

+	int tlen ;

+	jim_wide remain = 0;

+	const char *tok = Jim_GetString(argv[2], &tlen);

+	if ( sscanf(tok,"after#%lld",&id) == 1) {

+		remain =  Jim_DeleteTimeHandler(interp, id);

+		if (remain > -2)  {

+			Jim_SetResult(interp, Jim_NewIntObj(interp, remain));

+			return JIM_OK;

+		}

+	}

+        Jim_SetResultString(interp, "invalid event" , -1);

+        return JIM_ERR;

+	}

+    default:

+	fprintf(stderr,"unserviced option to after %d\n",option);

+    } 

+    return JIM_OK;

+}

+

+int Jim_OnLoad(Jim_Interp *interp)

+{

+    Jim_EventLoop *eventLoop;

+

+    Jim_InitExtension(interp);

+    if (Jim_PackageProvide(interp, "eventloop", "1.0", JIM_ERRMSG) != JIM_OK)

+        return JIM_ERR;

+

+    eventLoop = Jim_Alloc(sizeof(*eventLoop));

+    eventLoop->fileEventHead = NULL;

+    eventLoop->timeEventHead = NULL;

+    eventLoop->timeEventNextId = 1;

+    Jim_SetAssocData(interp, "eventloop", JimELAssocDataDeleProc, eventLoop);

+

+    Jim_CreateCommand(interp, "vwait", JimELVwaitCommand, NULL, NULL);

+    Jim_CreateCommand(interp, "after", JimELAfterCommand, NULL, NULL);

+

+    /* Export events API */

+    Jim_RegisterApi(interp, "Jim_CreateFileHandler", Jim_CreateFileHandler);

+    Jim_RegisterApi(interp, "Jim_DeleteFileHandler", Jim_DeleteFileHandler);

+    Jim_RegisterApi(interp, "Jim_CreateTimeHandler", Jim_CreateTimeHandler);

+    Jim_RegisterApi(interp, "Jim_DeleteTimeHandler", Jim_DeleteTimeHandler);

+    Jim_RegisterApi(interp, "Jim_ProcessEvents", Jim_ProcessEvents);

+    return JIM_OK;

+}

diff --git a/ecos/language/tcl/jim/current/src/jim.c b/ecos/language/tcl/jim/current/src/jim.c
index 7a5b121..b0e6c1c 100644
--- a/ecos/language/tcl/jim/current/src/jim.c
+++ b/ecos/language/tcl/jim/current/src/jim.c
@@ -2171,8 +2171,9 @@ static Jim_Obj *JimStringToUpper(Jim_Interp *interp, Jim_Obj *strObjPtr)
  * TODO: Lots of things work - via a hack

  *       However, no format item can be >= JIM_MAX_FMT 

  */

-Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,

-        int objc, Jim_Obj *const *objv)

+#define JIM_MAX_FMT 2048

+static Jim_Obj *Jim_FormatString_Inner(Jim_Interp *interp, Jim_Obj *fmtObjPtr,

+        int objc, Jim_Obj *const *objv, char *sprintf_buf)

 {

     const char *fmt, *_fmt;

     int fmtLen;

@@ -2188,8 +2189,6 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
         jim_wide wideValue;

 		double doubleValue;

 		/* we cheat and use Sprintf()! */

-#define JIM_MAX_FMT 2048

-		char sprintf_buf[JIM_MAX_FMT];

 		char fmt_str[100];

 		char *cp;

 		int width;

@@ -2454,6 +2453,15 @@ Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
     return resObjPtr;

 }

 

+Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr,

+        int objc, Jim_Obj *const *objv)

+{

+	char *sprintf_buf=malloc(JIM_MAX_FMT);

+	Jim_Obj *t=Jim_FormatString_Inner(interp, fmtObjPtr, objc, objv, sprintf_buf);

+	free(sprintf_buf);

+	return t; 

+}

+

 /* -----------------------------------------------------------------------------

  * Compared String Object

  * ---------------------------------------------------------------------------*/

@@ -8752,15 +8760,17 @@ int Jim_EvalFile(Jim_Interp *interp, const char *filename)
     int nread, totread, maxlen, buflen;

     int retval;

     Jim_Obj *scriptObjPtr;

-    char cwd[ 2048 ];

     

     if ((fp = fopen(filename, "r")) == NULL) {

+    	const int cwd_len=2048;

+		char *cwd=malloc(cwd_len);

         Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));

-	getcwd( cwd, sizeof(cwd) );

+	getcwd( cwd, cwd_len );

         Jim_AppendStrings(interp, Jim_GetResult(interp),

 	"Error loading script \"", filename, "\"",

 	    " cwd: ", cwd,

 	    " err: ", strerror(errno), NULL);

+	    free(cwd);

         return JIM_ERR;

     }

     buflen = 1024;

diff --git a/ecos/update.sh b/ecos/update.sh
index 86d2359..2fea269 100644
--- a/ecos/update.sh
+++ b/ecos/update.sh
@@ -1,5 +1,7 @@
 # Copy files from original places into eCos repository structure
 cp ../jim.c language/tcl/jim/current/src
 cp ../jim-aio.c language/tcl/jim/current/src
+cp ../jim-eventloop.c language/tcl/jim/current/src
 cp ../jim.h language/tcl/jim/current/include
+cp ../jim-eventloop.h language/tcl/jim/current/include
 
diff --git a/jim-aio.c b/jim-aio.c
index bbe87a3..67a44a2 100644
--- a/jim-aio.c
+++ b/jim-aio.c
@@ -58,10 +58,11 @@
 #endif
 #ifdef __ECOS
 #include <cyg/jimtcl/jim.h>
+#include <cyg/jimtcl/jim-eventloop.h>
 #else
 #include "jim.h"
-#endif
 #include "jim-eventloop.h"
+#endif
 
 #define AIO_CMD_LEN 128
 #define AIO_BUF_LEN 1024
@@ -379,7 +380,8 @@ static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
         Jim_SetResult(interp, Jim_NewIntObj(interp, feof(af->fp)));
         return JIM_OK;
     } else if (option  == OPT_NDELAY) {
-	int fmode = af->flags;
+#ifdef O_NDELAY
+    	int fmode = af->flags;
 
         if (argc == 3) {
 		jim_wide wideValue;
@@ -397,6 +399,9 @@ static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
 	}
         Jim_SetResult(interp, Jim_NewIntObj(interp, (fmode & O_NONBLOCK)?1:0));
         return JIM_OK;
+#else
+        return JIM_ERR;
+#endif
     } else if   (  (option  == OPT_READABLE) 
 		|| (option  == OPT_WRITABLE) 
 		|| (option  == OPT_EXCEPTION) 
@@ -572,10 +577,8 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
 		SOCK_STREAM_CL, 
 		SOCK_STREAM_SERV 
     };
-    int modeLen;
     int socktype;
     int sock;
-    FILE *fsock;
     const char *hostportarg;
     int hostportlen;
     char a[0x20];
@@ -588,7 +591,6 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
     char* stport;
     unsigned int srcport;
     unsigned int port;
-    int elemcnt;
     struct sockaddr_in sa;
     struct hostent *he;
     int res;
@@ -618,10 +620,12 @@ static int JimAioSockCommand(Jim_Interp *interp, int argc,
     srcport = atol(stsrcport);
     port = atol(stport);
     he = gethostbyname(sthost);
+    /* FIX!!!! this still results in null pointer exception here.  
     if (!he)
-	herror("gethostbyname");
+    	herror("gethostbyname");
     fprintf(stderr,"Official name is: %s\n", he->h_name);
     fprintf(stderr,"IP address: %s\n", inet_ntoa(*(struct in_addr*)he->h_addr));
+     */
 
     sock = socket(PF_INET,SOCK_STREAM,0);
     fprintf(stderr,"srcp: %x port: %x IP: %x sock: %d type: %d\n",srcport,port,he->h_addr,sock,socktype);
@@ -742,10 +746,10 @@ Jim_OnLoad(Jim_Interp *interp)
 Jim_AioInit(Jim_Interp *interp)
 #endif
 {
-    #ifndef JIM_STATICEXT
+#ifndef JIM_STATICEXT
     Jim_InitExtension(interp);
-    #endif
 	Jim_ImportEventloopAPI(interp);
+#endif
     if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG) != JIM_OK)
         return JIM_ERR;
     Jim_CreateCommand(interp, "aio.open", JimAioOpenCommand, NULL, NULL);
diff --git a/jim-eventloop.c b/jim-eventloop.c
index 4a7acba..2dbb47c 100644
--- a/jim-eventloop.c
+++ b/jim-eventloop.c
@@ -1,22 +1,43 @@
-/* Jim - Event Loop extension
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * A copy of the license is also included in the source distribution
- * of Jim, as a TXT file name called LICENSE.
+/* Jim - A small embeddable Tcl interpreter
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+ * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
+ * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
+ * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 
+ * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
+ * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
+ * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
+ * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
+ * 
+ * The FreeBSD license
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * official policies, either expressed or implied, of the Jim Tcl Project.
+ **/
 /* TODO:
  *
  *  - to really use flags in Jim_ProcessEvents()
@@ -26,8 +47,16 @@
 
 #define JIM_EXTENSION
 #define __JIM_EVENTLOOP_CORE__
+#ifdef __ECOS
+#include <pkgconf/jimtcl.h>
+#endif
+#ifdef __ECOS
+#include <cyg/jimtcl/jim.h>
+#include <cyg/jimtcl/jim-eventloop.h>
+#else
 #include "jim.h"
 #include "jim-eventloop.h"
+#endif
 
 /* POSIX includes */
 #include <sys/time.h>
diff --git a/jim-eventloop.h b/jim-eventloop.h
index caf89d7..e09170e 100644
--- a/jim-eventloop.h
+++ b/jim-eventloop.h
@@ -1,22 +1,44 @@
-/* Jim eventloop extension
- * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
- *
-  * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
+/* Jim - A small embeddable Tcl interpreter
  *
- * A copy of the license is also included in the source distribution
- * of Jim, as a TXT file name called LICENSE.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ------ USAGE -------
+ * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
+ * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
+ * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net> 
+ * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
+ * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
+ * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
+ * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
+ * 
+ * The FreeBSD license
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * official policies, either expressed or implied, of the Jim Tcl Project.
+ **/
+/* ------ USAGE -------
  *
  * In order to use this file from other extensions include it in every
  * file where you need to call the eventloop API, also in the init
@@ -75,7 +97,7 @@ JIM_STATIC int JIM_API(Jim_ProcessEvents) (Jim_Interp *interp, int flags);
 #define JIM_GET_API(name) \
     Jim_GetApi(interp, "Jim_" #name, ((void *)&Jim_ ## name))
 
-#if defined JIM_EXTENSION || defined JIM_EMBEDDED
+#if defined(JIM_EXTENSION) || defined(JIM_EMBEDDED)
 /* This must be included "inline" inside the extension */
 static void Jim_ImportEventloopAPI(Jim_Interp *interp)
 {