Affix

 view release on metacpan or  search on metacpan

lib/Affix.c  view on Meta::CPAN

}
XS_INTERNAL(Affix_unpin) {
    dXSARGS;
    if (items != 1)
        croak_xs_usage(cv, "var");

    SV * sv = ST(0);
    // Pins are often references to magical scalars; unwrap if necessary
    if (SvROK(sv) && !sv_isobject(sv))
        sv = SvRV(sv);

    if (SvMAGICAL(sv)) {
        MAGIC * mg = mg_find(sv, PERL_MAGIC_ext);
        while (mg) {
            // Check if this magic belongs to the Affix 2.0 memory system
            if (is_v2_vtable(mg->mg_virtual)) {
                // sv_unmagicext returns 0 on success
                if (sv_unmagicext(sv, PERL_MAGIC_ext, mg->mg_virtual) == 0)
                    XSRETURN_YES;
            }
            mg = mg->mg_moremagic;
        }
    }
    XSRETURN_NO;
}
// Handles UTF-16LE (Windows) and UTF-32 (Linux/Mac) conversion to UTF-8 SV
static void pull_pointer_as_wstring(pTHX_ Affix * affix, SV * sv, const infix_type * type, void * p, bool readonly) {
    PERL_UNUSED_VAR(affix);
    PERL_UNUSED_VAR(type);

    wchar_t * wstr = *(wchar_t **)p;

    if (wstr == nullptr) {
        sv_setsv(sv, &PL_sv_undef);
        return;
    }

    // Calculate length (like wcslen)
    size_t wlen = 0;
    while (wstr[wlen])
        wlen++;

    // Pre-allocate SV buffer.
    // Worst case UTF-8 expansion: 1 wchar (4 bytes) -> 4 UTF-8 bytes.
    // +1 for null terminator.
    SvPVCLEAR(sv);
    char * d = SvGROW(sv, (wlen * UTF8_MAXBYTES) + 1);
    wchar_t * s = wstr;

    while (*s) {
        UV uv = (UV)*s++;

        // Handle Windows Surrogate Pairs (UTF-16LE)
        if (sizeof(wchar_t) == 2 && uv >= 0xD800 && uv <= 0xDBFF) {
            if (*s >= 0xDC00 && *s <= 0xDFFF) {
                UV low = (UV)*s++;
                uv = ((uv - 0xD800) << 10) + (low - 0xDC00) + 0x10000;
            }
        }

        d = (char *)uvchr_to_utf8((U8 *)d, uv);
    }
    *d = 0;

    // Set Perl SV properties
    SvCUR_set(sv, d - SvPVX(sv));
    SvPOK_on(sv);
    SvUTF8_on(sv);
}

