• Yuxuan Shui (13/13) Apr 01 2016 Clang has this nice feature that it will warn you when you passed
• Alex Parrill (8/21) Apr 01 2016 Not as-is, because the format string is a runtime argument and
• Yuxuan Shui (3/12) Apr 01 2016 That's kind of ugly. Now I really wish D can unify template
• Jacob Carlborg (4/6) Apr 02 2016 Sounds like AST macros.
• Andrei Alexandrescu (3/27) Apr 02 2016 What happened to the work that added a compile-time string to writef? --...
• Daniel Murphy (11/24) Apr 01 2016 That's something I want to do with this eventually:
• Johan Engelen (4/17) Apr 02 2016 I thought LDC already did that when `-check-printf-calls` is

Yuxuan Shui <yshuiv7 gmail.com> writes:

Clang has this nice feature that it will warn you when you passed 
wrong arguments to printf:

#include <stdio.h>
int main(){
	long long u = 10;
	printf("%c", u);
}

clang something.c:
something.c:4:15: warning: format specifies type 'int' but the 
argument has type 'long long' [-Wformat]

With the CTFE power of D, we should be able to do the same thing 
when the format string is available at compile time. Instead of 
throwing exceptions at run time.

Alex Parrill <initrd.gz gmail.com> writes:

On Friday, 1 April 2016 at 21:25:46 UTC, Yuxuan Shui wrote:
 Clang has this nice feature that it will warn you when you 
 passed wrong arguments to printf:

 #include <stdio.h>
 int main(){
 	long long u = 10;
 	printf("%c", u);
 }

 clang something.c:
 something.c:4:15: warning: format specifies type 'int' but the 
 argument has type 'long long' [-Wformat]

 With the CTFE power of D, we should be able to do the same 
 thing when the format string is available at compile time. 
 Instead of throwing exceptions at run time.

Not as-is, because the format string is a runtime argument and 
not a compile-time constant.

Consider:

     writefln(rand() >= 0.5 ? "%s" : "%d", 123);

It's certainly possible with a new, templated writef function. 
Hypothetically:

     writefln_ctfe!"%s"(1234); // would fail

Yuxuan Shui <yshuiv7 gmail.com> writes:

On Friday, 1 April 2016 at 23:26:14 UTC, Alex Parrill wrote:
 On Friday, 1 April 2016 at 21:25:46 UTC, Yuxuan Shui wrote:
 [...]

 Not as-is, because the format string is a runtime argument and 
 not a compile-time constant.

 Consider:

     writefln(rand() >= 0.5 ? "%s" : "%d", 123);

 It's certainly possible with a new, templated writef function. 
 Hypothetically:

     writefln_ctfe!"%s"(1234); // would fail

That's kind of ugly. Now I really wish D can unify template 
arguments and function arguments known at compile time.

Jacob Carlborg <doob me.com> writes:

On 2016-04-02 01:40, Yuxuan Shui wrote:

 That's kind of ugly. Now I really wish D can unify template arguments
 and function arguments known at compile time.

Sounds like AST macros.

-- 
/Jacob Carlborg

Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:

On 04/01/2016 07:26 PM, Alex Parrill wrote:
 On Friday, 1 April 2016 at 21:25:46 UTC, Yuxuan Shui wrote:
 Clang has this nice feature that it will warn you when you passed
 wrong arguments to printf:

 #include <stdio.h>
 int main(){
     long long u = 10;
     printf("%c", u);
 }

 clang something.c:
 something.c:4:15: warning: format specifies type 'int' but the
 argument has type 'long long' [-Wformat]

 With the CTFE power of D, we should be able to do the same thing when
 the format string is available at compile time. Instead of throwing
 exceptions at run time.

 Not as-is, because the format string is a runtime argument and not a
 compile-time constant.

 Consider:

      writefln(rand() >= 0.5 ? "%s" : "%d", 123);

 It's certainly possible with a new, templated writef function.
 Hypothetically:

      writefln_ctfe!"%s"(1234); // would fail

What happened to the work that added a compile-time string to writef? -- 
Andrei

Daniel Murphy <yebbliesnospam gmail.com> writes:

On 2/04/2016 8:25 AM, Yuxuan Shui wrote:
 Clang has this nice feature that it will warn you when you passed wrong
 arguments to printf:

 #include <stdio.h>
 int main(){
      long long u = 10;
      printf("%c", u);
 }

 clang something.c:
 something.c:4:15: warning: format specifies type 'int' but the argument
 has type 'long long' [-Wformat]

 With the CTFE power of D, we should be able to do the same thing when
 the format string is available at compile time. Instead of throwing
 exceptions at run time.

That's something I want to do with this eventually: 
https://github.com/D-Programming-Language/dmd/pull/3799

When arguments (or anything about the arguments) is known at compile 
time, some subsets of in-contracts can be checked.

Currently only stuff like this is supported:
auto iota(int low, int high) in { assert(low <= high); } body { ... }

iota(23, 7); // Error

But it's not impossible that
assert(checkFormatArgs(format, args));
could work one day.

Johan Engelen <j j.nl> writes:

On Friday, 1 April 2016 at 21:25:46 UTC, Yuxuan Shui wrote:
 Clang has this nice feature that it will warn you when you 
 passed wrong arguments to printf:

 #include <stdio.h>
 int main(){
 	long long u = 10;
 	printf("%c", u);
 }

 clang something.c:
 something.c:4:15: warning: format specifies type 'int' but the 
 argument has type 'long long' [-Wformat]

 With the CTFE power of D, we should be able to do the same 
 thing when the format string is available at compile time. 
 Instead of throwing exceptions at run time.

I thought LDC already did that when `-check-printf-calls` is 
passed, but the implementation is unfinished and it does not do 
any checking at the moment.