Thread overview | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
March 09, 2011 I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
This is on Windows 7. Using a def file to stop the terminal window coming up. win.def EXETYPE NT SUBSYSTEM WINDOWS bug.d import std.stdio; import std.string; void main() { auto f = File( "z.txt", "w" ); scope( exit ) f.close; string foo = "bar"; foreach( n; 0 .. 10 ) { writefln( "%s", foo ); f.write( format( "count duck-u-lar: %s\n", n ) ); } } output (from in z.txt): count duck-u-lar: 0 |
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Joel Christensen | On 03/10/2011 12:19 AM, Joel Christensen wrote: > This is on Windows 7. Using a def file to stop the terminal window coming up. > > win.def > EXETYPE NT > SUBSYSTEM WINDOWS > > bug.d > import std.stdio; > import std.string; > > void main() { > auto f = File( "z.txt", "w" ); > scope( exit ) > f.close; > string foo = "bar"; > foreach( n; 0 .. 10 ) { > writefln( "%s", foo ); > f.write( format( "count duck-u-lar: %s\n", n ) ); > } > } > > output (from in z.txt): > count duck-u-lar: 0 What do you mean, crashing writefln? What do you get on the terminal? About the file, there seems to be a bug --but unrelated to writefln. The file is closed, I guess because of scope(exit), before the output stream is flushed. If this is the right interpretation, then there is a precedence issue; scope's action should not be performed before the func's own action is actually completed. Denis -- _________________ vita es estrany spir.wikidot.com |
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to spir | On 10-Mar-11 1:04 PM, spir wrote:
> On 03/10/2011 12:19 AM, Joel Christensen wrote:
>> This is on Windows 7. Using a def file to stop the terminal window
>> coming up.
>>
>> win.def
>> EXETYPE NT
>> SUBSYSTEM WINDOWS
>>
>> bug.d
>> import std.stdio;
>> import std.string;
>>
>> void main() {
>> auto f = File( "z.txt", "w" );
>> scope( exit )
>> f.close;
>> string foo = "bar";
>> foreach( n; 0 .. 10 ) {
>> writefln( "%s", foo );
>> f.write( format( "count duck-u-lar: %s\n", n ) );
>> }
>> }
>>
>> output (from in z.txt):
>> count duck-u-lar: 0
>
> What do you mean, crashing writefln? What do you get on the terminal?
> About the file, there seems to be a bug --but unrelated to writefln. The
> file is closed, I guess because of scope(exit), before the output stream
> is flushed. If this is the right interpretation, then there is a
> precedence issue; scope's action should not be performed before the
> func's own action is actually completed.
>
> Denis
It quits out the at about the 2nd attempt at printing text (that doesn't go to the terminal because of the def file argument in the compile arguments).
I didn't see any problem with the File stuff, I can use writeln and it does all ten iterations, (not printing any thing of course). I used write instead of writeln, write doesn't flush like writeln, maybe.
I noticed my program that had been running fine before, but suddenly bailed out almost strait away since I used the def file in the compile arguments.
Joel
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Joel Christensen | On Wed, Mar 9, 2011 at 5:19 PM, Joel Christensen <joelcnz@gmail.com> wrote:
> This is on Windows 7. Using a def file to stop the terminal window coming up.
>
> win.def
> EXETYPE NT
> SUBSYSTEM WINDOWS
>
> bug.d
> import std.stdio;
> import std.string;
>
> void main() {
> auto f = File( "z.txt", "w" );
> scope( exit )
> f.close;
> string foo = "bar";
> foreach( n; 0 .. 10 ) {
> writefln( "%s", foo );
> f.write( format( "count duck-u-lar: %s\n", n ) );
> }
> }
>
> output (from in z.txt):
> count duck-u-lar: 0
>
My understanding is that the "0..10" isn't actually a range notation,
and you need to use iota(0, 10). I may be wrong, but if I'm right,
hopefully someone can explain why this syntax works?
I remember there being a discussion about this recently; I'll see if I
can find it.
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
On Wednesday 09 March 2011 23:15:13 Andrew Wiley wrote:
> On Wed, Mar 9, 2011 at 5:19 PM, Joel Christensen <joelcnz@gmail.com> wrote:
> > This is on Windows 7. Using a def file to stop the terminal window coming up.
> >
> > win.def
> > EXETYPE NT
> > SUBSYSTEM WINDOWS
> >
> > bug.d
> > import std.stdio;
> > import std.string;
> >
> > void main() {
> > auto f = File( "z.txt", "w" );
> > scope( exit )
> > f.close;
> > string foo = "bar";
> > foreach( n; 0 .. 10 ) {
> > writefln( "%s", foo );
> > f.write( format( "count duck-u-lar: %s\n", n ) );
> > }
> > }
> >
> > output (from in z.txt):
> > count duck-u-lar: 0
>
> My understanding is that the "0..10" isn't actually a range notation,
> and you need to use iota(0, 10). I may be wrong, but if I'm right,
> hopefully someone can explain why this syntax works?
> I remember there being a discussion about this recently; I'll see if I
> can find it.
0..10 works with foreach. It's specific to foreach. iota also works, because it produces a range rather being built in to the language. As such, iota works in places _other_ than foreach. But 0..10 works just fine in foreach. It definitely pre-dates iota.
- Jonathan M Davis
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
On Thu, Mar 10, 2011 at 1:31 AM, Jonathan M Davis <jmdavisProg@gmx.com> wrote:
> On Wednesday 09 March 2011 23:15:13 Andrew Wiley wrote:
>> On Wed, Mar 9, 2011 at 5:19 PM, Joel Christensen <joelcnz@gmail.com> wrote:
>> > This is on Windows 7. Using a def file to stop the terminal window coming up.
>> >
>> > win.def
>> > EXETYPE NT
>> > SUBSYSTEM WINDOWS
>> >
>> > bug.d
>> > import std.stdio;
>> > import std.string;
>> >
>> > void main() {
>> > auto f = File( "z.txt", "w" );
>> > scope( exit )
>> > f.close;
>> > string foo = "bar";
>> > foreach( n; 0 .. 10 ) {
>> > writefln( "%s", foo );
>> > f.write( format( "count duck-u-lar: %s\n", n ) );
>> > }
>> > }
>> >
>> > output (from in z.txt):
>> > count duck-u-lar: 0
>>
>> My understanding is that the "0..10" isn't actually a range notation,
>> and you need to use iota(0, 10). I may be wrong, but if I'm right,
>> hopefully someone can explain why this syntax works?
>> I remember there being a discussion about this recently; I'll see if I
>> can find it.
>
> 0..10 works with foreach. It's specific to foreach. iota also works, because it produces a range rather being built in to the language. As such, iota works in places _other_ than foreach. But 0..10 works just fine in foreach. It definitely pre-dates iota.
>
> - Jonathan M Davis
>
Ah, then I guess I just need to learn me some D. Sorry for the noise.
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Joel Christensen | On Wed, 09 Mar 2011 18:19:55 -0500, Joel Christensen <joelcnz@gmail.com> wrote:
> This is on Windows 7. Using a def file to stop the terminal window coming up.
>
> win.def
> EXETYPE NT
> SUBSYSTEM WINDOWS
>
> bug.d
> import std.stdio;
> import std.string;
>
> void main() {
> auto f = File( "z.txt", "w" );
> scope( exit )
> f.close;
> string foo = "bar";
> foreach( n; 0 .. 10 ) {
> writefln( "%s", foo );
> f.write( format( "count duck-u-lar: %s\n", n ) );
> }
> }
>
> output (from in z.txt):
> count duck-u-lar: 0
If I dust off my rusty old Windows hat, I believe if you try to write to stdout while there is no console window, you will encounter an error.
So don't do that ;) I'm not sure what you were expecting...
-Steve
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Andrew Wiley | On 3/10/11 4:15 AM, Andrew Wiley wrote:
> On Wed, Mar 9, 2011 at 5:19 PM, Joel Christensen<joelcnz@gmail.com> wrote:
>> This is on Windows 7. Using a def file to stop the terminal window coming
>> up.
>>
>> win.def
>> EXETYPE NT
>> SUBSYSTEM WINDOWS
>>
>> bug.d
>> import std.stdio;
>> import std.string;
>>
>> void main() {
>> auto f = File( "z.txt", "w" );
>> scope( exit )
>> f.close;
>> string foo = "bar";
>> foreach( n; 0 .. 10 ) {
>> writefln( "%s", foo );
>> f.write( format( "count duck-u-lar: %s\n", n ) );
>> }
>> }
>>
>> output (from in z.txt):
>> count duck-u-lar: 0
>>
>
> My understanding is that the "0..10" isn't actually a range notation,
> and you need to use iota(0, 10). I may be wrong, but if I'm right,
> hopefully someone can explain why this syntax works?
> I remember there being a discussion about this recently; I'll see if I
> can find it.
It works because it's a specialized syntax for foreach. Oh, and I think in case statements you can use it too, but I don't remember if the first was inclusive and the second exclusive, or both, or what. But... it just works for those cases. For the rest you have to use iota...
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Andrew Wiley | On 3/10/11 4:40 AM, Andrew Wiley wrote:
> On Thu, Mar 10, 2011 at 1:31 AM, Jonathan M Davis<jmdavisProg@gmx.com> wrote:
>> On Wednesday 09 March 2011 23:15:13 Andrew Wiley wrote:
>>> On Wed, Mar 9, 2011 at 5:19 PM, Joel Christensen<joelcnz@gmail.com> wrote:
>>>> This is on Windows 7. Using a def file to stop the terminal window coming
>>>> up.
>>>>
>>>> win.def
>>>> EXETYPE NT
>>>> SUBSYSTEM WINDOWS
>>>>
>>>> bug.d
>>>> import std.stdio;
>>>> import std.string;
>>>>
>>>> void main() {
>>>> auto f = File( "z.txt", "w" );
>>>> scope( exit )
>>>> f.close;
>>>> string foo = "bar";
>>>> foreach( n; 0 .. 10 ) {
>>>> writefln( "%s", foo );
>>>> f.write( format( "count duck-u-lar: %s\n", n ) );
>>>> }
>>>> }
>>>>
>>>> output (from in z.txt):
>>>> count duck-u-lar: 0
>>>
>>> My understanding is that the "0..10" isn't actually a range notation,
>>> and you need to use iota(0, 10). I may be wrong, but if I'm right,
>>> hopefully someone can explain why this syntax works?
>>> I remember there being a discussion about this recently; I'll see if I
>>> can find it.
>>
>> 0..10 works with foreach. It's specific to foreach. iota also works, because it
>> produces a range rather being built in to the language. As such, iota works in
>> places _other_ than foreach. But 0..10 works just fine in foreach. It definitely
>> pre-dates iota.
>>
>> - Jonathan M Davis
>>
>
> Ah, then I guess I just need to learn me some D. Sorry for the noise.
No, D needs to change, not you. Ah, consistency...
|
March 10, 2011 Re: I seem to be able to crash writefln | ||||
---|---|---|---|---|
| ||||
Posted in reply to Ary Manzana | Ary Manzana:
> It works because it's a specialized syntax for foreach. Oh, and I think in case statements you can use it too, but I don't remember if the first was inclusive and the second exclusive, or both, or what. But... it just works for those cases. For the rest you have to use iota...
Yes, it's a quite messy design. And Walter & Andrei seem to think it's OK.
Bye,
bearophile
|
Copyright © 1999-2021 by the D Language Foundation