types in procedure arguments

types in procedure arguments

[Chris Papademetrious]

 I've got a small problem that most likely extends from my lack of
knowledge about Ada 95, so I'm turning to the gurus for help.

 I have a procedure that I'd like to pass a list of "Points" (just a
two-dimensional coordinate) as an input.  Now, I have a doubly linked
list type defined in a package.  This package requires a generic
argument of what it is a linked list *of*, so, I need to instantiate
the list package with the parameter of type Point before I can define
the input argument as a List argument.

 No problem, I'll just put the procedure in a package wrapper, and
define the linked list type before the procedure, to make everything
happy!  Well, that works, except when I try to USE the procedure in
another package.  When I passed a list parameter where I call the
procedure, I get the following error:

 lazarus(10:55)/home/chrispy/bot > gnatmake best_test
gcc -c best_test.adb
best_test.adb:45:35: expected private type "LIST_ID" defined at
double_list.ads: 43
best_test.adb:45:35: found private type "LIST_ID" defined at
double_list.ads:43
gnatmake: "best_test.adb" compilation error

 The source location for the type it expected and the type it got are
the same, BUT they're incompatible types!  To me, this means that this
problem arises from the fact that I had to redefine the list type to
be able to specify it as a function argument in the procedure package
itself, because that is essentially a NEW, incompatible type.

 How the heck do I get around something like this??

 - Chris


-=-=-=-=-=-=-=-=-=-=-=-=-
 Chris Papademetrious
 Data Fusion Laboratory
 Drexel University
 Philadelphia, PA
-=-=-=-=-=-=-=-=-=-=-=-=-

Re: types in procedure arguments

[Stephen Leake]

Chris Papademetrious wrote:
> 
>  I've got a small problem that most likely extends from my lack of
> knowledge about Ada 95, so I'm turning to the gurus for help.

Unless you post code, we probably can't help. As a wild guess, you might
try making the list type a parameter of the generic package.
-- 
- Stephe

Re: types in procedure arguments

[Chris Papademetrious]

 Hello, folks.  I posted a question here awhile ago, and haven't
received an answer.  If anyone could review my question and offer
advice, I would really appreciate it.  It's the type of question that
isn't covered in Ada books because it's more of a "how to approach it"
kind of question.  I'll repost the question in the next message.  All
help would be appreciated.

 BTW, I'm the author of the recently-released Ada 95 matrix math
package.  Being a relative newcomer to the language, I'm trying to do
my best to repay the Ada community for their kindness in helping me
get up to speed quickly.

 - Chris


-=-=-=-=-=-=-=-=-=-=-=-=-
 Chris Papademetrious
 Data Fusion Laboratory
 Drexel University
 Philadelphia, PA
-=-=-=-=-=-=-=-=-=-=-=-=-

Re: types in procedure arguments

[Chris Papademetrious]

 I've got a small problem that most likely extends from my lack of
knowledge about Ada 95, so I'm turning to the gurus for help.

 I have a procedure that I'd like to pass a list of "Points" (just a
two-dimensional coordinate) as an input.  Now, I have a doubly linked
list type defined in a package.  This package requires a generic
argument of what it is a linked list *of*, so, I need to instantiate
the list package with the parameter of type Point before I can define
the input argument as a List argument.

 No problem, I'll just put the procedure in a package wrapper, and
define the linked list type before the procedure, to make everything
happy!  Well, that works, except when I try to USE the procedure in
another package.  When I passed a list parameter where I call the
procedure, I get the following error:

 lazarus(10:55)/home/chrispy/bot > gnatmake best_test
gcc -c best_test.adb
best_test.adb:45:35: expected private type "LIST_ID" defined at
double_list.ads: 43
best_test.adb:45:35: found private type "LIST_ID" defined at
double_list.ads:43
gnatmake: "best_test.adb" compilation error

 The source location for the type it expected and the type it got are
