cppmake 127.0.13__py3-none-any.whl → 127.0.16__py3-none-any.whl

cppmakelib/executor/scheduler.py

@@ -0,0 +1,91 @@
+from cppmakelib.basic.config      import config
+from cppmakelib.utility.decorator import member
+import asyncio
+import typing
+
+class Scheduler:
+    def __init__(self, value: int = config.parallel) -> None                            : ...
+    def schedule(self, value: int = 1)               -> typing.AsyncContextManager[None]: ...
+    max: int
+
+    class _ContextManager:
+        def       __init__  (self, scheduler: Scheduler, value: int)        -> None: ...
+        async def __aenter__(self)                                          -> None: ...
+        async def __aexit__ (self, *args: typing.Any, **kwargs: typing.Any) -> None: ...
+        _scheduler: Scheduler
+        _value    : int
+    class _NotifyFailedError(RuntimeError):
+        pass
+    async def _acquire   (self, value: int = 1) -> None: ...
+    def       _release   (self, value: int = 1) -> None: ...
+    def       _notify_one(self)                 -> None: ...
+    _value  : int
+    _waiters: dict[asyncio.Future[None], int]
+
+scheduler: Scheduler
+
+
+
+@member(Scheduler)
+def __init__(self: Scheduler, value: int = config.parallel) -> None:
+    assert value >= 0
+    self.max      = value
+    self._value   = value
+    self._waiters = {}
+
+@member(Scheduler)
+def schedule(self: Scheduler, value: int = 1) -> typing.AsyncContextManager[None]:
+    return Scheduler._ContextManager(self, value)
+
+@member(Scheduler._ContextManager)
+def __init__(self: Scheduler._ContextManager, scheduler: Scheduler, value: int):
+    self._scheduler = scheduler
+    self._value    = value
+
+@member(Scheduler._ContextManager)
+async def __aenter__(self: Scheduler._ContextManager) -> None:
+    return await self._scheduler._acquire(self._value)
+
+@member(Scheduler._ContextManager)
+async def __aexit__(self: Scheduler._ContextManager, *args: typing.Any, **kwargs: typing.Any) -> None:
+    self._scheduler._release(self._value)
+
+@member(Scheduler)
+async def _acquire(self: Scheduler, value: int = 1) -> None:
+    if self._value >= value and all(not waiter.cancelled() for waiter in self._waiters.keys()):
+        self._value -= value
+        return
+    future = asyncio.get_event_loop().create_future()
+    self._waiters[future] = value
+    try:
+        try:
+            await future
+        finally:
+            self._waiters.pop(future)
+    except asyncio.CancelledError:
+        if future.done() and not future.cancelled():
+            self._value += value
+        raise
+    finally:
+        while self._value > 0:
+            try:
+                self._notify_one()
+            except Scheduler._NotifyFailedError:
+                break
+    return
+
+@member(Scheduler)
+def _release(self: Scheduler, value: int = 1) -> None:
+    self._value += value
+    self._notify_one()
+
+@member(Scheduler)
+def _notify_one(self: Scheduler) -> None:
+    for future in self._waiters.keys():
+        if not future.done() and self._value >= self._waiters[future]:
+            self._value -= self._waiters[future]
+            future.set_result(None)
+            return
+    raise Scheduler._NotifyFailedError('no waiters notified')
+
+scheduler = Scheduler()

cppmakelib/logger/compile_commands.py

@@ -0,0 +1,30 @@
+from cppmakelib.utility.filesystemimport absolute_path, parent_path, create_dir
+from cppmakelib.utility.decorator import member
+import json
+
+class CompileCommandsLogger:
+    def __init__(self):
+        self.file = 'binary/.cache/compile_commands.json'
+        try:
+            self._content = json.load(open(self.file, 'r'))
+        except:
+            self._content = []
+
+    def __del__(self):
+        if len(self._content) > 0:
+            create_dir(parent_path(self.file))
+            json.dump(self._content, open(self.file, 'w'), indent=4)
+
+    def log_command(self, command, file):
+        for entry in self._content:
+            if entry['file'] == file:
+                self._content.remove(entry)
+        self._content.append({
+            'directory': absolute_path('.'),
+            'file'     : file,
+            'command'  : ' '.join(command)
+        })
+
+
+
+compile_commands_logger = CompileCommandsLogger()

