Re: how to import a package

["Jeffrey R. Carter" <spam.not.jrcarter@acm.not.spam.org>]

markww wrote:
> Hi,
> 
> I have this snippet of code (from members here) which defines a generic
> type:
> 
>     generic
>     type T is private;
>         package P is
>     type Node;
>     type Node_Ptr is access Node;
>         type Node is record
>             Data     : T;
>             Prev_Rec : access Node; -- points to the next record or
> null if none exists.
>             Next_Rec : access Node; -- points to the previous record or
> null if none exists.
>         end record;
>     end P;
> 
> Now my compiler (gnat) complains that Node, and Node_Ptr are not seen
> by the rest of the application. Is this because they are scoped within
> package P?

Package are very basic to Ada. 1st you must know how to make use of a 
package. If you don't know that, you're not ready to do anything useful 
with Ada. In general, if you have a library-level package P, you make it 
visible to another compilation unit through a context clause:

with P;
package Q is
    ...

In this case, you have a generic package, which is not a package but a 
way to create a package tailored to your needs. You can only mention a 
generic package in a context clause or instantiation. You still have to 
mention it in a context clause:

with P;
procedure My_Project is

then you have to use it to make a new package (instantiation):

package X is new P (T => Person_Rec);

Now the things declared in P are available in X. You have to use a 
qualified name to access them: X. Node. (Since you're a beginner, I'd 
recommend avoiding the use clause until you have a better idea how these 
things work.)

The above is for the most common case that P is a library-level generic 
package. In your case it appears your generic package is declared in 
your main procedure (which is not very useful), so it is not 
library-level and is directly visible; you neither need nor can use a 
context clause for P.

But all this is very basic. You should work through a tutorial or text 
and understand packages and generic packages before trying this; both 
are available at adapower.com or adaworld.com.

It would also help if you used basic Ada indentation standards:

generic
    type T is private;
package P is
    type Node;
    ...
end P;

Again, by the time you've worked through a tutorial or text you should 
have been exposed to a bunch of examples, and will hopefully have seen 
the logic behind the common indentation approach.

If you've already been through a tutorial or text, including generics, 
then there's something you didn't understand. In that case, I'm not sure 
which part you didn't understand.

-- 
Jeff Carter
"People called Romanes, they go the house?"
Monty Python's Life of Brian
79