Re: How do I get this to work??

["Nick Roberts" <Nick.Roberts@dial.pipex.com>]

Dear Chris,

The solution to your problem is (as ever) terrifically simple: declare the
variable Session at the same static level as the type Session_Ptr_Type. You
do not need a Session_Ptr variable at all. For example:


package Connection_Management is

   procedure Open_Connection;
   procedure Close_Connection;

   Connection_Error: exception;

end Connection_Management;


with Interfaces.C;
package body Connection_Management is

   type Session_Type is
      record
         Status : Interfaces.C.int := 0;
      end record;

   type Session_Ptr_Type is access all Session_Type;
   pragma Convention(C,Session_Ptr_Type);

   The_Session: aliased Session_Type;
   pragma Volatile(The_Session);

   function Open_Port (Session: in Session_Ptr_Type) return
Interfaces.C.int;
   pragma Import(C,Open_Port,"OpenPort");

   function Close_Port (Session: in Session_Ptr_Type) return
Interfaces.C.int;
   pragma Import(C,Close_Port,"ClosePort");

   procedure Open_Connection is
   begin
      if Open_Port(The_Session'Access) /= 0 then
         raise Connection_Error;
      end if;
   end Open_Connection;

   procedure Close_Connection is
   begin
      if Close_Port(The_Session'Access) /= 0 then
         raise Connection_Error;
      end if;
   end Close_Connection;

end Connection_Management;


For clarity, I have renamed Session as The_Session.

Of course, all this is to illustrate the declaration and use of a C pointer
type in Ada. In reality, the body of the above package would be programmed
as follows:


with Interfaces.C;
package body Connection_Management is

   type Session_Type is
      record
         Status : Interfaces.C.int := 0;
      end record;

   The_Session: Session_Type;
   pragma Volatile(The_Session);

   function Open_Port (Session: in out Session_Type) return
Interfaces.C.int;
   pragma Import(C,Open_Port,"OpenPort");

   function Close_Port (Session: in out Session_Type) return
Interfaces.C.int;
   pragma Import(C,Close_Port,"ClosePort");

   procedure Open_Connection is
   begin
      if Open_Port(The_Session) /= 0 then
         raise Connection_Error;
      end if;
   end Open_Connection;

   procedure Close_Connection is
   begin
      if Close_Port(The_Session) /= 0 then
         raise Connection_Error;
      end if;
   end Close_Connection;

end Connection_Management;


Ada automatically converts between an 'in out' parameter and the appropriate
C pointer type. Don't forget the Volatile pragma, or your compiler is
entitled to do something brown and sticky to you.

--
Nick Roberts
2104: Witty remark not found - try again later

Chris Warwick wrote in message <76tbvv$ba5$1@nntp3.uunet.ca>...
|Sorry, perhaps I should have been a little more specific...
|
|Chris Warwick wrote in message <76s0dp$1v4$1@nntp3.uunet.ca>...
|>   package Ada_Front_End is
|>
|>      type Session_Type is
|>         record
|>            Status : integer := 0;
|>         end record;
|>
|>      type Session_Ptr_Type is access Session_Type;
|>
|>      function Close_Port (Session : in Session_Ptr_Type) return integer;
|>   end Ada_Front_End;
|>
|>   procedure Close_Connection is
|>      Session : aliased constant Ada_Front_End.Session_Type;
|>      Session_Ptr : Session_Ptr_Type := Session'Access;
|
|It barfs here, because Session_Ptr_Type has greater scope than Session. My
|problem is Close_Port needs a pointer to a Session, so I have to define the
|Session_Ptr_Type at the highest level...
|
|>   begin
|>      Ada_Front_End.Close_Port
|>            (Session => Session_Ptr);
|>   end Close_Connection;