cppmakelib/logger/module_mapper.py

@@ -0,0 +1,6 @@
+from cppmakelib.utility.filesystem import path
+
+class ModuleMapperLogger:
+    def mapper_file_of(self, import_dir: path) -> path: ...
+
+module_mapper_logger: ModuleMapperLogger

cppmakelib/logger/unit_status.py

@@ -0,0 +1,224 @@
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.error.logic        import LogicError
+from cppmakelib.executor.operation import when_all
+from cppmakelib.unit.code          import Code
+from cppmakelib.unit.module        import Module
+from cppmakelib.unit.object        import Object
+from cppmakelib.unit.source        import Source
+from cppmakelib.utility.filesystem import path
+from cppmakelib.utility.decorator  import member
+import json
+import re
+import typing
+
+class UnitStatusLogger:
+    # ========
+    def __init__                          (self, build_cache_dir: path)                     -> None      : ...
+    def __del__                           (self)                                            -> None      : ...
+    # ========
+    def             get_code_preprocessed (self, code  : Code)                              -> bool      : ...
+    def             set_code_preprocessed (self, code  : Code,    preprocessed: bool)       -> None      : ...
+    # ========
+    async def async_get_module_name       (self, module: Module)                            -> str       : ...
+    def             set_module_name       (self, module: Module,  name        : str)        -> None      : ...
+    async def async_get_module_imports    (self, module: Module)                            -> list[path]: ...
+    async def async_set_module_imports    (self, module: Module,  imports     : list[path]) -> None      : ...
+    def             get_module_precompiled(self, module: Module)                            -> bool      : ...
+    def             set_module_precompiled(self, module: Module,  precompiled : bool)       -> None      : ...
+    # ========
+    async def async_get_source_imports    (self, source: Source)                            -> list[path]: ...
+    async def async_set_source_imports    (self, source: Source,  imports     : list[path]) -> None      : ...
+    def             get_source_compiled   (self, source: Source)                            -> bool      : ...
+    def             set_source_compiled   (self, source: Source,  compiled    : bool)       -> None      : ...
+    # ========
+    def             get_object_libs       (self, object: Object)                            -> list[path]: ...
+    def             set_object_libs       (self, object: Object,  libs        : list[path]) -> None      : ...
+    def             get_object_shared     (self, object: Object)                            -> bool      : ...
+    def             set_object_shared     (self, object: Object,  shared      : bool)       -> None      : ...
+    def             get_object_linked     (self, object: Object)                            -> bool      : ...
+    def             set_object_linked     (self, object: Object,  linked      : bool)       -> None      : ...
+    # ========
+
+    class _StatusNotFoundError(KeyError):
+        pass
+    def _get    (self, entry: list[str], check: dict[str, typing.Any], result: str)                   -> typing.Any           : ...
+    def _set    (self, entry: list[str], check: dict[str, typing.Any], result: dict[str, typing.Any]) -> None                 : ...
+    def _reflect(self, object: object)                                                                -> dict[str, typing.Any]: ...
+    _content : typing.Any
+    
+
+
+@member(UnitStatusLogger)
+def __init__(self: UnitStatusLogger, build_cache_dir: path) -> None:
+    try:
+        self._content = json.load(open(f'{build_cache_dir}/unit_status.json', 'r'))
+    except:
+        self._content = {}
+
+@member(UnitStatusLogger)
+def get_code_preprocessed(self: UnitStatusLogger, code: Code) -> bool:
+    try:
+        return self._get(entry=['code', 'preprocessed', code.file], check={'code': code, 'compiler': compiler}, result='preprocessed')
+    except UnitStatusLogger._StatusNotFoundError:
+        return False
+
+@member(UnitStatusLogger)
+def set_code_preprocessed(self: UnitStatusLogger, code: Code, preprocessed: bool) -> None:
+    self._set(entry=['code', 'preprocessed', code.file], check={'code': code, 'compiler': compiler}, result={'preprocessed': preprocessed})
+
+@member(UnitStatusLogger)
+async def async_get_module_name(self: UnitStatusLogger, module: Module) -> str:
+    try:
+        name = self._get(entry=['module', 'name', module.file], check={'module': module, 'compiler': compiler}, result='name')
+    except UnitStatusLogger._StatusNotFoundError:
+        await module.async_preprocess()
+        statements = re.findall(
+            pattern=r'^\s*(export\s+)?module\s+(\w+([\.:]\w+)*)\s*;\s*$',
+            string =open(module.preprocessed_file).read(),
+            flags  =re.MULTILINE
+        )
+        if len(statements) == 0:
+            raise LogicError(f'module {module.file} does not have a export statement')
+        elif len(statements) == 1:
+            name = statements[0].group(2)
+            self.set_module_name(module=module, name=name)
+        else: # len(exports) >= 2:
+            raise LogicError(f'module {module.file} has multiple export statements (with statements = {statements})')
+    return name
+        
+@member(UnitStatusLogger)
+def set_module_name(self: UnitStatusLogger, module: Module, name: str) -> None:
+    self._set(entry=['module', 'name', module.file], check={'module': module, 'compiler': compiler}, result={'name': name})
+
+@member(UnitStatusLogger)
+async def async_get_module_imports(self: UnitStatusLogger, module: Module) -> list[path]:
+    try:
+        imports = self._get(entry=['module', 'imports', module.file], check={'module':  module, 'compiler': compiler}, result='imports')
+    except UnitStatusLogger._StatusNotFoundError:
+        await module.async_preprocess()
+        statements = re.findall(
+            pattern=r'^\s*import\s+module\s+(\w+([\.:]\w+)*)\s*;\s$',
+            string =open(module.preprocessed_file, 'r').read(),
+            flags  =re.MULTILINE
+        )
+        imports = [f'{module.context_package.search_module_dir}/{statement.group(1).replace('.', '/').replace(':', '/')}' for statement in statements]
+        await self.async_set_module_imports(module=module, imports=imports)
+    return imports
+
+@member(UnitStatusLogger)
+async def async_set_module_imports(self: UnitStatusLogger, module: Module, imports: list[path]) -> None:
+    self._set(entry=['module', 'imports', module.file],        check={'module': module,                     'compiler': compiler}, result={'imports': imports})
+    self._set(entry=['object', 'libs',    module.object_file], check={'object': Object(module.object_file), 'compiler': compiler}, result={'libs'   : [module.object_file for module in await when_all([Module.__anew__(Module, import_) for import_ in imports])]})
+
+@member(UnitStatusLogger)
+def get_module_precompiled(self: UnitStatusLogger, module: Module) -> bool:
+    try:
+        return self._get(entry=['module', 'precompiled', module.file], check={'module': module, 'compiler': compiler}, result='precompiled')
+    except UnitStatusLogger._StatusNotFoundError:
+        return False
+
+@member(UnitStatusLogger)
+def set_module_precompiled(self: UnitStatusLogger, module: Module, precompiled: bool) -> None:
+    self._set(entry=['module', 'precompiled', module.file], check={'module': module, 'compiler': compiler}, result={'precompiled': precompiled})
+
+@member(UnitStatusLogger)
+async def async_get_source_imports(self: UnitStatusLogger, source: Source) -> list[path]:
+    try:
+        imports = self._get(entry=['source', 'imports', source.file], check={'source': source, 'compiler': compiler}, result='imports')
+    except UnitStatusLogger._StatusNotFoundError:
+        await source.async_preprocess()
+        statements = re.findall(
+            pattern=r'^\s*import\s+module\s+(\w+([\.:]\w+)*)\s*;\s$',
+            string =open(source.preprocessed_file, 'r').read(),
+            flags  =re.MULTILINE
+        )
+        imports = [f'{source.context_package.search_module_dir}/{statement.group(1).replace('.', '/').replace(':', '/')}' for statement in statements]
+        await self.async_set_source_imports(source=source, imports=imports)
+    return imports
+
+@member(UnitStatusLogger)
+async def async_set_source_imports(self: UnitStatusLogger, source: Source, imports: list[path]) -> None:
+    self._set(entry=['source', 'imports', source.file],        check={'source': source,                     'compiler': compiler}, result={'imports': imports})
+    self._set(entry=['object', 'libs',    source.object_file], check={'object': Object(source.object_file), 'compiler': compiler}, result={'libs'   : [module.object_file for module in await when_all([Module.__anew__(Module, import_) for import_ in imports])]})
+
+@member(UnitStatusLogger)
+def get_source_compiled(self: UnitStatusLogger, source: Source) -> bool:
+    try:
+        return self._get(entry=['source', 'compiled', source.file], check={'source': source, 'compiler': compiler}, result='compiled')
+    except UnitStatusLogger._StatusNotFoundError:
+        return False
+
+@member(UnitStatusLogger)
+def set_source_compiled(self: UnitStatusLogger, source: Source, compiled: bool) -> None:
+    self._set(entry=['source', 'compiled', source.file], check={'source': source, 'compiler': compiler}, result={'compiled': compiled})        
+
+@member(UnitStatusLogger)
+def get_object_libs(self: UnitStatusLogger, object: Object) -> list[path]:
+    try:
+        return self._get(entry=['object', 'libs', object.file], check={'object': object, 'compiler': compiler}, result='libs')
+    except UnitStatusLogger._StatusNotFoundError:
+        raise LogicError(f'object does not have a libs cache (from a module or source)')
+
+@member(UnitStatusLogger)
+def set_object_libs(self: UnitStatusLogger, object: Object, libs: list[path]) -> None:
+    self._set(entry=['object', 'libs', object.file], check={'object': object, 'compiler': compiler}, result={'libs': libs})
+
+@member(UnitStatusLogger)
+def get_object_shared(self: UnitStatusLogger, object: Object) -> bool:
+    try:
+        return self._get(entry=['object', 'shared', object.file], check={'object': object, 'compiler': compiler}, result='shared')
+    except UnitStatusLogger._StatusNotFoundError:
+        return False
+    
+@member(UnitStatusLogger)
+def set_object_shared(self: UnitStatusLogger, object: Object, shared: bool) -> None:
+    self._set(entry=['object', 'shared', object.file], check={'object': object, 'compiler': compiler}, result={'shared': shared})
+
+@member(UnitStatusLogger)
+def get_object_linked(self: UnitStatusLogger, object: Object) -> bool:
+    try:
+        return self._get(entry=['object', 'linked', object.file], check={'object': object, 'compiler': compiler}, result='linked')
+    except UnitStatusLogger._StatusNotFoundError:
+        return False
+    
+@member(UnitStatusLogger)
+def set_object_linked(self: UnitStatusLogger, object: Object, linked: bool) -> None:
+    self._set(entry=['object', 'linked', object.file], check={'object': object, 'compiler': compiler}, result={'linked': linked})
+
+@member(UnitStatusLogger)
+def _get(self: UnitStatusLogger, entry: list[str], check: dict[str, typing.Any], result: str) -> typing.Any | typing.Literal[False]:
+    ptr = self._content
+    for subentry in entry:
+        if subentry not in ptr.keys():
+            raise UnitStatusLogger._StatusNotFoundError()
+        ptr = ptr[subentry]
+    for subcheck in check.keys():
+        if ptr[subcheck] != self._reflect(ptr[subcheck]):
+            raise UnitStatusLogger._StatusNotFoundError()
+    return ptr[result]
+
+@member(UnitStatusLogger)
+def _set(self: UnitStatusLogger, entry: list[str], check: dict[str, typing.Any], result: dict[str, typing.Any]) -> None:
+    ptr = self._content
+    for subentry in entry:
+        if subentry not in ptr.keys():
+            ptr[subentry] = {}
+        ptr = ptr[subentry]
+    for subcheck in check.keys():
+        ptr[subcheck] = self._reflect(check[subcheck])
+    for subresult in result.keys():
+        ptr[subresult] = self._reflect(result[subresult])
+
+@member(UnitStatusLogger)
+def _reflect(self: UnitStatusLogger, object: object) -> dict[str, typing.Any]:
+    reflected = vars(object)
+    for key, value in reflected.items():
+        if hasattr(value, '__dict__'):
+            reflected[key] = '...'
+        elif isinstance(value, list):
+            for index, subvalue in enumerate(typing.cast(list[object], value)):
+                value[index] = self._reflect(subvalue)
+        else:
+            reflected.pop(key)
+    return reflected
+        

