Specifying options for dependencies

[davidchisnall]

In a few cases, we’ve wanted to be able to specify that a target depends on another target and that the dependency must be built with a specific option. At the moment, we just end up documenting increasingly long xmake config strings that you must run.

Is there something I can use in a target to change the default for an option? Can I set it in on_load or similar? It would be nice to be able to explicitly define option values as dependencies, I’m not sure if such a thing exists already.

[waruqi]

option("foo", {description = "add foo dep", default = false})

target("foo")
    set_default(false)
    set_kind("static")
    add_files("src/*.cpp")

target("test")
    set_kind("binary")
    add_files("src/*.cpp")
    if has_config("foo") then
        add_deps("foo")
    end

[waruqi]

Therefore, you need to configure and modify the dependent target option status and compilation configuration in the parent target?

What if multiple targets depend on the tcpip target and need different ipv6 configurations, how does cmake compile this tcpip? Compile tcpip twice, one with ipv6 and one without ipv6?

[davidchisnall]

If I explicitly disable an option in a dependency that another dependency explicitly breaks, I'd expect linker failures. Don't shoot yourself in the foot. In an ideal world, we'd get a warning at configure time that two dependencies had explicitly done this, but generally you only ever do this in the top level target, so it's not an issue.

[davidchisnall]

The current state is far worse: The user sets the correct set of build options or gets something that doesn't work correctly even though the top-level build file was written by someone who knew what the options for the included ones needed to be.

[waruqi]

I still don't quite understand your question and requirements, but if my previous understanding is correct, it is not a good practice to modify the configuration in the dependent target by the parent target.

Of course, if you really want to do this, you can do everything in the script scope, there is no need to use option, it is global.

option("ipv6", {default = false})

target("tcpip")
    if has_config("ipv6") then
        set_values("properties.ipv6", true)
    end
    on_config(function (target)
        if target:values("properties.ipv6") then
            add_defines("IPV6_ENABLE=1")
        end
    end)

target("myProgram")
    add_deps("tcpip")
    on_load(function (target)
        target:dep("tcpip"):values_set("properties.ipv6", true)
    end)

[davidchisnall]

Thanks.

If you believe this is not good practice, how would you solve this problem? Most non-trivial reusable targets want to expose some configuration to the things that use them.

[davidchisnall]

Thinking a bit more, it's not very easy to add this as a rule (in a way that is actually useful), because the declarative syntax is not extensible in xmake (at least, not in any documented way).

The thing I want to do is:

• Declare a configuration property on a target.
• Bind that property to an option.
• Override that property later.

Something that looks like this:

-- Declare the command-line option
option("ipv6", {default = false})

target("tcpip")
    -- Declare the property.  If this is not explicitly set, it will be set to whatever the ipv6 option is set to.
    add_property("ipv6", { default = "options.ipv6" })
    if has_property("ipv6") then
        add_defines("IPV6_ENABLE=1")
    end

target("myProgram")
    add_deps("tcpip", { options = { ipv6 = true } })

Internally, this should expand to something much like your example.

[waruqi]

you can add custom description scope api for target.

target.add_property, or use function to wrap add_values

#4276

and use custom rule to do it.

but we can only add has_property in script scope.

[davidchisnall]

There seem to be a bunch of cool undocumented things in xmake. Is there a list somewhere of public APIs that are not yet documented? I wouldn’t mind submitting some docs, but I don’t currently have a good way of telling whether something is intended as a supported public API or something for internal use and subject to change.