cppmake 0.0.1__tar.gz → 0.0.2__tar.gz

{cppmake-0.0.1 → cppmake-0.0.2}/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.4
 Name: cppmake
-Version: 0.0.1
+Version: 0.0.2
 Summary: none
-Home-page: https://github.com/anonymouspc/cppmake
-Author: {'name': 'anonymouspc', 'email': 'shyeyian@petalmail.com'}
 Author-email: anonymouspc <shyeyian@petalmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/anonymouspc/cppmake
@@ -11,6 +9,4 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: license.txt
-Dynamic: author
-Dynamic: home-page
 Dynamic: license-file

cppmake-0.0.2/cppmake/build.py

@@ -0,0 +1,29 @@
+from cppmake.error   import BuildError
+from cppmake.module  import Module
+from cppmake.object  import Object
+from cppmake.package import Package
+from cppmake.source  import Source
+import sys
+
+if __name__ == "__main__":
+    open(".log", 'w')
+
+    try:
+        Object("main")
+        for package in Package.pool.values():
+            package.build()
+        for module in Module.pool.values():
+            module.compile()
+        for source in Source.pool.values():
+            source.compile()
+        for object in Object.pool.values():
+            object.link()
+
+    except BuildError as e:
+        print(e, end="", file=sys.stderr)
+        print(e, end="", file=open(".log", 'a'))
+        exit(-1)
+
+    except KeyboardInterrupt as e:
+        exit(-1)
+        

cppmake-0.0.2/cppmake/clean.py

@@ -0,0 +1,6 @@
+from cppmake.config import type
+import shutil
+
+if __name__ == "__main__":
+    try:  shutil.rmtree(f"./bin/{type}/module")
+    except: pass

cppmake-0.0.2/cppmake/cppmake/algorithm.py

@@ -0,0 +1,19 @@
+def recursive_find(node, func, root=True, flatten=False):
+    return _recursive_find_with_cache(node=node, func=func, root=root, flatten=flatten, cache=[])
+
+def _recursive_find_with_cache(node, func, root, flatten, cache):
+    if root:
+        result = func(node)
+        if result is not None:
+            if not flatten:
+                if result not in cache:
+                    cache += [result]
+            else:
+                for element in result:
+                    if element not in cache:
+                        cache += [element]
+
+    for import_module in node.import_modules:
+        _recursive_find_with_cache(node=import_module, func=func, root=True, flatten=flatten, cache=cache)
+
+    return cache

cppmake-0.0.2/cppmake/cppmake/compiler.py