cppmakelib/system/all.py

@@ -0,0 +1,25 @@
+from cppmakelib.error.config   import ConfigError
+from cppmakelib.system.linux   import Linux
+from cppmakelib.system.macos   import Macos
+from cppmakelib.system.windows import Windows
+
+system: Linux | Macos | Windows
+
+
+
+def _choose_system() -> Linux | Macos | Windows:
+    matches: list[Linux | Macos | Windows] = []
+    errors : list[Exception]               = []
+    for System in (Linux, Macos, Windows):
+        try:
+            matches += [System()]
+        except ConfigError as error:
+            errors += [error]
+    if len(matches) == 0:
+        raise ConfigError(f'system is not supported (with matches = {matches})') from ExceptionGroup('no compiler is matched', errors)
+    elif len(matches) == 1:
+        return matches[0]
+    else:
+        raise ConfigError(f'system is ambiguous (with matches = {matches})')
+
+system = _choose_system()

cppmakelib/system/linux.py

@@ -0,0 +1,26 @@
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.utility.decorator  import member
+from cppmakelib.utility.filesystem import path
+
+import sys
+
+class Linux:
+    def __init__(self) -> None: ...
+    executable_suffix: str  = ''
+    object_suffix    : str  = '.o'
+    static_suffix    : str  = '.a'
+    dynamic_suffix   : str  = '.so'
+    compiler         : path = 'g++'
+
+    def _check(self) -> None: ...
+
+
+
+@member(Linux)
+def __init__(self: Linux) -> None:
+    self._check()
+
+@member(Linux)
+def _check(self: Linux) -> None:
+    if sys.platform != 'linux':
+        raise ConfigError(f'linux check failed (with sys.platform = {sys.platform})')