the same, BUT they're incompatible types!  To me, this means that this
problem arises from the fact that I had to redefine the list type to
be able to specify it as a function argument in the procedure package
itself, because that is essentially a NEW, incompatible type.

 How the heck do I get around something like this??

 - Chris


-=-=-=-=-=-=-=-=-=-=-=-=-
 Chris Papademetrious
 Data Fusion Laboratory
 Drexel University
 Philadelphia, PA
-=-=-=-=-=-=-=-=-=-=-=-=-

Re: types in procedure arguments

[Robert Dewar]

pdemrtious asked

about

"gcc -c best_test.adb
best_test.adb:45:35: expected private type "LIST_ID" defined at
double_list.ads: 43
best_test.adb:45:35: found private type "LIST_ID" defined at
double_list.ads:43
"

This is almost certainly a bug in GNAT, but you did not say what version
you are using (most such bugs were squashed a while ago). If you are using
the current version, or even a version from 3.04 on, then send along a bug
report to report@gnat.com. if you are using an earlier version, then upgrade
first.

Re: types in procedure arguments

[Chris Papademetrious]

 I have gotten some replies via email, and am beginning to believe
that this is a more interesting problem than I first thought!  Here's
a very simplified version of the situation.  Essentially, in the real
problem, I'm using a presupplied doubly-linked-list package and vector
math package (gotta put that reuse principle to work, right?).  For
the example below, I'm just using placeholder packages to illustrate.
Clip the following section and run it through "gnatchop" and you will
see the problem that leads to:

lazarus(18:39)/home/chrispy/bot > gnatmake tst
gcc -c tst.adb
tst.adb:13:39: expected private type "LIST_ID" defined at
tst_double_list.ads:4
tst.adb:13:39: found private type "LIST_ID" defined at
tst_double_list.ads:4
gnatmake: "tst.adb" compilation error


 Thank you for your time and energy, folks.  Several people have
expressed interest in the outcome of this, and I thank you for your
help in resolving it.

 - Chris

-- cut here

with Tst_Double_List; -- double linked-list package
with Tst_Vectors;

package Tst_Best_Congruence is

   package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
Tst_Vectors.Vector);

   procedure Best_Congruence
   (
      List: in out Vec_List.LIST_ID
   );

end Tst_Best_Congruence;
generic
   type ELEMENT_OBJECT is private;
package Tst_Double_List is
   type LIST_ID is limited private;
private
   type LIST_ID is 
      record
         Item1, Item2, Item3: ELEMENT_OBJECT;
      end record;
end Tst_Double_List;
package Tst_Vectors is
  type Vector is array (0..9) of Float;
end Tst_Vectors;
with Tst_Double_List; -- double linked-list package
with Tst_Best_Congruence;
with Tst_Vectors;

procedure Tst is

  package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
Tst_Vectors.Vector);

  L: Vec_List.LIST_ID;

begin

  Tst_Best_Congruence.Best_Congruence(L);

end Tst;
package body Tst_Best_Congruence is

  procedure Best_Congruence
  (
     List: in Point_List.LIST_ID
  ) is
  begin
    List := List;
  end Best_Congruence;

end Tst_Best_Congruence;


-=-=-=-=-=-=-=-=-=-=-=-=-
 Chris Papademetrious
 Data Fusion Laboratory
 Drexel University
 Philadelphia, PA
-=-=-=-=-=-=-=-=-=-=-=-=-

Re: types in procedure arguments

[Norman H. Cohen]

Chris Papademetrious wrote:

>  I want to pass the type LIST_ID to a procedure I've defined.  The
> problem is that I've defined the type LIST_ID twice:
> 
>  1. at the beginning of the level where I call this procedure
>  2. in the package that holds the procedure itself, so I can use the
> type LIST_ID as a procedure argument
> 
>  The problem here is that each of these originates a new and unique
> "type LIST_ID" which aren't compatible with each other.  Thus, the
> calling statement that passes a type (1) of LIST_ID does not match the
> type (2) LIST_ID of the argument in the procedure being called!
> 
>  This seems basic, the idea of calling a subprogram with a type, and
> needing to define the type in a package so the subprogram can be
> declared.  How is this handled in Ada 95???  I'd be more than happy to
> provide a small test program, if anyone could lend me a hand.  I've
> been battling this for two weeks, and no books have been of any help.

