++

PhilipDeegan · PhilipDeegan · commit 86e44175d15c · 2026-01-11T20:47:41.000+01:00
diff --git a/.clang-format b/.clang-format
@@ -1,69 +1,8 @@
-AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: true
-AlignEscapedNewlinesLeft: false
-AlignOperands: true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: true
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: true
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterFunction: true
-  AfterClass: true
-  AfterControlStatement: true
-  AfterEnum: false
-  AfterNamespace: true
-  AfterStruct: true
-  AfterUnion: true
-  BeforeCatch: true
-  BeforeElse: true
-BinPackArguments: true
-BinPackParameters: true
-BreakBeforeBinaryOperators: All
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: true
-BreakStringLiterals: true
+IndentWidth: 2
+BasedOnStyle: 'google'
 ColumnLimit: 100
-CommentPragmas: '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-IndentCaseLabels: true
-IndentWidth: 4
-IndentWrappedFunctionNames: false
-KeepEmptyLinesAtTheStartOfBlocks: false
-MaxEmptyLinesToKeep: 4
-NamespaceIndentation: Inner
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-ReflowComments: true
 SortIncludes: false
-SpaceAfterTemplateKeyword: false
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles: false
-SpacesInCStyleCastParentheses: false
-SpacesInContainerLiterals: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-Standard: Cpp11
-TabWidth: 4
+QualifierAlignment: Right
 UseTab: Never
+DerivePointerAlignment: false
+PointerAlignment: Left
diff --git a/mod.cpp b/mod.cpp
@@ -33,139 +33,109 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "maiken/module/init.hpp"
 
