Re: Division by zero

[Stuart Palin <stuart.palin@0.0>]

Lurker wrote:
> 
> "Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
> > The reason is that it simplifies the language definition.
> 
> You don't seem to find any problem with complicating
> the language definition in the case of static expressions though.
> And, detecting division by static zero should be a non-issue
> really.

But evaluating static expressions is a general rule that can
support error detection in a wide range of cases - basically
all the predefined operators.  Consider:

    type T is range 1..10;
    x, y : T;
    ...
    x := 5 + 6;  -- Constraint error will be raised!
    or
    y := x + 10; -- Constraint Error will be raised!

[GNAT produces warnings that constraint error will be raised
in these cases]

If you are adding a rule for "/", what about the other
operators (which also include "mod" and "rem").  If you
don't have the additional rules the language starts to
appear arbitrary: now you have to start remembering what all
the arbitrary rules are.

As has been said elsewhere, you can add the rules but they
make the compiler more complex (and if you are not careful
can interact with other rules in unexpected ways).  It is
right that the Ada standard considers both the benefit and
cost of the rules.  Personally I think the standard has got
it right in this case: it has defined a generic rule that
has benefits and seems to be little cost to the compiler (it
will most likely want to evaluate static expressions at
compile time).

> Sorry, I still don't see how complex it would be. If an expression is
> static, compiler knows it at compile time, correct? So let's say the
> rule is that predefined division operation is illegal if the static
> divisor evaluates to zero.

But how complicated will the language become if everyone's
pet 'simple rule' got put in.

There are tools available for carrying out much more
detailed analysis of code behaviour (e.g. SPARK &
Polyspace).  For people really concerned with errors in
their code (not just divide by zero) they offer automated
ways of detecting them.

Regards
--
Stuart