JSON-SIMD

 view release on metacpan or  search on metacpan

SIMD.xs  view on Meta::CPAN

	CODE:
        // as long as these writes are atomic, the race should not matter
        // as existing threads either already use 0, or use the old value,
        // which is sitll correct for the initial thread.
        json_stash = 0;
        bool_stash = 0;
        bool_false = 0;
        bool_true  = 0;

void new (char *klass)
	PPCODE:
{
	SV *pv = NEWSV (0, sizeof (JSON));
        SvPOK_only (pv);
        json_init ((JSON *)SvPVX (pv));
        XPUSHs (sv_2mortal (sv_bless (
           newRV_noinc (pv),
           strEQ (klass, "JSON::SIMD") ? JSON_STASH : gv_stashpv (klass, 1)
        )));
}

void boolean_values (JSON *self, SV *v_false = 0, SV *v_true = 0)
	PPCODE:
        self->flags   &= ~F_CORE_BOOLS;
        self->v_false = newSVsv (v_false);
        self->v_true  = newSVsv (v_true);
        XPUSHs (ST (0));

void get_boolean_values (JSON *self)
	PPCODE:
        if (self->v_false && self->v_true)
          {
            EXTEND (SP, 2);
            PUSHs (self->v_false);
            PUSHs (self->v_true);
          }

void core_bools (JSON *self, int enable = 1)
	PPCODE:
        if (enable)
          {
            self->flags   |= F_CORE_BOOLS;
            self->v_false = newSVsv (&PL_sv_no);
            self->v_true  = newSVsv (&PL_sv_yes);
          }
        else
          {
            self->flags   &= ~F_CORE_BOOLS;
            self->v_false = 0;
            self->v_true  = 0;
          }
        XPUSHs (ST (0));

void get_core_bools (JSON *self)
	PPCODE:
{
        int result = self->flags & F_CORE_BOOLS;
#if PERL_VERSION_GE(5,36,0)
        if (self->v_false && self->v_true && SvIsBOOL(self->v_false) && SvIsBOOL(self->v_true))
          {
            result = F_CORE_BOOLS;
          }
#endif
        XPUSHs (boolSV (result));
}

