more attempts at the JS interrupt code - don't allow interruption of JS that's already interrupted

Author: gfwilliams

src/jsinteractive.c

@@ -25,6 +25,7 @@
 #include "jsflash.h" // load and save to flash
 #include "jswrap_interactive.h" // jswrap_interactive_setTimeout
 #include "jswrap_object.h" // jswrap_object_keys_or_property_names
+#include "jswrap_timer.h" // jstOnRunInterruptJSEvent
 #include "jsnative.h" // jsnSanityTest
 #include "jswrap_storage.h" // for Packet Transfer IO
 #ifdef USE_FILESYSTEM
@@ -2204,21 +2205,6 @@ void jsiHandleIOEventForConsole(uint8_t *eventData, int eventLen) {
   jsiSetBusy(BUSY_INTERACTIVE, false);
 }
 
-/** This is called if a EV_RUN_INTERRUPT_JS is received, or when a EXEC_RUN_INTERRUPT_JS is set.
-It executes JavaScript code that was pushed to the queue by a require("timer").add({type:"EXEC", fn:myFunction... */
-static void jsiOnRunInterruptJSEvent(const uint8_t *eventData, unsigned int eventLen) {
-  for (unsigned int i=0;i<eventLen;i++) {
-    uint8_t timerIdx = eventData[i];
-    JsVar *timerFns = jsvObjectGetChildIfExists(execInfo.hiddenRoot, JSI_TIMER_RUN_JS_NAME);
-    if (timerFns) {
-      JsVar *fn = jsvGetArrayItem(timerFns, timerIdx);
-      if (jsvIsFunction(fn))
-        jsvUnLock(jspExecuteFunction(fn, execInfo.root, 0, NULL));
-      jsvUnLock2(timerFns, fn);
-    }
-  }
-}
-
 void jsiIdle() {
   // This is how many times we have been here and not done anything.
   // It will be zeroed if we do stuff later
@@ -2264,7 +2250,7 @@ void jsiIdle() {
       jsvUnLock(usartClass);
 #endif
     } else if (eventType == EV_RUN_INTERRUPT_JS) {
-      jsiOnRunInterruptJSEvent(eventData, eventLen);
+      jstOnRunInterruptJSEvent(eventData, eventLen);
     } else if (eventType == EV_CUSTOM) {
       jstOnCustomEvent(eventFlags, eventData, eventLen);
       jswOnCustomEvent(eventFlags, eventData, eventLen);
@@ -3021,13 +3007,4 @@ void jsiDebuggerLine(JsVar *line) {
 }
 #endif // USE_DEBUGGER
 
-/** This is called from the parser if EXEC_RUN_INTERRUPT_JS is set.
-It executes JavaScript code that was pushed to the queue by require("timer").add({type:"EXEC", fn:myFunction... */
-void jsiRunInterruptingJS() {
-  uint8_t data[IOEVENT_MAX_LEN];
-  memset(data, 0, sizeof(data));
-  unsigned int len;
-  if (jshPopIOEventOfType(EV_RUN_INTERRUPT_JS, data, &len))
-    jsiOnRunInterruptJSEvent(data, sizeof(data));
-}
 

src/jsinteractive.h

@@ -202,8 +202,4 @@ extern void jsiTimersChanged(); // Flag timers changed so we can skip out of the
 extern void jsiDebuggerLoop(); ///< Enter the debugger loop
 #endif
 
-/** This is called from the parser if EXEC_RUN_INTERRUPT_JS is set.
-It executes JavaScript code that was pushed to the queue by require("timer").add({type:"EXEC", fn:myFunction... */
-void jsiRunInterruptingJS();
-
 #endif /* JSINTERACTIVE_H_ */

src/jsparse.c

@@ -20,6 +20,7 @@
 #include "jswrap_json.h" // for jsfPrintJSON
 #include "jswrap_espruino.h" // for jswrap_espruino_memoryArea
 #include "jswrap_string.h" // for jswrap_string_charAt
+#include "jswrap_timer.h" // jstRunInterruptingJS
 #ifndef ESPR_NO_REGEX
 #include "jswrap_regexp.h" // for jswrap_regexp_constructor
 #endif
@@ -2951,17 +2952,22 @@ NO_INLINE JsVar *jspeStatementFunctionDecl(bool isClass) {
 }
 
 NO_INLINE JsVar *jspeStatement() {
+  if (execInfo.execute&(EXEC_RUN_INTERRUPT_JS
 #ifdef USE_DEBUGGER
-  if (execInfo.execute&EXEC_DEBUGGER_NEXT_LINE &&
-      lex->tk!=';' &&
-      JSP_SHOULD_EXECUTE) {
-    lex->tokenLastStart = lex->tokenStart;
-    jsiDebuggerLoop();
-  }
+    |EXEC_DEBUGGER_NEXT_LINE
 #endif
-  if (execInfo.execute&EXEC_RUN_INTERRUPT_JS) {
-    execInfo.execute&=~EXEC_RUN_INTERRUPT_JS;
-    jsiRunInterruptingJS();
+  )) {
+#ifdef USE_DEBUGGER
+    if (execInfo.execute&EXEC_DEBUGGER_NEXT_LINE &&
+        lex->tk!=';' &&
+        JSP_SHOULD_EXECUTE) {
+      lex->tokenLastStart = lex->tokenStart;
+      jsiDebuggerLoop();
+    }
+#endif
+    if (execInfo.execute&EXEC_RUN_INTERRUPT_JS) {
+      jstRunInterruptingJS();
+    }
   }
   if (lex->tk==LEX_ID ||
       lex->tk==LEX_INT ||

src/jsparse.h

@@ -129,7 +129,7 @@ typedef enum  {
   EXEC_NO_PARSE_MASK = EXEC_INTERRUPTED|EXEC_ERROR, ///< in these cases we should exit as fast as possible - skipping out of parsing
   EXEC_SAVE_RESTORE_MASK = EXEC_YES|EXEC_BREAK|EXEC_CONTINUE|EXEC_RETURN|EXEC_IN_LOOP|EXEC_IN_SWITCH|EXEC_ERROR_MASK, ///< the things JSP_SAVE/RESTORE_EXECUTE should keep track of
   EXEC_CTRL_C_MASK = EXEC_CTRL_C | EXEC_CTRL_C_WAIT, ///< Ctrl-C was pressed at some point
-  EXEC_PERSIST = EXEC_ERROR_MASK|EXEC_CTRL_C_MASK, ///< Things we should keep track of even after executing
+  EXEC_PERSIST = EXEC_ERROR_MASK|EXEC_CTRL_C_MASK|EXEC_RUN_INTERRUPT_JS, ///< Things we should keep track of even after executing
 } JsExecFlags;
 
 /** This structure is used when parsing the JavaScript. It contains

src/jstimer.c

@@ -357,6 +357,7 @@ bool utilTimerRemoveTask(int id) {
     // now we're at the last timer task - work back until we've just gone back past utilTimerTasksTail
     while (ptr != endPtr) {
       if (utilTimerTasks[ptr]==id) {
+        utilTimerTaskInfo[utilTimerTasks[ptr]].type |= UET_FINISHED;
         // shift tail back along
         unsigned char next = (ptr+UTILTIMERTASK_TASKS-1) & (UTILTIMERTASK_TASKS-1);
         while (next!=endPtr) {
@@ -594,8 +595,8 @@ bool jstSetWakeUp(JsSysTime period) {
     nextTime = utilTimerTaskInfo[utilTimerTasks[utilTimerTasksTail]].time;
   }
   jshInterruptOn();
-
-  if (hasTimer && wakeupTime >= nextTime) {
+  JsSysTime currTime = jshGetSystemTime();
+  if (hasTimer && ((currTime+wakeupTime) >= (utilTimerSetTime+nextTime))) {
     // we already had a timer, and it's going to wake us up sooner.
     // don't create a WAKEUP timer task
     return true;

src/jswrap_timer.c

@@ -32,12 +32,45 @@ require("timer").list()
 
 This replaces `E.dumpTimers()` and `Pin.writeAtTime`
 */
+volatile bool runningInterruptingJS = false;
 
 static void jswrap_timer_queue_interrupt_js(JsSysTime time, void* userdata) {
   uint8_t timerIdx = (uint8_t)(size_t)userdata;
-  jshPushIOCharEvents(EV_RUN_INTERRUPT_JS, (char*)&timerIdx, 1);
-  execInfo.execute |= EXEC_RUN_INTERRUPT_JS;
-  jshHadEvent();
+  // if we were already running interrupting JS, don't interrupt it to run more!
+  if (!runningInterruptingJS) {
+    jshPushIOCharEvents(EV_RUN_INTERRUPT_JS, (char*)&timerIdx, 1);
+    execInfo.execute |= EXEC_RUN_INTERRUPT_JS;
+    jshHadEvent();
+  }
+}
+
+/** This is called if a EV_RUN_INTERRUPT_JS is received, or when a EXEC_RUN_INTERRUPT_JS is set.
+It executes JavaScript code that was pushed to the queue by a require("timer").add({type:"EXEC", fn:myFunction... */
+void jstOnRunInterruptJSEvent(const uint8_t *eventData, unsigned int eventLen) {
+  runningInterruptingJS = true;
+  execInfo.execute &= ~EXEC_RUN_INTERRUPT_JS;
+  for (unsigned int i=0;i<eventLen;i++) {
+    uint8_t timerIdx = eventData[i];
+    JsVar *timerFns = jsvObjectGetChildIfExists(execInfo.hiddenRoot, JSI_TIMER_RUN_JS_NAME);
+    if (timerFns) {
+      JsVar *fn = jsvGetArrayItem(timerFns, timerIdx);
+      if (jsvIsFunction(fn)) {
+        jsvUnLock(jspExecuteFunction(fn, execInfo.root, 0, NULL));
+        jsiCheckErrors(false); // check for any errors and report them
+      }
+      jsvUnLock2(timerFns, fn);
+    }
+  }
+  runningInterruptingJS = false;
+}
+
+/** This is called from the parser if EXEC_RUN_INTERRUPT_JS is set.
+It executes JavaScript code that was pushed to the queue by require("timer").add({type:"EXEC", fn:myFunction... */
+void jstRunInterruptingJS() {
+  uint8_t data[IOEVENT_MAX_LEN];
+  unsigned int len = 0;
+  if (jshPopIOEventOfType(EV_RUN_INTERRUPT_JS, data, &len))
+    jstOnRunInterruptJSEvent(data, len);
 }
 
 

src/jswrap_timer.h

@@ -20,3 +20,11 @@ JsVar *jswrap_timer_list();
 JsVar *jswrap_timer_get(int id);
 int jswrap_timer_add(JsVar *timer);
 void jswrap_timer_remove(int id);
+
+/** This is called if a EV_RUN_INTERRUPT_JS is received, or when a EXEC_RUN_INTERRUPT_JS is set.
+It executes JavaScript code that was pushed to the queue by a require("timer").add({type:"EXEC", fn:myFunction... */
+void jstOnRunInterruptJSEvent(const uint8_t *eventData, unsigned int eventLen);
+
+/** This is called from the parser if EXEC_RUN_INTERRUPT_JS is set.
+It executes JavaScript code that was pushed to the queue by require("timer").add({type:"EXEC", fn:myFunction... */
+void jstRunInterruptingJS();