@@ -0,0 +1,106 @@
+from cppmake.config import type, compiler, compile_flags, link_flags, define_flags
+from cppmake.error  import BuildError
+from cppmake.run    import run
+import os
+import re
+import subprocess
+
+def preprocess_file(code_file, name=None, module_file=None):
+    command = ""
+    if compiler == "g++" or compiler == "clang++":
+        command = f"{compiler} "                \
+                  f"{' '.join(compile_flags)} " \
+                  f"-E -x c++ - "               \
+                  f"-o -"
+        if compiler == "g++":
+            if not hasattr(preprocess_file, "initialized"):
+                open(f"./bin/{type}/module/mapper.txt", 'w')
+                preprocess_file.initialized = True
+            if name is not None and module_file is not None:
+                with open(f"./bin/{type}/module/mapper.txt", 'a') as writer:
+                    writer.write(f"{name} {module_file}\n")
+    elif compiler == "cl":
+        command = f"{compiler} "    \
+                  f"/E {code_file}"
+
+    try:
+        reader = open(code_file, 'r').read()
+        reader = re.sub(r'^\s*#\s*include\s+(?!<version>).*$', "", reader, flags=re.MULTILINE)
+        return subprocess.run(command, shell=True, check=True, capture_output=True, text=True, input=reader).stdout
+    except FileNotFoundError as e:
+        raise BuildError(f"fatal error: {e.filename} not found")
+    except subprocess.CalledProcessError as e:
+        raise BuildError(e.stderr)
+    
+def compile_module(code_file, include_dirs, module_file, object_file):
+    os.makedirs(os.path.dirname(module_file), exist_ok=True)
+    os.makedirs(os.path.dirname(object_file), exist_ok=True)
+    commands = []
+    if compiler == "g++":
+        commands = [f"g++ "
+                    f"{' '.join(compile_flags)} "
+                    f"{' '.join(f'-I {include_path}'  for include_path in include_dirs)} "
+                    f"{' '.join(f'-D {key}="{value}"' for key, value   in define_flags.items())} "
+                    f"-c {code_file} "
+                    f"-o {object_file}"]
+    elif compiler == "clang++":
+        commands = [f"clang++ "
+                    f"{' '.join(compile_flags)} "
+                    f"{' '.join(f'-I {include_path}'  for include_path in include_dirs)} "
+                    f"{' '.join(f'-D {key}="{value}"' for key, value   in define_flags.items())} "
+                    f"--precompile -x c++-module {code_file} "
+                    f"-o                         {module_file}",
+                    
+                    f"clang++ "
+                    f"{' '.join(compile_flags)} "
+                    f"-c {module_file} "
+                    f"-o {object_file}"]
+    elif compiler == "cl":
+        commands = [f"cl "
+                    f"{' '.join(compile_flags)} "
+                    f"{' '.join(f'/I {include_path}'  for include_path in include_dirs)} "
+                    f"{' '.join(f'/D {key}="{value}"' for key, value   in define_flags.items())} "
+                    f"/c /interface /TP {code_file} "
+                    f"/ifcOutput        {module_file} "
+                    f"/Fo               {object_file}"]
+    for command in commands:
+        run(command)
+        
+def compile_source(code_file, include_dirs, object_file):
+    os.makedirs(os.path.dirname(object_file), exist_ok=True)
+    command = ""
+    if compiler == "g++" or compiler == "clang++":
+        command = f"{compiler} "                                                                 \
+                  f"{' '.join(compile_flags)} "                                                  \
+                  f"{' '.join(f'-I {include_path}'  for include_path in include_dirs)} "         \
+                  f"{' '.join(f'-D {key}="{value}"' for key, value   in define_flags.items())} " \
+                  f"-c {code_file} "                                                             \
+                  f"-o {object_file}"
+    elif compiler == "cl":
+        command = f"cl "                                                                         \
+                  f"{' '.join(compile_flags)} "                                                  \
+                  f"{' '.join(f'/I {include_path}'  for include_path in include_dirs)} "         \
+                  f"{' '.join(f'/D {key}="{value}"' for key, value   in define_flags.items())} " \
+                  f"/c  {code_file} "                                                            \
+                  f"/Fo {object_file}"
+    run(command)
+        
+def link_object(object_files, library_files, executable_file):
+    os.makedirs(os.path.dirname(executable_file), exist_ok=True)
+    command = ""
+    if compiler == "g++" or compiler == "clang++":
+        command = f"{compiler} "                \
+                  f"{' '.join(link_flags)} "    \
+                  f"{' '.join(object_files)} "  \
+                  f"{' '.join(library_files)} " \
+                  f"-o {executable_file}"
+    elif compiler == "cl":
+        command = f"cl "                        \
+                  f"{' '.join(link_flags)} "    \
+                  f"{' '.join(object_files)} "  \
+                  f"{' '.join(library_files)} " \
+                  f"/Fe {executable_file}"
+    run(command)
+    
+def run_executable(executable_file):
+    run(f"./{executable_file}")

cppmake-0.0.2/cppmake/cppmake/config.py

