Simpler question, create instance of unknown tag

Simpler question, create instance of unknown tag

[Scott Moody]

My last input question can be boiled down to a simple
question:

  Can one use an Ada.Tags.Tag  value (call it a meta-type)
  and dynamically use it to create a concrete object 
   where the new object'Tag = this_tag_value

The compilers definitely can do this (for the Input implementation)
but can us mortals do it?

-scott

Re: Simpler question, create instance of unkno

[Scott Moody]

One more quick thing; Looking at the gnat implementation they
do the following:

               --  Read the internal tag (RM 13.13.2(34)) and use it to
               --  initialize a dummy object with the right tag value:

               --    Dnn : root_type;
               --    Dnn._tag := Internal_Tag (String'Input (Strm))

               --  This dummy object is not initialized (other than its tag)
               --  and is used only to provide a controlling argument for the
               --  eventual _Input call.

Unfortunately this is hidden from me..  Am I trying to do something
that is even too dynamic for the new Ada? Without this capability
I cannot overload the 'Class'Input operations without a Case statement..

scott

ps. my return email is getting goofed up by news. It is:
   scott@plato.ds.boeing.com

Re: Simpler question, create instance of unknown tag

[Robert Dewar]

Scott asked:

"  Can one use an Ada.Tags.Tag  value (call it a meta-type)
  and dynamically use it to create a concrete object
   where the new object'Tag = this_tag_value

The compilers definitely can do this (for the Input implementation)
but can us mortals do it?"

No, there is no way to do it, and I have found several times that this
is a minor irritation. For the most part, GNAT translates the stream
attributes into legitimate lower level Ada, but it can't do that for
Input (see GNAT sources for details on the very interesting "kludge"
needed to implement this feature).

It's hard to think of a nice syntax for adding this to the language?

Re: Simpler question, create instance of unknown tag

[Tucker Taft]

Robert Dewar (dewar@cs.nyu.edu) wrote:
: Scott asked:

: "  Can one use an Ada.Tags.Tag  value (call it a meta-type)
:   and dynamically use it to create a concrete object
:    where the new object'Tag = this_tag_value

: The compilers definitely can do this (for the Input implementation)
: but can us mortals do it?"

: No, there is no way to do it, and I have found several times that this
: is a minor irritation. For the most part, GNAT translates the stream
: attributes into legitimate lower level Ada, but it can't do that for
: Input (see GNAT sources for details on the very interesting "kludge"
: needed to implement this feature).

: It's hard to think of a nice syntax for adding this to the language?

You can actually do this in our Ada/Java system (aka "AppletMagic(tm)").
Ada.Tags.Tag is underneath the same type as java.lang.Class; that 
is a tag corresponds to a "class object."  The operation "newInstance"
takes a class object and returns an "Object" of the corresponding
class, having allocated it on the heap and initialized it via
the "default" (parameterless) constructor.  You can then
use unchecked conversion (which is checked by the Java VM ;-)
to convert the result to some more useful Ada type (probably the
root type of some type hierarchy).

This only works usefully if the type has a meaningful default 
constructor, which in Ada/Java means the type must have no 
discriminants and be of a "limited" type.

This is of course totally nonportable, but it provides an environment
for experimenting with this capability to see how it might be
useful, and how it might be made available in "standard" Ada.
Having a generic child of Ada.Tags might be one appropriate
way to accomplish this, to bundle together the call on newInstance
and the (checked) conversion to the appropriate Ada type.

-Tucker Taft   stt@inmet.com   http://www.inmet.com/~stt/
Intermetrics, Inc.  Cambridge, MA  USA

Re: Simpler question, create instance of unknown tag

[Norman H. Cohen]

In article <DoHFu8.E2A@world.std.com>, bobduff@world.std.com (Robert A Duff)
writes: 

|> I believe Norm Cohen could write an entire novel using only the reserved
|> words of Ada.  Maybe even just the reserved words of Ada 83.

And with out XOR or REM or ELSIF

Range of task is not at all limited
Begin with entry and end with exit and accept delay

--
Norman H. Cohen    ncohen@watson.ibm.com

Re: Simpler question, create instance of unknown tag

[Robert A Duff]

In article <4in6bu$klb@watnews1.watson.ibm.com>,
Norman H. Cohen <ncohen@watson.ibm.com> wrote:
>...

:-)

Re: Simpler question, create instance of unknown tag

[AdaWorks]

Robert A Duff (bobduff@world.std.com) wrote:

: Anyway, I like the above idea.  Now tell me how to support this:

:     X: T'Class;

: It would be nice ;-).

  Yeah, Bob. This is one of the first things one encounters in the
  early stages of learning Ada 95.  

  I have been writing, for some programs, something such as:

         function Get return T'Class;

  and then, for the declaration:

         X : T'Class := Get;

  to ensure compilation.

  The next trick is to decide how to implement function Get. This turns
  out to be quite useful for some situations.

  But then, my guess is that you already do this too.
  
  Richard Riehle
-- 

richard@adaworks.com
AdaWorks Software Engineering
Suite 27
2555 Park Boulevard
Palo Alto, CA 94306
(415) 328-1815
FAX  328-1112