I'm writing CTFE on Windows, latest DMD compiler. How should I write a message to the console (stderr) from a CTFE function call during compilation?

On Thursday, 4 April 2024 at 14:06:19 UTC, Richard (Rikki) Andrew Cattermole wrote:

static assert(0, "message");

assert(0, "message");

That's ... unfortunate.

Some search of the forum led me to some decade plus old discussion of a possible CTFE writeln function that would be a no-op at runtime, which to my surprise led me to find core_builtins.__ctfeWrite but when I tried it out, it compiled yet output no text to the console. Given your remarks I suppose I should have expected this.

On Thursday, 4 April 2024 at 15:07:21 UTC, Richard (Rikki) Andrew Cattermole wrote:

enum X = computeX("A message");

string computeX(string msg) {
    auto s = "CTFE msg: ";
    auto x = imported!"std.format".format("%s%s\n", s, msg);
    __ctfeWrite(x);
    return x;
}

void main() {
    import std.stdio;
    writeln(X);
}

Produces no output on compilation, and writes out CTFE msg: A message when run.

On Thursday, 4 April 2024 at 15:43:55 UTC, Carl Sturtivant wrote:

enum X = computeX("A message");

string computeX(string msg) {
    auto s = "CTFE msg: ";
    auto x = imported!"std.format".format("%s%s\n", s, msg);
    __ctfeWrite(x);
    return x;
}

void main() {
    import std.stdio;
    writeln(X);
}

pragma(msg, x) ?

On Friday, 5 April 2024 at 07:37:20 UTC, Paolo Invernizzi wrote:

No.

__ctfeWrite(x) is executed inside an executing function like any other statement in it, and can have an argument x computed during that execution.

It is defined to output the computed text x to stderr when the function it is a part of is called as CTFE by the compiler and to be a no-op if that function is called at run time in the compiled executable.

So it is a replacement for std.stdio.write in a CTFE function, handy among other things for reporting what's going on during the execution of that function by the compiler.

pragma(msg, x) works during its compilation, so putting it as a line in a CTFE-called function would not execute it when the function is called by the compiler. That being the case, x may not be a value computed when that function executes. Such a value is "not available at compile time", only at CTFE run time. The CTFE function is not running when it is being compiled.

It is possible that x in pragma(msg, x) be computed with a call to a function as its return value, i.e. computed by CTFE, but that call will be made when pragma(msg, x) is compiled, and is a part of compiling it. Only when the function has returned producing x does the pragma(msg, x) do its work.