C array to Ada pointer to unconstrained array without copying memory

[Duncan Sands <baldrick@free.fr>]

Greetings.  Given a C pointer Ptr to a type T (which points to a block of memory
containing a C array of T's) and the length of the array Length, there are various
tricks for getting an Ada array of the right size (defined on the stack - important!)
that uses the block of memory to hold the array data, i.e. no copying required.

For example,

type Ada_Array is array (Positive range <>) of T;

...

[have Length and Ptr]

subtype Array2 is Ada_Array (1 .. Length);

X : Array2;
for X'Address use Ptr; -- ok, Ptr should be of type System'Address, but hey!

And then you can make use of X.  However being defined on the stack, it
can be quite awkward to use.  It would be nice to have the same thing but
with X dynamically allocated.  For example,

type Ada_Array_Pointer is access Ada_Array;

...

[have Length and Ptr]

X_Ptr : Ada_Array_Pointer;

[do some clever stuff to set up X_Ptr to point to an array where the
data is given by Ptr, and the bounds are somewhere else, but where? :)]

[Pass X_Ptr around and dereference it etc.]

The problem is the bounds of course.  For example, GNAT usually uses
fat pointers, consisting of two normal pointers where one points to the
data, and the other to the bounds.  So the "clever stuff" will need to
allocate some memory to hold the bounds and set up the fat pointer
appropriately.

Does anyone know a good way to do this?  The solution only needs to
work with GNAT.  I appreciate that deallocating the pointer may need
to be handled specially.

All the best,

Duncan.