-namespace mkn
-{
-namespace python3
-{
+namespace mkn {
+namespace python3 {
 
-    class ModuleMaker : public maiken::Module
-    {
-    private:
+class ModuleMaker : public maiken::Module {
+ private:
 #if defined(_WIN32)
-        const bool config_expected = 0;
+  const bool config_expected = 0;
 #else
-        const bool config_expected = 1;
+  const bool config_expected = 1;
 #endif
-        bool pyconfig_found = 0;
-        std::string HOME, PY = "python3", PYTHON, PY_CONFIG = "python-config",
-                          PY3_CONFIG = "python3-config", PATH = mkn::kul::env::GET("PATH");
-        mkn::kul::Dir bin;
-        std::shared_ptr<kul::cli::EnvVar> path_var;
+  bool pyconfig_found = 0;
+  std::string HOME, PY = "python3", PYTHON, PY_CONFIG = "python-config",
+                    PY3_CONFIG = "python3-config", PATH = mkn::kul::env::GET("PATH");
+  mkn::kul::Dir bin;
+  std::shared_ptr<kul::cli::EnvVar> path_var;
 
-    protected:
-        static void VALIDATE_NODE(YAML::Node const& node)
-        {
-            using namespace mkn::kul::yaml;
-            Validator({NodeValidator("args")}).validate(node);
-        }
+ protected:
+  static void VALIDATE_NODE(YAML::Node const& node) {
+    using namespace mkn::kul::yaml;
+    Validator({NodeValidator("args")}).validate(node);
+  }
 
-    public:
-        void init(maiken::Application& a, YAML::Node const& /*node*/)
-            KTHROW(std::exception) override
-        {
-            bool finally = 0;
-            if (!kul::env::WHICH(PY.c_str()))
-                PY = "python";
-            PYTHON = mkn::kul::env::GET("PYTHON");
-            if (!PYTHON.empty())
-                PY = PYTHON;
+ public:
+  void init(maiken::Application& a, YAML::Node const& /*node*/) KTHROW(std::exception) override {
+    bool finally = 0;
+    if (!kul::env::WHICH(PY.c_str())) PY = "python";
+    PYTHON = mkn::kul::env::GET("PYTHON");
+    if (!PYTHON.empty()) PY = PYTHON;
 #if defined(_WIN32)
-            if (PY.rfind(".exe") == std::string::npos)
-                PY += ".exe";
+    if (PY.rfind(".exe") == std::string::npos) PY += ".exe";
 #endif
-            mkn::kul::Process p(PY);
-            mkn::kul::ProcessCapture pc(p);
-            HOME = mkn::kul::env::GET("PYTHON3_HOME");
-            if (!HOME.empty())
-            {
+    mkn::kul::Process p(PY);
+    mkn::kul::ProcessCapture pc(p);
+    HOME = mkn::kul::env::GET("PYTHON3_HOME");
+    if (!HOME.empty()) {
 #if defined(_WIN32)
-                bin = mkn::kul::Dir(HOME);
-                if (!bin)
-                    KEXCEPT(kul::Exception, "$PYTHON3_HOME does not exist");
+      bin = mkn::kul::Dir(HOME);
+      if (!bin) KEXCEPT(kul::Exception, "$PYTHON3_HOME does not exist");
 #else
-                bin = mkn::kul::Dir("bin", HOME);
-                if (!bin)
-                    KEXCEPT(kul::Exception, "$PYTHON3_HOME/bin does not exist");
+      bin = mkn::kul::Dir("bin", HOME);
+      if (!bin) KEXCEPT(kul::Exception, "$PYTHON3_HOME/bin does not exist");
 #endif
-                path_var = std::make_shared<kul::cli::EnvVar>("PATH", bin.real(),
-                                                              mkn::kul::cli::EnvVarMode::PREP);
-                mkn::kul::env::SET(path_var->name(), path_var->toString().c_str());
-                p.var(path_var->name(), path_var->toString());
-            };
+      path_var =
+          std::make_shared<kul::cli::EnvVar>("PATH", bin.real(), mkn::kul::cli::EnvVarMode::PREP);
+      mkn::kul::env::SET(path_var->name(), path_var->toString().c_str());
+      p.var(path_var->name(), path_var->toString());
+    };
 #if defined(_WIN32)
-            pyconfig_found = false; // doesn't exist on windows (generally)
+    pyconfig_found = false;  // doesn't exist on windows (generally)
 #else
-            pyconfig_found = mkn::kul::env::WHICH(PY3_CONFIG.c_str());
+    pyconfig_found = mkn::kul::env::WHICH(PY3_CONFIG.c_str());
 #endif
-            if (!pyconfig_found)
-            {
-                pyconfig_found = mkn::kul::env::WHICH(PY_CONFIG.c_str());
-                PY3_CONFIG     = PY_CONFIG;
-            }
-            try
-            {
-                p << "-c"
-                  << "\"import sys; print(sys.version_info[0])\"";
-                p.start();
+    if (!pyconfig_found) {
+      pyconfig_found = mkn::kul::env::WHICH(PY_CONFIG.c_str());
+      PY3_CONFIG = PY_CONFIG;
+    }
+    try {
+      p << "-c"
+        << "\"import sys; print(sys.version_info[0])\"";
+      p.start();
 
-                if (!pyconfig_found && config_expected)
-                {
-                    finally = 1;
-                    KEXCEPT(kul::Exception, "python-config does not exist on path");
-                }
-            }
-            catch (const mkn::kul::Exception& e)
-            {
-                KERR << e.stack();
-            }
-            catch (const std::exception& e)
-            {
-                KERR << e.what();
-            }
-            catch (...)
-            {
-                KERR << "UNKNOWN ERROR CAUGHT";
-            }
-            if (finally)
-                exit(2);
-            using namespace mkn::kul::cli;
+      if (!pyconfig_found && config_expected) {
+        finally = 1;
+        KEXCEPT(kul::Exception, "python-config does not exist on path");
+      }
+    } catch (mkn::kul::Exception const& e) {
+      KERR << e.stack();
+    } catch (std::exception const& e) {
+      KERR << e.what();
+    } catch (...) {
+      KERR << "UNKNOWN ERROR CAUGHT";
+    }
+    if (finally) exit(2);
+    using namespace mkn::kul::cli;
 
-            std::string extension;
-            if (pyconfig_found)
-            {
-                mkn::kul::os::PushDir pushd(a.project().dir());
-                mkn::kul::Process p(PY3_CONFIG);
-                mkn::kul::ProcessCapture pc(p);
-                p << "--extension-suffix";
-                if (path_var)
-                    p.var(path_var->name(), path_var->toString());
-                p.start();
-                extension = pc.outs();
-            }
-            else
-            {
-                mkn::kul::Process p(PY);
-                mkn::kul::ProcessCapture pc(p);
-                p << "-c"
-                  << "\"import sysconfig; "
-                     "print(sysconfig.get_config_var('EXT_SUFFIX'))\"";
-                p.start();
-                extension = pc.outs();
-            }
-            a.m_cInfo.lib_ext    = mkn::kul::String::LINES(extension)[0]; // drop EOL
-            a.m_cInfo.lib_prefix = "";
-            a.mode(maiken::compiler::Mode::SHAR);
-        }
-    };
-} // namespace python3
-} // namespace mkn
+    std::string extension;
+    if (pyconfig_found) {
+      mkn::kul::os::PushDir pushd(a.project().dir());
+      mkn::kul::Process p(PY3_CONFIG);
+      mkn::kul::ProcessCapture pc(p);
+      p << "--extension-suffix";
+      if (path_var) p.var(path_var->name(), path_var->toString());
+      p.start();
+      extension = pc.outs();
+    } else {
+      mkn::kul::Process p(PY);
+      mkn::kul::ProcessCapture pc(p);
+      p << "-c"
+        << "\"import sysconfig; "
+           "print(sysconfig.get_config_var('EXT_SUFFIX'))\"";
+      p.start();
+      extension = pc.outs();
+    }
+    a.m_cInfo.lib_ext = mkn::kul::String::LINES(extension)[0];  // drop EOL
+    a.m_cInfo.lib_prefix = "";
+    a.mode(maiken::compiler::Mode::SHAR);
+  }
+};
+}  // namespace python3
+}  // namespace mkn
 
-extern "C" MKN_KUL_PUBLISH maiken::Module* maiken_module_construct()
-{
-    return new mkn::python3::ModuleMaker;
+extern "C" MKN_KUL_PUBLISH maiken::Module* maiken_module_construct() {
+  return new mkn::python3::ModuleMaker;
 }
 
-extern "C" MKN_KUL_PUBLISH void maiken_module_destruct(maiken::Module* p)
-{
-    delete p;
-}
+extern "C" MKN_KUL_PUBLISH void maiken_module_destruct(maiken::Module* p) { delete p; }