// Direct marshalling experiment
void Affix_trigger_backend(pTHX_ CV * cv) {
    // Backend optimization is not yet thread-clone friendly in this patch.
    // For now, assume it works or isn't used in the threading test.
    dSP;
    dAXMARK;
    dXSTARG;

    Affix_Backend * backend = (Affix_Backend *)CvXSUBANY(cv).any_ptr;

    if (UNLIKELY((SP - MARK) != backend->num_args))
        croak("Wrong number of arguments to affixed function. Expected %" UVuf ", got %" UVuf,
              (UV)backend->num_args,
              (UV)(SP - MARK));

    size_t ret_size = infix_type_get_size(backend->ret_type);
    void * ret_buffer;
    if (ret_size <= 2048)
        ret_buffer = AFFIX_ALLOCA(ret_size);
    else {
        Newxz(ret_buffer, ret_size, char);
        SAVEFREEPV(ret_buffer);
    }
    SV ** perl_stack_frame = &ST(0);

    backend->cif(ret_buffer, (void **)perl_stack_frame);

    switch (backend->ret_opcode) {
    case OP_RET_VOID:
        sv_setsv(TARG, &PL_sv_undef);
        break;
    case OP_RET_BOOL:
        sv_setbool(TARG, *(bool *)ret_buffer);
        break;
    case OP_RET_SINT8:
        sv_setiv(TARG, *(int8_t *)ret_buffer);
        break;
    case OP_RET_UINT8:
        sv_setuv(TARG, *(uint8_t *)ret_buffer);
        break;
    case OP_RET_SINT16:
        sv_setiv(TARG, *(int16_t *)ret_buffer);
        break;
    case OP_RET_UINT16:
        sv_setuv(TARG, *(uint16_t *)ret_buffer);
        break;
    case OP_RET_SINT32:
        sv_setiv(TARG, *(int32_t *)ret_buffer);
        break;
    case OP_RET_UINT32:
        sv_setuv(TARG, *(uint32_t *)ret_buffer);

lib/Affix.c  view on Meta::CPAN

                    char ** ptr_slot = (char **)infix_arena_alloc(
                        _affix_call_args_arena(aTHX_ affix), sizeof(char *), _Alignof(char *));
                    *ptr_slot = SvPV_nolen(rv);
                    *(void **)c_arg_ptr = ptr_slot;
                    return;
                }
            }
        }
        if (SvTYPE(rv) == SVt_PVAV) {
            AV * av = (AV *)rv;
            size_t len = av_len(av) + 1;
            size_t element_size = infix_type_get_size(pointee_type);
            if (element_size > 0 && len > SIZE_MAX / element_size)
                croak("Array size overflow: %zu elements * %zu bytes", len, element_size);
            size_t total_size = len * element_size;
            char * c_array =
                (char *)infix_arena_alloc(_affix_call_args_arena(aTHX_ affix), total_size, _Alignof(void *));
            if (!c_array)
                croak("Failed to allocate from arena for array marshalling");
            memset(c_array, 0, total_size);
            for (size_t i = 0; i < len; ++i) {
                SV ** elem_sv_ptr = av_fetch(av, i, 0);
                if (elem_sv_ptr)
                    sv2ptr(aTHX_ affix, *elem_sv_ptr, c_array + (i * element_size), pointee_type);
            }
            *(void **)c_arg_ptr = c_array;
            return;
        }
        const infix_type * copy_type = (pointee_type->category == INFIX_TYPE_VOID)
            ? (SvIOK(rv)       ? infix_type_create_primitive(INFIX_PRIMITIVE_SINT64)
                   : SvNOK(rv) ? infix_type_create_primitive(INFIX_PRIMITIVE_DOUBLE)
                   : SvPOK(rv) ? (*(void **)c_arg_ptr = SvPV_nolen(rv), (infix_type *)nullptr)
                               : (croak("Cannot pass reference to this type of scalar for a 'void*' parameter"),
                                  (infix_type *)nullptr))
            : pointee_type;
        if (!copy_type)
            return;
        void * dest_c_ptr =
            infix_arena_alloc(_affix_call_args_arena(aTHX_ affix), infix_type_get_size(copy_type),
                              infix_type_get_alignment(copy_type));
        SV * sv_to_marshal = (SvTYPE(rv) == SVt_PVHV) ? sv : rv;
        sv2ptr(aTHX_ affix, sv_to_marshal, dest_c_ptr, copy_type);
        *(void **)c_arg_ptr = dest_c_ptr;
        return;
    }
    if (SvPOK(sv)) {
        bool is_char_ptr = (pointee_type->category == INFIX_TYPE_PRIMITIVE &&
                            (pointee_type->meta.primitive_id == INFIX_PRIMITIVE_SINT8 ||
                             pointee_type->meta.primitive_id == INFIX_PRIMITIVE_UINT8));
        bool is_void_ptr = (pointee_type->category == INFIX_TYPE_VOID);
        if (is_char_ptr || is_void_ptr) {
            *(const char **)c_arg_ptr = SvPV_nolen(sv);
            return;
        }
        // Wide string pointer (wchar_t* / WString)
        if (pointee_type->category == INFIX_TYPE_PRIMITIVE &&
            (pointee_type->meta.primitive_id == INFIX_PRIMITIVE_UINT16 ||
             pointee_type->meta.primitive_id == INFIX_PRIMITIVE_UINT32) &&
            infix_type_get_size(pointee_type) == sizeof(wchar_t)) {
            STRLEN wlen;
            U8 * s = (U8 *)SvPVutf8(sv, wlen);
            U8 * e = s + wlen;
            size_t el_sz = sizeof(wchar_t);
            wchar_t * wbuf =
                (wchar_t *)infix_arena_alloc(_affix_call_args_arena(aTHX_ affix), (wlen + 1) * el_sz, el_sz);
            wchar_t * d = wbuf;
            while (s < e) {
                STRLEN rlen;
                UV uv = utf8_to_uvchr_buf(s, e, &rlen);
                if (rlen == 0)
                    break;
                if (el_sz == 2 && uv > 0xFFFF) {
                    uv -= 0x10000;
                    *d++ = (wchar_t)((uv >> 10) + 0xD800);
                    *d++ = (wchar_t)((uv & 0x3FF) + 0xDC00);
                }
                else
                    *d++ = (wchar_t)uv;
                s += rlen;
            }
            *d = 0;
            *(wchar_t **)c_arg_ptr = wbuf;
            return;
        }
    }
    sv_dump(sv);
    char signature_buf[256];
    if (infix_type_print(signature_buf, sizeof(signature_buf), (infix_type *)type, INFIX_DIALECT_SIGNATURE) !=
        INFIX_SUCCESS) {
        strncpy(signature_buf, "[error printing type]", sizeof(signature_buf) - 1);
        signature_buf[sizeof(signature_buf) - 1] = '\0';
    }
    croak("Don't know how to handle this type of scalar as a pointer argument yet: %s", signature_buf);
}

