Initial commit: Klammertext source distribution

Curated source subset assembled by klammertext-dev's doc/make_dist.sh: the Klammermachine (mac), the Standard Klammer Set (sks), the commands (com), editor plugins and install guides (doc), a test subset (tst), and lib/bin placeholders. Builds with 'make -C com'.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

mac/machine.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <string>
+
+// #include "source.h"
+#include "katom_list.h"
+#include "klammer_set.h"
+#include "target_set.h"
+#include "argtype_set.h"
+#include "state.h"
+
+#include "error.h"
+
+class Machine
+{
+public:
+    using input_sources_t =
+        std::vector<std::variant<fs::path, std::string>>;
+
+    Machine();
+
+    // Copy constructor
+    Machine(const Machine& other) 
+        : m_argtypes(other.m_argtypes)
+        , m_state(other.m_state)
+        , m_targets(other.m_targets)
+        , m_klammers(other.m_klammers)
+        , m_result(other.m_result)
+    {}
+
+    // Copy assignment operator
+    Machine& operator=(const Machine& other) {
+        if (this != &other) {
+            m_argtypes = other.m_argtypes;
+            m_state = other.m_state;
+            m_targets = other.m_targets;
+            m_klammers = other.m_klammers;
+            m_result = other.m_result;
+        }
+        return *this;
+    }
+    
+    void process_cond_katoms(std::vector<Katom>& katoms);
+    void process_eval_katoms(std::vector<Katom>& katoms);
+    void mark_literal_klammer_content(std::vector<Katom>& katoms);
+    void escape_target_characters(const Target& target, std::vector<Katom>& katoms);
+    
+    // std::vector<Katom> 
+    void process_katoms(
+        std::vector<Katom>& katoms, const std::string& source,
+        bool nonascii=true, bool literal=true, bool ignore=true, bool whitespace=true,
+        bool klammers=true, bool eval=true, bool cond=true, bool read=true);
+
+    std::vector<Katom> process(
+        std::string text, const std::string& source,
+        bool nonascii=true, bool literal=true, bool ignore=true, bool whitespace=true,
+        bool klammers=true, bool eval=true, bool cond=true, bool read=true);
+
+    void read(const fs::path& pathname);
+    void read(const std::string& s);
+
+    void expand_read_katoms(
+        std::vector<Katom>& katoms, std::string source_filename,
+        bool nonascii=true, bool literal=true, bool ignore=true, bool ws=true,
+        bool klammers=true, bool eval=true, bool cond=true, bool read=true);
+
+    void expand_constant_klammers(katom_list& katoms, const Katom& op, const Katom& cl);
+    void extract_machine_definitions();
+    void extract_klammer_definitions();
+    void extract_klammer_definitions(katom_list katoms);
+    void update_state(const std::map<std::string, std::string>& arg_map);
+
+    katom_list apply_klammer(Klammer& klammer, const std::string& target, katom_iter arguments_begin, katom_iter arguments_end);
+
+    void apply_klammer_set(Klammer_set& klammer_set,
+               katom_list& katoms, const std::string& target, katom_iter begin, katom_iter end);
+
+    void apply(Klammer_set& klammer_set, katom_list& katoms, const std::string& target);
+
+    std::string run_phase_functions();
+    std::string apply(const std::string& target_name, bool final_processing=true, bool escape_characters=true);
+
+    Argtype_set m_argtypes {};
+    State m_state {};
+    Target_set m_targets {};
+    Klammer_set m_klammers {};
+    input_sources_t m_sources {};
+    std::string m_result {};
+    std::vector<Katom> m_katoms {};
+};
+
+/*
+class Machine {
+private:
+    std::string m_name;
+    int m_id;
+    std::vector<std::string> m_sources;
+    bool m_active;
+    double m_value;
+
+public:
+    // Default constructor
+    Machine() : m_name(""), m_id(0), m_sources(), m_active(false), m_value(0.0) {}
+    
+    // Copy constructor
+    Machine(const Machine& other) 
+        : m_name(other.m_name)           // Copy name
+        , m_id(other.m_id)               // Copy id
+        , m_sources()                     // Initialize m_sources as empty
+        , m_active(other.m_active)        // Copy active status
+        , m_value(other.m_value)          // Copy value
+    {
+        // m_sources is now empty, ready for new initialization
+    }
+    
+    // Assignment operator (if needed)
+    Machine& operator=(const Machine& other) {
+        if (this != &other) {
+            m_name = other.m_name;
+            m_id = other.m_id;
+            m_sources.clear();  // Clear and leave empty
+            m_active = other.m_active;
+            m_value = other.m_value;
+        }
+        return *this;
+    }
+};
+*/