Re: Disallowing Pre-Defined Operations

["Marin D. Condic" <mcondic-nospam@quadruscorp.com>]

Robert Dewar wrote:
> Why does this need a language feature? This is the sort of thing
> that is perfectly easy to program in Ada now. Sure you might
> get a little bit more efficient implementation if it was built
> in, but compilers could already do that by use of Intrinsic
> conventions, I see no reason for a new language feature here.
> 
In my experience, while one could certainly write source level code to
do the job, this ends up sufficiently inefficient to be not useful in
the kinds of systems that need it most - real time control computers.
You could degenerate to programming it in assembler, but often this gets
clumsy. (typically, you want to do something to trap overflow interrupts
and this can be difficult or problematic if you are not the compiler.
Either that, or you're working with sub-ranges of the word size and you
want a trap similar to Constraint_Error which gets problematic when
you've got lots of sub-ranges.) A solution does exist because I've done
it, but it would be easier - and may have other efficiency & error
checking benefits - if there were direct compiler support for it as an
intrinsic type.

Certainly, it would be easier for your average fresh-out or
inexperienced user to take advantage of it if it were intrinsic. And you
never quite know what sort of uses something like this might get put to
if it was simply right there to use.

> Does anyone have any experience with saturating numeric types
> in existing Ada programs?
> 
Yup. In Ada83 at least. Its not real pretty. Havn't had to do it in
Ada95 yet. Day ain't over, yet! :-)

If its too hard to implement or you just don't think it has enough
interest for ACT to support it, by all means drop the idea on the floor.
The original question was basically "What new features would it benefit
Ada to have?" I don't know about the rest of the world but if Ada had
saturated math data types *I* would have beaten it to death in the
engine control business. I'd suspect that other embedded programmers
would find the feature *very* useful and (here's the good part!) it
doesn't exist (that I am aware of) in the more popular languages for
that market sector. (Product distinction?)

It doesn't sound to me like something that would require some massive
compiler rewrite or some fundamental change in Ada syntax or semantics.
I'm no expert, but it seems fairly small and self-contained such that a
compiler could provide it as an option that could be toggled by
switches. Syntax? Maybe "type T is saturated digits 6 ;" or "type T is
saturated range -128..127 ;" Maybe as a pragma? "pragma Saturate (T) ;"
I personally wouldn't be fussy. :-)

MDC
-- 
=============================================================
Marin David Condic   - Quadrus Corporation -   1.800.555.3393
1015-116 Atlantic Boulevard, Atlantic Beach, FL 32233
http://www.quadruscorp.com/
m c o n d i c @ q u a d r u s c o r p . c o m

***PLEASE REMOVE THE "-NOSPAM" PART OF MY RETURN ADDRESS***

Visit my web site at:  http://www.mcondic.com/

"Because that's where they keep the money."
    --  Willie Sutton when asked why he robbed banks. 
=============================================================