I have encountered Tup in the past and could not figure out how to define a "generator". As in: a function that defines how some output can be generated from a certain input running multiple commands. I don't want to copy those commands for every input I need to process.

Edit: Generator is a term typically used in CMake and Meson for this, in Make I'd use a pattern rule mostly.

Not sure how to exactly to build a "generator" either, but it seems that it would be a build rule that generates multiple outputs from multiple inputs right? If that's the case there's a `foreach` function for convenience, but it doesn't seem to have something for multiple commands. Though there's this Lua example on their website that leaves me wondering if what you want is possible, here's the code (since the documentation seems offline atm):

```

inputs = { 'file1.c', 'file2.c' }

outputs = { '%B.o' }

commandA = 'gcc %f -c -o %o'

commandB = 'gcc %f -o %o'

objects = tup.foreach_rule(inputs, commandA, outputs) tup.rule(objects, commandB, {'app'})

```

Which apparently is a shortcut for saying:

```

tup.definerule{

    inputs = {'file1.c'},  
    command = 'gcc file1.c -c -o file1.o',  
    outputs = {'file1.o'}  

}

tup.definerule{

    inputs = {'file2.c'},  
    command = 'gcc file2.c -c -o file2.o',  
    outputs = {'file2.o'}  

}

tup.definerule{

    inputs = {'file1.o', 'file2.o'},  
    command = 'gcc file1.o file2.o -c -o app',  
    outputs = {'app'}  

}

```

Reference: http://web.archive.org/web/20201026140926/http://gittup.org/...

If you want to have a way to specify rules that use the same command, but still specify the rules manually, look up "!macros" in `man tup`. If the issue is that the commands need to write and read some temp files, then note that you can write temp files in a tup command (they need to be placed in $TMPDIR iirc). Note that the tup command can be calling a script that you place alongside, in case this makes specifying your sequences of commands easier. You can define the macro in top-level Tuprules.tup and use include_rules in all the Tupfiles to get it included.

Does this fail to address your problem?

Thanks, the `!macro` thing seems to be what I was looking for. Having intermediary temporary files is of course fine.

The use-case at that time was to convert a LaTeX file containing a TIKZ image (therefore having a .tikz file extension) to an SVG which required compiling the LaTeX code to PDF, cropping the PDF and converting it to SVG. Since there were multiple occurrences of this across the project, I wanted to have that as a reusable "function" in the build system. I did not want to write a dedicated script for this because of portability issues (Shell vs. Batch).

How does !macro rid you of that portability issue? One way or another, you'd need to have a command that does that whole sequence of operations. If it's inline, I'd expect same portability problem (`&&` in Bash corresponds to something else in `.bat`).

You are right, glancing over the Man page I thought you could just specify multiple commands. But it doesn't seem like it. So, my problem persists.

What you could do is use Tup's LUA support (you can write tupfiles and tuprules in LUA, and you can define and use LUA functions in them): have each rule handle just one step of your process, generate the whole necessary DAG of rules, encapsulate all of that in a LUA function defined in tuprules.lua and call that function in tupfile.lua for every diagram you want to generate. One thing that you lose is the ability to use `foreach` with your construction (other than by creating a variant of your constructions that embeds foreachness, or by using tup.glob and iterating).

I specifically wanted to avoid the LUA support. As soon as we get there I'd rather go with Ruby and Rakefiles.