Re: Strange argc check in stable snapshot

Berger, Daniel wrote:
>>int main(int argc, char *argv[])
>>{
>>     if (argc < 0)
>>         return 0;
>>     else
>>         main(-1, 0);
>>}
>>
>>This is perfectly legal C. There's nothing special about 
>>main() except 
>>that the loader uses it as the entry point. Any other 
>>function can call 
>>it, including itself.
>>
>>The argc in question is nonnegative by convention only. Someone could 
>>just make a mistake and call it with the wrong argument.
>>
>>Steve
> 
> Not exactly what I meant, but I'll donate $100 anyway.  I would consider
> specifying argc manually a BUG.  At the very least, it's really crappy
> code and not the sort of thing I would make an explicit check for.  I
> would force a change in the offending caller's code.

Of course it's a bug. That's what the test is for.

Two examples are getting confounded here. My only purpose in citing the 
main() example was to show that even the case where everyone assumes 
argc *cannot* be negative, it can. I can think of other ways to do it 
with syntactically and semantically conforming but buggy code (e.g., 
off-by-one errors, typos), and just bad code (stack corruption).

The function under consideration here, however, is not main(), but a 
part of the Ruby interpreter. If Matz and the other developers don't 
make a mistake, it will never be called with invalid arguments.  If Matz 
decides that the probability of making that particular mistake is so low 
as to not bother, that's reasonable... even though there's virtually 
nothing you can do on a computer that's as fast as checking the sign of 
an integer.

What's not reasonable is saying it can't happen. It can.

But to be a good sport about it, I'll donate $100 too. Let's make this 
like a political fundraiser: $100 to participate in the thread. Any 
takers? :-)

Steve