cppmakelib/system/macos.py

@@ -0,0 +1,26 @@
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.utility.decorator  import member
+from cppmakelib.utility.filesystem import path
+
+import sys
+
+class Macos:
+    def __init__(self) -> None: ...
+    executable_suffix: str  = ''
+    object_suffix    : str  = '.o'
+    static_suffix    : str  = '.a'
+    dynamic_suffix   : str  = '.dylib'
+    compiler         : path = 'clang++'
+
+    def _check(self) -> None: ...
+
+
+
+@member(Macos)
+def __init__(self: Macos) -> None:
+    self._check()
+
+@member(Macos)
+def _check(self: Macos) -> None:
+    if sys.platform != 'darwin':
+        raise ConfigError(f'macos check failed (with sys.platform = {sys.platform})')

cppmakelib/system/windows.py

@@ -0,0 +1,26 @@
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.utility.decorator  import member
+from cppmakelib.utility.filesystem import path
+
+import sys
+
+class Windows:
+    def __init__(self) -> None: ...
+    executable_suffix: str  = '.exe'
+    object_suffix    : str  = '.obj'
+    static_suffix    : str  = '.lib'
+    dynamic_suffix   : str  = '.dll'
+    compiler         : path = 'cl.exe'
+
+    def _check(self) -> None: ...
+
+
+
+@member(Windows)
+def __init__(self: Windows) -> None:
+    self._check()
+
+@member(Windows)
+def _check(self: Windows) -> None:
+    if sys.platform != 'win32' and sys.platform != 'win64':
+        raise ConfigError(f'windows check failed (with sys.platform = {sys.platform})')

