Re: Compiler Warnings (Was: Suprise of comparison result)

Re: Compiler Warnings (Was: Suprise of comparison result)

[Nick Roberts]

> In the warning text, T is replaced by the expanded name of type T.

Corrigendum:

In the warning text, R is replaced by the image of the value R.

-- 
Nick Roberts
Computer Consultant (UK)
http://www.callnetuk.com/home/nickroberts
http://www.adapower.com/lab/adaos

Re: Suprise of comparison result

[Robert Dewar]

In article <37fd7e17.0@news.pacifier.com>,
  "Steve Doiel" <nospam_steved@pacifier.com> wrote:
> I'm suprised that Ada behaves this way.  Both ObjectAda and
> GNAT give the same result.

That's because it is the well defined result of what was
written. You can always be surprised when you use a construct
you do not understand, in this case the problem is not knowing
the meaning of unary minus on modular types.

> If I were programming in C I would not be suprised at this
> result.  But in Ada?

Well I guess that's because you understand in C the nature
of unsigned modular types. Well the semantics of modular types
are pretty much identical in C and Ada, so the behavior will
indeed be similar!


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Suprise of comparison result

[Robert Dewar]

In article <7tke70$lf4$1@ash.prod.itd.earthlink.net>,
  "David C. Hoos, Sr." <david.c.hoos.sr@ada95.com> wrote:
> I believe what happens is that the literals -32768 and 32767
                                              ^^^^^^

This is not a literal, very few languages have negative
literals (APL is an exception). Understanding this is
important in nearly all languages.

To test your understanding, what is the result of

-5 mod 3

Most people get this wrong!


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Suprise of comparison result

[Robert Dewar]

In article <37fece61.0@news.pacifier.com>,
  "Steve Doiel" <nospam_steved@pacifier.com> wrote:
> The behavior I had hoped for was a compile time error when I
attempted to
> compare an integer value (-32768) to a modular value.  I
understand that
> things just don't work that way, but it was a bit of a
dissapointment.


But what possible basis would there be for an error here.
It is very useful to have unary minus work on modular
numbers, and it would indeed be a nasty irregularity
if -x was not the same as 0-x for modular types.

If you properly understand twos complement arithmetic,
the use of unary minus is often convenient, for example
doing

   x := -1;

to set x to all 1 bits is often convenient ...


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Suprise of comparison result

[Robert Dewar]

In article <wccr9j5nat8.fsf@world.std.com>,
  Robert A Duff <bobduff@world.std.com> wrote:
> Ada's modular types really are at the C level.  Don't use them
> if you don't want to program at that level.

I disagree, they have a well defined abstract semantics that
is nothing to do with level. If you understand these semantics
there is no reason to avoid them, and this has nothing to do
with being at the C "level".


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Suprise of comparison result

[Ted Dennison]

In article <7udvrl$npq$1@nnrp1.deja.com>,
  Robert Dewar <robert_dewar@my-deja.com> wrote:
> In article <7tke70$lf4$1@ash.prod.itd.earthlink.net>,
>   "David C. Hoos, Sr." <david.c.hoos.sr@ada95.com> wrote:
> > I believe what happens is that the literals -32768 and 32767
>                                               ^^^^^^
>
> This is not a literal, very few languages have negative
> literals (APL is an exception). Understanding this is
> important in nearly all languages.

That bit me quite badly recently in OpenToken too. Recognition of
negative literals had to be removed to support programming languages,
but that broke existing code for simpler languages. We eventually had to
add support for negative literals as an option. The header comments may
be enlightening:

  -- One would probably want to disallow signs in languages that use '-'
or
  -- '+' as an operator between integers. If your syntax does not have
such a
  -- concept, you will probably want to allow them.





--
T.E.D.


Sent via Deja.com http://www.deja.com/
Before you buy.

Re: Suprise of comparison result

[Robert A Duff]

Robert Dewar <robert_dewar@my-deja.com> writes:

> To test your understanding, what is the result of
> 
> -5 mod 3
> 
> Most people get this wrong!

Which indicates that (this part of) the language is poorly designed.
But it could be fixed by changing the precedences -- you wouldn't have to
make "-5" be a literal.

It seems to me that unary operators should never be lower precedence
than binary operators.  Do you agree with this language design
principle?

- Bob
-- 
Change robert to bob to get my real email address.  Sorry.

Re: Suprise of comparison result

[Robert Dewar]

In article <wccyaczqrb3.fsf@world.std.com>,
  Robert A Duff <bobduff@world.std.com> wrote:
> Robert Dewar <robert_dewar@my-deja.com> writes:
>
> > To test your understanding, what is the result of
> >
> > -5 mod 3
> >
> > Most people get this wrong!
>
> Which indicates that (this part of) the language is poorly
designed.
> But it could be fixed by changing the precedences -- you
wouldn't have to
> make "-5" be a literal.
>
> It seems to me that unary operators should never be lower
precedence
> than binary operators.  Do you agree with this language design
> principle?


I am not sure, would you really want to apply this principle
to APL?


Sent via Deja.com http://www.deja.com/
Before you buy.