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

cppmakelib/compiler/clang.py

@@ -0,0 +1,196 @@
+from cppmakelib.basic.config       import config
+from cppmakelib.compiler.gcc       import Gcc
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.error.subprocess   import SubprocessError
+from cppmakelib.executor.run       import async_run
+from cppmakelib.utility.decorator  import member, syncable, unique
+from cppmakelib.utility.filesystem import create_dir, exist_file, parent_dir, path
+from cppmakelib.utility.version    import Version
+
+class Clang(Gcc):
+    def           __init__    (self, file: path = 'clang++')                                                                                                                                                                                                            -> None: ...
+    async def    __ainit__    (self, file: path = 'clang++')                                                                                                                                                                                                            -> None: ...
+    def             precompile(self, module_file: path, precompiled_file: path, object_file: path, compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    async def async_precompile(self, module_file: path, precompiled_file: path, object_file: path, compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    def             preparse  (self, header_file: path, preparsed_file  : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [],                               diagnostic_file: path | None = None) -> None: ...
+    async def async_preparse  (self, header_file: path, preparsed_file  : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [],                               diagnostic_file: path | None = None) -> None: ...
+    def             compile   (self, source_file: path, object_file     : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    async def async_compile   (self, source_file: path, object_file     : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    preparsed_suffix  : str = '.pch'
+    precompiled_suffix: str = '.pcm'
+    file              : path
+    version           : Version
+    stdlib_name       : str
+    stdlib_module_file: path
+    stdlib_static_file: path
+    stdlib_shared_file: path
+    compile_flags     : list[str]
+    link_flags        : list[str]
+    define_macros     : dict[str, str]
+
+    async def _async_get_version           (self) -> Version: ...
+    async def _async_get_stdlib_name       (self) -> str: ...
+    async def _async_get_stdlib_module_file(self) -> path   : ...
+
+
+
+@member(Clang)
+@syncable
+@unique
+async def __ainit__(
+    self: Clang, 
+    file: path = 'clang++'
+) -> None:
+    self.file               = file
+    self.version            = await self._async_get_version()
+    self.stdlib_name        = await self._async_get_stdlib_name()
+    self.stdlib_module_file = await self._async_get_stdlib_module_file()
+    self.compile_flags = [
+       f'-std={config.std}',
+       f'-stdlib={self.stdlib_name}',
+        *(['-O0', '-g'] if config.type == 'debug'   else
+          ['-O3']       if config.type == 'release' else
+          ['-Os']       if config.type == 'size'    else 
+          [])
+    ]
+    self.link_flags = [
+        *(['-s']          if config.type == 'release' or config.type == 'size' else []),
+        *(['-lstdc++exp'] if self.stdlib_name == 'libstdc++'                   else [])
+    ]
+    self.define_macros = {
+        **({'DEBUG' : 'true'} if config.type == 'debug'   else 
+           {'NDEBUG': 'true'} if config.type == 'release' else 
+           {})
+    }
+
+@member(Clang)
+@syncable
+async def async_precompile(
+    self            : Clang, 
+    module_file     : path, 
+    precompiled_file: path, 
+    object_file     : path, 
+    compile_flags   : list[str]      = [], 
+    define_macros   : dict[str, str] = {}, 
+    include_dirs    : list[path]     = [], 
+    import_dirs     : list[path]     = [], 
+    diagnostic_file : path | None    = None
+) -> None:
+    create_dir(parent_dir(precompiled_file))
+    create_dir(parent_dir(object_file))
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            *[f'-fprebuilt-module-path={import_dir}' for import_dir in import_dirs],
+            '--precompile', '-x', 'c++-module', module_file,
+            '-o', precompiled_file
+        ]
+    )
+    await async_run(
+        file=self.file,
+        args=[
+            *[f'-fprebuilt-module-path={import_dir}' for import_dir in import_dirs],
+            '-c', module_file,
+            '-o', object_file
+        ]
+    )
+
+@member(Gcc)
+@syncable
+async def async_preparse(
+    self           : Gcc,
+    header_file    : path,
+    preparsed_file : path,
+    compile_flags  : list[str]      = [],
+    define_macros  : dict[str, str] = {},
+    include_dirs   : list[path]     = [],
+    diagnostic_file: path | None    = None
+) -> None:
+    create_dir(parent_dir(preparsed_file))
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            '-c', '-x', 'c++-header', header_file,
+            '-o', preparsed_file
+        ]
+    )
+
+@member(Clang)
+@syncable
+async def async_compile(
+    self: Clang, 
+    source_file    : path, 
+    object_file    : path, 
+    compile_flags  : list[str]      = [], 
+    define_macros  : dict[str, str] = {}, 
+    include_dirs   : list[path]     = [], 
+    import_dirs    : list[path]     = [], 
+    diagnostic_file: path | None    = None
+) -> None:
+    create_dir(parent_dir(object_file))
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            *[f'-fprebuilt-module-path={import_dir}' for import_dir in import_dirs],
+            '-c', '-x', 'c++', source_file,
+            '-o', object_file
+        ]
+    )
+
+@member(Clang)
+async def _async_get_version(self: Clang) -> Version:
+    try:
+        stdout = await async_run(
+            file=self.file,
+            args=['--version'],
+            return_stdout=True
+        )
+    except SubprocessError as error:
+        raise ConfigError(f'clang check failed (with file = {self.file})') from error
+    if not stdout.startswith('clang') and 'clang version' not in stdout:
+        raise ConfigError(f'clang check failed (with file = {self.file}, subprocess = "{self.file} --version", stdout = "{stdout.splitlines()[0]} ...", requires = "clang++ ..." or "... clang version ...")')
+    version = Version.parse(stdout)
+    if version < 21:
+        raise ConfigError(f'clang version is too old (with file = {self.file}, version = {version}, requires = 21+)')
+    return version
+
+async def _async_get_stdlib_name(self: Clang) -> str:
+    stderr = await async_run(
+        file=self.file,
+        args=[
+            *self.compile_flags,
+            '-v',
+        ],
+        return_stderr=True
+    )
+    if 'selected gcc installation' in stderr.lower():
+        return 'libstdc++'
+    else:
+        return 'libc++'    
+
+async def _async_get_stdlib_module_file(self: Clang) -> path:
+    if self.stdlib_name == 'libc++':
+        resource_dir = await async_run(
+            file=self.file,
+            args=['--print-resource-dir'],
+            return_stdout=True,
+        )
+        resource_dir = path(resource_dir.strip())
+        search_file = f'{resource_dir}/../../../share/libc++/v1/std.cppm'
+        if exist_file(search_file): 
+            return search_file
+        else:
+            raise ConfigError(f'libc++ module_file is not found (with search_file = {search_file})')
+    elif self.stdlib_name == 'libstdc++':
+        return await Gcc._async_get_stdlib_module_file(self)
+    else:
+        assert False

