Re: Expanding CTFE code during compilation
On 7/23/22 2:27 PM, Azi Hassan wrote:
On Saturday, 23 July 2022 at 00:56:39 UTC, Steven Schveighoffer wrote:
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
I stand corrected, I must've got it confused with version(unittest)
And *I* stand corrected! `unittest` is also a keyword, so clearly that's
not disqualifying. Indeed, the grammar specifically includes
`version(unittest)` and `version(assert)`.
However, because `debug` is exactly like `version` in how it operates,
`version(debug)` would make little sense.
-Steve
Re: Expanding CTFE code during compilation
On Saturday, 23 July 2022 at 00:56:39 UTC, Steven Schveighoffer
wrote:
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the
lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
-Steve
I stand corrected, I must've got it confused with
version(unittest)
Re: Expanding CTFE code during compilation
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
-Steve
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 14:11:52 UTC, Dennis wrote: On Wednesday, 20 July 2022 at 00:33:06 UTC, Azi Hassan wrote: Where did you find it though ? I checked dmd --help and man dmd before making this thread, but to no avail. It was implemented as an internal debugging tool, not a documented feature: https://github.com/dlang/dmd/pull/6556 It turned out to be useful for users as well though, and got exposure through the "AST" button on https://run.dlang.io/ Maybe it's time to document it, currently there's only this: https://wiki.dlang.org/DMD_Source_Guide#View_emitted_templates_instances_and_string.2Fmixins I see, thanks. I'll be sure to check the wiki next time.
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 01:15:44 UTC, Steven Schveighoffer
wrote:
On 7/19/22 8:57 PM, Steven Schveighoffer wrote:
There's a slight bloat in the compiler symbol table when but
other than that it should be effective.
Obviously I didn't finish that thought...
"when `-debug` isn't used on the command line"
-Steve
Oh, interesting syntax. I was thinking something along the lines
of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 00:33:06 UTC, Azi Hassan wrote: Where did you find it though ? I checked dmd --help and man dmd before making this thread, but to no avail. It was implemented as an internal debugging tool, not a documented feature: https://github.com/dlang/dmd/pull/6556 It turned out to be useful for users as well though, and got exposure through the "AST" button on https://run.dlang.io/ Maybe it's time to document it, currently there's only this: https://wiki.dlang.org/DMD_Source_Guide#View_emitted_templates_instances_and_string.2Fmixins
Re: Expanding CTFE code during compilation
On 7/19/22 8:57 PM, Steven Schveighoffer wrote: There's a slight bloat in the compiler symbol table when but other than that it should be effective. Obviously I didn't finish that thought... "when `-debug` isn't used on the command line" -Steve
Re: Expanding CTFE code during compilation
On 7/19/22 8:33 PM, Azi Hassan wrote:
Nice, a compile time console.log. Thanks a lot, this will come in handy.
I wonder if it can be combined with version(debug) to only run the
pragma line if compiled with -g, this way we can keep the printEnum!
line as it is. Then again, the code would become polluted by debugging
logic
Yep:
```d
debug template printEnum(...) {
... // everything we already did
}
else
enum printEnum(alias x) = x;
```
There's a slight bloat in the compiler symbol table when but other than
that it should be effective.
-Steve
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 22:41:43 UTC, Steven Schveighoffer
wrote:
On 7/19/22 5:43 PM, Azi Hassan wrote:
Just in case this is a consequence of the XY problem, the
reason why I'm looking for this is to make sure that the code
I wrote did evaluate to what I'm expecting it to. Right now I
do this with an enum assignment followed by static asserts,
but I'd love it for there to be some sort of visual feedback.
Thanks in advance
```d
template printEnum(alias x, string file = __FILE__, size_t line
= __LINE__)
{
enum printEnum = x;
pragma(msg, file, "(", int(line), "): ", printEnum);
}
enum x = printEnum!(iota(1, 5).reduce!"a * b");
```
This will spit out the file, line, and value for the
declaration. Assuming this is useful for your double-checking
you could do this, and then switch it back when you have
verified that it's correct.
-Steve
Nice, a compile time console.log. Thanks a lot, this will come in
handy. I wonder if it can be combined with version(debug) to only
run the pragma line if compiled with -g, this way we can keep the
printEnum! line as it is. Then again, the code would become
polluted by debugging logic
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 22:27:56 UTC, Dennis wrote:
On Tuesday, 19 July 2022 at 21:43:01 UTC, Azi Hassan wrote:
I'm wondering if the offers has the option of executing the
parts that can be evaluated at compile time and then replacing
them with the result of this evaluation.
Try the `-vcg-ast` flag:
```D
import object;
import std;
void main()
{
enum int x = 24;
writeln(24);
return 0;
}
// ... and a bunch of template instances
```
Thanks a lot, this is exactly what I had in mind. Where did you
find it though ? I checked dmd --help and man dmd before making
this thread, but to no avail.
Re: Expanding CTFE code during compilation
On 7/19/22 5:43 PM, Azi Hassan wrote:
Just in case this is a consequence of the XY problem, the reason why I'm
looking for this is to make sure that the code I wrote did evaluate to
what I'm expecting it to. Right now I do this with an enum assignment
followed by static asserts, but I'd love it for there to be some sort of
visual feedback.
Thanks in advance
```d
template printEnum(alias x, string file = __FILE__, size_t line = __LINE__)
{
enum printEnum = x;
pragma(msg, file, "(", int(line), "): ", printEnum);
}
enum x = printEnum!(iota(1, 5).reduce!"a * b");
```
This will spit out the file, line, and value for the declaration.
Assuming this is useful for your double-checking you could do this, and
then switch it back when you have verified that it's correct.
-Steve
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 21:43:01 UTC, Azi Hassan wrote:
I'm wondering if the offers has the option of executing the
parts that can be evaluated at compile time and then replacing
them with the result of this evaluation.
Try the `-vcg-ast` flag:
```D
import object;
import std;
void main()
{
enum int x = 24;
writeln(24);
return 0;
}
// ... and a bunch of template instances
```
Expanding CTFE code during compilation
Hello,
Apologies in advance if this has been asked before. I can't find
the right words to express what I'm looking for, but essentially,
I'm wondering if the offers has the option of executing the parts
that can be evaluated at compile time and then replacing them
with the result of this evaluation. The C equivalent would be
compiling with the -E flag as explained here :
https://stackoverflow.com/questions/4900870/can-gcc-output-c-code-after-preprocessing
For example :
```
//main.d
import std;
void main()
{
enum x = iota(1, 5).reduce!"a * b";
x.writeln();
}
```
Then after running something like
```
dmd --expand-ctfe main.d -o expanded.d
cat expanded.d
```
We'd get :
```
//expanded.d
import std;
void main()
{
24.writeln();
}
```
Just in case this is a consequence of the XY problem, the reason
why I'm looking for this is to make sure that the code I wrote
did evaluate to what I'm expecting it to. Right now I do this
with an enum assignment followed by static asserts, but I'd love
it for there to be some sort of visual feedback.
Thanks in advance
