Re: This can't be done in Ada...or?

["Randy Brukardt" <randy@rrsoftware.com>]

"Jeffrey Carter" <spam@spam.com> wrote in message
news:1bwQd.1171$kU3.57@newsread1.news.pas.earthlink.net...
...
> It's too late now, but this might have been a good thing to suggest for
> Ada 0X. Compilers already have to have this information available, or
> PragmARC.Reflection wouldn't work. We should be able to get at it
> without all this overhead.

It was suggested, as someone else noted. AI-282 was the result. It failed to
go anywhere for a variety of reasons: there was no champion on the ARG (no
one that wanted it badly enough to do the work needed); the proposal was too
magic for the tastes of many members; at least one major compiler uses
incremental compilation that would be destroyed by access to line numbers
(which could change without any other significant change), so they opposed
the package; exactly what the full subprogram name would be in a generic is
unclear (the instance name or the template name?); we don't like code that
changes its meaning if it is moved, and so on.

I personally don't feel strongly, but I think it's unnecessary. And there
would be a lot of space overhead whenever it is used (maybe that's not as
important anymore, but Janus/Ada at least was designed around space
minimization). Usually there is something better to report than the name of
a subprogram. (I may be spoiled by the exception walkbacks built into the
Janus/Ada runtime, which provides the information only when you actually
need it -- to debug an unexpected exception.)

One alternative to a lot of constants, especially for the package names, is
to declare an enumeration type in your tracing package. For instance, from
the Janus/Ada compiler:

    package J2Trace is
      type Unit_Names is (J2Type_Decs, J2CodeGen, J2Resolution,
J2Symbol_Table,...);
      function Trace_Unit (Unit : in Unit_Names) return Boolean;
      procedure Elaboration_Trace (Unit : in Unit_Names);
      ...
   end J2Trace;

Passing an enumeration has less overhead than passing a string (because
there is no need to construct and pass the bounds), you can make sure that
the names are spelled consistently, you can use the names for tracing
control (as above with function Trace_Unit), and you can use
Unit_Names'Image to display the unit when you need it. The main downside is
that you have to update the tracing package when a new unit is added to the
program, but that usually is a rare event.

                 Randy Brukardt