cppmakelib/compiler/emcc.py

@@ -0,0 +1,79 @@
+from cppmakelib.basic.config       import config
+from cppmakelib.compiler.clang     import Clang
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.error.subprocess   import SubprocessError
+from cppmakelib.executor.run       import async_run
+from cppmakelib.utility.decorator  import member, syncable, unique
+from cppmakelib.utility.filesystem import path
+from cppmakelib.utility.version    import Version
+
+class Emcc(Clang):
+    def        __init__(self, file: path = 'em++') -> None: ...
+    async def __ainit__(self, file: path = 'em++') -> None: ...
+    file              : path
+    version           : Version
+    stdlib_name       : str = 'libc++'
+    stdlib_module_file: path
+    stdlib_static_file: path
+    stdlib_shared_file: path
+    compile_flags     : list[str]
+    link_flags        : list[str]
+    define_macros     : dict[str, str]
+
+    async def _async_get_version    (self) -> Version: ...
+    async def _async_get_stdlib_name(self) -> str    : ...
+
+@member(Emcc)
+@syncable
+@unique
+async def __ainit__(
+    self: Emcc, 
+    file: path = 'em++'
+) -> None:
+    self.file               = file
+    self.version            = await self._async_get_version()
+    self.stdlib_name        = 'libc++'
+    self.stdlib_module_file = await self._async_get_stdlib_module_file()
+    self.compile_flags = [
+       f'-std={config.std}', '-fexceptions',
+        *(['-O0', '-g'] if config.type == 'debug'   else
+          ['-O3']       if config.type == 'release' else
+          ['-Os']       if config.type == 'size'    else 
+          [])
+    ]
+    self.link_flags = [
+        *(['-s'] if config.type == 'release' or config.type == 'size' else []),
+    ]
+    self.define_macros = {
+        **({'DEBUG' : 'true'} if config.type == 'debug'   else 
+           {'NDEBUG': 'true'} if config.type == 'release' else 
+           {})
+    }
+
+@member(Emcc)
+async def _async_get_version(self: Emcc) -> Version:
+    try:
+        stdout = await async_run(
+            file=self.file,
+            args=['--version'],
+            return_stdout=True
+        )
+    except SubprocessError as error:
+        raise ConfigError(f'emcc check failed (with file = {self.file})') from error
+    if not stdout.startswith('em++'):
+        raise ConfigError(f'emcc check failed (with file = {self.file}, subprocess = "{self.file} --version", stdout = "{stdout.splitlines()[0]} ...", requires = "em++ ...")')
+    version = Version.parse(stdout)
+    if version < 4:
+        raise ConfigError(f'emcc version is too old (with file = {self.file}, version = {version}, requires = 4+)')
+    return version
+
+@member(Emcc)
+async def _async_get_stdlib_module_file(self: Emcc) -> path:
+    clang_stdlib_name = await Clang._async_get_stdlib_name(self)
+    if clang_stdlib_name == 'libc++':
+        try:
+            return await Clang._async_get_stdlib_module_file(self)
+        except ConfigError as error:
+            raise ConfigError(f'libc++ module_file is not found (with file = {self.file}, subcompiler = clang++)') from error
+    else:
+        raise ConfigError(f'libc++ module_file is not found (with file = {self.file}, clang_stdlib_name = {clang_stdlib_name})')