@@ -0,0 +1,94 @@
+import argparse
+import os
+import sys
+os.environ["LANG"] = "en_US.UTF-8"
+
+
+
+# Arguments
+
+parser = argparse.ArgumentParser(description="build.py")
+parser.add_argument("--type",    choices=["debug", "release"], default="debug")
+parser.add_argument("--verbose", action="store_true",                         )
+argv = parser.parse_args()
+type    = argv.type
+verbose = argv.verbose
+
+
+
+# System
+
+if sys.platform == "win32":
+    system            = "windows"
+    compiler          = "cl"
+    executable_suffix = "exe"
+    shared_suffix     = "dll"
+elif sys.platform == "linux":
+    system            = "linux"
+    compiler          = "g++"
+    executable_suffix = ""
+    shared_suffix     = "so"
+elif sys.platform == "darwin":
+    system            = "macos"
+    compiler          = "clang++"
+    executable_suffix = ""
+    shared_suffix     = "dylib"
+
+
+
+# Flags
+
+if compiler == "g++":
+    compile_flags = [
+        "-std=c++26", 
+        "-Wall",
+        "-fdiagnostics-color=always",
+        "-fmodules",
+       f"-fmodule-mapper=./bin/{type}/module/mapper.txt",
+    ]
+    link_flags = ["-static"]
+    if type == "debug":
+        compile_flags += ["-g", "-O0", "-DDEBUG" ]
+    elif type == "release":
+        compile_flags += [      "-O3", "-DNDEBUG"]
+        compile_flags += ["-s"]
+    module_suffix  = "gcm"
+    object_suffix  = "o"
+    library_suffix = "a"
+elif compiler == "clang++":
+    compile_flags = [
+        "-std=c++26", 
+        "-Wall", 
+        "-fdiagnostics-color=always",
+       f"-fprebuilt-module-path=./bin/{type}/module",
+    ]
+    link_flags = []
+    if type == "debug":
+        compile_flags += ["-g", "-O0", "-DDEBUG" ]
+    elif type == "release":
+        compile_flags += [      "-O3", "-DNDEBUG"]
+        link_flags    += ["-s"]
+    module_suffix  = "pcm"
+    object_suffix  = "o"
+    library_suffix = "a"
+elif compiler == "cl":
+    compile_flags = [
+        "/std:c++latest",
+        "/EHsc",
+        "/W4"
+    ]
+    link_flags = ["/MT"]
+    if type == "debug":
+        compile_flags += ["/Z7", "/Od", "/DDEBUG" ]
+    elif type == "release":
+        compile_flags += [       "/O2", "/DNDEBUG"]
+    module_suffix  = "ifc"
+    object_suffix  = "obj"
+    library_suffix = "lib"
+
+define_flags  = {
+    "abstract": '0', 
+    "extends" : ':',
+    "in"      : ':', 
+    "self"    : "(*this)"
+}

cppmake-0.0.2/cppmake/cppmake/error.py

@@ -0,0 +1,2 @@
+class BuildError(Exception):
+    pass

cppmake-0.0.2/cppmake/cppmake/executable.py

@@ -0,0 +1,43 @@
+from cppmake.compiler import run_executable
+from cppmake.config   import executable_suffix, type
+from cppmake.object   import Object
+
+class Executable:
+    pool    = {}
+    current = 0
+    total   = 0
+    
+    def __new__(self, name):
+        if name in Executable.pool.keys():
+            return Executable.pool[name]
+        else:
+            self = super().__new__(self)
+            Executable.pool[name] = self
+
+            # Info
+            self.name            = name
+            self.executable_file = f"./bin/{type}/src/{self.name.replace('.', '.').replace(':', '/')}.{executable_suffix}" if executable_suffix != "" else \
+                                   f"./bin/{type}/src/{self.name.replace('.' ,'.').replace(':', '/')}"
+            
+            # Subtask
+            Object(self.name)
+
+            # Status
+            self.runned = False
+            Executable.total += 1
+
+            # Return
+            return self
+
+    def run(self):
+        if not self.runned:
+            # Subtask
+            Object(self.name).link()
+
+            # Self
+            Executable.current += 1
+            print(f"run executable [{Executable.current}/{Executable.total}]: {self.name}")
+            run_executable(executable_file=f"./{self.executable_file}")
+
+            # Status
+            self.runned = True

cppmake-0.0.2/cppmake/cppmake/make.py

