Re: writef %d of string

2011-12-04 Thread Stewart Gordon 

On 02/12/2011 03:19, bearophile wrote:

Stewart Gordon:


It's perfectly legal code,


If that code is legal, then in my opinion it's the rules of the language that 
are wrong
and in need to be changed :-)


You mean all programming languages should support CTFE for argument validation?

What if the format string isn't even known at compile time in the first place?


Some C(++) compilers understand printf and will warn if the format string 
doesn't
match the arguments, but even this is rare AIUI.


I don't know what 'AIUI' means.


As I understand it.

http://www.acronymfinder.com/ is your friend.


And GCC (and Clang too) do it, so it's not a rare thing.


I meant rare among the world's various C compilers.  Are you going by usage 
statistics?


To enforce well-formed format strings at compile time would require it to be 
made a
language builtin.


Or just a built-in rule, as in GCC.


What do you mean by a built-in rule exactly?


Or maybe template metaprogramming can do it.


Of course. It's not hard to create something like this: writelnt!%d %f(53, 
1.55);

But I think you need a D compiler able to remove unneeded template 
instantiations from
the binary, to avoid bloat.

snip

Maybe there's a way that the template instances can be very small, delegating most of the 
work to non-templated functions.


Stewart.

Re: writef %d of string

2011-12-04 Thread bearophile 
Stewart Gordon:

 You mean all programming languages should support CTFE for argument 
 validation?

This is not necessary, and it's not sufficient...


 What if the format string isn't even known at compile time in the first place?

In this case the format string validation is done at run-time. It's 
opportunistic static typing. And it's better than leaving all the tests at 
run-time. In a dynamically typed language I accept format strings to be 
verified at run-time. In a compiled language I want some of advantages of 
static typing, where possible.


 http://www.acronymfinder.com/ is your friend.

Or even better, reduce the usage of uncommon acronyms in normal communications 
:-)


 I meant rare among the world's various C compilers.  Are you going by usage 
 statistics?

In the end D wants to be better than C and C compilers.


 What do you mean by a built-in rule exactly?

In GCC there is a hard-coded routine that tests (or tries to) the correctness 
of format strings known at compile-time.


 Maybe there's a way that the template instances can be very small, delegating 
 most of the 
 work to non-templated functions.

This is easy to do, just call the same runtime function after the compile-time 
test done in the template :-) But DMD probably has to learn to better remove 
unnecessary template instances from the resulting binary. Walter has discussed 
this topic a bit several times.

Bye,
bearophile

Re: writef %d of string

2011-12-01 Thread Stewart Gordon 

On 12/10/2011 23:41, bearophile wrote:

This code, that a sane language/language implementation refuses at 
compile-time, runs:


It's perfectly legal code, so the best a compiler can correctly do is give a warning. 
Some C(++) compilers understand printf and will warn if the format string doesn't match 
the arguments, but even this is rare AIUI.


To enforce well-formed format strings at compile time would require it to be made a 
language builtin.  Or maybe template metaprogramming can do it.



import std.stdio;
void main() {
 writefln(%d, hello);
}


And it outputs:
['h', 'e', 'l', 'l', 'o']

Is this good/expected/acceptable/buggy?


It certainly should either throw an exception or generate more sane output such as Andrej 
is getting.  What DMD version are you using?


Stewart.

Re: writef %d of string

2011-12-01 Thread bearophile 
Stewart Gordon:

It's perfectly legal code,

If that code is legal, then in my opinion it's the rules of the language that 
are wrong and in need to be changed :-)


Some C(++) compilers understand printf and will warn if the format string 
doesn't match the arguments, but even this is rare AIUI.

I don't know what 'AIUI' means. And GCC (and Clang too) do it, so it's not a 
rare thing.


To enforce well-formed format strings at compile time would require it to be 
made a language builtin.

Or just a built-in rule, as in GCC.


Or maybe template metaprogramming can do it.

Of course. It's not hard to create something like this:
writelnt!%d %f(53, 1.55);

But I think you need a D compiler able to remove unneeded template 
instantiations from the binary, to avoid bloat.


It certainly should either throw an exception or generate more sane output 
such as Andrej is getting.  What DMD version are you using?

I am using 2.057GitHead on 32 bit Windows. I don't know if this Phobos bug is 
in bugzilla.

Bye,
bearophile

writef %d of string

2011-10-12 Thread bearophile 
This code, that a sane language/language implementation refuses at 
compile-time, runs:


import std.stdio;
void main() {
writefln(%d, hello);
}


And it outputs:
['h', 'e', 'l', 'l', 'o']

Is this good/expected/acceptable/buggy?

Bye,
bearophile

Re: writef %d of string

2011-10-12 Thread Andrej Mitrovic 
That's a sweet trick right there. I get different results but I guess
this is due to new std.format changes:

[104, 101, 108, 108, 111]