view release on metacpan or  search on metacpan

SIMD.xs  view on Meta::CPAN

interrupt:
  self->incr_pos = p - SvPVX (self->incr_text);
  //printf ("interrupt<%.*s>\n", self->incr_pos, SvPVX(self->incr_text));//D
  //printf ("return pos %d mode %d nest %d\n", self->incr_pos, self->incr_mode, self->incr_nest);//D
}

/////////////////////////////////////////////////////////////////////////////
// XS interface functions

MODULE = JSON::SIMD		PACKAGE = JSON::SIMD

BOOT:
{
	int i;

        for (i = 0; i < 256; ++i)
          decode_hexdigit [i] =
            i >= '0' && i <= '9' ? i - '0'
            : i >= 'a' && i <= 'f' ? i - 'a' + 10
            : i >= 'A' && i <= 'F' ? i - 'A' + 10
            : -1;

        json_stash = gv_stashpv ("JSON::SIMD"                , 1);
        bool_stash = gv_stashpv ("Types::Serialiser::Boolean", 1);
        bool_false = get_bool ("Types::Serialiser::false");
        bool_true  = get_bool ("Types::Serialiser::true");

        sv_json = newSVpv ("JSON", 0);
        SvREADONLY_on (sv_json);

        simdjson_global_init();

        CvNODEBUG_on (get_cv ("JSON::SIMD::incr_text", 0)); /* the debugger completely breaks lvalue subs */
}

PROTOTYPES: DISABLE

void CLONE (...)
	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));
}

void ascii (JSON *self, int enable = 1)
	ALIAS:
        ascii             = F_ASCII
        latin1            = F_LATIN1
        utf8              = F_UTF8
        indent            = F_INDENT
        canonical         = F_CANONICAL
        space_before      = F_SPACE_BEFORE
        space_after       = F_SPACE_AFTER
        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;