"""Support for c2hs"""
load("@bazel_skylib//lib:paths.bzl", "paths")
load(
"@io_tweag_rules_haskell//haskell:providers.bzl",
"C2hsLibraryInfo",
"HaskellInfo",
)
load(":cc.bzl", "cc_interop_info")
load(":private/context.bzl", "haskell_context")
load(":private/dependencies.bzl", "gather_dep_info")
load(
":private/path_utils.bzl",
"declare_compiled",
"target_unique_name",
)
load(":private/set.bzl", "set")
load(":private/version_macros.bzl", "version_macro_includes")
def _c2hs_library_impl(ctx):
hs = haskell_context(ctx)
cc = cc_interop_info(ctx)
args = hs.actions.args()
c2hs = ctx.toolchains["@io_tweag_rules_haskell//haskell/c2hs:toolchain"].c2hs
if len(ctx.files.srcs) != 1:
fail("srcs field should contain exactly one file.")
chs_file = ctx.files.srcs[0]
# Output a Haskell source file.
chs_dir_raw = target_unique_name(hs, "chs")
hs_file = declare_compiled(hs, chs_file, ".hs", directory = chs_dir_raw)
chi_file = declare_compiled(hs, chs_file, ".chi", directory = chs_dir_raw)
args.add_all([chs_file.path, "-o", hs_file.path])
args.add("-C-E")
args.add_all(["--cpp", cc.tools.cpp])
args.add("-C-includeghcplatform.h")
args.add("-C-includeghcversion.h")
args.add_all(["-C" + x for x in cc.cpp_flags])
args.add_all(["-C" + x for x in cc.include_args])
dep_chi_files = [
dep[C2hsLibraryInfo].chi_file
for dep in ctx.attr.deps
if C2hsLibraryInfo in dep
]
chi_includes = [
"-i" + dep[C2hsLibraryInfo].import_dir
for dep in ctx.attr.deps
if C2hsLibraryInfo in dep
]
args.add_all(chi_includes)
version_macro_headers = set.empty()
if ctx.attr.version:
dep_info = gather_dep_info(ctx, ctx.attr.deps)
(version_macro_headers, version_macro_flags) = version_macro_includes(dep_info)
args.add_all(["-C" + x for x in version_macro_flags])
hs.actions.run_shell(
inputs = depset(transitive = [
depset(cc.hdrs),
depset([hs.tools.ghc, c2hs, chs_file]),
depset(dep_chi_files),
depset(cc.files),
set.to_depset(version_macro_headers),
]),
outputs = [hs_file, chi_file],
command = """
# Include libdir in include path just like hsc2hs does.
libdir=$({ghc} --print-libdir)
{c2hs} -C-I$libdir/include "$@"
""".format(
ghc = hs.tools.ghc.path,
c2hs = c2hs.path,
),
mnemonic = "HaskellC2Hs",
arguments = [args],
env = hs.env,
)
idir = paths.join(
hs.bin_dir.path,
hs.label.workspace_root,
hs.label.package,
chs_dir_raw,
)
return [
DefaultInfo(files = depset([hs_file])),
C2hsLibraryInfo(
chi_file = chi_file,
import_dir = idir,
),
]
c2hs_library = rule(
_c2hs_library_impl,
attrs = {
"deps": attr.label_list(),
"srcs": attr.label_list(allow_files = [".chs"]),
"src_strip_prefix": attr.string(
doc = "Directory in which module hierarchy starts.",
),
"version": attr.string(
doc = "Executable version. If this is specified, CPP version macros will be generated for this build.",
),
"_cc_toolchain": attr.label(
default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
),
},
toolchains = [
"@io_tweag_rules_haskell//haskell:toolchain",
"@io_tweag_rules_haskell//haskell/c2hs:toolchain",
],
)
def _c2hs_toolchain_impl(ctx):
return [
platform_common.ToolchainInfo(
name = ctx.label.name,
c2hs = ctx.file.c2hs,
),
]
_c2hs_toolchain = rule(
_c2hs_toolchain_impl,
attrs = {
"c2hs": attr.label(
doc = "The c2hs executable.",
mandatory = True,
allow_single_file = True,
),
},
)
def c2hs_toolchain(name, c2hs, **kwargs):
"""Declare a Haskell c2hs toolchain.
You need at least one of these declared somewhere in your `BUILD`
files for the `chs_library` rule to work. Once declared, you then
need to *register* the toolchain using `register_toolchains` in
your `WORKSPACE` file (see example below).
Example:
In a `BUILD` file:
```bzl
c2hs_toolchain(
name = "c2hs",
c2hs = "@c2hs//:bin",
)
```
where `@c2hs` is an external repository defined in the
`WORKSPACE`, e.g. using:
```bzl
nixpkgs_package(
name = "c2hs",
attribute_path = "haskell.packages.ghc822.c2hs",
)
register_toolchains("//:c2hs")
```
"""
impl_name = name + "-impl"
_c2hs_toolchain(
name = impl_name,
c2hs = c2hs,
visibility = ["//visibility:public"],
**kwargs
)
native.toolchain(
name = name,
toolchain_type = "@io_tweag_rules_haskell//haskell/c2hs:toolchain",
toolchain = ":" + impl_name,
)
