Using controlled types to trace program execution

[Nige <nigel.scott@uk.thalesgroup.com>]

Hi all,

I am trying to come up with a way of tracing program execution using
controlled types. Ie, I want to be able to declare an object as a
procedure or function is entered, which would add itself to some sort of
stack during it's initialization and remove itself once it goes out of
scope.

The benfit of this is that I would not have to explicitly have some sort
of enter and exit calls whenever a subprogram is called.

The problem is, that however I try to identify the declaration of the
object, the compiler throws it out.

The approaches I have tried are:

* A controlled object with an access to a string as a discriminant.

* A generic package containing a controlled type with a discrete type as
a discriminant.

* extending the type with a string/string access to identify it.

Does anyone have any ideas how I could acomplish this or even if it is
possible? I may be trying to do something that is not sensible/possible
of course...

Ideally I'd simply like to have:

procedure Something is

  Here : Trace.Location ("Something");

begin
  null;
end Something;

 ... where the package Trace would store the string "Something" until
the object Here goes out of scope. Then at any time I can examine the
contents of the stack in the package Trace...

The nearest I have got is to use new to allocate strings as the objects
are declared, but then the strings can't be deallocated explicitly,
because the strings are not variables.
eg

  Here : Trace.Location (new String'("Something"));

Hope I've made some sense,

Nige