Basic signal handling

src/dds/compile.cpp

 
 #include <dds/proc.hpp>
 #include <dds/util/algo.hpp>
+#include <dds/util/signal.hpp>
 
 #include <spdlog/spdlog.h>
 
             lk.unlock();
             try {
                 compilation.compile(tc);
+                cancellation_point();
             } catch (...) {
                 lk.lock();
                 exceptions.push_back(std::current_exception());

src/dds/ddslim.main.cpp

         return 1;
     }
 
+    dds::install_signal_handlers();
+
     try {
         if (build.cmd) {
             return build.run();

src/dds/proc.nix.cpp

 #ifndef _WIN32
 #include "./proc.hpp"
 
+#include <dds/util/signal.hpp>
+
 #include <spdlog/fmt/fmt.h>
 
 #include <poll.h>
 
     while (true) {
         rc = ::poll(&stdio_fd, 1, -1);
+        if (rc && errno == EINTR) {
+            errno = 0;
+            continue;
+        }
         check_rc(rc > 0, "Failed in poll()");
         std::string buffer;
         buffer.resize(1024);
     } else if (WIFSIGNALED(status)) {
         res.signal = WTERMSIG(status);
     }
+
+    cancellation_point();
     return res;
 }
 

src/dds/util/signal.cpp

+#include "./signal.hpp"
+
+#include <csignal>
+
+namespace {
+
+std::sig_atomic_t got_signal = 0;
+
+void handle_signal(int sig) { got_signal = sig; }
+
+}  // namespace
+
+using namespace dds;
+
+void dds::notify_cancel() noexcept { got_signal = SIGINT; }
+
+void dds::install_signal_handlers() noexcept {
+    std::signal(SIGINT, handle_signal);
+    std::signal(SIGTERM, handle_signal);
+}
+
+bool dds::is_cancelled() noexcept { return got_signal != 0; }
+void dds::cancellation_point() {
+    if (is_cancelled()) {
+        throw user_cancelled();
+    }
+}

src/dds/util/signal.hpp

+#pragma once
+
+#include <stdexcept>
+
+namespace dds {
+
+class user_cancelled : public std::exception {};
+
+void install_signal_handlers() noexcept;
+
+void notify_cancel() noexcept;
+void reset_cancelled() noexcept;
+bool is_cancelled() noexcept;
+void cancellation_point();
+
+}  // namespace dds