@@ -0,0 +1,70 @@
+from cppmake.algorithm import recursive_find
+from cppmake.config    import system, type
+from cppmake.error     import BuildError
+from cppmake.module    import Module
+from cppmake.package   import Package
+from cppmake.run       import run
+import os
+import shutil
+
+def include(name, dir=None, file=None):
+    if dir is not None:
+        shutil.copytree(dir,  f"./bin/{type}/package/{name}/install/include", dirs_exist_ok=True)
+    if file is not None:
+        os.makedirs          (f"./bin/{type}/package/{name}/install/include", exist_ok=True)
+        shutil.copyfile(file, f"./bin/{type}/package/{name}/install/include/{os.path.basename(file)}")
+    if dir is None and file is None:
+        raise BuildError("include() accepts at least 2 arguments")
+
+def src(name, dir, src_to_include=None):
+    if src_to_include is None:
+        src_to_include = f"{name}/src"
+    shutil.copytree(dir, f"./bin/{type}/package/{name}/install/include/{src_to_include}", dirs_exist_ok=True)
+
+def module(name, file, replace={}):
+    with open(file, 'r') as reader, open(f"./module/{name}.cpp", 'w') as writer:
+        content = reader.read()
+        content = content.replace("module;", "module;\n#undef in\n#undef self")
+        for old, new in replace.items():
+            content = content.replace(old, new)
+        writer.write(content)
+
+def cmake(name, dir, args=[]):
+    run(f"cmake -S ./{dir} "
+            f"      -B ./bin/{type}/package/{name}/build "
+            f'      -DCMAKE_PREFIX_PATH="{';'.join(recursive_find(node=Module(name), func=lambda module: Package(module.name).install_dir if Package.exist(module.name) else None, root=True))}" '
+            f"      -DCMAKE_INSTALL_PREFIX=./bin/{type}/package/{name}/install "
+            f"      -DCMAKE_BUILD_TYPE={type} "
+            f"{' '.join(args)}")
+    run(f"cmake --build   ./bin/{type}/package/{name}/build -j {os.cpu_count()}", quiet=True)
+    run(f"cmake --install ./bin/{type}/package/{name}/build -j {os.cpu_count()}")
+
+def autogen(name, file, args=[]):
+    if not Package(name).is_configured:
+        run(f"./{file} {' '.join(args)}")
+
+def configure(name, file, args=[]):
+    if not Package(name).is_configured:
+        cwd = f"./bin/{type}/package/{name}/build"
+        try:
+            os.makedirs(cwd, exist_ok=True)
+            run(f"./{os.path.relpath(file, cwd)} --prefix={os.path.abspath(f"./bin/{type}/package/{name}/install")} {' '.join(args)}", cwd=cwd)
+        except:
+            shutil.rmtree(cwd)
+            raise
+
+def make(name, dir, args=[]):
+    if system == "linux" or system == "macos":
+        cwd = f"./bin/{type}/package/{name}/build"
+        run(f"make         -j{os.cpu_count()} {' '.join(args)}", cwd=cwd, quiet=True)
+        run(f"make install -j{os.cpu_count()}",                  cwd=cwd, quiet=True)
+    else:
+        raise BuildError("make is only supported on linux and macos")
+
+def nmake(name, dir, args=[]):
+    if system == "windows":
+        cwd = f"./bin/{type}/package/{name}/build"
+        run(f"nmake         -j{os.cpu_count()} {' '.join(args)}", cwd=cwd, quiet=True)
+        run(f"nmake install -j{os.cpu_count()}",                  cwd=cwd, quiet=True)
+    else:
+        raise BuildError("nmake is only supported on windows")

cppmake-0.0.2/cppmake/cppmake/module.py

