pxt-common-packages 9.3.5 → 9.3.9

package/libs/base/core.cpp

@@ -473,7 +473,7 @@ String concat(String s, String other) {
         if (IS_CONS(other) || IS_CONS(s->cons.right))
             goto mkCons;
         auto lenAR = s->cons.right->getUTF8Size();
-        lenB = other->getUTF8Size();
+        lenB = other->getUTF8Size(); // de-consify other
         if (lenAR + lenB > SHORT_CONCAT_STRING)
             goto mkCons;
         // if (s->cons.right + other) is short enough, use associativity

package/libs/base/gc.cpp

@@ -544,7 +544,11 @@ static void sweep(int flags) {
 
     if (midPtr) {
         uint32_t currFree = 0;
+#ifdef PXT_ESP32
+        auto limit = freeSize * 1 / 4;
+#else
         auto limit = freeSize * 1 / 2;
+#endif
         for (auto p = firstFree; p; p = p->nextFree) {
             auto len = VAR_BLOCK_WORDS(p->vtable);
             currFree += len;
@@ -792,9 +796,11 @@ void *gcAllocate(int numbytes) {
         if (i == 0)
             gc(0);
         // GC didn't help, try new block
-        else if (i == 1)
+        else if (i == 1) {
+            DMESG("gcAlloc(%d) (%d/%d free; %d max block) -> new block", numbytes,
+                  gcStats.lastFreeBytes, gcStats.totalBytes, gcStats.lastMaxBlockBytes);
             allocateBlock();
-        else
+        } else
             // the block allocated was apparently too small
             soft_panic(PANIC_GC_OOM);
     }

package/libs/color/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P133761(s) {
+function _main___P133933(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___134002 = (undefined);
-    globals._pollEventQueue___134015 = (undefined);
+    globals._intervals___134174 = (undefined);
+    globals._pollEventQueue___134187 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P133761.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
-_main___P133761.continuations = [  ]
+_main___P133933.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
+_main___P133933.continuations = [  ]
 
-function _main___P133761_mk(s) {
+function _main___P133933_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P133761, depth: s.depth + 1,
+        parent: s, fn: _main___P133933, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P133761_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P133761
+return _main___P133933
 })

package/libs/core---esp32/pxt.h

@@ -41,7 +41,9 @@ typedef Buffer Sound;
 typedef struct worker *worker_t;
 worker_t worker_alloc(const char *id, uint32_t stack_size);
 int worker_run(worker_t w, TaskFunction_t fn, void *arg);
+int worker_run_wait(worker_t w, TaskFunction_t fn, void *arg);
 void worker_set_idle(worker_t w, TaskFunction_t fn, void *arg);
+extern worker_t fg_worker;
 
 void memInfo();
 

package/libs/core---esp32/usb.cpp

@@ -240,41 +240,66 @@ int HF2::handlePkt(int sz) {
     return sendResponse(0);
 }
 
-void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend) {
-    if (!connected)
-        return;
+struct BufferEntry {
+    unsigned size;
+    uint8_t flag;
+    uint8_t data[0];
+};
 
-    uint32_t buf[64 / 4]; // aligned
+static void send_buffer_core(void *ent_) {
+    auto ent = (BufferEntry *)ent_;
 
-    if (prepend + 1)
-        size += 4;
+    uint32_t buf[64 / 4]; // aligned
+    auto size = ent->size;
+    auto data = ent->data;
 
-    while (connected && size > 0) {
+    while (hf2.connected && size > 0) {
         memset(buf + 1, 0, 60);
         int s = 63;
         if (size <= 63) {
             s = size;
-            buf[0] = flag;
+            buf[0] = ent->flag;
         } else {
-            buf[0] = flag == HF2_FLAG_CMDPKT_LAST ? HF2_FLAG_CMDPKT_BODY : flag;
+            buf[0] = ent->flag == HF2_FLAG_CMDPKT_LAST ? HF2_FLAG_CMDPKT_BODY : ent->flag;
         }
         buf[0] |= s;
         uint8_t *dst = (uint8_t *)buf;
         dst++;
-        if (prepend + 1) {
-            memcpy(dst, &prepend, 4);
-            prepend = -1;
-            dst += 4;
-            s -= 4;
-            size -= 4;
-        }
         memcpy(dst, data, s);
-        data = (const uint8_t *)data + s;
+        data = data + s;
         size -= s;
 
-        tinyusb_cdcacm_write_queue(TINYUSB_CDC_ACM_0, (uint8_t *)buf, sizeof(buf));
+        if (tinyusb_cdcacm_write_queue(TINYUSB_CDC_ACM_0, (uint8_t *)buf, sizeof(buf)) <
+            sizeof(buf))
+            DMESG("CDC write fail");
         // tinyusb_cdcacm_write_flush(TINYUSB_CDC_ACM_0, 0); - prints warnings
     }
+
+    xfree(ent);
+}
+
+void HF2::sendBuffer(uint8_t flag, const void *data, unsigned size, uint32_t prepend) {
+    if (!connected)
+        return;
+
+    if (prepend + 1)
+        size += 4;
+
+    auto ent = (BufferEntry *)xmalloc(sizeof(BufferEntry) + size);
+    ent->size = size;
+    ent->flag = flag;
+    auto dst = ent->data;
+
+    if (prepend + 1) {
+        memcpy(dst, &prepend, 4);
+        dst += 4;
+        size -= 4;
+    }
+
+    memcpy(dst, data, size);
+
+    if (worker_run_wait(fg_worker, send_buffer_core, ent))
+        DMESG("HF2 queue full");
 }
 
 int HF2::sendEvent(uint32_t evId, const void *data, int size) {

package/libs/core---esp32/worker.cpp

@@ -48,4 +48,12 @@ int worker_run(worker_t w, TaskFunction_t fn, void *arg) {
     return -1;
 }
 
+int worker_run_wait(worker_t w, TaskFunction_t fn, void *arg) {
+    qitem_t evt = {fn, arg};
+    if (xQueueSend(w->queue, &evt, 100) == pdPASS)
+        return 0;
+    return -1;
+}
+
+
 }

package/libs/core---vm/scheduler.cpp

@@ -24,11 +24,18 @@
 #define THROW throw()
 #define THREAD_DBG(...)
 
+static uint8_t in_xmalloc_panic;
+
 void *xmalloc(size_t sz) {
     auto r = malloc(sz);
     if (r == NULL) {
         DMESG("failed to allocate %d bytes", sz);
-        oops(50); // shouldn't happen
+        if (in_xmalloc_panic) {
+            target_panic(PANIC_GC_OOM);
+        } else {
+            in_xmalloc_panic = 1;
+            soft_panic(PANIC_GC_OOM); // this can happen on esp32 etc; shouldn't on linux/ios etc
+        }
     }
     return r;
 }

package/libs/core---vm/vm.cpp

@@ -155,12 +155,16 @@ void vm_stack_trace() {
     auto end = vmImg->stackTop;
     auto ptr = ctx->sp;
     DMESG(" PC:%x", (ctx->pc - ctx->imgbase) << 1);
-    while (ptr < end) {
+    int max = 30;
+    while (ptr < end && max) {
         auto v = (uintptr_t)*ptr++;
         if (VM_IS_ENCODED_PC(v)) {
             DMESG(" PC:%x", VM_DECODE_PC(v) << 1);
+            max--;
         }
     }
+    if (max == 0)
+        DMESG(" ...");
 }
 
 //%
@@ -214,18 +218,21 @@ void op_callind(FiberContext *ctx, unsigned arg) {
 void op_ret(FiberContext *ctx, unsigned arg) {
     SPLIT_ARG(retNumArgs, numTmps);
 
-    // check if we're leaving a function that still has open try blocks
-    // (this results from invalid code generation)
-    if (ctx->tryFrame && ctx->tryFrame->registers[0] == (uintptr_t)ctx->currAction) {
-        DMESG("try frame %p left on return", ctx->tryFrame);
-        target_panic(PANIC_VM_ERROR);
-    }
-
     POP(numTmps);
     auto retaddr = (intptr_t)POPVAL();
     ctx->currAction = (RefAction *)POPVAL();
     POP(retNumArgs);
 
+    // check if we're leaving a function that still has open try blocks
+    // (this results from invalid code generation)
+    if (ctx->tryFrame &&
+        ctx->tryFrame->registers[2] < (uint8_t *)ctx->sp - (uint8_t *)vmImg->stackBase) {
+        DMESG("try frame %p left on return %d/%d", ctx->tryFrame, ctx->tryFrame->registers[2],
+              (uint8_t *)ctx->sp - (uint8_t *)vmImg->stackBase);
+        vm_stack_trace();
+        target_panic(PANIC_VM_ERROR);
+    }
+
     if (retaddr == (intptr_t)TAG_STACK_BOTTOM) {
         ctx->pc = NULL;
     } else {