Re: Division by zero

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Lurker" <nowhere@nothing.com> writes:

> "Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
> news:wccy88ugorw.fsf@shell01.TheWorld.com...
> 
> > 11.6(5) is all about run time effects.  If divide by zero were illegal
> > (which means at compile time), then 11.6 would not apply.  11.6 is also
> > (as you said) all about implementation permissions -- i.e. not
> > portable.  I would hope a legality rule in this area would be portable.
> 
> OK, I don't want to get *too* deep into the language wars sort
> of thing.

Language wars?  To have a language war, you have to crosspost to two or
more newsgroups, and insult the advocates of one or more languges.  ;-)

>... My surprise was quite pragmatic - I was called in (as a
> consultant) to investigate and fix a problem that led to actual program
> crash in production. The reason for that crash, as it happened, was
> division by zero in some obscure and rarely used part of the code.
> Now, I would understand it if it was a variable which is generally
> unsolvable. But a constant? At first I thought it must be a bug in this
> particular compiler version. But since then I've had quite a few replies
> stating that's how it should be. So I don't know anymore...

Whether it's a compiler bug or not is a matter of opinion.  It depends
whether you think compilers ought to be smart enough to detect the case
you're interested in (which, as I recall, was something like X/0,
where X is not static).  I think it's a bug, and I would report it.
You can convince the compile vendor that it's a bug by giving them
money.  ;-)

But this case is *not* a violation of the Ada standard.  The compiler
*should* detect this case (IMHO), but is not required to do so by the
standard.  There are many other cases compilers *should* detect.
For example:

    package P is
        Y: constant Integer;
    private
        Y: constant Integer := 0;
    end P;

    ... X/P.Y ... -- compiler should warn, but P.Y is *not* static

and:

    procedure P(X: Integer) is
        Y: Integer;
    begin
        if ... then
            Y := 0;
            ... X/Y ... -- compiler should warn
        else
            Y := 7;
        end if;
    end P;

I'm not sure about this one:

    procedure P(X: Integer) is
        Y: Integer;
    begin
        if ... then
            Y := 0;
        else
            Y := 7;
        end if;
        ... X/Y ... -- should compiler warn?
    end P;

There's probably a bug, but maybe not.

- Bob