@@ -0,0 +1,82 @@
+from cppmake.algorithm import recursive_find
+from cppmake.config    import type, module_suffix, object_suffix
+from cppmake.compiler  import preprocess_file, compile_module
+from cppmake.error     import BuildError
+from cppmake.package   import Package
+import os
+import re
+
+class Module:
+    pool    = {}
+    current = 0
+    total   = 0
+
+    def __new__(self, name, from_modules=[]):
+        if name in Module.pool.keys():
+            return Module.pool[name]
+        else:
+            self = super().__new__(self)
+            Module.pool[name] = self
+
+            # Info
+            self.name        = name
+            self.code_file   =            f"./module/{self.name.replace('.', '/').replace(':', '/')}.cpp"
+            self.module_file = f"./bin/{type}/module/{self.name.replace('.', '.').replace(':', '-')}.{module_suffix}"
+            self.object_file = f"./bin/{type}/module/{self.name.replace('.', '.').replace(':', '-')}.{object_suffix}"
+            self.content     = preprocess_file(code_file=self.code_file, name=self.name, module_file=self.module_file)
+
+            # Import
+            self.from_modules   = from_modules
+            self.import_modules = []
+            import_names = re.findall(r'^\s*(?:export\s+)?import\s+([\w\.:]+)\s*;\s*$', self.content, flags=re.MULTILINE)
+            for import_name in import_names:
+                if import_name.startswith(':'):
+                    import_name = f"{self.name.partition(':')[0]}{import_name}"
+                if import_name in self.from_modules:
+                    raise BuildError(f"fatal error: module dependency circle {' -> '.join(module.name for module in self.from_modules + [self] + [Module(import_name)])}")
+                self.import_modules += [Module(name=import_name, from_modules=self.from_modules + [self])]
+
+            # Subtask
+            if Package.exist(self.name):
+                Package(self.name, by_module=self)
+
+            # Status
+            self.is_compiled = all(module.is_compiled for module in self.import_modules)              and \
+                               (not Package.exist(self.name) or Package(self.name).is_built)          and \
+                               os.path.isfile(self.module_file)                                       and \
+                               os.path.getmtime(self.code_file) <= os.path.getmtime(self.module_file)
+            if not self.is_compiled:
+                Module.total += 1
+
+            # Check
+            if self.module_file is not None:
+                export_names = re.findall(r'^\s*export\s+module\s+([\w\.:]+)\s*;\s*$', self.content, flags=re.MULTILINE)
+                if (len(export_names) != 1 or export_names[0] != self.name):
+                    raise BuildError(f"fatal error: file {self.code_file} should export module {self.name}")
+                
+            # Return
+            return self
+
+    def compile(self):
+        if not self.is_compiled:
+            # Import
+            for import_module in self.import_modules:
+                import_module.compile()
+
+            # Subtask
+            if Package.exist(self.name):
+                Package(self.name).build()
+
+            # Self
+            Module.current += 1
+            print(f"compile module [{Module.current}/{Module.total}]: {self.name}")
+            compile_module(code_file   =self.code_file, 
+                           include_dirs=recursive_find(node=self, func=lambda module: Package(module.name).include_dir if Package.exist(module.name) else None, root=True), 
+                           module_file =self.module_file, 
+                           object_file =self.object_file)
+            
+            # Status
+            self.is_compiled = True
+
+    def __eq__(self, str):
+        return self.name == str

cppmake-0.0.2/cppmake/cppmake/object.py

@@ -0,0 +1,53 @@
+from cppmake.algorithm import recursive_find
+from cppmake.compiler  import link_object
+from cppmake.config    import type, object_suffix, executable_suffix
+from cppmake.package   import Package
+from cppmake.source    import Source
+import os
+
+class Object:
+    pool    = {}
+    current = 0
+    total   = 0
+    
+    def __new__(self, name):
+        if name in Object.pool.keys():
+            return Object.pool[name]
+        else:
+            self = super().__new__(self)
+            Object.pool[name] = self
+
+            # Info
+            self.name            = name
+            self.object_file     = f"./bin/{type}/src/{self.name.replace('.', '.').replace(':', '-')}.{object_suffix}"
+            self.executable_file = f"./bin/{type}/src/{self.name.replace('.', '.').replace(':', '-')}.{executable_suffix}" if executable_suffix != "" else \
+                                   f"./bin/{type}/src/{self.name.replace('.', '.').replace(':', '-')}"
+            
+            # Subtask
+            Source(self.name)
+
+            # Status
+            self.is_linked = Source(self.name).is_compiled                                               and \
+                             os.path.isfile(self.object_file)                                            and \
+                             os.path.isfile(self.executable_file)                                        and \
+                             os.path.getmtime(self.object_file) <= os.path.getmtime(self.executable_file)
+            if not self.is_linked:
+                Object.total += 1
+
+            # Return
+            return self
+
+    def link(self):
+        if not self.is_linked:
+            # Subtask
+            Source(self.name).compile()
+
+            # Self
+            Object.current += 1
+            print(f"link object [{Object.current}/{Object.total}]: {self.name}")
+            link_object(object_files   =recursive_find(node=Source(self.name), func=lambda source_or_module: source_or_module.object_file,                                     root=True               ),
+                        library_files  =recursive_find(node=Source(self.name), func=lambda module: Package(module.name).library_files if Package.exist(module.name) else None, root=False, flatten=True),
+                        executable_file=self.executable_file)
+            
+            # Status
+            self.is_linked = True

cppmake-0.0.2/cppmake/cppmake/package.py

