Невозможно преобразовать void * в массив байтов

Вы определяете

type byte is range 0..255;

Ада требует, чтобы базовый тип целочисленного типа со знаком (определяемый с помощью «диапазона») был целочисленным типом со знаком, примерно симметричным относительно нуля, с диапазоном, достаточно большим, чтобы удерживать диапазон в объявлении типа. Это означает, что базовый тип Byte должен быть достаточно большим, чтобы вмещать -255 .. 255. Таким образом, Byte'Base, вероятно, является 16-разрядным целым числом с дополнением до двух со знаком. И действительно, вы показываете, что ваш результат содержит такие значения, как 12331, которые слишком велики, чтобы поместиться в 0..255.

C int в вашей системе выглядит 32-битным, с прямым порядком байтов. Вот почему вы получаете 2 значения для каждого int, с операндом в 1-м слове и нулем во 2-м. Это означает, что оператор будет находиться в младшем разряде 5-го слова.

В самом деле, 12331 бэр 256 = 43, то есть «+».

Чтобы сделать это правильно, объявите

type Byte is mod 256;
pragma Convention (C, Byte);

type Byte_List is array (Interfaces.C.int range 0 .. 15) of Byte;
pragma Convention (C, Byte_List);

function Read (List : Byte_List; Size : Interfaces.C.Int; Timeout : Interfaces.C.Int)
return Interfaces.C.Int;
pragma Import (C, Read, "read_message");

Затем вы можете вызвать это с помощью

Status : Interfaces.C.Int;
List   : Byte_List;
...
Status := Read (List, 9, 1);

и вы должны обнаружить, что List содержит

2 0 0 0 5 0 0 0 43

Важные правила:

Все, что вы передаете в функцию C, должно быть условным C. (Да, иногда нестандартные типы C будут работать, но иногда они не будут работать, в то время как условные типы C будут работать всегда.)

Никогда не передавайте System.Address в C. Чтобы передать массив, просто передайте массив; Ада передает указатель C-конвенции на 1-й элемент массива функции C, что дает вам то, что вы хотите. В других случаях, когда требуется указатель, вы должны передать тип доступа Convention-C. (System.Address будет работать с некоторыми компиляторами, но не со всеми. Тот факт, что он работает с вашим текущим компилятором, не означает, что он будет работать с другим, в том числе с другой версией вашего текущего компилятора.)

Хммм... похоже, здесь можно использовать пакеты (и дженерики!).

-- We need to define the base-type for the buffer.
Subtype Byte_Array is Interfaces.C.char_array;


-- Taking an address for the size (size_t type), and an address for the
-- location of the buffer we create one with the package's instantiation.

Generic
    Buffer_Location,
    Size_Location : in System.Address;
Package Buffer_Package is
    Length   : constant Interfaces.C.size_t
      with Address => Size_Location, Import, Convention => C;

    Subtype Buffer_Type is Byte_Array(1..Length);

    Buffer : Buffer_Type
      with Address => Buffer_Location, Import, Convention => C;

    Pragma Assert( Length >= 0 );
End Buffer_Package;


Generic
    with package Buf_Pkg is new Buffer_Package( others => <> );
Package Parse is

    Type Operators is ( Identity, '*', '/', '+', '-' );

    -- There are three forms of Node:
    --   1) Unary operation: only the string-field "right" exists.
    --   2) Binary operation #1: in addition to "Right" is the string "Left"
    --   3) Binary operation #2: in addition to "Right" is a pointer to a node.
    Type Node( Op : Operators; Len_1, Len_2 : Natural ) is record
        Right : String(1..Len_1);
        case Op is
        when Identity => null;
        when others   => 
            case Len_2 is
            when Positive  => Left : String(1..Len_2);
            when 0         => Ptr  : not null access Node;
            end case;
        end case;
    end record;

    Function Exec( Input : Node ) return Float;

    -- YOUR READ FUNCTION HERE! (Use Buf_Pkg.Buffer.)

private
    Function Value( Input : Node ) return Float;
end Parse;

Package body Parse is
    Function Exec( Input : Node ) return Float renames Value;

    Function Value( Input : Node ) return Float is
        Subtype Unary is Operators range Identity..Identity;
    begin
        declare
            Right : constant Float:= Float'value(Input.Right);
            Left  : constant Float:= (if Input.Op in Unary then 0.0 else
                          (if Input.Len_2 in Positive then Float'value(Input.Left)
                           else Value(Input.Ptr.all)
                          ));
        begin
            case Input.Op is
            when Identity => return Right;
            when '*' => return Left * Right;
            when '/' => return Left / Right;
            when '+' => return Left + Right;
            when '-' => return Left - Right;
            end case;
        end;
    end Value;
end Parse;

Чтение из буфера в Node-дерево остается в качестве упражнения для OP.

Если вы хотите, чтобы компилятор соответствовал типу или переменной, вы должны указать это явно.

type Byte is range 0 .. 255;

Только с помощью объявления выше, типу Byte может быть выделено что угодно от 8 бит и выше. Вы можете добавить объявление размера, чтобы указать требуемый размер:

type Byte is range 0 .. 255;
for Byte'Size use 8;

Теперь компилятору приходится умещать переменные типа Byte в 8 бит (или не компилировать исходный текст).

С неограниченными массивами способ сделать это немного отличается:

type Bytes is array (Integer range <>) of Byte;
pragma Pack (Bytes);

Всякий раз, когда вы взаимодействуете с C, вы должны хранить список сопоставлений в абзацах B.3(63-75) в справочном руководстве. Это поможет вам отслеживать, насколько сильно вы должны настроить сторону Ada, чтобы она соответствовала стороне C.

Если у вас есть значение System.Address и вы хотите получить объект, на который указывает адрес, вы не можете использовать Ada.Unchecked_Conversion для System.Address. Это преобразует байты в самом адресе, а не байты, на которые указывает адрес. То, что вы хотите, это что-то вроде

The_Buffer : Byte_Array;
for The_Buffer'Address use Buffer;

или, в Аде 2012 (я думаю):

The_Buffer : Byte_Array with Address => Buffer;

Это сообщает компилятору, что The_Buffer — это объект, адрес которого является значением Buffer. Тогда вы можете сказать

myArray := The_Buffer;

чтобы скопировать его в локальную переменную.

Это не решит всех проблем с вашим кодом. Я сильно подозреваю, что Buffer на самом деле не является действительным System.Address, поскольку в нем, похоже, есть байты из ввода, что неверно для адреса. Не видя больше кода (особенно кода, который вызывает process_byte_array), трудно сказать, что именно нужно сделать.