cppmakelib/compiler/gcc.py

@@ -0,0 +1,237 @@
+from cppmakelib.basic.config         import config
+from cppmakelib.error.config         import ConfigError
+from cppmakelib.error.subprocess     import SubprocessError
+from cppmakelib.executor.run         import async_run
+from cppmakelib.logger.module_mapper import module_mapper_logger
+from cppmakelib.utility.decorator    import member, syncable, unique
+from cppmakelib.utility.filesystem   import create_dir, exist_file, parent_dir, path
+from cppmakelib.utility.version      import Version
+import re
+
+class Gcc:
+    def           __init__    (self, file: path = 'g++')                                                                                                                                                                                                                 -> None: ...
+    async def    __ainit__    (self, file: path = 'g++')                                                                                                                                                                                                                 -> None: ...
+    def             preprocess(self, code_file  : path, preprocessed_file: path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [])                                                                    -> None: ...
+    async def async_preprocess(self, code_file  : path, preprocessed_file: path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [])                                                                    -> None: ...
+    def             preparse  (self, header_file: path, preparsed_file   : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [],                               diagnostic_file: path | None = None) -> None: ...
+    async def async_preparse  (self, header_file: path, preparsed_file   : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [],                               diagnostic_file: path | None = None) -> None: ...
+    def             precompile(self, module_file: path, precompiled_file : path, object_file: path, compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    async def async_precompile(self, module_file: path, precompiled_file : path, object_file: path, compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    def             compile   (self, source_file: path, object_file      : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    async def async_compile   (self, source_file: path, object_file      : path,                    compile_flags: list[str] = [], define_macros: dict[str, str] = {}, include_dirs: list[path] = [], import_dirs: list[path] = [], diagnostic_file: path | None = None) -> None: ...
+    def             share     (self, object_file: path, dynamic_file     : path,                    link_flags   : list[str] = [],                                     lib_files   : list[path] = [])                                                                    -> None: ...
+    async def async_share     (self, object_file: path, dynamic_file     : path,                    link_flags   : list[str] = [],                                     lib_files   : list[path] = [])                                                                    -> None: ...
+    def             link      (self, object_file: path, executable_file  : path,                    link_flags   : list[str] = [],                                     lib_files   : list[path] = [])                                                                    -> None: ...
+    async def async_link      (self, object_file: path, executable_file  : path,                    link_flags   : list[str] = [],                                     lib_files   : list[path] = [])                                                                    -> None: ...
+    preprocessed_suffix: str = '.ipp'
+    preparsed_suffix   : str = '.gch'
+    precompiled_suffix : str = '.gcm'  
+    diagnostic_suffix  : str = '.sarif'
+    file               : path
+    version            : Version
+    stdlib_name        : str = 'libstdc++'
+    stdlib_module_file : path
+    stdlib_static_file : path
+    stdlib_shared_file : path
+    compile_flags      : list[str]
+    link_flags         : list[str]
+    define_macros      : dict[str, str]
+
+    async def _async_get_version           (self) -> Version: ...
+    async def _async_get_stdlib_module_file(self) -> path   : ...
+
+
+
+@member(Gcc)
+@syncable
+@unique
+async def __ainit__(
+    self: Gcc, 
+    file: path = 'g++'
+) -> None:
+    self.file               = file
+    self.version            = await self._async_get_version()
+    self.stdlib_module_file = await self._async_get_stdlib_module_file()
+    self.compile_flags = [
+       f'-std={config.std}', '-fmodules', 
+        *(['-O0', '-g'] if config.type == 'debug'   else
+          ['-O3']       if config.type == 'release' else
+          ['-Os']       if config.type == 'size'    else 
+          []) 
+    ]
+    self.link_flags = [
+        *(['-s'] if config.type == 'release' or config.type == 'size' else []),
+        '-lstdc++exp'
+    ]
+    self.define_macros = {
+        **({'DEBUG'  : 'true'} if config.type == 'debug'   else
+           {'DNDEBUG': 'true'} if config.type == 'release' else
+           {})
+    }
+
+@member(Gcc)
+@syncable
+async def async_preprocess(
+    self             : Gcc, 
+    unit_file        : path, 
+    preprocessed_file: path, 
+    compile_flags    : list[str]      = [], 
+    define_macros    : dict[str, str] = {}, 
+    include_dirs     : list[path]     = []
+) -> None:
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            '-E', unit_file,
+            '-o', preprocessed_file
+        ],
+        print_stdout=False,
+    )
+
+@member(Gcc)
+@syncable
+async def async_preparse(
+    self           : Gcc,
+    header_file    : path,
+    preparsed_file : path,
+    compile_flags  : list[str]      = [],
+    define_macros  : dict[str, str] = {},
+    include_dirs   : list[path]     = [],
+    diagnostic_file: path | None    = None
+) -> None:
+    create_dir(parent_dir(preparsed_file))
+    create_dir(parent_dir(diagnostic_file)) if diagnostic_file is not None else None
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            *([f'-fdiagnostics-add-output=sarif:file={diagnostic_file}'] if diagnostic_file is not None else []),
+            '-c', '-x', 'c++-header', header_file,
+            '-o', preparsed_file
+        ]
+    )
+    
+
+@member(Gcc)
+@syncable
+async def async_precompile(
+    self            : Gcc, 
+    module_file     : path, 
+    precompiled_file: path, 
+    object_file     : path, 
+    compile_flags   : list[str]      = [], 
+    define_macros   : dict[str, str] = {}, 
+    include_dirs    : list[path]     = [], 
+    import_dirs     : list[path]     = [], 
+    diagnostic_file : path | None    = None
+) -> None:
+    create_dir(parent_dir(precompiled_file))
+    create_dir(parent_dir(object_file))
+    create_dir(parent_dir(diagnostic_file)) if diagnostic_file is not None else None
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            *[f'-fmodule-mapper={module_mapper_logger.mapper_file_of(import_dir=import_dir)}' for import_dir in import_dirs],
+            *([f'-fdiagnostics-add-output=sarif:file={diagnostic_file}'] if diagnostic_file is not None else []),
+            '-c', '-x', 'c++-module', module_file,
+            '-o', object_file
+        ]
+    )
+
+@member(Gcc)
+@syncable
+async def async_compile(
+    self           : Gcc, 
+    source_file    : path,
+    object_file    : path,
+    compile_flags  : list[str] = [],
+    define_macros  : dict[str, str] = {}, 
+    include_dirs   : list[path] =[], 
+    import_dirs    : list[path] = [], 
+    diagnostic_file: path | None = None
+) -> None:
+    create_dir(parent_dir(object_file))
+    create_dir(parent_dir(diagnostic_file)) if diagnostic_file is not None else None
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.compile_flags + compile_flags),
+            *[f'-D{key}={value}' for key, value  in (self.define_macros | define_macros).items()],
+            *[f'-I{include_dir}' for include_dir in include_dirs],
+            *[f'-fmodule-mapper={module_mapper_logger.mapper_file_of(import_dir=import_dir)}' for import_dir in import_dirs],
+            *([f'-fdiagnostics-add-output=sarif:file={diagnostic_file}'] if diagnostic_file is not None else []),
+            '-c', '-x', 'c++', source_file,
+            '-o', object_file
+        ]
+    )
+
+@member(Gcc)
+@syncable
+async def async_link(
+    self           : Gcc, 
+    object_file    : path, 
+    executable_file: path, 
+    link_flags     : list[str]  = [], 
+    lib_files      : list[path] = []
+) -> None:
+    create_dir(parent_dir(executable_file))
+    await async_run(
+        file=self.file,
+        args=[
+            *(self.link_flags + link_flags),
+            *([object_file] + lib_files),
+            '-o', executable_file
+        ]
+    )
+
+@member(Gcc)
+async def _async_get_version(self: Gcc) -> Version:
+    try:
+        stdout = await async_run(
+            file=self.file,
+            args=['--version'],
+            return_stdout=True
+        )
+    except SubprocessError as error:
+        raise ConfigError(f'gcc check failed (with file = {self.file})') from error
+    if not stdout.startswith('g++'):
+        raise ConfigError(f'gcc check failed (with file = {self.file}, subprocess = "{self.file} --version", stdout = "{stdout.splitlines()[0]} ...", requires = "g++ ...")')
+    version = Version.parse(stdout)
+    if version < 15:
+        raise ConfigError(f'gcc version is too old (with file = {self.file}, version = {version}, requires = 15+)')
+    return version
+
+@member(Gcc)
+async def _async_get_stdlib_module_file(self: Gcc) -> path:
+    stderr = await async_run(
+        file=self.file,
+        args=[
+            *self.compile_flags,
+            '-E', '-x', 'c++', '-',
+            '-v' 
+        ], 
+        print_stderr =config.verbose, 
+        return_stderr=True
+    )
+    search_dirs = re.search(
+        pattern=r'^#include <...> search starts here:$\n(.*)\n^end of search list.$', 
+        string=stderr, 
+        flags=re.MULTILINE | re.DOTALL | re.IGNORECASE
+    )
+    if search_dirs is None:
+        raise ConfigError(f'libstdc++ module_file is not found (with subprocess = "{self.file} -v -E -x c++ -", stdout = ..., requires = "... #include <...> starts here ... end of search list ...")')
+    search_dirs  = [path(search_dir.strip())    for search_dir in search_dirs.group(1).splitlines()]
+    search_files = [f'{search_dir}/bits/std.cc' for search_dir in search_dirs]
+    for search_file in search_files:
+        if exist_file(search_file):
+            return search_file
+    else:
+        raise ConfigError(f'libstdc++ module_file is not found (with search_files = {search_files})')