@@ -0,0 +1,74 @@
+from cppmake.algorithm import recursive_find
+from cppmake.config    import type, library_suffix, shared_suffix
+import os
+
+class Package:
+    pool    = {}
+    current = 0
+    total   = 0
+
+    def __new__(self, name, by_module=None):       
+        name = name.partition('.')[0]
+
+        if name in Package.pool.keys():
+            Package.pool[name].by_modules += [by_module] if by_module is not None else []
+            return Package.pool[name]
+        else:
+            self = super().__new__(self)
+            self.by_modules = [by_module] if by_module is not None else []
+            Package.pool[name] = self
+
+            # Info
+            self.name          = name
+            self.package_file  = f"./tool/package/{self.name.replace('.', '/').replace(':', '/')}.py"
+            self.install_dir   = None
+            self.include_dir   = None
+            self.library_files = None
+            self.update()
+            
+            # Status
+            self.is_configured = os.path.isdir(f"./bin/{type}/package/{self.name}/build")
+            self.is_built      = os.path.isdir(f"./bin/{type}/package/{self.name}/install")
+            self.is_installed  = (not os.path.isdir(f"./bin/{type}/package/{self.name}/install/include") or os.path.getmtime(f"./bin/{type}/package/{self.name}/install/include") < os.path.getmtime("./include")) and \
+                                 (not os.path.isdir(f"./bin/{type}/package/{self.name}/install/lib"    ) or os.path.getmtime(f"./bin/{type}/package/{self.name}/install/lib"    ) < os.path.getmtime("./lib"    ))
+            if not self.is_built:
+                Package.total += 1
+
+            # Check
+            assert Package.exist(self.name)
+
+            # Return
+            return self
+        
+    def build(self, from_packages=[]):
+        if not self.is_built:
+            # Import 
+            for by_module in self.by_modules:
+                for import_package in recursive_find(node=by_module, func=lambda module: Package(module.name) if Package.exist(module.name) else None):
+                    if import_package not in from_packages and import_package is not self:
+                        import_package.build(from_packages=from_packages + [self])
+
+            # Self
+            Package.current += 1
+            print(f"build package [{Package.current}/{Package.total}]: {self.name}")
+            exec(f"from package.{self.name} import *")
+            self.update()
+
+            # Status
+            self.is_built = True
+        
+    def exist(name):
+        name = name.partition('.')[0]
+        return os.path.isfile(f"./tool/package/{name}.py")
+    
+    def update(self):
+        self.install_dir   =  f"./bin/{type}/package/{self.name}/install"         if os.path.isdir (f"./bin/{type}/package/{self.name}/install")         else None
+        self.include_dir   =  f"./bin/{type}/package/{self.name}/install/include" if os.path.isdir (f"./bin/{type}/package/{self.name}/install/include") else None
+        self.library_files = [f"./bin/{type}/package/{self.name}/install/lib/{file}"                                                                                                              \
+                              for file in os.listdir    (f"./bin/{type}/package/{self.name}/install/lib")                                                                                         \
+                              if          os.path.isfile(f"./bin/{type}/package/{self.name}/install/lib/{file}") and (file.endswith(f".{library_suffix}") or file.endswith(f".{shared_suffix}"))] \
+                              if          os.path.isdir (f"./bin/{type}/package/{self.name}/install/lib") else None
+                
+    def __eq__(self, str):
+        return self.name == str
+    

cppmake-0.0.2/cppmake/cppmake/run.py

@@ -0,0 +1,23 @@
+from cppmake.error  import BuildError
+from cppmake.config import verbose
+import subprocess
+import sys
+
+def run(command, quiet=False, **kwargs):
+    if verbose:
+        print(command)
+        p = subprocess.Popen(command, shell=True, stdout=None if verbose >= 2 else subprocess.DEVNULL, stderr=subprocess.PIPE, text=True, **kwargs)
+        e = ""
+        while p.poll() is None:
+            e += p.stderr.readline()
+        if p.poll() == 0:
+            print(e, end="", file=sys.stderr)
+        else:
+            raise BuildError(e)
+    else:
+        try:
+            p = subprocess.run(command, shell=True, check=True, capture_output=True, text=True, **kwargs)
+            if not quiet:
+                print(p.stderr, end="", file=sys.stderr)
+        except subprocess.CalledProcessError as e:
+            raise BuildError(e.stderr)