The terminology you are using ("the level where I call this procedure",
"use the type LIST_ID as a procedure argument", "calling statement that
passes a type", "calling a subprogram with a type") does not make any
sense in Ada terms, so I can only guess what you mean.  You can pass a
type to a generic template to create an instance of that template; you
can pass a parameter OF a given type to a procedure.  Even though your
original query mentioned generic units, my best guess is that what you
are concerned with is passing a an object OF a given type to a
subprogram. 

If you want one compilation unit to declare a subprogram, another to
call the subprogram, and a third to declare the type used for one of the
parameters, the first two compilation units can be given a with clause
naming the third one.  For example:

   package Parameter_Types is
      type Parameter_Type is ...;
   end Parameter_Types;

   with Parameter_Types; use Parameter_Types;
   procedure Callee (Formal_Parameter: in Parameter_Type) is
      ...
   begin
      ...
   end Callee;

   with Parameter_Types, Callee; use Parameter_Types;
   procedure Caller is
      Actual_Parameter: Parameter_Type;
      ...
   begin
      Callee (Actual_Parameter);
      ...
   end Caller;

The first of these three units could just as easily have been the
instantiation of a generic package:

   with Generic_Template;
   package Parameter_Types is new Generic_Template ( ... );

Does this answer your question?

-- 
Norman H. Cohen
mailto:ncohen@watson.ibm.com
http://www.research.ibm.com/people/n/ncohen

Re: types in procedure arguments

[Chris Papademetrious]

dewar@schonberg.cs.nyu.edu (Robert Dewar) wrote:
>"gcc -c best_test.adb
>best_test.adb:45:35: expected private type "LIST_ID" defined at
>double_list.ads: 43
>best_test.adb:45:35: found private type "LIST_ID" defined at
>double_list.ads:43
>"

>This is almost certainly a bug in GNAT, but you did not say what version
>you are using (most such bugs were squashed a while ago). If you are using
>the current version, or even a version from 3.04 on, then send along a bug
>report to report@gnat.com. if you are using an earlier version, then upgrade
>first.

 We're using gnat 3.05, and I really believe that GNAT is correct and
I'm misunderstanding something about Ada 95 here.

 I want to pass the type LIST_ID to a procedure I've defined.  The
problem is that I've defined the type LIST_ID twice:

 1. at the beginning of the level where I call this procedure
 2. in the package that holds the procedure itself, so I can use the
type LIST_ID as a procedure argument

 The problem here is that each of these originates a new and unique
"type LIST_ID" which aren't compatible with each other.  Thus, the
calling statement that passes a type (1) of LIST_ID does not match the
type (2) LIST_ID of the argument in the procedure being called!

 This seems basic, the idea of calling a subprogram with a type, and
needing to define the type in a package so the subprogram can be
declared.  How is this handled in Ada 95???  I'd be more than happy to
provide a small test program, if anyone could lend me a hand.  I've
been battling this for two weeks, and no books have been of any help.

 - Chris


-=-=-=-=-=-=-=-=-=-=-=-=-
 Chris Papademetrious
 Data Fusion Laboratory
 Drexel University
 Philadelphia, PA
-=-=-=-=-=-=-=-=-=-=-=-=-

Re: types in procedure arguments

[Stephen Leake]

As has been said many times in response to other posts, please post the
code, so we can revise it. At a wild guess, make the LIST_ID type a
parameter to the generic package.

-- 
- Stephe

Re: types in procedure arguments

[Robert Dewar]

Papdemetrious says

" I have gotten some replies via email, and am beginning to believe
that this is a more interesting problem than I first thought!  Here's
a very simplified version of the situation.  Essentially, in the real
problem, I'm using a presupplied doubly-linked-list package and vector
math package (gotta put that reuse principle to work, right?).  For
the example below, I'm just using placeholder packages to illustrate.
Clip the following section and run it through "gnatchop" and you will
see the problem that leads to:"


This is obviously a GNAT bug, at the very least the error message is wrong,
but despite all the email and posts, this still has not been reported to
report@gnat.com!

Re: types in procedure arguments

[Robert A Duff]

In article <52piii$8n7@noc2.drexel.edu>,
Chris Papademetrious <st92j0gw@dunx1.ocs.drexel.edu> wrote:
> I have gotten some replies via email, and am beginning to believe
>that this is a more interesting problem than I first thought!  Here's
>a very simplified version of the situation.  Essentially, in the real
>problem, I'm using a presupplied doubly-linked-list package and vector
>math package (gotta put that reuse principle to work, right?).

Now that I see the source code, I see what you're talking about.
You need to have just one instantiation of Tst_Double_List, not two.
You could make that a library unit, and import it into both
Tst_Best_Congruence and Tst.  However, I assume Tst_Best_Congruence
is the re-used thing, and you don't want to modify it.  In that case,
you could do something like this:

    with Tst_Best_Congruence;
    with Tst_Vectors;
    procedure Tst is

      package Vec_List renames Tst_Best_Congruence.Vec_List;
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

      L: Vec_List.LIST_ID;
    begin
      Tst_Best_Congruence.Best_Congruence(L);
    end Tst;

Or, don't use the renaming, and just say:

    L: Tst_Best_Conguence.Vec_List.LIST_ID;

Or, use use_clauses:

    with Tst_Best_Congruence;
    use Tst_Best_Congruence;
    use Tst_Best_Congruence.Vec_List;
    with Tst_Vectors;
    procedure Tst is
      L: LIST_ID;
    begin
      Best_Congruence(L);
    end Tst;

(I didn't compile these -- sorry for any silly mistakes.)

>  procedure Best_Congruence
>  (
>     List: in Point_List.LIST_ID
>  ) is
>  begin
>    List := List;

That's illegal -- you can modify an 'in' parameter.

- Bob

Re: types in procedure arguments

[Stephen Leake]

At last! some real code.

Chris Papademetrious wrote:
> [snip]
>  Thank you for your time and energy, folks.  Several people have
> expressed interest in the outcome of this, and I thank you for your
> help in resolving it.
> 
>  - Chris
> with Tst_Double_List; -- double linked-list package
> with Tst_Vectors;
> 
> package Tst_Best_Congruence is
> 
>    package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
> Tst_Vectors.Vector);
> 
>    procedure Best_Congruence
>    (
>       List: in out Vec_List.LIST_ID
>    );
> 
> end Tst_Best_Congruence;
> generic
>    type ELEMENT_OBJECT is private;
> package Tst_Double_List is
>    type LIST_ID is limited private;
> private
>    type LIST_ID is
>       record
>          Item1, Item2, Item3: ELEMENT_OBJECT;
>       end record;
> end Tst_Double_List;
> package Tst_Vectors is
>   type Vector is array (0..9) of Float;
> end Tst_Vectors;
> with Tst_Double_List; -- double linked-list package
> with Tst_Best_Congruence;
> with Tst_Vectors;
> 
> procedure Tst is
> 
>   package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
> Tst_Vectors.Vector);