cppmakelib/compiler/msvc.py

@@ -0,0 +1,24 @@
+from cppmakelib.utility.decorator import syncable, unique
+from cppmakelib.utility.version   import Version
+import sys
+
+class Msvc:
+    name                = 'msvc'
+    intermediate_suffix = '.i'
+    precompiled_suffix  = '.ixx'
+
+    @syncable
+    @unique
+    async def __ainit__(self, path='cl'):
+        self.path    = path
+        self.version = await self._async_get_version()
+        assert False
+    
+    async def _async_get_version(self):
+        return await Version.async_parse(
+            name   =self.name,
+            command=[self.path],
+            pipe   =sys.stderr,
+            check  =lambda stderr: stderr.startswith('Microsoft') and 'msvc' in stderr,
+            lowest =19.36
+        )

cppmakelib/error/config.py

@@ -0,0 +1,5 @@
+from cppmakelib.utility.color import red, bold
+
+class ConfigError(Exception):
+    def __str__(self):
+        return f'{red(bold('fatal error:'))} {super().__str__()}'

cppmakelib/error/logic.py

@@ -0,0 +1,6 @@
+from cppmakelib.utility.color import red, bold
+
+class LogicError(Exception):
+    def __str__(self):
+        return f'{red(bold('fatal error:'))} {super().__str__()}'
+

