The equivalent of Make pattern rules in Meson?

[epsilon537]

Hi,

I was wondering if it's possible to express the equivalent of a Make pattern rule in Meson?
In my current GNU Make-based build system, some dependencies are specified in .yml files and extracted via a tool called Bender. In my Makefile I have the following:

# $(MEM_FILES) is a list of files with extension .mem, generated by running a shell script.
MEM_FILES := $(shell bender script flist ...)

mytarget: $(MEM_FILES) <other dependencies>
   <recipe to build mytarget>

%.mem: ...
   <recipe to generate a .mem file>

Can I do this in Meson? I have a feeling that the answer is going to be 'pattern rules are the root of all evil' or something like that, but I couldn't info any info about it in the context of Meson.

Thanks for any help/insight.

[eli-schwartz]

Pattern rules are just another way to say "use the same commands for multiple targets". Since Meson is a generator of ninja files, and ninja itself is the equivalent of Make, what ends up happening is that you can specify a command pattern in Meson by using foreach loops:

targets: [mem, files, from, bender]

foreach t: targets
    custom_target(output: t, command: [recipe, to, generate, a, mem, file])
endforeach

Technical note: ninja does not support pattern rules, instead reasoning that as you will use a generator anyway, the generator should grok the pattern and then write out the full list of targets. Pattern rules, and the need to expand and validate them, are one cause of slowness in Make, so, Ninja claims that it's able to be faster by not supporting pattern rules. When the build system generator (such as Meson) performs this calculation instead, it can do so once and "freeze" that list during configuration.

[epsilon537]

Thanks for the quick response. The problem is that the contents of the file list ([mem, files, from, bender] in your example) is not known ahead of time. The filename list is generated by Bender. That's essentially a form of globbing. It can be done with run_command(), but it's discouraged because Meson has to be reconfigured every time: https://mesonbuild.com/FAQ.html#but-i-really-want-to-use-wildcards.
Anyway, I think I get it. I guess I'll just have to decide if I want to proceed this way or not.

[eli-schwartz]

Note that even there, Make distinguishes between pattern rules, which define how to create .mem files, and target lists, which define what targets to detect rules for.

You can do both pattern rules and wildcard target collection, but many people only do the former (in fact that's how basic .c -> .o handling works, even when you have a list of sources hardcoded in the Makefile).

I don't know what bender is or how it works, but is it possible to do something like produce a sources.lst file, check that into git, and read it with meson fs = import('fs'); sources = fs.read('sources.lst')? Add a CI check to ensure the list is always up to date.

Meson will automatically reconfigure if the list file is modified e.g. by git pull.

[epsilon537]

You're right. The problem here has more to do with shell command-based target collection than with pattern rules.

Bender is a dependency management tool for hardware design projects: https://github.com/pulp-platform/bender

My current build system has Bender as a front-end (sources and dependencies are specified in a .yml manifest) and GNU Make as a back-end. I was looking to replace GNU Make with Meson, but I now realize that's not such a good idea because Meson doesn't like being the backend.

The reason I wanted to replace Make with Meson is that, while Make is the back-end for my RTL builds, it's also the front-end for the software builds that run on that RTL (an FPGA SoC). Meson is a more convenient build system for software than Make, so I wanted to make the switch. I don't think I have to argue that case here :-)

I might just split my build system in two: Bender+Make for RTL and Meson+Ninja for software.