nabbasi@pacbell.net

nabbasi@pacbell.net

[how to read C extern variables from Ada?]

Hello,

It is easy to interface to C from Ada. But one problem that I could not
see mentioned in annex B, is how to get access to 'extern' variables.

For example, I can call getopt() from Ada. But the problem is that getopt()
sets values into an extern variables that are defined is C header files, 
and so can be read from C client programs after the call to getopt() 
returns.

--------------------
SYNOPSIS
    #include <unistd.h>

    int getopt(int argc, char * const argv[], const char *optstring);
    extern char *optarg;
    extern int optind, opterr, optopt;
-----------------------

So, in the above, after I call getopt(), I need a way to 'read' optarg. There
is no C API to read optarg. So, How to do this in Ada??

thanks,
Nasser

ps. offcourse I could write a small C stub that the Ada program calls, and
then it calls getopt(), and this C stub could read the extern
variables. and I define an API to this C stub function to return these
variables via function call. But I wanted to see if I can do the whole thing
in 100% pure Ada :), it also makes the Makefile simpler.  This is GNAT 3.11p.

Re: nabbasi@pacbell.net

[Matthew Heaney]

how to read C extern variables from Ada? <how@newsguy.com> writes:

> --------------------
> SYNOPSIS
>     #include <unistd.h>
> 
>     int getopt(int argc, char * const argv[], const char *optstring);
>     extern char *optarg;
>     extern int optind, opterr, optopt;
> -----------------------
> 
> So, in the above, after I call getopt(), I need a way to 'read' optarg. There
> is no C API to read optarg. So, How to do this in Ada??

Use pragma Import.  (I think.) 

how to read C extern variables from Ada?

[David C. Hoos, Sr.]

how to read C extern variables from Ada? wrote in message
<7bbd3c$gf7@drn.newsguy.com>...
>Hello,
>
>It is easy to interface to C from Ada. But one problem that I could not
>see mentioned in annex B, is how to get access to 'extern' variables.
>
>For example, I can call getopt() from Ada. But the problem is that getopt()
>sets values into an extern variables that are defined is C header files,
>and so can be read from C client programs after the call to getopt()
>returns.
>
>--------------------
>SYNOPSIS
>    #include <unistd.h>
>
>    int getopt(int argc, char * const argv[], const char *optstring);
>    extern char *optarg;
>    extern int optind, opterr, optopt;
>-----------------------
>
>So, in the above, after I call getopt(), I need a way to 'read' optarg.
There
>is no C API to read optarg. So, How to do this in Ada??
>
The simple answer is that one uses pragma import, e.g.:

Option_Argument : Interfaces.C.Char_Array;
pragma Import (C. Option_Argument, "optarg");

But, the details get a little messy.  Here's a possible implementation:

--- begin source code ---
with Ada.Command_Line;
with Ada.Text_Io;
with Interfaces.C.Pointers;
with System;
procedure Command_Line_Options is
   package C_String_Pointers is new Interfaces.C.Pointers
     (Index => Interfaces.C.Size_T,
      Element => Interfaces.C.Char,
      Element_Array => Interfaces.C.Char_Array,
      Default_Terminator => Interfaces.C.Nul);

   type C_String_Vector is array (Interfaces.C.Size_T range <>) of
     aliased C_String_Pointers.Pointer;

   package C_String_Vector_Pointers is new Interfaces.C.Pointers
     (Index => Interfaces.C.Size_T,
      Element => C_String_Pointers.Pointer,
      Element_Array => C_String_Vector,
      Default_Terminator => Null);

   subtype String_Pointer is C_String_Pointers.Pointer;

   subtype C_String_Vector_Pointer is C_String_Vector_Pointers.Pointer;

   use type Interfaces.C.Char_Array;
   use type Interfaces.C.Int;
   use type C_String_Pointers.Pointer;

   function Next_Option_Character_Pos
     (Argument_Count  : in Interfaces.C.Int;
      Argument_Vector_Pointer : in C_String_Vector_Pointer;
      Option_String   : in Interfaces.C.Char_Array)
      return Interfaces.C.Int;
   pragma Import (C, Next_Option_Character_Pos, "getopt");

   Argument_Vector_Pointer : C_String_Vector_Pointer;
   pragma Import (C, Argument_Vector_Pointer, "gnat_argv");

   Argument_Vector : constant C_String_Vector :=
     C_String_Vector_Pointers.Value (Ref => Argument_Vector_Pointer);

   Argument_Count : constant Interfaces.C.Int := Argument_Vector'Length - 1;
   Option_Argument_Pointer : C_String_Pointers.Pointer;
   pragma Import (C, Option_Argument_Pointer, "optarg");

   Option_Character_Pos : Interfaces.C.Int := 0;
   Option_Character : Character;

   Option_Index  :  Interfaces.C.Int;
   pragma Import (C, Option_Index, "optind");

   Option_Error  :  Interfaces.C.Int;
   pragma Import (C, Option_Error, "opterr");

   Option_Option :  Interfaces.C.Int;
   pragma Import (C, Option_Option, "optopt");

