Add interruptINVOKE

Move readArgs code from Proxy to util.cpp

Author: tolauwae

src/Debug/debugger.cpp

@@ -227,6 +227,10 @@ bool Debugger::checkDebugMessages(Module *m, RunningState *program_state) {
             this->handleUpdateModule(m, interruptData);
             free(interruptData);
             break;
+        case interruptINVOKE:
+            this->handleInvoke(m, interruptData);
+            free(interruptData);
+            break;
         case interruptWOODDUMP:
             *program_state = WARDUINOpause;
             free(interruptData);
@@ -350,6 +354,15 @@ uint8_t *Debugger::findOpcode(Module *m, Block *block) {
     return opcode;
 }
 
+void Debugger::handleInvoke(Module *m, uint8_t *interruptData) {
+    uint32_t fidx = read_L32(&interruptData);
+
+    Type func = *m->functions[fidx].type;
+    StackValue *args = readArgs(func, interruptData);
+
+    WARDuino::instance()->invoke(m, fidx, func.param_count, args);
+}
+
 void Debugger::handleInterruptRUN(Module *m, RunningState *program_state) {
     this->channel->write("GO!\n");
     if (*program_state == WARDUINOpause && this->isBreakpoint(m->pc_ptr)) {

src/Debug/debugger.h

@@ -46,6 +46,9 @@ enum InterruptTypes {
     interruptUPDATELocal = 0x21,
     interruptUPDATEModule = 0x22,
 
+    // Remote REPL
+    interruptINVOKE = 0x40,
+
     // Pull Debugging
     interruptWOODDUMP = 0x60,
     interruptOffset = 0x61,
@@ -94,6 +97,10 @@ class Debugger {
 
     void pushMessage(uint8_t *msg);
 
+    //// Handle REPL interrupts
+
+    void handleInvoke(Module *m, uint8_t *interruptData);
+
     //// Handle Interrupt Types
 
     void handleInterruptRUN(Module *m, RunningState *program_state);

src/Edward/proxy.cpp

@@ -99,53 +99,7 @@ char *printValue(StackValue *v) {
 }
 
 StackValue *Proxy::readRFCArgs(Block *func, uint8_t *data) {
-    if (func->type->param_count == 0) {
-        printf("ProxyFunc %" PRIu32 "takes no arg\n", func->fidx);
-        return nullptr;
-    }
-
-    auto *args = new StackValue[func->type->param_count];
-    uint32_t *params = func->type->params;
-    for (uint32_t i = 0; i < func->type->param_count; i++) {
-        args[i].value.uint64 = 0;  // init whole union to 0
-        args[i].value_type = params[i];
-
-        switch (params[i]) {
-            case I32: {
-                memcpy(&args[i].value.uint32, data, sizeof(uint32_t));
-                data += sizeof(uint32_t);
-                printf("arg %" PRIu32 ": i32 value %" PRIu32 "\n", i,
-                       args[i].value.uint32);
-                break;
-            }
-            case F32: {
-                memcpy(&args[i].value.f32, data, sizeof(float));
-                data += sizeof(float);
-                printf("arg %" PRIu32 ": F32 value %.7f \n", i,
-                       args[i].value.f32);
-                break;
-            }
-            case I64: {
-                memcpy(&args[i].value.uint64, data, sizeof(uint64_t));
-                data += sizeof(uint64_t);
-                printf("arg %" PRIu32 ": I64 value %" PRIu64 "\n", i,
-                       args[i].value.uint64);
-                break;
-            }
-            case F64: {
-                memcpy(&args[i].value.f64, data, sizeof(double));
-                data += sizeof(double);
-                printf("arg %" PRIu32 ": f64 value %.7f \n", i,
-                       args[i].value.f64);
-                break;
-            }
-            default: {
-                FATAL("incorrect argument type: %" PRIu32 "\n", params[i]);
-                break;
-            }
-        }
-    }
-    return args;
+    return readArgs(*func->type, data);
 }
 
 void Proxy::setupCalleeArgs(Module *m, RFC *callee) {

src/Utils/util.cpp

@@ -5,6 +5,40 @@
 
 #include "macros.h"
 
+StackValue *readArgs(Type function, uint8_t *data) {
+    auto *args = new StackValue[function.param_count];
+    for (uint32_t i = 0; i < function.param_count; i++) {
+        args[i] = {static_cast<uint8_t>(function.params[i]), {0}};
+
+        switch (args[i].value_type) {
+            case I32: {
+                memcpy(&args[i].value.uint32, data, sizeof(uint32_t));
+                data += sizeof(uint32_t);
+                break;
+            }
+            case F32: {
+                memcpy(&args[i].value.f32, data, sizeof(float));
+                data += sizeof(float);
+                break;
+            }
+            case I64: {
+                memcpy(&args[i].value.uint64, data, sizeof(uint64_t));
+                data += sizeof(uint64_t);
+                break;
+            }
+            case F64: {
+                memcpy(&args[i].value.f64, data, sizeof(double));
+                data += sizeof(double);
+                break;
+            }
+            default: {
+                FATAL("no argument of type %" PRIu32 "\n", args[i].value_type);
+            }
+        }
+    }
+    return args;
+}
+
 // Little endian base (LED128)
 
 uint64_t read_LEB_(uint8_t **pos, uint32_t maxbits, bool sign) {

src/Utils/util.h

@@ -6,6 +6,17 @@
 #include <cstdlib>
 #include <string>
 
+#include "../WARDuino.h"
+
+/**
+ * Read arguments for function from binary data.
+ *
+ * @param type
+ * @param data
+ * @return The arguments as a list of StackValues. Returns nullptr for arity 0.
+ */
+StackValue *readArgs(Type function, uint8_t *data);
+
 /**
  * Read a Little endian base value of 32 bits
  * see: https://en.wikipedia.org/wiki/LEB128