You don't want to do this second instantiation here.

>   L: Vec_List.LIST_ID;

This should be:

L :  Tst_Best_Congruence.Vec_List.LIST_ID;

> 
> begin
> 
>   Tst_Best_Congruence.Best_Congruence(L);

Using full names for clarity, the "LIST_ID" type this call wants to see
is Tst_Best_Congruence.Vec_List.LIST_ID (the one declared in
Tst_Best_Congruence), not Test.Vec_List.LIST_ID (the one declared in
Tst). In cases like this, you can always write down the full names of
things to see what's going on. Instantiating a package a second time
produces a distinct type, and Ada gives it a distinct name.

> 
> end Tst;

> -=-=-=-=-=-=-=-=-=-=-=-=-
>  Chris Papademetrious
>  Data Fusion Laboratory
>  Drexel University
>  Philadelphia, PA
> -=-=-=-=-=-=-=-=-=-=-=-=-

-- 
- Stephe

Re: types in procedure arguments

[Norman H. Cohen]

Chris Papademetrious wrote:

> with Tst_Double_List; -- double linked-list package
> with Tst_Vectors;
> 
> package Tst_Best_Congruence is
> 
>    package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
> Tst_Vectors.Vector);
> 
>    procedure Best_Congruence
>    (
>       List: in out Vec_List.LIST_ID
>    );
> 
> end Tst_Best_Congruence;
> generic
>    type ELEMENT_OBJECT is private;
> package Tst_Double_List is
>    type LIST_ID is limited private;
> private
>    type LIST_ID is 
>       record
>          Item1, Item2, Item3: ELEMENT_OBJECT;
>       end record;
> end Tst_Double_List;
> package Tst_Vectors is
>   type Vector is array (0..9) of Float;
> end Tst_Vectors;
> with Tst_Double_List; -- double linked-list package
> with Tst_Best_Congruence;
> with Tst_Vectors;
> 
> procedure Tst is
> 
>   package Vec_List is new Tst_Double_List(ELEMENT_OBJECT =>
> Tst_Vectors.Vector);
> 
>   L: Vec_List.LIST_ID;
> 
> begin
> 
>   Tst_Best_Congruence.Best_Congruence(L);
> 
> end Tst;
> package body Tst_Best_Congruence is
> 
>   procedure Best_Congruence
>   (
>      List: in Point_List.LIST_ID
>   ) is
>   begin
>     List := List;
>   end Best_Congruence;
> 
> end Tst_Best_Congruence;

