Interfacing Ada to C - getting Wide Strings from wchar_t *

Question

I'm interfacing to a USB device (on Debian Stretch) using hidraw, and I need to process some information supplied by the USB device in the form of wchar_t* which I need to convert into (Ada) Wide_String. This is giving some trouble and I'm not seeing a clean way forward using the facilities in Interfaces.C and Interfaces.C.Strings.

All files are edited down without destroying their consistency. They will build, but without one of these, they won't actually run.

The problem is that device information like Serial Number and Product Name are presented by the Linux device driver as an access stddef_h.wchar_t from which I want to return a Wide_String or even a normal String) and I'm not seeing any good way to get there.

Interfaces.C.Strings has function Value (Item : in chars_ptr) return String; but no equivalent exists for Wide_String that I can see. So I think I need an equivalent Value function for wide characters.

The approach below uses To_Ada (from Interfaces.C) to return a Wide_String given a wchar_array. It fails, of course, because an access wchar_t is not convertible to a wchar_array.

-- helper function to deal with wchar_t * to wide_string
   function Value (P : access stddef_h.wchar_t) return Wide_String is
      temp : Wide_String(1 .. 256);
      count : natural := 0;
      -- ugliness to convert pointer types
      type sd_wchar_ptr is access all stddef_h.wchar_t;
      type wchar_array_ptr is access wchar_array;
      Function To_Wchar_Array_Ptr is new Ada.Unchecked_Conversion(sd_wchar_ptr, wchar_array_ptr);

      -- this does NOT create the required wchar_array pointer
      WCP : wchar_array_ptr := To_Wchar_Array_Ptr(sd_wchar_ptr(P));
   begin
      Put_Line("Wide string");
      To_Ada(WCP.all, temp, count);
      Put_Line("Wide string length " & natural'image(count));
      return temp(1..count); 
   end Value;

and the inevitable result

./test_hid
Wide string

Execution terminated by unhandled exception raised STORAGE_ERROR : stack overflow or erroneous memory access

A similar character by character approach would be possible ... if (and I can't believe I'm saying this!) you could increment access types...

Feels like there's something missing from Interfaces.C here... what am I missing? any ideas to get round this relatively trivial seeming stumbling block?

EDIT : I'm leaning towards some brazen theft from the Interfaces.C.Strings sources with appropriate changes, but I'd welcome alternative suggestions.

---

The rest of this below is the full story so far (including all code necessary to reproduce)

Step 1 : generate low level Ada bindings automatically using gcc.

gcc -c -fdump-ada-spec-slim /usr/include/hidapi/hidapi.h

producing the low level binding package hidapi_hidapi_h

pragma Ada_2005;
pragma Style_Checks (Off);

with Interfaces.C; use Interfaces.C;
with Interfaces.C.Strings;
with stddef_h;
with System;

package hidapi_hidapi_h is

   --  see source file /usr/include/hidapi/hidapi.h

   type hid_device_info is record
      path : Interfaces.C.Strings.chars_ptr;  -- /usr/include/hidapi/hidapi.h:51
      vendor_id : aliased unsigned_short;  -- /usr/include/hidapi/hidapi.h:53
      product_id : aliased unsigned_short;  -- /usr/include/hidapi/hidapi.h:55
      serial_number : access stddef_h.wchar_t;  -- /usr/include/hidapi/hidapi.h:57
      release_number : aliased unsigned_short;  -- /usr/include/hidapi/hidapi.h:60
      manufacturer_string : access stddef_h.wchar_t;  -- /usr/include/hidapi/hidapi.h:62
      product_string : access stddef_h.wchar_t;  -- /usr/include/hidapi/hidapi.h:64
      usage_page : aliased unsigned_short;  -- /usr/include/hidapi/hidapi.h:67
      usage : aliased unsigned_short;  -- /usr/include/hidapi/hidapi.h:70
      interface_number : aliased int;  -- /usr/include/hidapi/hidapi.h:75
      next : access hid_device_info;  -- /usr/include/hidapi/hidapi.h:78
   end record;
   pragma Convention (C_Pass_By_Copy, hid_device_info);  -- /usr/include/hidapi/hidapi.h:49

   function hid_enumerate (arg1 : unsigned_short; arg2 : unsigned_short) return access hid_device_info;  -- /usr/include/hidapi/hidapi.h:132
   pragma Import (C, hid_enumerate, "hid_enumerate");

end hidapi_hidapi_h;

This is a low level binding, exposing C types (and the binding generator has decided that the wchar_t in Interfaces.C isn't good enough, it wants one from stddef.h too, so...

pragma Ada_2005;
pragma Style_Checks (Off);

with Interfaces.C; use Interfaces.C;

package stddef_h is

   --  unsupported macro: NULL ((void *)0)
   subtype size_t is unsigned_long;  -- /usr/lib/gcc/x86_64-linux-gnu/6/include/stddef.h:216

   subtype wchar_t is int;  -- /usr/lib/gcc/x86_64-linux-gnu/6/include/stddef.h:328

end stddef_h;

Because it is a low level binding; we want to hide it (and implement RAII etc) behind a simpler and more usable high level binding, so ... (below)

with Ada.Finalization;  use Ada.Finalization;
private with hidapi_hidapi_h;
private with System;

package hidapi is

   type id is new natural range 0 .. 2**16 - 1;
   type hid_device is new Limited_Controlled with private;

   -- find first matching devices by enumeration : the RA part of RAII. 
   function enumerate (vendor_id, product_id : id) return hid_device;

   -- accessors for device characteristics on enumerated device 
   function Serial_No      (D : hid_device) return Wide_String;
   function Product_String (D : hid_device) return Wide_String;

private

   type hid_device is new Limited_Controlled with record
      member : access hidapi_hidapi_h.hid_device_info;  
      addr : System.Address;
   end record;

end hidapi;

and its implementation, containing the problem function value to return a Wide_String.

with hidapi_hidapi_h;
with Interfaces.C; use Interfaces.C;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Unchecked_Conversion;
with stddef_h;

package body hidapi is

   function enumerate (vendor_id, product_id : id) return hid_device is
      use hidapi_hidapi_h;
      first  : access hid_device_info;
   begin
      first  := hid_enumerate(unsigned_short(vendor_id), unsigned_short(product_id));
      if first /= null then
         return H : hid_device do
            H.member := first;
            H.addr := System.Null_Address;
         end return;
      else raise Program_Error;
      end if;
   end enumerate;

-- helper function to deal with wchar_t * to wide_string
   function Value (P : access stddef_h.wchar_t) return Wide_String is
      temp : Wide_String(1 .. 256);
      count : natural := 0;

      type sd_wchar_ptr is access all stddef_h.wchar_t;
      type wchar_array_ptr is access wchar_array;
      Function To_Wchar_Array_Ptr is new Ada.Unchecked_Conversion(sd_wchar_ptr, wchar_array_ptr);

      WCP : wchar_array_ptr := To_Wchar_Array_Ptr(sd_wchar_ptr(P));
   begin
      Put_Line("Wide string");
      To_Ada(WCP.all, temp, count);
      Put_Line("Wide string length " & natural'image(count));
      return temp(1..count); 
   end Value;

   function Serial_No (D : hid_device) return Wide_String is
   use hidapi_hidapi_h;
   begin
      return Value(D.member.serial_number);
   end Serial_No;

   function Product_String (D : hid_device) return Wide_String is
   use hidapi_hidapi_h;
   begin
      return Value(D.member.product_string);
   end Product_String;

end hidapi;

And of course a test case to exercise it...

with Hidapi;
with Ada.Wide_Text_IO;

procedure Test_Hid is

      usbrelay_vendor_id  : constant Hidapi.id := 16#16c0#;
      usbrelay_product_id : constant Hidapi.id := 16#05df#;

      Device : Hidapi.hid_device := Hidapi.Enumerate(usbrelay_vendor_id, usbrelay_product_id);
begin

   Ada.Wide_Text_IO.Put_Line("Serial  : " & Device.Serial_No);
   Ada.Wide_Text_IO.Put_Line("Product : " & Device.Product_String);

end Test_Hid;

Answer 1

One answer, slavishly copying the approach in the package body for Tnterfaces.C.Strings with necessary changes.

The naughty stuff is in functions "+" and Peek which use Unchecked Conversions on pointers,

• to permit address arithmetic. Not pointer increment, but pointer+offset. One change is that the offset has to be scaled for 4 byte characters. I haven't set that scaling in a portable manner, but note that "+" will overload for each different return type so that offsets will be scaled appropriately for different named access types.
• to allow the stddef_h.wchar_t to be viewed as a Wide_Wide_Character in the absence of any type conversion function. Whether the representation is correct is another matter (here, it is) but this technique could also be used to fake the input type of a suitable conversion function like To_Ada in Interfaces.C.

The remainder is straightforward character by character handling. One other change (so far) is to return Wide_Wide_Character rather than Wide_Character (because as the stddef_h package above reveals, the stored characters are 32 bit, same size as Interfaces.C.int. I'm happy to change my interface, but Wide_String could be easily handled by Ada.Strings packages.

   type sd_wchar_ptr is access all stddef_h.wchar_t;
   type w_w_char_ptr is access all char32_t;

   -- Two Unchecked_Conversions to allow pointer arithmetic
   -- And a third to allow the resulting storage to be interpreted as Wide_Wide_Char
   function To_Sd_wchar_ptr is new Ada.Unchecked_Conversion (System.Address, sd_wchar_ptr);
   function To_Address is new Ada.Unchecked_Conversion (sd_wchar_ptr, System.Address);
   function To_Wchar_Ptr is new Ada.Unchecked_Conversion (sd_wchar_ptr, w_w_char_ptr);

   -- pointer + offset arithmetic, with offset scaled for size of stddef_h.wchar_t;
   -- TODO: attempted better way of computing word size ran into type errors
   function "+" (Left : sd_wchar_ptr; Right : size_t) return sd_wchar_ptr is
   begin
      return To_Sd_wchar_ptr (To_Address (Left) + Storage_Offset (Right) * 4);
   end "+";

   function Peek (From : sd_wchar_ptr) return char32_t is
   begin
      return To_Wchar_Ptr(From).all;
   end Peek;

   function Strlen (Item : sd_wchar_ptr) return size_t is
      Item_Index : size_t := 0;

   begin
      if Item = Null then
         raise Program_Error;
      end if;

      loop
         if Peek (Item + Item_Index) = char32_nul then
            return Item_Index;
         end if;

         Item_Index := Item_Index + 1;
      end loop;
   end Strlen;

   function Value (Item : sd_wchar_ptr) return char32_array is
      Result : char32_array (0 .. Strlen (Item));

   begin
      if Item = Null then
         raise Program_Error;
      end if;
      Put_Line("String length " & size_t'image(Strlen(Item)));
      --  Note that the following loop will also copy the terminating Nul

      for J in Result'Range loop
         Result (J) := Peek (Item + J);
      end loop;

      return Result;
   end Value;

-- helper function to deal with wchar_t * to wide_wide_string
   function Value (Item : access stddef_h.wchar_t) return Wide_Wide_String is
   begin
      return To_Ada (Value (sd_wchar_ptr(Item)));
   end Value;