cppmake-0.0.2/cppmake/cppmake/source.py

@@ -0,0 +1,61 @@
+from cppmake.algorithm import recursive_find
+from cppmake.compiler  import preprocess_file, compile_source
+from cppmake.config    import type, object_suffix
+from cppmake.module    import Module
+from cppmake.package   import Package
+import os
+import re
+  
+class Source:
+    pool    = {}
+    current = 0
+    total   = 0
+
+    def __new__(self, name):
+        if name in Source.pool.keys():
+            return Source.pool[name]
+        else:
+            self = super().__new__(self)
+            Source.pool[name] = self
+
+            # Info
+            self.name        = name
+            self.code_file   =            f"./src/{self.name.replace('.', '/').replace(':', '/')}.cpp"
+            self.object_file = f"./bin/{type}/src/{self.name.replace('.', '.').replace(':', '-')}.{object_suffix}"
+            self.content     = preprocess_file(code_file=self.code_file)
+
+            # Import
+            self.import_modules = []
+            import_names = re.findall(r'^\s*import\s+([\w\.:]+)\s*;\s*$', self.content, flags=re.MULTILINE)
+            for import_name in import_names:
+                self.import_modules += [Module(name=import_name)]
+
+            # Status
+            self.is_compiled = all(module.is_compiled for module in self.import_modules)              and \
+                               os.path.isfile(self.object_file)                                       and \
+                               os.path.getmtime(self.code_file) <= os.path.getmtime(self.object_file)
+            if not self.is_compiled:
+                Source.total += 1
+
+            # Return
+            return self
+
+    def compile(self):
+        if not self.is_compiled:
+            # Import
+            for import_module in self.import_modules:
+                import_module.compile()
+
+            # Self
+            Source.current += 1
+            print(f"compile source [{Source.current}/{Source.total}]: {self.name}")
+            compile_source(code_file   =self.code_file, 
+                           include_dirs=recursive_find(node=self, func=lambda module: Package(module.name).include_dir if Package.exist(module.name) else None, root=False),
+                           object_file =self.object_file)
+            
+            # Status
+            self.is_compiled = True
+
+    def __eq__(self, str):
+        return self.name == str
+

cppmake-0.0.2/cppmake/test.py

@@ -0,0 +1,34 @@
+from cppmake.error      import BuildError
+from cppmake.executable import Executable
+from cppmake.module     import Module
+from cppmake.object     import Object
+from cppmake.package    import Package
+from cppmake.source     import Source
+import os
+import sys
+
+if __name__ == "__main__":
+    open(".log", 'w')
+
+    try:
+        for root, _, files in os.walk("./src/test"):
+            for file in files:
+                Executable(f"{root.replace('/', '.').lstrip('.')}.{file.removesuffix(".cpp")}")
+        for package in Package.pool.values():
+            package.build()
+        for module in Module.pool.values():
+            module.compile()
+        for source in Source.pool.values():
+            source.compile()
+        for object in Object.pool.values():
+            object.link()
+        for executable in Executable.pool.values():
+            executable.run()
+                
+    except BuildError as e:
+        print(e, end="", file=sys.stderr)
+        print(e, end="", file=open(".log", 'a'))
+        exit(-1)
+
+    except KeyboardInterrupt as e:
+        exit(-1)

cppmake-0.0.2/cppmake/tree.py