begin

   Ada.Text_Io.Put_Line
     ("Argument count =>" & Interfaces.C.Int'Image (Argument_Count));

   for A in Argument_Vector'First ..
     Interfaces.C.Size_T'Pred (Argument_Vector'Last) loop
      Ada.Text_Io.Put_Line
        ("Argument (" & Interfaces.C.Size_T'Image (A) & ") is """ &
         Interfaces.C.To_Ada
         (C_String_Pointers.Value (Argument_Vector (A))) &
         """");
   end loop;

     Option_Error := 1;

     loop
        Option_Character_Pos := Next_Option_Character_Pos
          (Argument_Count =>  Argument_Count,
           Argument_Vector_Pointer => Argument_Vector_Pointer,
           Option_String => "a:bc" & Interfaces.C.nul);

        exit when Option_Character_Pos < 0 or else Option_Character_Pos >
255;

        Option_Character := Character'Val (Option_Character_Pos);

        Ada.Text_Io.Put_Line
          ("Option_Index =" &
           Interfaces.C.Int'Image (Option_Index));

        Ada.Text_Io.Put_Line
          ("Option_Option =" &
           Interfaces.C.Int'Image (Option_Option));

        Ada.Text_Io.Put_Line
          ("Option_Character =" & Option_Character);

        for A in Argument_Vector'First ..
          Interfaces.C.Size_T'Pred (Argument_Vector'Last) loop
           Ada.Text_Io.Put_Line
             ("Argument (" & Interfaces.C.Size_T'Image (A) & ") is """ &
              Interfaces.C.To_Ada
              (C_String_Pointers.Value (Argument_Vector (A))) &
              """");
        end loop;

          if Option_Argument_Pointer /= null then
             Ada.Text_Io.Put_Line
               ("Option argument = """ &
                Interfaces.C.To_Ada
                (C_String_Pointers.Value (Option_Argument_Pointer)));
          end if;

     end loop;

end Command_Line_Options;

--- end source code ---

Re: nabbasi@pacbell.net

[Stephen Leake]

how to read C extern variables from Ada? <how@newsguy.com> writes:

> Hello,
> 
> It is easy to interface to C from Ada. But one problem that I could not
> see mentioned in annex B, is how to get access to 'extern' variables.
> 
> For example, I can call getopt() from Ada. But the problem is that getopt()
> sets values into an extern variables that are defined is C header files, 
> and so can be read from C client programs after the call to getopt() 
> returns.
> 
> --------------------
> SYNOPSIS
>     #include <unistd.h>
> 
>     int getopt(int argc, char * const argv[], const char *optstring);
>     extern char *optarg;
>     extern int optind, opterr, optopt;
> -----------------------
> 
> So, in the above, after I call getopt(), I need a way to 'read' optarg. There
> is no C API to read optarg. So, How to do this in Ada??

Ada code to import 'optarg':

optarg : Interfaces.C.strings.Chars_Ptr;
pragma Import (C, optarg, "optarg");

I haven't compiled this, but it should work with GNAT.

> ps. offcourse I could write a small C stub that the Ada program calls, and
> then it calls getopt(), and this C stub could read the extern
> variables. and I define an API to this C stub function to return these
> variables via function call. But I wanted to see if I can do the whole thing
> in 100% pure Ada :), it also makes the Makefile simpler.  This is GNAT 3.11p.

I have tried to import an object exported by a DLL, using ObjectAda on
Windows NT, and that doesn't work. So I had to add an access function
to the DLL. But in the above, getopt() is probably not in a DLL, but
just a normal library, so you should be ok.

-- Stephe