is there an include directive?

[stsp]

I have a project that is used in the
build process of other projects in a
very non-trivial ways.
To not complicate makefiles, that
project provides the part of a makefile
that other projects can just include
and forget.

Is there anything like this in meson?
I've only found subdir which is close
but not quite the include via system-wide
path.

[stsp]

So is there really no means for the
include-based componentization and
some high-level macrosification?
My projects provides the makefile
"snips" to other projects, which wrap
them into their own macros and
provide to other projects, and so on.
At a top-level, all the tricky generators
are hidden behind the simple include.

Is there nothing in meson I can use
to do the same? The only componentization
here, is "subdir"? "subdir" componentization
doesn't help when 90% of the files you
compile, are auto-generated in a build dir.
But at the same time you need to hide
the complexity from an end user, so the
linear approach doesn't work.

[nils-werner]

Your question is really hard to understand without some example.

[stsp]

For example this is a "recipe" that
one project provides to its users:
https://github.com/stsp/thunk_gen/blob/main/scripts/thunk_gen.mk
Its not a complete makefile. Its just
a recipe that is needed to hook this
project into a build process.

One of its users does this:
https://github.com/stsp/dj64dev/blob/master/dj64.mk#L91
Here, it just includes the aforementioned
file and wraps it into its own recipes.
And provides that to other users.

The user then includes this one:
https://github.com/stsp/dj64dev/blob/master/demos/hello/makefile#L35
and gets a very simple makefile.
Because all the tricky stuff is hidden
behind the simple include.

Now this is not the best example.
I could wrap these recipes into a
makefile macros. Then the user
would have to use these macros
via eval/call makefile directives.
I've seen a very complex build systems
written entirely on make, and the
end-user files were not complicated
at all, because he was working with
the very high-level macros, included
from other files (which he should
never touch or even read).

So make is very flexible. You can
build meson's DSL on top of its macro
abilities. Then whoever includes the
file with these macros, gets meson DSL. :)
I'd like my meson-based recipes to
be as modular. So can I provide the
user with a file that he only have to
include, and get all the work done
automatically?

[stsp]

In terms of meson, that could be the
file with a bunch of custom_targets() with
parametrized inputs and outputs, but
with pre-defined deps between each other.
By just including such a file, you get the
dirty bits of a build process hidden behind
the include.