Re: ObjectAda vs Gnat -- bugs

["Nick Roberts" <Nick.Roberts@dial.pipex.com>]

Robert Dewar <dewar@merv.cs.nyu.edu> wrote in article
<dewar.864017071@merv>...
> Nick says
> 
> <<On the other hand, it seems to me to be sensible to have the compiler
> 'implement' enumeration literals as function calls, and then simply have
it
> _optimise_ the calls into immediate values (pretty near the end of the
> optimisation process).
> 
> This way, you get the overloading behaviour of enumeration literals 'for
> free', and without any danger of getting it wrong (a la GNAT), and you
also
> get the bonus of optimising genuine parameterless functions which are
> defined to return an (effectively) static value into immediate values as
> well. I would argue that this is an optimisation which most compilers
ought
> to provide, anyway (anybody disagree?).>>
> 
> Well you have to dig in to the front end of a compiler a bit more to see
> why thiings are more complicated. The trouble is that enumeration
literals
> are different from functions in some important ways, for example, they
> are static constants, and also they can be used as selectors in te
> aggregate for an enumeration rep clause -- there are many other
subtleties.
> So if you tried to implement them this way, apart from the significant
> inefficiency for large enumeration types, you would simply swap one set
of
> special cases for another. It would not help at all, and in fact I think
> would likely make things much worse. We find that when you distort the 
> RM this way, you usually live to regret it :-)


I am convinced.

I need to wait for my brain to finish all its passes before emitting code
:-)

However, one could perhaps define a nifty little function such as:

   function Is_Parameterless_Function (Entity: Ada_Entity'Class) return
Boolean is
   begin
      return (Entity in Ada_Function and then
Parameter_Count(Ada_Subprogram(Entity)) = 0) or
             Entity in Ada_Enumeration_Literal;
   end;

It may still have to be used judiciously!

Nick.