Object Instances

[leonerd]

What should an actual object instance be?

The Object::Pad implementation has no choice but to use something existing, so its native representation is a blessed arrayref, where the elements of the array store the fields directly.

I suspect for a real core implementation we'd want a new kind of SV itself, complete with its own body type and reftype name

class C { }
is(builtin::reftype(C->new), "OBJECT", 'Object instance reftype is OBJECT');

[leonerd]

Latest implementation now defines a new SV type, SVt_PVOBJ with its own body type. The fields are stored in an allocated SV** array, but it no longer shares any implementation details with AVs.

[leonerd]

Current Implementation (2022-08-17)

An object instance is an SV of a new type, SVt_PVOBJ (distinct from PVAV, PVHV, or anything else that previously existed). Regular perl code would encounter them via an RV to a blessed instance, similar to classical object instances on e.g. blessed hash references. The SvOBJECT() flag is still set on such an instance, and its class is still stored in SvSTASH(); thus code such as

if(SvROK(sv) && SvOBJECT(SvRV(sv))) ...

will still work as it does with classical objects. Most code that operates opaquely on an object instance should not need to be aware of the difference.

Internally, the XPVOBJ structure stores the following fields:

    /* Required to align with XPVMG and other structures */
    HV*         xmg_stash;
    union _xmgu xmg_u;

    /* Fields for an object instance */
    SSize_t     xobject_maxfield;
    SSize_t     xobject_iter_sv_at; /* this is only used by Perl_sv_clear() */
    SV**        xobject_fields;

These additional fields:

• xobject_maxfield - the index of the highest valid element of xobject_fields
• xobject_iter_sv_at - a rarely-used field that is required by the non-recursive iteration behaviour of Perl_sv_clear() to temporarily store progress while it destroys an entire tree of object instances. Most regular code should not need to care about this field
• xobject_fields - a pointer to an array of SV pointers storing the actual field data for this instance.

Since the size of an instance is fixed at the compiletime of its class, we do not need to store the usual pair of MAX+FILL and implement some sort of reällocation logic. A single malloc() operation at the time the instance SV is created is sufficient to create an array large enough for all of its fields, and thereafter does not need to be modified. The maxfield field is used largely for sanity-check purposes in assert() statements before accessing elements of the fields array, to ensure the code is not operating on an invalid instance.

Further, since naked object storage is never directly visible by pureperl code, there is no need to guard array or hash-shaped fields by wrapping them in an SVt_RV. Therefore, the fields array will store pointers to AVs and HVs directly for these types of fields.

API

Code outside of class.c should not need to directly create a new object instance. As such, there is no direct API for doing so. Internal functions within class.c ensure that the right thing happens.

Other code can distinguish an object instance by the usual kind of SvTYPE() test:

if(SvTYPE(sv) == SVt_PVOBJ) ...

If this is found to be true, the fields can be accessed by macros:

SSize_t  ObjectMAXFIELD(sv);
SV     **ObjectFIELDS(sv);

There is currently no helper API to make field access safer (e.g. by checking the requested fieldix is within the bounds that are valid on the object instance), but some sort of API would likely be useful to add.