github.phpd.cn/thought-machine/please@v12.2.0+incompatible/src/parse/rules/c_rules.build_defs

"""Rules to build C targets.

These are just wrappers around the C++ rules; the logic of the two is identical
other than using different config settings.

Both C and C++ can be mixed and matched arbitrarily, but of course to do so
you must pay attention to interoperability when needed (e.g. 'extern "C"' and so forth).
"""

def c_library(name:str, srcs:list=[], hdrs:list=[], private_hdrs:list=[], deps:list=[],
              visibility:list=None, test_only:bool&testonly=False, compiler_flags:list&cflags&copts=[], linker_flags:list&ldflags&linkopts=[],
              pkg_config_libs:list=[], includes:list=[], defines:list|dict=[], alwayslink:bool=False):
    """Generate a C library target.

    Args:
      name (str): Name of the rule
      srcs (list): C source files to compile.
      hdrs (list): Header files. These will be made available to dependent rules, so the distinction
                   between srcs and hdrs is important.
      private_hdrs (list): Header files that are available only to this rule and not exported to
                           dependent rules.
      deps (list): Dependent rules.
      visibility (list): Visibility declaration for this rule.
      test_only (bool): If True, is only available to other test rules.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker; these will not be used here but will be
                           picked up by a c_binary or c_test rule.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config. Again, the ldflags
                              will be picked up by c_binary or c_test rules.
      includes (list): List of include directories to be added to the compiler's path.
      defines (list | dict): List of tokens to define in the preprocessor.
                             Alternatively can be a dict of name -> value to define, in which case
                             values are surrounded by quotes.
      alwayslink (bool): If True, any binaries / tests using this library will link in all symbols,
                         even if they don't directly reference them. This is useful for e.g. having
                         static members that register themselves at construction time.
    """
    return cc_library(
        name = name,
        srcs = srcs,
        hdrs = hdrs,
        private_hdrs = private_hdrs,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        includes = includes,
        defines = defines,
        alwayslink = alwayslink,
        _c = True,
    )



def c_object(name:str, src:str, hdrs:list=[], private_hdrs:list=[], out:str=None, test_only:bool&testonly=False,
             compiler_flags:list&cflags&copts=[], linker_flags:list&ldflags&linkopts=[], pkg_config_libs:list=[], includes:list=[],
             defines:list|dict=[], alwayslink:bool=False, visibility:list=None, deps:list=[]):
    """Generate a C object file from a single source.

    N.B. This is fairly low-level; for most use cases c_library should be preferred.

    Args:
      name (str): Name of the rule
      src (str): C or C++ source file to compile. This can be another rule, but if so it must
                 have exactly one output.
      hdrs (list): Header files. These will be made available to dependent rules, so the distinction
                   between srcs and hdrs is important.
      private_hdrs (list): Header files that are available only to this rule and not exported to
                           dependent rules.
      out (str): Name of the output file. Defaults to name + .o.
      deps (list): Dependent rules.
      visibility (list): Visibility declaration for this rule.
      test_only (bool): If True, is only available to other test rules.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker; these will not be used here but will be
                           picked up by a c_binary or c_test rule.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config. Again, the ldflags
                              will be picked up by c_binary or c_test rules.
      includes (list): List of include directories to be added to the compiler's path.
      defines (list | dict): List of tokens to define in the preprocessor.
                             Alternatively can be a dict of name -> value to define, in which case
                             values are surrounded by quotes.
      alwayslink (bool): If True, any binaries / tests using this library will link in all symbols,
                         even if they don't directly reference them. This is useful for e.g. having
                         static members that register themselves at construction time.
    """
    return cc_object(
        name = name,
        src = src,
        hdrs = hdrs,
        private_hdrs = private_hdrs,
        out = out,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        includes = includes,
        defines = defines,
        alwayslink = alwayslink,
        _c = True,
    )


def c_static_library(name:str, srcs:list=[], hdrs:list=[], compiler_flags:list&cflags&copts=[], linker_flags:list&ldflags&linkopts=[],
                     deps:list=[], visibility:list=None, test_only:bool&testonly=False, pkg_config_libs:list=[]):
    """Generates a C static library (.a).

    This is essentially just a collection of other c_library rules into a single archive.
    Optionally this rule can have sources of its own, but it's quite reasonable just to use
    it as a collection of other rules.

    Args:
      name (str): Name of the rule
      srcs (list): C or C++ source files to compile.
      hdrs (list): Header files.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker.
      deps (list): Dependent rules.
      visibility (list): Visibility declaration for this rule.
      test_only (bool): If True, is only available to other test rules.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config.
    """
    return cc_static_library(
        name = name,
        srcs = srcs,
        hdrs = hdrs,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        _c = True,
    )


