Adam D. Ruppe:
You could just version it:
version(foo_main)
void main() {}
That's not good enough.
What I as talking about is: when the D compilers know a module is
the main module, it defines a _standard_ version boolean flag,
named like "is_main_module" as true. And it gives a compiler
error if it can't find a main. Otherwise "is_main_module" is
false.
It's meant to be used as:
module modulea;
int foo() { return 0; }
static if (is_main_module) {
unittest {}
void main() { // demo code
import std.stdio;
writeln(foo());
}
}
module moduleb;
import modulea;
int bar() { return 1; }
static if (is_main_module) {
unittest {}
void main() { // demo code
import std.stdio;
writeln(foo());
writeln(bar());
}
}
When you compile modulea, defines its is_main_module as true, it
runs its unittests (if you have used -unittest), and its main,
that is a demo for the A module.
If you compile the moduleb (with rdmd or something), it knows
moduleb has to contain the main, it defines is_main_module=true
in moduleb and defines is_main_module=false for modulea. So it
compiles the main of moduleb and ignores the main of modulea. So
it runs the demo code for moduleb only.
Using a non-standard user-defined version as you suggest misses
all this, and it's not good enough. Standardization and
automation is important here.
Bye,
bearophile