SIMD.xs  view on Meta::CPAN

        pretty            = F_PRETTY
        allow_nonref      = F_ALLOW_NONREF
        shrink            = F_SHRINK
        allow_blessed     = F_ALLOW_BLESSED
        convert_blessed   = F_CONV_BLESSED
        relaxed           = F_RELAXED
        allow_unknown     = F_ALLOW_UNKNOWN
        allow_tags        = F_ALLOW_TAGS
        use_simdjson      = F_USE_SIMDJSON
        encode_core_bools = F_ENCODE_CORE_BOOLS
	PPCODE:
{
        if (enable)
          self->flags |=  ix;
        else
          self->flags &= ~ix;

        if (self->flags & F_USE_SIMDJSON && self->flags & F_ALLOW_TAGS)
          self->flags &= ~F_USE_SIMDJSON;
        if (self->flags & F_USE_SIMDJSON && self->flags & F_RELAXED)
          self->flags &= ~F_USE_SIMDJSON;

SIMD.xs  view on Meta::CPAN

        get_space_after       = F_SPACE_AFTER
        get_allow_nonref      = F_ALLOW_NONREF
        get_shrink            = F_SHRINK
        get_allow_blessed     = F_ALLOW_BLESSED
        get_convert_blessed   = F_CONV_BLESSED
        get_relaxed           = F_RELAXED
        get_allow_unknown     = F_ALLOW_UNKNOWN
        get_allow_tags        = F_ALLOW_TAGS
        get_use_simdjson      = F_USE_SIMDJSON
        get_encode_core_bools = F_ENCODE_CORE_BOOLS
	PPCODE:
        XPUSHs (boolSV (self->flags & ix));

void max_depth (JSON *self, U32 max_depth = 0x80000000UL)
	PPCODE:
        self->max_depth = max_depth;
        XPUSHs (ST (0));

U32 get_max_depth (JSON *self)
	CODE:
        RETVAL = self->max_depth;
	OUTPUT:
        RETVAL

void max_size (JSON *self, U32 max_size = 0)
	PPCODE:
        self->max_size = max_size;
        XPUSHs (ST (0));

int get_max_size (JSON *self)
	CODE:
        RETVAL = self->max_size;
	OUTPUT:
        RETVAL

void filter_json_object (JSON *self, SV *cb = &PL_sv_undef)
	PPCODE:
{
        SvREFCNT_dec (self->cb_object);
        self->cb_object = SvOK (cb) ? newSVsv (cb) : 0;

        XPUSHs (ST (0));
}

void filter_json_single_key_object (JSON *self, SV *key, SV *cb = &PL_sv_undef)
	PPCODE:
{
	if (!self->cb_sk_object)
          self->cb_sk_object = newHV ();

        if (SvOK (cb))
          hv_store_ent (self->cb_sk_object, key, newSVsv (cb), 0);
        else
          {
            hv_delete_ent (self->cb_sk_object, key, G_DISCARD, 0);

SIMD.xs  view on Meta::CPAN

              {
                SvREFCNT_dec (self->cb_sk_object);
                self->cb_sk_object = 0;
              }
          }

        XPUSHs (ST (0));
}

void encode (JSON *self, SV *scalar)
	PPCODE:
        PUTBACK; scalar = encode_json (scalar, self); SPAGAIN;
        XPUSHs (scalar);

void decode (JSON *self, SV *jsonstr)
	PPCODE:
        PUTBACK; jsonstr = decode_json (jsonstr, self, 0, 0); SPAGAIN;
        XPUSHs (jsonstr);

void decode_prefix (JSON *self, SV *jsonstr)
	PPCODE:
{
	SV *sv;
        STRLEN offset;
        PUTBACK; sv = decode_json (jsonstr, self, &offset, 0); SPAGAIN;
        EXTEND (SP, 2);
        PUSHs (sv);
        PUSHs (sv_2mortal (newSVuv (ptr_to_index (jsonstr, SvPV_nolen (jsonstr) + offset))));
}

void decode_at_pointer (JSON *self, SV *jsonstr, SV *path)
	PPCODE:
        PUTBACK; jsonstr = decode_json (jsonstr, self, 0, path); SPAGAIN;
        XPUSHs (jsonstr);

void incr_parse (JSON *self, SV *jsonstr = 0)
	PPCODE:
{
	if (!self->incr_text)
          self->incr_text = newSVpvn ("", 0);

        /* if utf8-ness doesn't match the decoder, need to upgrade/downgrade */
        if (!DECODE_WANTS_OCTETS (self) == !SvUTF8 (self->incr_text))
          if (DECODE_WANTS_OCTETS (self))
            {
              if (self->incr_pos)
                self->incr_pos = utf8_length ((U8 *)SvPVX (self->incr_text),

SIMD.xs  view on Meta::CPAN

	CODE:
        SvREFCNT_dec (self->v_false);
        SvREFCNT_dec (self->v_true);
        SvREFCNT_dec (self->cb_sk_object);
        SvREFCNT_dec (self->cb_object);
        SvREFCNT_dec (self->incr_text);

PROTOTYPES: ENABLE

void encode_json (SV *scalar)
	PPCODE:
{
        JSON json;
        json_init (&json);
        json.flags |= F_UTF8;
        PUTBACK; scalar = encode_json (scalar, &json); SPAGAIN;
        XPUSHs (scalar);
}

void decode_json (SV *jsonstr)
	PPCODE:
{
        JSON json;
        json_init (&json);
        json.flags |= F_UTF8;
        PUTBACK; jsonstr = decode_json (jsonstr, &json, 0, 0); SPAGAIN;
        XPUSHs (jsonstr);
}

void simdjson_version ()
	PPCODE:
{
        SV *version_info;
        PUTBACK; version_info = simdjson_get_version(); SPAGAIN;
        XPUSHs (version_info);
}

void is_core_bool (SV *scalar)
	PPCODE:
{
#if PERL_VERSION_GE(5,36,0)
        XPUSHs( boolSV( SvIsBOOL( scalar )));
#else
        XPUSHs( boolSV( 0 ));
#endif
}