cppmakelib/unit/binary.py

@@ -0,0 +1,26 @@
+from cppmakelib.basic.context      import context
+from cppmakelib.unit.package       import Package
+from cppmakelib.utility.decorator  import member, unique
+from cppmakelib.utility.filesystem import path
+
+class Binary:
+    def           __new__  (cls,  file       : path) -> Binary: ...
+    def           __init__ (self, file       : path) -> None  : ...
+    def             install(self, install_dir: path) -> Binary: ...
+    async def async_install(self, install_dir: path) -> Binary: ...
+    def             sign   (self)                    -> Binary: ...
+    async def async_sign   (self)                    -> Binary: ...
+    def             strip  (self)                    -> Binary: ...
+    async def async_strip  (self)                    -> Binary: ...
+    file           : path
+    context_package: Package
+    link_flags     : list[str]
+
+
+
+@member(Binary)
+@unique
+def __init__(self: Binary, file: path) -> None:
+    self.file            = file
+    self.context_package = context.package
+    self.link_flags      = self.context_package.link_flags

cppmakelib/unit/code.py

@@ -0,0 +1,62 @@
+from cppmakelib.basic.context      import context
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.executor.scheduler import scheduler
+from cppmakelib.unit.package       import Package
+from cppmakelib.unit.preprocessed  import Preprocessed
+from cppmakelib.utility.algorithm  import recursive_collect
+from cppmakelib.utility.decorator  import member, once, relocatable, syncable, unique
+from cppmakelib.utility.filesystem import modified_time_file, path, relative_path
+from cppmakelib.utility.time       import time
+
+class Code:
+    def           __new__          (cls: ..., file: path) -> Code        : ...
+    async def    __anew__          (cls: ..., file: path) -> Code        : ...
+    def           __init__         (self,     file: path) -> None        : ...
+    async def    __ainit__         (self,     file: path) -> None        : ...
+    def             preprocess     (self)                 -> Preprocessed: ...
+    async def async_preprocess     (self)                 -> Preprocessed: ...
+    def             is_preprocessed(self)                 -> bool        : ...
+    async def async_is_preprocessed(self)                 -> bool        : ...
+    file             : path
+    modified_time    : time
+    preprocessed_file: path
+    compile_flags    : list[str]
+    define_macros    : dict[str, str]
+    context_package  : Package
+
+
+
+@member(Code)
+@relocatable
+@syncable
+@unique
+async def __ainit__(self: Code, file: path) -> None:
+    self.file              = file
+    self.modified_time     = modified_time_file(self.file)
+    self.context_package   = context.package
+    self.preprocessed_file = f'{self.context_package.build_code_dir}/{relative_path(from_path=self.context_package.dir, to_path=self.file)}'
+    self.compile_flags     = self.context_package.compile_flags
+    self.define_macros     = self.context_package.define_macros
+
+@member(Code)
+@syncable
+@once
+async def async_preprocess(self: Code) -> Preprocessed:
+    if not await self.async_is_preprocessed():
+        async with scheduler.schedule():
+            await compiler.async_preprocess(
+                code_file        =self.file,
+                preprocessed_file=self.preprocessed_file,
+                compile_flags    =self.compile_flags,
+                define_macros    =self.define_macros,
+                include_dirs     =[self.context_package.search_header_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_include_dir)
+            )
+        self.context_package.unit_status_logger.set_code_preprocessed(code=self, preprocessed=True)
+    return Preprocessed(self.preprocessed_file)
+
+@member(Code)
+@syncable
+@once
+async def async_is_preprocessed(self: Code) -> bool:
+    return self.context_package.unit_status_logger.get_code_preprocessed(code=self)
+               

