IPC between texedit and tecomp with piped+async subprocesses

IO redirection from tecomp for texedit to recieve its output while
it's run in the background

.tokeignore

@@ -1,5 +1,5 @@
 vendor/
-tests/
+examples/
 deps/
 docs/
 build/

texedit/CMakeLists.txt

@@ -30,7 +30,11 @@ set(SRCS
     "gui/main_frame.cpp"
     "gui/preview_panel.cpp"
     "gui/prog_info.cpp"
+    "process/compiler/tecomp_proc.cpp"
+    "process/process_mgr.cpp"
+    "process/process.cpp"
     "util/log.cpp"
+    "util/resources.cpp"
     "main.cpp"
 )
 

texedit/gui/main_frame.cpp

@@ -7,8 +7,10 @@
 
 #include "main_frame.hpp"
 
+#include "process/process.hpp"
 #include "util/log.hpp"
 #include "util/except.hpp"
+#include "util/resources.hpp"
 #include "command_ids.hpp"
 #include "editor_panel.hpp"
 #include "preview_panel.hpp"
@@ -18,7 +20,9 @@
 #include <wx/splitter.h>
 
 namespace te {
-    MainFrame::MainFrame() : wxFrame(nullptr, wxID_ANY, "TexEdit", wxDefaultPosition, wxSize{1024, 640}) {
+    MainFrame::MainFrame() : wxFrame{nullptr, wxID_ANY, "TexEdit", wxDefaultPosition, wxSize{1024, 640}}, _proc_mgr{this}, _tecomp{_proc_mgr} {
+        _tecomp.Start();
+
         BuildMenuBar();
         BuildSplitLayout();
     }
@@ -64,6 +68,13 @@ namespace te {
         SetMenuBar(menuBar);
     }
 
+    void MainFrame::OnIdle(wxIdleEvent &ev) {
+        wxString s = _proc_mgr.PollPipedOutput();
+        if (!s.IsEmpty()) {
+            std::cout << s;
+        }
+    }
+
     void MainFrame::ShowURL(const std::string &url) {
         if (!wxLaunchDefaultBrowser(url)) {
             util::log::Error("Failed to open URL \"" + url + "\"");
@@ -96,6 +107,7 @@ namespace te {
     }
 
     wxBEGIN_EVENT_TABLE(MainFrame, wxFrame)
+        EVT_IDLE(MainFrame::OnIdle)
         EVT_MENU(wxID_EXIT, MainFrame::OnMenuQuit)
         EVT_MENU(wxID_ABOUT, MainFrame::OnMenuAbout)
         EVT_MENU(cmds::Menu_URLSourcePage, MainFrame::OnMenuURLSourcePage)

texedit/gui/main_frame.hpp

@@ -11,15 +11,23 @@
 
 #include <wx/wx.h>
 
+#include "process/process_mgr.hpp"
+#include "process/compiler/tecomp_proc.hpp"
+
 namespace te {
     class MainFrame : public wxFrame {
     public:
         MainFrame();
 
     private:
+        ProcessManager _proc_mgr;
+        TECompProcess _tecomp;
+
         void BuildSplitLayout();
         void BuildMenuBar();
 
+        void OnIdle(wxIdleEvent &ev);
+
         void ShowURL(const std::string &url);
 
         void OnMenuAbout(wxCommandEvent &event);

texedit/main.cpp

@@ -14,27 +14,44 @@ wxIMPLEMENT_APP(te::Application);
 
 namespace te {
     bool Application::OnExceptionInMainLoop() {
+        wxString what;
         try {
             throw;
         } catch (const std::exception &e) {
-            util::log::Fatal(e.what());
-
-            if (wxMessageBox("An unexpected exception has occurred:\n"
-                             "\"" + std::string{e.what()} + "\"\n\n"
-                             "TexEdit can attempt to keep running so you can save your data. Do you want to try?",
-                             "Fatal Error", wxYES | wxNO | wxICON_ERROR)
-                    == wxYES) {
-                util::log::Warn("Attempting to continue execution following a potentially fatal exception");
-                return true;
-            }
+            what = e.what();
+        } catch (...) {
+            what = "Unknown runtime error";
+        }
+
+        util::log::Fatal(what.ToStdString());
+
+        if (wxMessageBox("An unexpected exception has occurred:\n"
+                         "\"" + what + "\"\n\n"
+                         "TexEdit can attempt to keep running so you can save your data. Do you want to try?",
+                         "Fatal Error", wxYES | wxNO | wxICON_ERROR)
+                == wxYES) {
+            util::log::Warn("Attempting to continue execution following a potentially fatal exception");
+            return true;
         }
 
         return false;
     }
 
     void Application::OnUnhandledException() {
-        wxMessageBox("An unhandled exception has occurred and TexEdit cannot recover.\n"
-                     "The program will now terminate.",
+        wxString what;
+        try {
+            throw;
+        } catch (const std::exception &e) {
+            what = e.what();
+        } catch (...) {
+            what = "Unknown runtime error";
+        }
+
+        util::log::Fatal("(unhandled) " + what.ToStdString());
+
+        wxMessageBox("An unexpected exception has occurred:\n"
+                     "\"" + what + "\"\n\n"
+                     "This was unhandled and TexEdit cannot recover. The program will now terminate.",
                      "Unhandled Exception", wxOK | wxICON_ERROR);
     }
 

texedit/process/compiler/tecomp_proc.cpp

@@ -0,0 +1,30 @@
+/*
+ *   Copyright (c) 2024 Jack Bennett.
+ *   All Rights Reserved.
+ *
+ *   See the LICENCE file for more information.
+ */
+
+#include "tecomp_proc.hpp"
+
+#include "util/except.hpp"
+#include "util/resources.hpp"
+
+namespace te {
+    TECompProcess::TECompProcess(ProcessManager &mgr) : _mgr{mgr}, _id{1} {
+        _cmd = util::res::RelToExec("tecomp");
+        if (!util::res::ValidateExecutable(_cmd.ToStdString())) {
+            throw util::except::MissingComponentException("tecomp");
+        }
+    }
+
+    void TECompProcess::Start() {
+        const char *const argv[] = {
+            _cmd.ToUTF8(),
+            "watch", "examples", "examples/HelloWorld.tex",
+            0
+        };
+
+        _mgr.ExecutePipedAsync(_id, argv);
+    }
+}

texedit/process/compiler/tecomp_proc.hpp

@@ -0,0 +1,33 @@
+/*
+ *   Copyright (c) 2024 Jack Bennett.
+ *   All Rights Reserved.
+ *
+ *   See the LICENCE file for more information.
+ */
+
+#pragma once
+#ifndef __texedit__tecomp_proc_hpp__
+#define __texedit__tecomp_proc_hpp__
+
+#include <wx/wx.h>
+
+#include "process/process_mgr.hpp"
+
+namespace te {
+    class TECompProcess {
+    public:
+        TECompProcess(ProcessManager &mgr);
+
+        void Start();
+
+        inline int GetID() { return _id; }
+
+    private:
+        ProcessManager &_mgr;
+        wxString _cmd;
+
+        int _id;
+    };
+}
+
+#endif

texedit/process/process.cpp

@@ -0,0 +1,45 @@
+/*
+ *   Copyright (c) 2024 Jack Bennett.
+ *   All Rights Reserved.
+ *
+ *   See the LICENCE file for more information.
+ */
+
+#include "process.hpp"
+
+#include "process_mgr.hpp"
+
+#include <wx/txtstrm.h>
+#include <iostream>
+
+namespace te {
+    Process::Process(wxEvtHandler *parent, ProcessManager *mgr) : wxProcess(parent), _mgr{mgr} {
+    }
+
+    void Process::OnTerminate(int pid, int status) {
+        _mgr->HandleProcessTerminated(this, pid, status);
+    }
+
+    PipedProcess::PipedProcess(wxEvtHandler *parent, ProcessManager *mgr) : Process(parent, mgr) {
+        Redirect();
+    }
+
+    wxString PipedProcess::ReadLineStdout() {
+        wxString r{""};
+
+        if (IsInputAvailable()) {
+            wxTextInputStream tis(*GetInputStream());
+            r << _cmd << " (stdout): " << tis.ReadLine() << "\n";
+        }
+        if (IsErrorAvailable()) {
+            wxTextInputStream tis(*GetErrorStream());
+            r << _cmd << " (stderr): " << tis.ReadLine() << "\n";
+        }
+
+        return r;
+    }
+
+    void PipedProcess::OnTerminate(int pid, int status) {
+        _mgr->HandlePipedProcessTerminated(this, pid, status);
+    }
+}

texedit/process/process.hpp

@@ -0,0 +1,43 @@
+/*
+ *   Copyright (c) 2024 Jack Bennett.
+ *   All Rights Reserved.
+ *
+ *   See the LICENCE file for more information.
+ */
+
+#pragma once
+#ifndef __texedit__process_mgr_hpp__
+#define __texedit__process_mgr_hpp__
+
+#include <wx/process.h>
+
+#include <vector>
+
+namespace te {
+    class ProcessManager;
+
+    class Process : public wxProcess {
+    public:
+        Process(wxEvtHandler *parent, ProcessManager *mgr);
+
+        virtual void OnTerminate(int pid, int status) override;
+
+        inline void SetCmd(const wxString &cmd) { _cmd = cmd; }
+        inline wxString GetCmd() { return _cmd; }
+
+    protected:
+        ProcessManager *_mgr;
+        wxString _cmd{};
+    };
+
+    class PipedProcess : public Process {
+    public:
+        PipedProcess(wxEvtHandler *parent, ProcessManager *mgr);
+
+        wxString ReadLineStdout();
+
+        virtual void OnTerminate(int pid, int status) override;
+    };
+}
+
+#endif