I'm not sure I understand what this is about, can you please add a test case to cover it?

I'm not sure I understand what this is about

Any pointer contains inside a link to where it points and at least one element:

// C
int *getArray() 
{
    int *array = new int[42];
    array[0] = 1;
    array[1] = 2;

    return array;
}

// >> \FFI::cdef()
extern int *getArray(void);

// >> PHP
$data = $ffi->getArray();
dump($data);

// >> VarDumper representation

FFI\CData<int32_t*> { #0
    0: FFI\CData<int32_t> { #1
        +cdata: 1
    }
}

Although the size and type of the memory area where the pointer refers is not known (I propose to provide an alternative for void*, a pointer to something undefined) in advance, there is at least a zero element there (if the memory area is available).

In this case, if the CData was not transferred, a structure based on the type will be formed:

FFI\CType<int32_t*> { #0
    0: FFI\CType<int32_t> { #1 }
}

We can also get where the pointer "points" to via array access:

echo $data[0]->cdata; // 1
// OR (magic of FFI: alternative, but not strict option)
echo $data->cdata; // 1

Ok, ill add a tests

That might be a dumb question as I don't know FFI much, by why $data[0]? Is this tested?

As I noted above, this is getting real data by a pointer to this data: $data->getType(); // int* and $data[0]->getType(); // int

No, there are no tests for pointers. Can be added, no problem.

I replace the custom truncation by a CutStub.
Can't we know the size of the truncated data btw?
I think this is also not tested, isn't it? Can it be?

Can't we know the size of the truncated data btw?

In most cases, strings contain a trailing \0 (or \0\0 in wchar_t). This is how, for example, the function FFI::string($pointerToChar); // "string\0" works.

However, this is not entirely safe, since the function can return strings without the terminating \0, and store the length separately:

struct CustomString {
    char* data;
    int length;
}

In this case, while we are reading the data from char array, we can get into the "junk memory" or get an Access Violation or Segmentation Fault errors (https://en.wikipedia.org/wiki/Segmentation_fault). Therefore, there is a limit on the length of the line, so that even when reading extra data, we can stop in time.

No, this has only been tested in manual mode. You are right, we need to add to this too.

From what I understand, a pointer pointing to a function is going to be dumped the same as dumping a function.
Did I get this right? Shouldn't we make a difference between both?
Do we have the same concern for other kind of pointed values?

From what I understand, a pointer pointing to a function is going to be dumped the same as dumping a function.

Yep. However, a function is always a pointer to it (seemingly o___0).

It looks something like:

$pointer = function () { ... };

The variable contains a reference to a function (i.e. a pointer to it), but just like that, a function does not exist without a pointer to it.

Maybe I'm wrong on this. Need a C/C++ specialist, which I am not :D

Do we have the same concern for other kind of pointed values?

Perhaps arrays with a predetermined size 🤔