cppmakelib/unit/dynamic.py

@@ -0,0 +1,12 @@
+from cppmakelib.unit.binary        import Binary
+from cppmakelib.utility.decorator  import member, unique
+from cppmakelib.utility.filesystem import path
+
+class Dynamic(Binary):
+    def __new__  (cls,  file: path) -> Dynamic: ...
+    def __init__ (self, file: path) -> None   : ...
+
+@member(Dynamic)
+@unique
+def __init__(self: Dynamic, file: path) -> None:
+    super(Dynamic, self).__init__(file)

cppmakelib/unit/executable.py

@@ -0,0 +1,35 @@
+from cppmakelib.error.subprocess    import SubprocessError
+from cppmakelib.executor.run        import async_run
+from cppmakelib.unit.binary         import Binary
+from cppmakelib.utility.decorator   import member, once, syncable, unique
+from cppmakelib.utility.filesystem  import path
+
+class Executable(Binary):
+    def           __new__  (cls,  file: path) -> Executable: ...
+    def           __init__ (self, file: path) -> None      : ...
+    def             execute(self)             -> None      : ...
+    async def async_execute(self)             -> None      : ...
+    def             test   (self)             -> None      : ...
+    async def async_test   (self)             -> None      : ...
+
+
+
+@member(Executable)
+@unique
+def __init__(self: Executable, file: path) -> None:
+    super(Executable, self).__init__(file)
+    
+@member(Executable)
+@syncable
+@once
+async def async_execute(self: Executable) -> None:
+    try:
+        await async_run(file=self.file)
+    except SubprocessError:
+        pass
+
+@member(Executable)
+@syncable
+@once
+async def async_test(self: Executable) -> None:
+    await async_run(file=self.file)