cppmakelib/error/subprocess.py

@@ -0,0 +1,9 @@
+class SubprocessError(Exception):
+    def __init__(self, stderr, is_stderr_printed, code):
+        super().__init__(stderr)
+        self.is_stderr_printed = is_stderr_printed
+        self.code              = code
+
+    def __str__(self):
+        return super().__str__() if not self.is_stderr_printed else ''
+    

cppmakelib/executor/operation.py

@@ -0,0 +1,15 @@
+import asyncio
+import typing
+
+def sync_wait     [T](task :      typing.Coroutine[typing.Any, typing.Any, T] ) -> T      : ...
+def start_detached[T](task :      typing.Coroutine[typing.Any, typing.Any, T] ) -> None   : ...
+def when_all      [T](tasks: list[typing.Coroutine[typing.Any, typing.Any, T]]) -> list[T]: ...
+def when_any      [T](tasks: list[typing.Coroutine[typing.Any, typing.Any, T]]) -> T      : ...
+
+
+
+def sync_wait[T](task: typing.Coroutine[typing.Any, typing.Any, T]) -> T:
+    return asyncio.run(task)
+
+async def when_all[T](tasks: list[typing.Coroutine[typing.Any, typing.Any, T]]) -> list[T]:
+    return await asyncio.gather(*tasks)