This is what I thought the problem was.  As you noted in another post,
each instantiation 

   package Instance is new Tst_Double_List(T);

creates a NEW type Instance.List_ID, even if the generic actual
parameter T is the same in both cases and even if the instances
(declared in different declarative regions) have the same name.  You
have created one package named Vec_List nested inside the package
Tst_Best_Congruence and a completely distinct package named Vec_List
nested inside the procedure Tst.  Each of these packages provides a
distinct (although structurally identical) type named List_ID.  

(Perhaps you have experience with C++ templates, instances of which are
uniquely identified by the template name and the template arguments. 
Ada generic templates do not work that way.  An instance of an Ada
generic template comes into existence only as the result of an explicit
generic instantiation, and it is possible to create several distinct
instances with the same generic actual parameters.)

Your solution, as I sketched in my previous note, is to declare ONE
instance of Tst_Double_List, in a compilation unit consisting only of
the generic instantiation:

   with Tst_Double_List, Tst_Vectors;
   package Vec_List is 
      new Tst_Double_List(ELEMENT_OBJECT => Tst_Vectors.Vector);

This is, in effect, the declaration of a separately compiled package
named Vec_List.  Now you can write

   with Vec_List;
   package Tst_Best_Congruence is
      procedure Best_Congruence (List: in out Vec_List.List_ID);
   end Tst_Best_Congruence;

and

   with Vec_List, Tst_Best_Congruence;
   procedure Tst is
      L: Vec_List.List_ID;
   begin
      Tst_Best_Congruence.Best_Congruence(L);
   end Tst;

The with clauses for Vec_List on Tst_Best_Congruence and Tst now
reference the SAME instance of Tst_Double_List.

-- 
Norman H. Cohen
mailto:ncohen@watson.ibm.com
http://www.research.ibm.com/people/n/ncohen