cppmakelib/unit/header.py

@@ -0,0 +1,63 @@
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.executor.operation import when_all
+from cppmakelib.executor.scheduler import scheduler
+from cppmakelib.unit.code          import Code
+from cppmakelib.unit.preparsed     import Preparsed
+from cppmakelib.utility.algorithm  import recursive_collect
+from cppmakelib.utility.decorator  import member, once, relocatable, syncable, unique
+from cppmakelib.utility.filesystem import path, relative_path
+
+class Header(Code):
+    def           __new__       (cls: ..., file: path) -> Header   : ...
+    async def    __anew__       (cls: ..., file: path) -> Header   : ...
+    def           __init__      (self,     file: path) -> None     : ...
+    async def    __ainit__      (self,     file: path) -> None     : ...
+    def             preparse    (self)                 -> Preparsed: ...
+    async def async_preparse    (self)                 -> Preparsed: ...
+    def             is_preparsed(self)                 -> bool     : ...
+    async def async_is_preparsed(self)                 -> bool     : ...
+    name            : str
+    preparsed_file  : path
+    object_file     : path
+    diagnostic_file : path
+    include_headers : list[Header]
+
+
+
+@member(Header)
+@relocatable
+@syncable
+@unique
+async def __ainit__(self: Header, file: path) -> None:
+    await super(Header, self).__ainit__(file)
+    self.name            = relative_path(from_path=self.context_package.search_header_dir, to_path=self.file)
+    self.preparsed_file  = f'{self.context_package.build_header_dir}/{self.name}{compiler.preparsed_suffix}'
+    self.diagnostic_file = f'{self.context_package.build_header_dir}/{self.name}{compiler.diagnostic_suffix}'
+    self.include_headers = await when_all([Header.__anew__(Header, file) for file in self.context_package.unit_status_logger.get_header_includes(header=self)])
+
+@member(Header)
+@syncable
+@once
+async def async_preparse(self: Header) -> Preparsed:
+    if not await self.async_is_preparsed():
+        await when_all([header.async_preparse() for header in self.include_headers])
+        await self.async_preprocess()
+        async with scheduler.schedule():
+            await compiler.async_preparse(
+                header_file    =self.file,
+                preparsed_file =self.preparsed_file,
+                compile_flags  =self.compile_flags,
+                define_macros  =self.define_macros,
+                include_dirs   =[self.context_package.build_header_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_include_dir),
+                diagnostic_file=self.diagnostic_file
+            )
+        self.context_package.unit_status_logger.set_header_preparsed(header=self, result=True)
+    return Preparsed(self.preparsed_file)
+
+@member(Header)
+@syncable
+@once
+async def async_is_preparsed(self: Header) -> bool:
+    return all(await when_all([header.async_is_preparsed() for header in self.include_headers])) and \
+           await self.async_is_preparsed()                                                       and \
+           self.context_package.unit_status_logger.get_header_preparsed(header=self)