@@ -0,0 +1,50 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+from cppmake.source import *
+
+if __name__ == "__main__":
+    G = nx.DiGraph()
+
+    def _get_name(module):
+        if hasattr(module, "name"):
+            return module.name
+        elif hasattr(module, "name"):
+            return module.name
+
+    def _summon_graph(module):
+        G.add_node(_get_name(module))
+        for import_module in module.import_modules:
+            G.add_node(_get_name(import_module))
+            G.add_edge(_get_name(module), _get_name(import_module))
+            _summon_graph(import_module)
+
+    def _get_rgb(rank, total):
+        k = rank / (total - 1)
+        if 0.00 <= k <= 0.25:
+            r = 1
+            g = 4 * (k - 0.0)
+            b = 0
+        elif 0.25 <= k <= 0.50:
+            r = 1 - 4 * (k - 0.25)
+            g = 1
+            b = 0
+        elif 0.50 <= k <= 0.75:
+            r = 0
+            g = 1
+            b = 4 * (k - 0.50)
+        elif 0.75 <= k <= 1.00:
+            r = 0
+            g = 1 - 4 * (k - 0.75)
+            b = 1
+        return r, g, b
+
+    _summon_graph(Source("main"))
+    node_pos    = nx.spring_layout(G, k=12.5/(len(G.nodes)**0.5), iterations=100, scale=1.0)
+    label_pos   = {k: (v[0], v[1] + 0.05) for k, v in node_pos.items()}
+    ancest_dict = {node: len(nx.ancestors(G, node)) for node in G.nodes}
+    ancest_seq  = list(reversed(sorted(list(set(ancest_dict.values())))))
+    rank_dict   = {node: ancest_seq.index(ancest_dict[node]) for node in G.nodes}
+    node_color  = [_get_rgb(rank=rank_dict[node], total=len(ancest_seq)) for node in G.nodes]
+    nx.draw                (G, pos=node_pos,  node_size=1000/(len(G.nodes)**0.5), node_shape='.', edge_color="#B0B0B0", width=0.5, with_labels=False, node_color=node_color)
+    nx.draw_networkx_labels(G, pos=label_pos, font_size=  60/(len(G.nodes)**0.5), font_weight="bold")
+    plt.show()

{cppmake-0.0.1 → cppmake-0.0.2}/cppmake.egg-info/PKG-INFO

@@ -1,9 +1,7 @@
 Metadata-Version: 2.4
 Name: cppmake
-Version: 0.0.1
+Version: 0.0.2
 Summary: none
-Home-page: https://github.com/anonymouspc/cppmake
-Author: {'name': 'anonymouspc', 'email': 'shyeyian@petalmail.com'}
 Author-email: anonymouspc <shyeyian@petalmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/anonymouspc/cppmake
@@ -11,6 +9,4 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: license.txt
-Dynamic: author
-Dynamic: home-page
 Dynamic: license-file

cppmake-0.0.2/cppmake.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+license.txt
+pyproject.toml
+readme.md
+cppmake/build.py
+cppmake/clean.py
+cppmake/test.py
+cppmake/tree.py
+cppmake.egg-info/PKG-INFO
+cppmake.egg-info/SOURCES.txt
+cppmake.egg-info/dependency_links.txt
+cppmake.egg-info/top_level.txt
+cppmake/cppmake/algorithm.py
+cppmake/cppmake/compiler.py
+cppmake/cppmake/config.py
+cppmake/cppmake/error.py
+cppmake/cppmake/executable.py
+cppmake/cppmake/make.py
+cppmake/cppmake/module.py
+cppmake/cppmake/object.py
+cppmake/cppmake/package.py
+cppmake/cppmake/run.py
+cppmake/cppmake/source.py

cppmake-0.0.2/cppmake.egg-info/top_level.txt

@@ -0,0 +1 @@
+cppmake

{cppmake-0.0.1 → cppmake-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cppmake"
-version = "0.0.1"
+version = "0.0.2"
 authors = [{name = "anonymouspc", email = "shyeyian@petalmail.com"}]
 description = "none"
 readme = "readme.md"

cppmake-0.0.1/cppmake.egg-info/SOURCES.txt

@@ -1,8 +0,0 @@
-license.txt
-pyproject.toml
-readme.md
-setup.py
-cppmake.egg-info/PKG-INFO
-cppmake.egg-info/SOURCES.txt
-cppmake.egg-info/dependency_links.txt
-cppmake.egg-info/top_level.txt

cppmake-0.0.1/cppmake.egg-info/top_level.txt

@@ -1 +0,0 @@
-

cppmake-0.0.1/setup.py

@@ -1,20 +0,0 @@
-from setuptools import setup, find_packages
-from time       import time
-
-setup(
-    name="cppmake",
-    version=f"{time()}",
-    packages=find_packages(include=["cppmake", "cppmake.*"]),
-    install_requires=[],
-    entry_points={
-        "console_scripts": [
-            "cppmake=cppmake.build:main",
-        ],
-    },
-    author={
-        "name": "anonymouspc",
-        "email": "shyeyian@petalmail.com"
-    },
-    url="https://github.com/anonymouspc/cppmake",
-    license=""
-)