Merge branch 'feat/wood' of github.com:TOPLLab/WARDuino into feat/wood

Author: Carlos Rojas

.github/workflows/compile.yml

@@ -46,6 +46,7 @@ jobs:
     fill-out-template:
         name: Fill out template files
         runs-on: ubuntu-latest
+        if: github.event.pull_request.draft == false
         steps:
             - name: Checkout
               uses: actions/checkout@v2

documentation/OutOfPlaceDebugging.md

@@ -32,3 +32,6 @@ The supported interrupt messages:
 3. `interruptPOPEvent (0x72)` tells the VM to remove the event at the front of the queue and process it.
 4. `interruptPUSHEvent (0x73)` this messages' code is followed by a json representation of an event to be pushed on the
    stack.
+5. `interruptDUMPCallbackmapping (0x74)` requests a dump of the current callback mapping as json.
+6. `interruptRecvCallbackmapping (0x75)` sends a callback mapping as json to replace the current callback mapping.
+

src/Debug/debugger.cpp

@@ -21,7 +21,14 @@ Debugger::Debugger(int socket) { this->socket = socket; }
 
 void Debugger::addDebugMessage(size_t len, const uint8_t *buff) {
     uint8_t *data = this->parseDebugBuffer(len, buff);
-    if (data != nullptr) {
+    if (data != nullptr && *data == interruptRecvCallbackmapping) {
+        std::string text = (char *)buff;
+        auto *msg =
+            (uint8_t *)acalloc(sizeof(uint8_t), len, "interrupt buffer");
+        memcpy(msg, buff, len * sizeof(uint8_t));
+        *msg = *data;
+        this->debugMessages.push_back(msg);
+    } else if (data != nullptr) {
         this->debugMessages.push_back(data);
     }
 }
@@ -235,13 +242,20 @@ bool Debugger::checkDebugMessages(Module *m, RunningState *program_state) {
             dprintf(this->socket, "}\n");
             break;
         case interruptPOPEvent:
-            CallbackHandler::resolve_event();
+            CallbackHandler::resolve_event(true);
             break;
 #ifndef ARDUINO
         case interruptPUSHEvent:
             this->handlePushedEvent(m, reinterpret_cast<char *>(interruptData));
             break;
+        case interruptRecvCallbackmapping:
+            this->updateCallbackmapping(
+                m, reinterpret_cast<const char *>(interruptData + 2));
+            break;
 #endif
+        case interruptDUMPCallbackmapping:
+            this->dumpCallbackmapping();
+            break;
         default:
             // handle later
             dprintf(this->socket, "COULD not parse interrupt data!\n");
@@ -458,6 +472,10 @@ void Debugger::dumpEvents(long start, long size) const {
     CallbackHandler::resolving_event = false;
 }
 
+void Debugger::dumpCallbackmapping() const {
+    dprintf(this->socket, "%s\n", CallbackHandler::dump_callbacks().c_str());
+}
+
 /**
  * Read the change in bytes array.
  *
@@ -979,4 +997,17 @@ void Debugger::disconnect_drone() {
     pthread_mutex_unlock(&this->push_mutex);
     pthread_join(this->push_debugging_threadid, (void **)&ptr);
 }
+
+void Debugger::updateCallbackmapping(Module *m, const char *data) const {
+    nlohmann::basic_json<> parsed = nlohmann::json::parse(data);
+    CallbackHandler::clear_callbacks();
+    nlohmann::basic_json<> callbacks = *parsed.find("callbacks");
+    for (auto &array : callbacks.items()) {
+        auto callback = array.value().begin();
+        for (auto &functions : callback.value().items()) {
+            CallbackHandler::add_callback(
+                Callback(m, callback.key(), functions.value()));
+        }
+    }
+}
 #endif

src/Debug/debugger.h

@@ -42,7 +42,9 @@ enum InterruptTypes {
     interruptDUMPAllEvents = 0x70,
     interruptDUMPEvents = 0x71,
     interruptPOPEvent = 0x72,
-    interruptPUSHEvent = 0x73
+    interruptPUSHEvent = 0x73,
+    interruptDUMPCallbackmapping = 0x74,
+    interruptRecvCallbackmapping = 0x75
 };
 
 class Debugger {
@@ -92,6 +94,8 @@ class Debugger {
 
     void dumpEvents(long start, long size) const;
 
+    void dumpCallbackmapping() const;
+
     //// Handle live code update
 
     static bool handleChangedFunction(Module *m, uint8_t *bytes);
@@ -108,6 +112,9 @@ class Debugger {
 
     static uintptr_t readPointer(uint8_t **data);
 
+#ifndef ARDUINO
+    void updateCallbackmapping(Module *m, const char *interruptData) const;
+#endif
    public:
     // Public fields
 

src/WARDuino/CallbackHandler.cpp

@@ -71,7 +71,7 @@ void CallbackHandler::push_event(Event *event) {
     }
 }
 
-bool CallbackHandler::resolve_event() {
+bool CallbackHandler::resolve_event(bool force) {
     if (CallbackHandler::resolving_event || CallbackHandler::events->empty()) {
         return false;
     }
@@ -87,8 +87,8 @@ bool CallbackHandler::resolve_event() {
     }
 #endif
 
-    if (CallbackHandler::manual_event_resolution ||
-        WARDuino::instance()->program_state == WARDUINOpause) {
+    if (!force && (CallbackHandler::manual_event_resolution ||
+                   WARDuino::instance()->program_state == WARDUINOpause)) {
         return true;
     }
 
@@ -126,6 +126,28 @@ std::deque<Event>::const_iterator CallbackHandler::event_end() {
     return CallbackHandler::events->cend();
 }
 
+void CallbackHandler::clear_callbacks() { CallbackHandler::callbacks->clear(); }
+
+std::string CallbackHandler::dump_callbacks() {
+    std::string repr = R"({"callbacks": [)";
+    auto iterator = CallbackHandler::callbacks->begin();
+    while (iterator != CallbackHandler::callbacks->end()) {
+        repr += R"({")" + iterator->first + R"(": [)";
+        for (const auto &value : *iterator->second) {
+            auto callback = std::begin(*iterator->second);
+            while (callback != std::end(*iterator->second)) {
+                repr += std::to_string(callback->table_index);
+                repr += (++callback != iterator->second->end()) ? ", " : "";
+            }
+        }
+        iterator++;
+        repr += "]}";
+        repr += (iterator != CallbackHandler::callbacks->end()) ? ", " : "";
+    }
+    repr += "]}";
+    return repr;
+}
+
 // Callback class
 
 Callback::Callback(Module *m, std::string id, uint32_t tidx) {

src/WARDuino/CallbackHandler.h

@@ -39,11 +39,13 @@ class CallbackHandler {
 
     static void add_callback(const Callback &c);
     static void remove_callback(const Callback &c);
+    static void clear_callbacks();
+    static std::string dump_callbacks();
     static size_t callback_count(const std::string &topic);
     static void push_event(std::string topic, const unsigned char *payload,
                            unsigned int length);
     static void push_event(Event *event);
-    static bool resolve_event();
+    static bool resolve_event(bool force = false);
 
     // WOOD needed to know when to push events
     static bool manual_event_resolution;