static void plan_step_push_struct(pTHX_ Affix * affix,
                                  Affix_Plan_Step * step,
                                  SV ** perl_stack_frame,
                                  void * args_buffer,
                                  void ** c_args,
                                  void * ret_buffer) {
    PERL_UNUSED_VAR(ret_buffer);
    const infix_type * type = step->data.type;
    SV * sv = perl_stack_frame[step->data.index];
    void * c_arg_ptr = (char *)args_buffer + step->data.c_arg_offset;
    c_args[step->data.index] = c_arg_ptr;
    push_struct(aTHX_ affix, type, sv, c_arg_ptr);
}

static void plan_step_push_union(pTHX_ Affix * affix,
                                 Affix_Plan_Step * step,
                                 SV ** perl_stack_frame,
                                 void * args_buffer,
                                 void ** c_args,
                                 void * ret_buffer) {
    PERL_UNUSED_VAR(ret_buffer);
    const infix_type * type = step->data.type;
    SV * sv = perl_stack_frame[step->data.index];
    void * c_arg_ptr = (char *)args_buffer + step->data.c_arg_offset;
    c_args[step->data.index] = c_arg_ptr;
    push_union(aTHX_ affix, type, sv, c_arg_ptr);
}

static void plan_step_push_array(pTHX_ Affix * affix,
                                 Affix_Plan_Step * step,
                                 SV ** perl_stack_frame,
                                 void * args_buffer,
                                 void ** c_args,
                                 void * ret_buffer) {

lib/Affix.c  view on Meta::CPAN

            U32 flags = SvFLAGS(sv);                                                                            \
            if (LIKELY(flags & SVf_NOK))                                                                        \
                *(float *)ptr = (float)SvNVX(sv);                                                               \
            else if (flags & SVf_IOK)                                                                           \
                *(float *)ptr = (float)((flags & SVf_IVisUV) ? SvUVX(sv) : SvIVX(sv));                          \
            else                                                                                                \
                *(float *)ptr = (float)SvNV(sv);                                                                \
            c_args[step->data.index] = ptr;                                                                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_DOUBLE:                                                                                            \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            U32 flags = SvFLAGS(sv);                                                                            \
            if (LIKELY(flags & SVf_NOK))                                                                        \
                *(double *)ptr = SvNVX(sv);                                                                     \
            else if (flags & SVf_IOK)                                                                           \
                *(double *)ptr = (double)((flags & SVf_IVisUV) ? SvUVX(sv) : SvIVX(sv));                        \
            else                                                                                                \
                *(double *)ptr = (double)SvNV(sv);                                                              \
            c_args[step->data.index] = ptr;                                                                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_LONGDOUBLE:                                                                                        \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            U32 flags = SvFLAGS(sv);                                                                            \
            if (LIKELY(flags & SVf_NOK))                                                                        \
                *(long double *)ptr = SvNVX(sv);                                                                \
            else if (flags & SVf_IOK)                                                                           \
                *(long double *)ptr = (long double)((flags & SVf_IVisUV) ? SvUVX(sv) : SvIVX(sv));              \
            else                                                                                                \
                *(long double *)ptr = (long double)SvNV(sv);                                                    \
            c_args[step->data.index] = ptr;                                                                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_PTR_CHAR:                                                                                          \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            c_args[step->data.index] = ptr;                                                                     \
            if (SvPOK(sv))                                                                                      \
                *(const char **)ptr = SvPV_nolen(sv);                                                           \
            else if (!SvOK(sv))                                                                                 \
                *(void **)ptr = nullptr;                                                                        \
            else if (is_pin_v2(aTHX_ sv))                                                                       \
                *(void **)ptr = get_address_v2(aTHX_ sv);                                                       \
            else                                                                                                \
                step->executor(aTHX_ affix, step, &ST(0), args_buffer, c_args, ret_buffer);                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_PTR_WCHAR:                                                                                         \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            c_args[step->data.index] = ptr;                                                                     \
            if (SvPOK(sv)) {                                                                                    \
                STRLEN len;                                                                                     \
                U8 * s = (U8 *)SvPVutf8(sv, len);                                                               \
                U8 * e = s + len;                                                                               \
                size_t el_sz = sizeof(wchar_t);                                                                 \
                wchar_t * wbuf =                                                                                \
                    (wchar_t *)infix_arena_alloc(_affix_call_args_arena(aTHX_ affix), (len + 1) * el_sz, el_sz);\
                wchar_t * d = wbuf;                                                                             \
                while (s < e) {                                                                                 \
                    STRLEN rlen;                                                                                \
                    UV uv = utf8_to_uvchr_buf(s, e, &rlen);                                                     \
                    if (rlen == 0)                                                                              \
                        break;                                                                                  \
                    if (el_sz == 2 && uv > 0xFFFF) {                                                            \
                        uv -= 0x10000;                                                                          \
                        *d++ = (wchar_t)((uv >> 10) + 0xD800);                                                  \
                        *d++ = (wchar_t)((uv & 0x3FF) + 0xDC00);                                                \
                    }                                                                                           \
                    else                                                                                        \
                        *d++ = (wchar_t)uv;                                                                     \
                    s += rlen;                                                                                  \
                }                                                                                               \
                *d = 0;                                                                                         \
                *(wchar_t **)ptr = wbuf;                                                                        \
            }                                                                                                   \
            else if (!SvOK(sv))                                                                                 \
                *(void **)ptr = nullptr;                                                                        \
            else if (is_pin_v2(aTHX_ sv))                                                                       \
                *(void **)ptr = get_address_v2(aTHX_ sv);                                                       \
            else                                                                                                \
                step->executor(aTHX_ affix, step, &ST(0), args_buffer, c_args, ret_buffer);                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_POINTER:                                                                                           \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            c_args[step->data.index] = ptr;                                                                     \
            void * addr = get_address_v2(aTHX_ sv);                                                             \
            if (addr)                                                                                           \
                *(void **)ptr = addr;                                                                           \
            else if (is_pin_v2(aTHX_ sv))                                                                       \
                *(void **)ptr = get_address_v2(aTHX_ sv);                                                       \
            else if (!SvOK(sv) && SvREADONLY(sv))                                                               \
                *(void **)ptr = nullptr;                                                                        \
            else                                                                                                \
                step->executor(aTHX_ affix, step, &ST(0), args_buffer, c_args, ret_buffer);                     \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_SV:                                                                                                \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            c_args[step->data.index] = ptr;                                                                     \
            *(SV **)ptr = sv;                                                                                   \
            DISPATCH();                                                                                         \
        }                                                                                                       \
CASE_OP_PUSH_VECTOR:                                                                                            \
        {                                                                                                       \
            SV * sv = ST(step->data.index);                                                                     \
            void * ptr = (char *)args_buffer + step->data.c_arg_offset;                                         \
            c_args[step->data.index] = ptr;                                                                     \
            if (SvPOK(sv)) {                                                                                    \
                STRLEN len;                                                                                     \
                const char * buf = SvPV(sv, len);                                                               \
                size_t sz = infix_type_get_size(step->data.type);                                               \
                if (len >= sz) {                                                                                \
                    memcpy(ptr, buf, sz);                                                                       \
                    DISPATCH();                                                                                 \
                }                                                                                               \
            }                                                                                                   \



( run in 0.726 second using v1.01-cache-2.11-cpan-234fa220139 )