pu$�le

[Jonathan M Davis]

On Sunday 18 July 2010 00:38:38 Jonathan M Davis wrote:
> On Saturday 17 July 2010 22:52:21 strtr wrote:
> > I think I'll start subject tagging my posts: [D1/D2]
> > std.stdio in D1 doesn't mention a write function and feeding the writef
> > function an illegal UTF string will result in a UTF exception.
> > With this information, what do you think the output should be?
> 
> Well, I certainly think that throwing an exception for bad UTF-8 values
> makes sense, though D2's docs for writef say nothing about exceptions, and
> on my machine, running Linux, they just fail to print anything. Throwing
> an exception would likely have been better.
> 
> In any case, I would have expected it to increment stash by 2 on the first
> loop because $ would be valid and would hit both scope(exit) and
> scope(success). After that... That continue makes me awfulling nervous.
> You'd expect the scope statements to be run in reverse order with continue
> and then stash--. However, to run that continue statement would have to
> skip the other scope statements...
> 
> I think that we'll have to lower the body of that foreach loop to have any
> clue what's going on here. It should come out to something like this, I
> would think:
> 
> const char[] coins = `$�`;
> 
> void main()
> {
>         writef(`I made `);
>         int stash = 0;
>         scope(exit) writefln(stash,`.`);
>         scope(failure) stash--;
> 
>         foreach(coin;coins)
>         {
>             try
>             {
>                 try
>                 {
>                     try
>                     {
>                         try
>                         {
>                             writef(coin);
>                         }
>                         catch
>                         {
>                             continue;
>                             throw;
>                         }
>                     }
>                     catch
>                     {
>                         stash--;
>                         throw;
>                     }
> 
>                     stash++;
>                 }
>                 catch
>                 {
>                     throw;
>                 }
>             }
>             finally
>             {
>                 stash++;
>             }
>         }
> }
> 
> 
> That being the case, the exception from writef() will always get eaten by
> the continue because the throw that rethrows the exception would never
> occur. Normally, code like that should result in a compilation error, but
> it might not given that it's the compiler creating the try-catch block. My
> guess is that this is a bug in dmd. It makes no sense to me to allow any
> kind of goto, break, or continue statements in a scope statement's body.
> 
> Regardless, that continue would mean that the first stash++ would be
> skipped, but the second would still happen because it's in a finally
> block. That means that each of the 3 bad UTF-8 values which make up the
> euro symbol would each increment stash once. So, the overall result would
> then be 5.
> 
> It's possible that I lowered those scope statements incorrectly, but it
> looks to me like that's what the code should be doing. Regardless,
> continue in a scope statement should be an error.
> 
> - Jonathan M Davis

Hmm. Well, it seems that throw by itself is not legal D. You have to do 
something like

catch(Exception e)
{
    throw e;
}


But in any case,

catch(Exception e)
{
    continue;
    throw e;
}

compiles just fine. That seems to me like it shouldn't though, since then throw 
e; is an unreachable statement. In any case, I'll file a bug report on this.


- Jonathan M Davis