cppmakelib/executor/run.py

@@ -0,0 +1,84 @@
+from cppmakelib.basic.config            import config
+from cppmakelib.error.subprocess        import SubprocessError
+from cppmakelib.executor.operation      import when_all
+from cppmakelib.executor.scheduler      import Scheduler
+from cppmakelib.utility.filesystem      import path
+from cppmakelib.logger.compile_commands import compile_commands_logger
+from cppmakelib.utility.decorator       import syncable
+import asyncio
+import sys
+import typing
+
+def             run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, return_stdout: bool = False, return_stderr: bool = False) -> None | str | tuple[str, str]: ...
+async def async_run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, return_stdout: bool = False, return_stderr: bool = False) -> None | str | tuple[str, str]: ...
+
+if typing.TYPE_CHECKING:
+    @typing.overload
+    def             run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[False] = False, return_stderr: typing.Literal[False] = False) -> None           : ...
+    @typing.overload
+    def             run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[False] = False, return_stderr: typing.Literal[True])          -> str            : ...
+    @typing.overload
+    def             run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[True],          return_stderr: typing.Literal[False] = False) -> str            : ...
+    @typing.overload
+    def             run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[True],          return_stderr: typing.Literal[True])          -> tuple[str, str]: ...
+    @typing.overload
+    async def async_run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[False] = False, return_stderr: typing.Literal[False] = False) -> None           : ...
+    @typing.overload
+    async def async_run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[False] = False, return_stderr: typing.Literal[True])          -> str            : ...
+    @typing.overload
+    async def async_run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[True],          return_stderr: typing.Literal[False] = False) -> str            : ...
+    @typing.overload
+    async def async_run(file: path, args: list[str] = [], cwd: path = path('.'), print_command: bool = config.verbose, print_stdout: bool = config.verbose, print_stderr: bool = True, *, return_stdout: typing.Literal[True],          return_stderr: typing.Literal[True])          -> tuple[str, str]: ...
+
+
+
+_internal_scheduler = Scheduler(config.parallel)
+
+@syncable
+async def async_run(
+    file          : path,
+    args          : list[str] = [], 
+    cwd           : path      = path('.'), 
+    print_command : bool      = config.verbose,
+    print_stdout  : bool      = config.verbose,
+    print_stderr  : bool      = True,
+    return_stdout : bool      = False,
+    return_stderr : bool      = False,
+) -> None | str | tuple[str, str]:
+    async with _internal_scheduler.schedule():
+        proc = await asyncio.subprocess.create_subprocess_exec(
+            file, 
+            *args,
+            cwd   =cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        assert isinstance(proc.stdout, asyncio.StreamReader)
+        assert isinstance(proc.stderr, asyncio.StreamReader)
+        async def read(stream: asyncio.StreamReader, tee: typing.TextIO | None) -> str:
+            text = ''
+            while True:
+                line = await stream.readline()
+                if not stream.at_eof():
+                    line = line.decode()
+                    text += line
+                    print(line, end='', file=tee) if tee is not None else None
+                else:
+                    break
+            return text
+        stdout, stderr = await when_all([
+            read(stream=proc.stdout, tee=sys.stdout if print_stdout else None),
+            read(stream=proc.stderr, tee=sys.stderr if print_stderr else None)
+        ])
+        code = await proc.wait()
+        if code == 0:
+            if not return_stdout and not return_stderr:
+                return None
+            elif not return_stdout and return_stderr:
+                return stderr
+            elif return_stdout and not return_stderr:
+                return stdout
+            else: # return_stdout and return_stderr
+                return stdout, stderr
+        else:
+            raise SubprocessError(stderr=stderr, is_stderr_printed=print_stderr, code=code)