def c_shared_object(name:str, srcs:list=[], hdrs:list=[], out:str='', compiler_flags:list&cflags&copts=[],
                    linker_flags:list&ldflags&linkopts=[], deps:list=[], visibility:list=None, test_only:bool&testonly=False,
                    pkg_config_libs:list=[], includes:list=[]):
    """Generates a C shared object (.so) with its dependencies linked in.

    Args:
      name (str): Name of the rule
      srcs (list): C or C++ source files to compile.
      hdrs (list): Header files. These will be made available to dependent rules, so the distinction
                   between srcs and hdrs is important.
      out (str): Name of the output .so. Defaults to name + .so.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker.
      deps (list): Dependent rules.
      visibility (list): Visibility declaration for this rule.
      test_only (bool): If True, is only available to other test rules.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config.
      includes (list): Include directories to be added to the compiler's lookup path.
    """
    return cc_shared_object(
        name = name,
        srcs = srcs,
        hdrs = hdrs,
        out = out,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        includes = includes,
        _c = True,
    )


def c_binary(name:str, srcs:list=[], hdrs:list=[], private_hdrs:list=[], compiler_flags:list&cflags&copts=[],
             linker_flags:list&ldflags&linkopts=[], deps:list=[], visibility:list=None, pkg_config_libs:list=[],
             test_only:bool&testonly=False, static:bool=False):
    """Builds a binary from a collection of C rules.

    Args:
      name (str): Name of the rule
      srcs (list): C source files to compile.
      hdrs (list): Header files.
      private_hdrs (list): Header files that are available only to this rule and not exported to
                           dependent rules.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker.
      deps (list): Dependent rules.
      visibility (list): Visibility declaration for this rule.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config.
      test_only (bool): If True, this rule can only be used by tests.
      static (bool): If True, the binary will be linked statically.
    """
    return cc_binary(
        name = name,
        srcs = srcs,
        hdrs = hdrs,
        private_hdrs = private_hdrs,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        static = static,
        _c = True,
    )


def c_test(name:str, srcs:list=[], hdrs:list=[], compiler_flags:list&cflags&copts=[], linker_flags:list&ldflags&linkopts=[],
           pkg_config_libs:list=[], deps:list=[], data:list=[], visibility:list=None, flags:str='',
           labels:list&features&tags=[], flaky:bool|int=0, test_outputs:list=None, size:str=None, timeout:int=0,
           container:bool|dict=False, sandbox:bool=None):
    """Defines a C test target.

    Note that you must supply your own main() and test framework (ala cc_test when
    write_main=False).

    Args:
      name (str): Name of the rule
      srcs (list): C or C++ source files to compile.
      hdrs (list): Header files.
      compiler_flags (list): Flags to pass to the compiler.
      linker_flags (list): Flags to pass to the linker.
      pkg_config_libs (list): Libraries to declare a dependency on using pkg-config.
      deps (list): Dependent rules.
      data (list): Runtime data files for this test.
      visibility (list): Visibility declaration for this rule.
      flags (str): Flags to apply to the test invocation.
      labels (list): Labels to attach to this test.
      flaky (bool | int): If true the test will be marked as flaky and automatically retried.
      test_outputs (list): Extra test output files to generate from this test.
      size (str): Test size (enormous, large, medium or small).
      timeout (int): Length of time in seconds to allow the test to run for before killing it.
      container (bool | dict): If true the test is run in a container (eg. Docker).
      sandbox (bool): Sandbox the test on Linux to restrict access to namespaces such as network.
    """
    return cc_test(
        name = name,
        srcs = srcs,
        hdrs = hdrs,
        deps = deps,
        visibility = visibility,
        compiler_flags = compiler_flags,
        linker_flags = linker_flags,
        pkg_config_libs = pkg_config_libs,
        data = data,
        flags = flags,
        labels = labels,
        flaky = flaky,
        test_outputs = test_outputs,
        size = size,
        timeout = timeout,
        container = container,
        sandbox = sandbox,
        _c = True,
        write_main = False,
    )


def c_embed_binary(name:str, src:str, deps:list=[], visibility:list=None, test_only:list=False,
                   namespace:str=None):
    """Build rule to embed an arbitrary binary file into a C library.

    You can depend on the output of this as though it were a c_library rule.
    There are five functions available to access the data once compiled, all of which are
    prefixed with the file's basename:
      filename_start(): returns a const char* pointing to the beginning of the data.
      filename_end(): returns a const char* pointing to the end of the data.
      filename_size(): returns the length of the data in bytes.
      filename_start_nc(): returns a char* pointing to the beginning of the data.
                           This is a convenience wrapper using const_cast, you should not
                           mutate the contents of the returned pointer.
      filename_end_nc(): returns a char* pointing to the end of the data.
                         Again, don't mutate the contents of the pointer.
    You don't own the contents of any of these pointers so don't try to delete them :)

    Args:
      name (str): Name of the rule.
      src (str): Source file to embed.
      deps (list): Dependencies.
      visibility (list): Rule visibility.
      test_only (bool): If True, is only available to test rules.
      namespace (str): Deprecated. Allows specifying the namespace the symbols will be available in.
                       Since C does not have namespaces, the generated code will surround it in #ifdef
                       macros for C++, and in C it will be available in global scope - so semantically it
                       only really makes sense to pass 'namespace' to a cc_embed_binary rule.
    """
    return cc_embed_binary(
        name = name,
        src = src,
        deps = deps,
        visibility = visibility,
        test_only = test_only,
        namespace = namespace,
    )