[Proposal] Reuse other mate scripts

[cyanidle]

While the project is fresh, you should consider options to allow top-level projects to reuse targets from subdirectories. This is tied to #6.

How one would include static Lua library for example?

Currently you build targets (executables or libs) and use paths to them directly, but build system probably should generate ninja build file for all of them with correct dependencies, then build specified.

Without this reusing other libs/projects it complicated

[TomasBorquez]

You mean only one ninja build file instead of current x amount depending on amount of libs and exes created? Since now it creates exe-lua.ninja and static-liblua.ninja.

I'm thinking of something like LinkMateLibrary() since InstallStaticLib already returns the path to the output, any better idea?

[cyanidle]

There are a lot of things to learn from cmake and meson.

Both of them have some kind of object, that can be linked, that propagates its dependencies and flags (can be controlled).

For Mate I think should exist opaque? pointer to struct "Target"? Then function LinkLibrary, which accepts it. Like CMake but with "value semantics"

And about reuse, maybe build script should be defined inside some function other than main()?

We should not rely too heavily on cmake and meson tho, to not create a clone, rather explore own solutions, but inspired by thiers

[TomasBorquez]

We should not rely too heavily on cmake and meson tho, to not create a clone, rather explore own solutions, but inspired by thiers

Yeah the point of it is to keep it as simple as possible meanwhile as powerful as possible, its meant to be a C build system and extendable in the way the user that's using it wants to so I try to lean to the simplest I can and low/medium amount of magic

Both of them have some kind of object, that can be linked, that propagates its dependencies and flags (can be controlled).

For Mate I think should exist opaque? pointer to struct "Target"? Then function LinkLibrary, which accepts it. Like CMake but with "value semantics"

And about reuse, maybe build script should be defined inside some function other than main()?

About this, if user wants to reuse I don't see how they can't define a function in top dir, some in bottom dir and compile that, sort of like:

// mate.c
#define MATE_IMPLEMENTATION
#include "mate.h"

#include "src/build-lua.c"

i32 main() {
  // ...
  ExportedFunctionFromOtherScript()
}

And from there return StaticLib or whatever it is done in the script, then from there LinkStaticLibrary can be used, also these functions:

String CreateStaticLib(StaticLibOptions staticLibOptions);
String InstallStaticLib(void);

Could be:

StaticLib CreateStaticLib(StaticLibOptions staticLibOptions);
void InstallStaticLib(StaticLib *staticLib);

I guess stuff like AddFile or AddIncludePaths, would have to take Target as first arg:

#define AddFile(source) mateAddFile(S(source));
static void mateAddFile(String source);

would become:

#define AddFile(target, source) mateAddFile(&target.sources, S(source));
static void mateAddFile(StringVector *sources, String source);

this would break API but its more explicit, and StaticLib/Executable/SharedLib would all follow the same "interface", we can keep type in the target and if it's trying to use so function it can't use we can just Assert

[cyanidle]

Yes, looks good. Do not be afraid to break API