Merge pull request #93 from TOPLLab/fix/91

Fix/91

Author: tolauwae

platforms/Arduino/Arduino.ino

@@ -21,12 +21,12 @@ Module* m;
 #define UART_PIN 3
 
 void startDebuggerStd(void* pvParameter) {
+    Channel* sink = new Sink(stdout);
+    wac->debugger->setChannel(sink);
+    sink->open();
+
     uint8_t buffer[1024] = {0};
-    wac->debugger->setChannel(fileno(stdout));
-    write(fileno(stdout), "Got a message ... \n", 19);
     while (true) {
-        // taskYIELD();
-        // vTaskDelay(100 / portTICK_PERIOD_MS);
         yield();
 
         while (Serial.available()) {

platforms/CLI-Emulator/main.cpp

@@ -49,6 +49,9 @@ void print_help() {
             "binaries (default: wat2wasm)\n");
     fprintf(stdout,
             "    --file         Wasm file (module) to load and execute\n");
+    fprintf(stdout,
+            "    --no-debug     Run without debug thread"
+            "(default: false)\n");
     fprintf(stdout,
             "    --no-socket    Run debug on stdout"
             "(default: false)\n");
@@ -106,37 +109,20 @@ Module *load(WARDuino wac, const char *file_name, Options opt) {
     return nullptr;
 }
 
-void startDebuggerStd(WARDuino *wac, Module *m) {
-    int valread;
-    uint8_t buffer[1024] = {0};
-    wac->debugger->setChannel(fileno(stdout));
-    while (true) {
-        debug("waiting for debug command\n");
-        while ((valread = read(fileno(stdin), buffer, 1024)) != -1) {
-            write(fileno(stdout), "got a message ... \n", 19);
-            wac->handleInterrupt(valread - 1, buffer);
-            write(fileno(stdout), buffer, valread);
-            fflush(stdout);
-        }
+void *startDebuggerCommunication(void *arg) {
+    Channel *duplex = WARDuino::instance()->debugger->channel;
+    if (duplex == nullptr) {
+        return nullptr;
     }
-}
 
-void startDebuggerSocket(WARDuino *wac, Module *m, int port = 8192) {
-    int socket_fd = createSocketFileDescriptor();
-    struct sockaddr_in address = createAddress(port);
-    bindSocketToAddress(socket_fd, address);
-    startListening(socket_fd);
-    printf("Listening on port 172.0.0.1:%i\n", port);
+    duplex->open();
 
     ssize_t valread;
     uint8_t buffer[1024] = {0};
     while (true) {
-        int socket = listenForIncomingConnection(socket_fd, address);
-        wac->debugger->setChannel(socket);
-        while ((valread = read(socket, buffer, 1024)) != -1) {
-            write(socket, "got a message ... \n", 19);
-            wac->handleInterrupt(valread - 1, buffer);
-            write(socket, buffer, valread);
+        while ((valread = duplex->read(buffer, 1024)) != -1) {
+            duplex->write("got a message ... \n", 19);
+            WARDuino::instance()->handleInterrupt(valread - 1, buffer);
         }
     }
 }
@@ -165,18 +151,31 @@ int connectToProxyFd(const char *proxyfd) { return open(proxyfd, O_RDWR); }
 WARDuino *wac = WARDuino::instance();
 Module *m;
 
-void *runWAC(void *p) {
-    // Print value received as argument:
-    dbg_info("\n=== STARTED INTERPRETATION (in separate thread) ===\n");
-    wac->run_module(m);
-    wac->unload_module(m);
+struct debugger_options {
+    const char *socket;
+    bool no_socket;
+};
+
+void *setupDebuggerCommunication(debugger_options *options) {
+    dbg_info("\n=== STARTED DEBUGGER (in separate thread) ===\n");
+    // Start debugger
+    Channel *duplex;
+    if (options->no_socket) {
+        duplex = new Duplex(stdin, stdout);
+    } else {
+        int port = std::stoi(options->socket);
+        duplex = new WebSocket(port);
+    }
+
+    wac->debugger->setChannel(duplex);
 }
 
 int main(int argc, const char *argv[]) {
     ARGV_SHIFT();  // Skip command name
 
     bool return_exception = true;
     bool run_tests = false;
+    bool no_debug = false;
     bool no_socket = false;
     const char *socket = "8192";
     bool paused = false;
@@ -207,6 +206,8 @@ int main(int argc, const char *argv[]) {
             ARGV_GET(asserts_file);
         } else if (!strcmp("--watcompiler", arg)) {
             ARGV_GET(watcompiler);
+        } else if (!strcmp("--no-debug", arg)) {
+            no_debug = true;
         } else if (!strcmp("--no-socket", arg)) {
             no_socket = true;
         } else if (!strcmp("--socket", arg)) {
@@ -248,24 +249,23 @@ int main(int argc, const char *argv[]) {
             // Run in proxy mode
             wac->debugger->proxify();
         } else if (proxy) {
-            int connection = -1;
-
             // Connect to proxy device
+            Channel *connection = nullptr;
             try {
                 int port = std::stoi(proxy);
-                connection = connectToProxySocket(port);
+                connection = new WebSocket(port);
             } catch (std::invalid_argument const &ex) {
                 // argument is not a port
                 // treat as filename
-                connection = connectToProxyFd(proxy);
+                connection = new FileDescriptorChannel(open(proxy, O_RDWR));
             } catch (std::out_of_range const &ex) {
                 // argument is an integer but is out of range
                 fprintf(stderr,
                         "wdcli: out of range integer argument for --proxy\n");
                 return 1;
             }
 
-            if (connection < 0) {
+            if (connection == nullptr) {
                 // Failed to connect stop program
                 fprintf(stderr, "wdcli: failed to connect to proxy device\n");
                 return 1;
@@ -275,16 +275,25 @@ int main(int argc, const char *argv[]) {
             wac->debugger->startProxySupervisor(connection);
         }
 
-        // Run Wasm module (new thread)
+        // Start debugger (new thread)
         pthread_t id;
-        pthread_create(&id, nullptr, runWAC, nullptr);
-
-        // Start debugger
-        if (no_socket) {
-            startDebuggerStd(wac, m);
-        } else {
-            startDebuggerSocket(wac, m, std::stoi(socket));
+        if (!no_debug) {
+            auto *options =
+                (debugger_options *)malloc(sizeof(struct debugger_options));
+            options->no_socket = no_socket;
+            options->socket = socket;
+            setupDebuggerCommunication(options);
+            free(options);
+
+            pthread_create(&id, nullptr, startDebuggerCommunication, nullptr);
         }
+
+        // Run Wasm module
+        dbg_info("\n=== STARTED INTERPRETATION (main thread) ===\n");
+        wac->run_module(m);
+        wac->unload_module(m);
+        wac->debugger->stop();
+
         int *ptr;
         pthread_join(id, (void **)&ptr);
     }

platforms/ESP-IDF/main.cpp

@@ -28,18 +28,19 @@ WARDuino* wac = WARDuino::instance();
 Module* m;
 
 void startDebuggerStd(void* pvParameter) {
+    Channel* duplex = new Duplex(stdin, stdout);
+    wac->debugger->setChannel(duplex);
+    duplex->open();
+
     int valread;
     uint8_t buffer[1024] = {0};
-    wac->debugger->setChannel(fileno(stdout));
     while (true) {
         taskYIELD();
         vTaskDelay(1000 / portTICK_PERIOD_MS);
 
-        while ((valread = read(fileno(stdin), buffer, 1024)) != -1) {
-            write(fileno(stdout), "got a message ... \n", 19);
+        while ((valread = duplex->read(buffer, 1024)) != -1) {
+            duplex->write("got a message ... \n", 19);
             wac->handleInterrupt(valread - 1, buffer);
-            write(fileno(stdout), buffer, valread);
-            fflush(stdout);
         }
     }
 }

src/Debug/debugger.cpp

@@ -17,13 +17,13 @@
 
 // Debugger
 
-Debugger::Debugger(int address) { this->channel = new Channel(address); }
+Debugger::Debugger(Channel *duplex) { this->channel = duplex; }
 
 // Public methods
 
-void Debugger::setChannel(int address) {
+void Debugger::setChannel(Channel *duplex) {
     delete this->channel;
-    this->channel = new Channel(address);
+    this->channel = duplex;
 }
 
 void Debugger::addDebugMessage(size_t len, const uint8_t *buff) {
@@ -152,6 +152,7 @@ bool Debugger::checkDebugMessages(Module *m, RunningState *program_state) {
             break;
         case interruptHALT:
             this->channel->write("STOP!\n");
+            this->channel->close();
             free(interruptData);
             exit(0);
         case interruptPAUSE:
@@ -1014,7 +1015,7 @@ void Debugger::handleMonitorProxies(Module *m, uint8_t *interruptData) {
     this->channel->write("done!\n");
 }
 
-void Debugger::startProxySupervisor(int socket) {
+void Debugger::startProxySupervisor(Channel *socket) {
     this->connected_to_proxy = true;
     pthread_mutex_init(&this->supervisor_mutex, nullptr);
     pthread_mutex_lock(&this->supervisor_mutex);
@@ -1026,7 +1027,7 @@ void Debugger::startProxySupervisor(int socket) {
 bool Debugger::proxy_connected() const { return this->connected_to_proxy; }
 
 void Debugger::disconnect_proxy() {
-    if (this->proxy_connected()) {
+    if (!this->proxy_connected()) {
         return;
     }
     int *ptr;
@@ -1047,3 +1048,11 @@ void Debugger::updateCallbackmapping(Module *m, const char *data) {
         }
     }
 }
+
+// Stop the debugger
+void Debugger::stop() {
+    if (this->channel != nullptr) {
+        this->channel->close();
+        this->channel = nullptr;
+    }
+}

src/Debug/debugger.h

@@ -137,9 +137,13 @@ class Debugger {
         nullptr;  // Breakpoint to skip in the next interpretation step
 
     // Constructor
-    explicit Debugger(int address);
+    explicit Debugger(Channel *duplex);
 
-    void setChannel(int address);
+    void setChannel(Channel *duplex);
+
+    // Public methods
+
+    void stop();
 
     // Interrupts
 
@@ -174,7 +178,7 @@ class Debugger {
 
     bool isProxied(uint32_t fidx) const;
 
-    void startProxySupervisor(int socket);
+    void startProxySupervisor(Channel *socket);
 
     bool proxy_connected() const;
 

src/Edward/proxy_supervisor.cpp

@@ -56,9 +56,9 @@ Event *parseJSON(char *buff) {
     return new Event(*parsed.find("topic"), payload);
 }
 
-ProxySupervisor::ProxySupervisor(int socket, pthread_mutex_t *mutex) {
+ProxySupervisor::ProxySupervisor(Channel *duplex, pthread_mutex_t *mutex) {
     printf("Started supervisor.\n");
-    this->channel = new Channel(socket);
+    this->channel = duplex;
     this->mutex = mutex;
 
     pthread_create(&this->threadid, nullptr, readSocket, this);

src/Edward/proxy_supervisor.h

@@ -20,7 +20,7 @@ class ProxySupervisor {
     void deserializeRFCResult(RFC *rfc);
 
    public:
-    ProxySupervisor(int socket, pthread_mutex_t *mutex);
+    ProxySupervisor(Channel *duplex, pthread_mutex_t *mutex);
 
     void startPushDebuggerSocket();
 

src/Primitives/emulated.cpp

@@ -268,7 +268,7 @@ def_prim(print_string, twoToNoneU32) {
     uint32_t size = arg0.uint32;
     std::string text = parse_utf8_string(m->memory.bytes, size, addr);
     debug("EMU: print string at %i: ", addr);
-    printf("%s\n", text.c_str());
+    printf("%s", text.c_str());
     pop_args(2);
     return true;
 }