[ViewVC] Diff of: cvs/CBOR-XS/XS.xs

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.45 by root, Sun Dec 14 05:48:39 2014 UTC vs.
Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC

…		…
6	#include <string.h>	6	#include <string.h>
7	#include <stdlib.h>	7	#include <stdlib.h>
8	#include <stdio.h>	8	#include <stdio.h>
9	#include <limits.h>	9	#include <limits.h>
10	#include <float.h>	10	#include <float.h>
		11	#include <inttypes.h>
11		12
12	#define ECB_NO_THREADS 1	13	#define ECB_NO_THREADS 1
13	#include "ecb.h"	14	#include "ecb.h"
14		15
15	// compatibility with perl <5.18	16	// compatibility with perl <5.18
…		…
99		100
100	#define F_SHRINK 0x00000001UL	101	#define F_SHRINK 0x00000001UL
101	#define F_ALLOW_UNKNOWN 0x00000002UL	102	#define F_ALLOW_UNKNOWN 0x00000002UL
102	#define F_ALLOW_SHARING 0x00000004UL	103	#define F_ALLOW_SHARING 0x00000004UL
103	#define F_ALLOW_CYCLES 0x00000008UL	104	#define F_ALLOW_CYCLES 0x00000008UL
		105	#define F_FORBID_OBJECTS 0x00000010UL
104	#define F_PACK_STRINGS 0x00000010UL	106	#define F_PACK_STRINGS 0x00000020UL
		107	#define F_TEXT_KEYS 0x00000040UL
		108	#define F_TEXT_STRINGS 0x00000080UL
105	#define F_VALIDATE_UTF8 0x00000020UL	109	#define F_VALIDATE_UTF8 0x00000100UL
106		110
107	#define INIT_SIZE 32 // initial scalar size to be allocated	111	#define INIT_SIZE 32 // initial scalar size to be allocated
108		112
109	#define SB do {	113	#define SB do {
110	#define SE } while (0)	114	#define SE } while (0)
…		…
183		187
184	// minimum length of a string to be registered for stringref	188	// minimum length of a string to be registered for stringref
185	ecb_inline int	189	ecb_inline int
186	minimum_string_length (UV idx)	190	minimum_string_length (UV idx)
187	{	191	{
188	return idx > 23	192
189	? idx > 0xffU	193	return idx <= 23 ? 3
190	? idx > 0xffffU	194	: idx <= 0xffU ? 4
		195	: idx <= 0xffffU ? 5
191	? idx > 0xffffffffU	196	: idx <= 0xffffffffU ? 7
192	? 11	197	: 11;
193	: 7
194	: 5
195	: 4
196	: 3;
197	}	198	}
198		199
199	/////////////////////////////////////////////////////////////////////////////	200	/////////////////////////////////////////////////////////////////////////////
200	// encoder	201	// encoder
201		202
…		…
214	} enc_t;	215	} enc_t;
215		216
216	ecb_inline void	217	ecb_inline void
217	need (enc_t *enc, STRLEN len)	218	need (enc_t *enc, STRLEN len)
218	{	219	{
219	if (ecb_expect_false (enc->cur + len >= enc->end))	220	if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
220	{	221	{
221	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);	222	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
222	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);	223	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
223	enc->cur = SvPVX (enc->sv) + cur;	224	enc->cur = SvPVX (enc->sv) + cur;
224	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;	225	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
…		…
276	encode_tag (enc_t *enc, UV tag)	277	encode_tag (enc_t *enc, UV tag)
277	{	278	{
278	encode_uint (enc, MAJOR_TAG, tag);	279	encode_uint (enc, MAJOR_TAG, tag);
279	}	280	}
280		281
		282	// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
		283	ecb_noinline static void
		284	encode_str_utf8 (enc_t enc, int utf8, char str, STRLEN len)
		285	{
		286	STRLEN ulen = len;
		287	U8 p, pend = (U8 *)str + len;
		288
		289	for (p = (U8 *)str; p < pend; ++p)
		290	ulen += *p >> 7; // count set high bits
		291
		292	encode_uint (enc, MAJOR_TEXT, ulen);
		293
		294	need (enc, ulen);
		295	for (p = (U8 *)str; p < pend; ++p)
		296	if (*p < 0x80)
		297	enc->cur++ = p;
		298	else
		299	{
		300	enc->cur++ = 0xc0 + (p >> 6);
		301	enc->cur++ = 0x80 + (p & 63);
		302	}
		303	}
		304
281	ecb_inline void	305	ecb_inline void
282	encode_str (enc_t enc, int utf8, char str, STRLEN len)	306	encode_str (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
283	{	307	{
		308	if (ecb_expect_false (upgrade_utf8))
		309	if (!utf8)
		310	{
		311	encode_str_utf8 (enc, utf8, str, len);
		312	return;
		313	}
		314
284	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);	315	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
285	need (enc, len);	316	need (enc, len);
286	memcpy (enc->cur, str, len);	317	memcpy (enc->cur, str, len);
287	enc->cur += len;	318	enc->cur += len;
288	}	319	}
289		320
290	static void	321	ecb_inline void
291	encode_strref (enc_t enc, int utf8, char str, STRLEN len)	322	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
292	{	323	{
293	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))	324	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
294	{	325	{
295	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);	326	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
296		327
…		…
307	sv_setuv (*svp, enc->stringref_idx);	338	sv_setuv (*svp, enc->stringref_idx);
308	++enc->stringref_idx;	339	++enc->stringref_idx;
309	}	340	}
310	}	341	}
311		342
312	encode_str (enc, utf8, str, len);	343	encode_str (enc, upgrade_utf8, utf8, str, len);
313	}	344	}
314		345
315	static void encode_sv (enc_t enc, SV sv);	346	static void encode_sv (enc_t enc, SV sv);
316		347
317	static void	348	static void
…		…
332	SV **svp = av_fetch (av, i, 0);	363	SV **svp = av_fetch (av, i, 0);
333	encode_sv (enc, svp ? *svp : &PL_sv_undef);	364	encode_sv (enc, svp ? *svp : &PL_sv_undef);
334	}	365	}
335	else	366	else
336	for (i = 0; i <= len; ++i)	367	for (i = 0; i <= len; ++i)
337	encode_sv (enc, AvARRAY (av)[i]);	368	{
		369	SV *sv = AvARRAY (av)[i];
		370	encode_sv (enc, sv ? sv : &PL_sv_undef);
		371	}
338		372
339	--enc->depth;	373	--enc->depth;
340	}	374	}
341		375
342	static void	376	static void
…		…
360	while ((he = hv_iternext (hv)))	394	while ((he = hv_iternext (hv)))
361	{	395	{
362	if (HeKLEN (he) == HEf_SVKEY)	396	if (HeKLEN (he) == HEf_SVKEY)
363	encode_sv (enc, HeSVKEY (he));	397	encode_sv (enc, HeSVKEY (he));
364	else	398	else
365	encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	399	encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS \| F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
366		400
367	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	401	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
368	}	402	}
369		403
370	if (mg)	404	if (mg)
…		…
442	if (ecb_expect_false (SvOBJECT (sv)))	476	if (ecb_expect_false (SvOBJECT (sv)))
443	{	477	{
444	HV *stash = SvSTASH (sv);	478	HV *stash = SvSTASH (sv);
445	GV *method;	479	GV *method;
446		480
		481	if (enc->cbor.flags & F_FORBID_OBJECTS)
		482	croak ("encountered object '%s', but forbid_objects is enabled",
		483	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
447	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))	484	else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
448	{	485	{
449	dSP;	486	dSP;
450		487
451	ENTER; SAVETMPS; PUSHMARK (SP);	488	ENTER; SAVETMPS;
		489	PUSHMARK (SP);
452	// we re-bless the reference to get overload and other niceties right	490	// we re-bless the reference to get overload and other niceties right
453	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	491	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
454		492
455	PUTBACK;	493	PUTBACK;
456	// G_SCALAR ensures that return value is 1	494	// G_SCALAR ensures that return value is 1
…		…
469	}	507	}
470	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)	508	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
471	{	509	{
472	dSP;	510	dSP;
473		511
474	ENTER; SAVETMPS; PUSHMARK (SP);	512	ENTER; SAVETMPS;
		513	SAVESTACK_POS ();
		514	PUSHMARK (SP);
475	EXTEND (SP, 2);	515	EXTEND (SP, 2);
476	// we re-bless the reference to get overload and other niceties right	516	// we re-bless the reference to get overload and other niceties right
477	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	517	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
478	PUSHs (sv_cbor);	518	PUSHs (sv_cbor);
479		519
…		…
485	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)	525	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
486	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));	526	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
487		527
488	encode_tag (enc, CBOR_TAG_PERL_OBJECT);	528	encode_tag (enc, CBOR_TAG_PERL_OBJECT);
489	encode_uint (enc, MAJOR_ARRAY, count + 1);	529	encode_uint (enc, MAJOR_ARRAY, count + 1);
490	encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));	530	encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
491		531
492	while (count)	532	while (count)
493	encode_sv (enc, SP[1 - count--]);	533	encode_sv (enc, SP[1 - count--]);
494		534
495	PUTBACK;	535	PUTBACK;
…		…
554		594
555	if (SvPOKp (sv))	595	if (SvPOKp (sv))
556	{	596	{
557	STRLEN len;	597	STRLEN len;
558	char *str = SvPV (sv, len);	598	char *str = SvPV (sv, len);
559	encode_strref (enc, SvUTF8 (sv), str, len);	599	encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
560	}	600	}
561	else if (SvNOKp (sv))	601	else if (SvNOKp (sv))
562	encode_nv (enc, sv);	602	encode_nv (enc, sv);
563	else if (SvIOKp (sv))	603	else if (SvIOKp (sv))
564	{	604	{
…		…
581	}	621	}
582		622
583	static SV *	623	static SV *
584	encode_cbor (SV scalar, CBOR cbor)	624	encode_cbor (SV scalar, CBOR cbor)
585	{	625	{
586	enc_t enc = { };	626	enc_t enc = { 0 };
587		627
588	enc.cbor = *cbor;	628	enc.cbor = *cbor;
589	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));	629	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
590	enc.cur = SvPVX (enc.sv);	630	enc.cur = SvPVX (enc.sv);
591	enc.end = SvEND (enc.sv);	631	enc.end = SvEND (enc.sv);
…		…
623	U32 depth; // recursion depth	663	U32 depth; // recursion depth
624	U32 maxdepth; // recursion depth limit	664	U32 maxdepth; // recursion depth limit
625	AV *shareable;	665	AV *shareable;
626	AV *stringref;	666	AV *stringref;
627	SV *decode_tagged;	667	SV *decode_tagged;
		668	SV *err_sv; // optional sv for error, needs to be freed
628	} dec_t;	669	} dec_t;
629		670
630	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	671	// set dec->err to ERRSV
		672	ecb_cold static void
		673	err_errsv (dec_t *dec)
		674	{
		675	if (!dec->err)
		676	{
		677	dec->err_sv = newSVsv (ERRSV);
631		678
632	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	679	// chop off the trailing \n
		680	SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
		681	*SvEND (dec->err_sv) = 0;
633		682
		683	dec->err = SvPVutf8_nolen (dec->err_sv);
		684	}
		685	}
		686
		687	// the following functions are used to reduce code size and help the compiler to optimise
		688	ecb_cold static void
		689	err_set (dec_t dec, const char reason)
		690	{
		691	if (!dec->err)
		692	dec->err = reason;
		693	}
		694
		695	ecb_cold static void
		696	err_unexpected_end (dec_t *dec)
		697	{
		698	err_set (dec, "unexpected end of CBOR data");
		699	}
		700
		701	ecb_cold static void
		702	err_nesting_exceeded (dec_t *dec)
		703	{
		704	err_set (dec, ERR_NESTING_EXCEEDED);
		705	}
		706
		707	#define ERR_DO(do) SB do; goto fail; SE
		708	#define ERR(reason) ERR_DO (err_set (dec, reason))
		709	#define ERR_ERRSV ERR_DO (err_errsv (dec))
		710
		711	#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
		712
634	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	713	#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
635	#define DEC_DEC_DEPTH --dec->depth	714	#define DEC_DEC_DEPTH --dec->depth
636		715
637	static UV	716	static UV
638	decode_uint (dec_t *dec)	717	decode_uint (dec_t *dec)
639	{	718	{
…		…
716	av_push (av, decode_sv (dec));	795	av_push (av, decode_sv (dec));
717	}	796	}
718	}	797	}
719	else	798	else
720	{	799	{
721	int i, len = decode_uint (dec);	800	UV i, len = decode_uint (dec);
722		801
723	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays	802	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
724	av_fill (av, len - 1);	803	av_fill (av, len - 1);
725		804
726	for (i = 0; i < len; ++i)	805	for (i = 0; i < len; ++i)
…		…
743	// byte or utf-8 strings as keys, but only when !stringref	822	// byte or utf-8 strings as keys, but only when !stringref
744		823
745	if (ecb_expect_true (!dec->stringref))	824	if (ecb_expect_true (!dec->stringref))
746	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))	825	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
747	{	826	{
748	I32 len = decode_uint (dec);	827	STRLEN len = decode_uint (dec);
749	char key = (char )dec->cur;	828	char key = (char )dec->cur;
750		829
		830	WANT (len);
751	dec->cur += len;	831	dec->cur += len;
752		832
753	hv_store (hv, key, len, decode_sv (dec), 0);	833	hv_store (hv, key, len, decode_sv (dec), 0);
754		834
755	return;	835	return;
756	}	836	}
757	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))	837	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
758	{	838	{
759	I32 len = decode_uint (dec);	839	STRLEN len = decode_uint (dec);
760	char key = (char )dec->cur;	840	char key = (char )dec->cur;
761		841
		842	WANT (len);
762	dec->cur += len;	843	dec->cur += len;
763		844
764	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))	845	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
765	if (!is_utf8_string (key, len))	846	if (!is_utf8_string (key, len))
766	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");	847	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
…		…
770	return;	851	return;
771	}	852	}
772		853
773	SV *k = decode_sv (dec);	854	SV *k = decode_sv (dec);
774	SV *v = decode_sv (dec);	855	SV *v = decode_sv (dec);
		856
		857	// we leak memory if uncaught exceptions are thrown by random magical
		858	// methods, and this is hopefully the only place where it can happen,
		859	// so if there is a chance of an exception, take the very slow path.
		860	// since catching exceptions is "undocumented/internal/forbidden" by
		861	// the new p5p powers, we need to call out to a perl function :/
		862	if (ecb_expect_false (SvAMAGIC (k)))
		863	{
		864	dSP;
		865
		866	ENTER; SAVETMPS;
		867	PUSHMARK (SP);
		868	EXTEND (SP, 3);
		869	PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
		870	PUSHs (sv_2mortal (k));
		871	PUSHs (sv_2mortal (v));
		872
		873	PUTBACK;
		874	call_pv ("CBOR::XS::_hv_store", G_VOID \| G_DISCARD \| G_EVAL);
		875	SPAGAIN;
		876
		877	FREETMPS; LEAVE;
		878
		879	if (SvTRUE (ERRSV))
		880	ERR_ERRSV;
		881
		882	return;
		883	}
775		884
776	hv_store_ent (hv, k, v, 0);	885	hv_store_ent (hv, k, v, 0);
777	SvREFCNT_dec (k);	886	SvREFCNT_dec (k);
778		887
779	fail:	888	fail:
…		…
804	decode_he (dec, hv);	913	decode_he (dec, hv);
805	}	914	}
806	}	915	}
807	else	916	else
808	{	917	{
809	int pairs = decode_uint (dec);	918	UV pairs = decode_uint (dec);
		919
		920	WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
810		921
811	while (pairs--)	922	while (pairs--)
812	decode_he (dec, hv);	923	decode_he (dec, hv);
813	}	924	}
814		925
…		…
902	sv = newRV_noinc (decode_sv (dec));	1013	sv = newRV_noinc (decode_sv (dec));
903	break;	1014	break;
904		1015
905	case CBOR_TAG_STRINGREF_NAMESPACE:	1016	case CBOR_TAG_STRINGREF_NAMESPACE:
906	{	1017	{
		1018	// do nmot use SAVETMPS/FREETMPS, as these will
		1019	// erase mortalised caches, e.g. "shareable"
907	ENTER; SAVETMPS;	1020	ENTER;
908		1021
909	SAVESPTR (dec->stringref);	1022	SAVESPTR (dec->stringref);
910	dec->stringref = (AV )sv_2mortal ((SV )newAV ());	1023	dec->stringref = (AV )sv_2mortal ((SV )newAV ());
911		1024
912	sv = decode_sv (dec);	1025	sv = decode_sv (dec);
913		1026
914	FREETMPS; LEAVE;	1027	LEAVE;
915	}	1028	}
916	break;	1029	break;
917		1030
918	case CBOR_TAG_STRINGREF:	1031	case CBOR_TAG_STRINGREF:
919	{	1032	{
…		…
970	}	1083	}
971	break;	1084	break;
972		1085
973	case CBOR_TAG_PERL_OBJECT:	1086	case CBOR_TAG_PERL_OBJECT:
974	{	1087	{
		1088	if (dec->cbor.flags & F_FORBID_OBJECTS)
		1089	goto filter;
		1090
975	sv = decode_sv (dec);	1091	sv = decode_sv (dec);
976		1092
977	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)	1093	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
978	ERR ("corrupted CBOR data (non-array perl object)");	1094	ERR ("corrupted CBOR data (non-array perl object)");
979		1095
…		…
989	if (!method)	1105	if (!method)
990	ERR ("cannot decode perl-object (package does not have a THAW method)");	1106	ERR ("cannot decode perl-object (package does not have a THAW method)");
991		1107
992	dSP;	1108	dSP;
993		1109
994	ENTER; SAVETMPS; PUSHMARK (SP);	1110	ENTER; SAVETMPS;
		1111	PUSHMARK (SP);
995	EXTEND (SP, len + 1);	1112	EXTEND (SP, len + 1);
996	// we re-bless the reference to get overload and other niceties right	1113	// we re-bless the reference to get overload and other niceties right
997	PUSHs (*av_fetch (av, 0, 1));	1114	PUSHs (*av_fetch (av, 0, 1));
998	PUSHs (sv_cbor);	1115	PUSHs (sv_cbor);
999		1116
…		…
1007	SPAGAIN;	1124	SPAGAIN;
1008		1125
1009	if (SvTRUE (ERRSV))	1126	if (SvTRUE (ERRSV))
1010	{	1127	{
1011	FREETMPS; LEAVE;	1128	FREETMPS; LEAVE;
1012	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1129	ERR_ERRSV;
1013	}	1130	}
1014		1131
1015	SvREFCNT_dec (sv);	1132	SvREFCNT_dec (sv);
1016	sv = SvREFCNT_inc (POPs);	1133	sv = SvREFCNT_inc (POPs);
1017		1134
…		…
1020	FREETMPS; LEAVE;	1137	FREETMPS; LEAVE;
1021	}	1138	}
1022	break;	1139	break;
1023		1140
1024	default:	1141	default:
		1142	filter:
1025	{	1143	{
		1144	SV *tag_sv = newSVuv (tag);
		1145
1026	sv = decode_sv (dec);	1146	sv = decode_sv (dec);
1027		1147
1028	dSP;	1148	dSP;
1029	ENTER; SAVETMPS; PUSHMARK (SP);	1149	ENTER; SAVETMPS;
		1150	SAVESTACK_POS ();
		1151	PUSHMARK (SP);
1030	EXTEND (SP, 2);	1152	EXTEND (SP, 2);
1031	PUSHs (newSVuv (tag));	1153	PUSHs (tag_sv);
1032	PUSHs (sv);	1154	PUSHs (sv);
1033		1155
1034	PUTBACK;	1156	PUTBACK;
1035	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);	1157	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);
1036	SPAGAIN;	1158	SPAGAIN;
1037		1159
1038	if (SvTRUE (ERRSV))	1160	if (SvTRUE (ERRSV))
1039	{	1161	{
		1162	SvREFCNT_dec (tag_sv);
1040	FREETMPS; LEAVE;	1163	FREETMPS; LEAVE;
1041	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1164	ERR_ERRSV;
1042	}	1165	}
1043		1166
1044	if (count)	1167	if (count)
1045	{	1168	{
		1169	SvREFCNT_dec (tag_sv);
1046	SvREFCNT_dec (sv);	1170	SvREFCNT_dec (sv);
1047	sv = SvREFCNT_inc (POPs);	1171	sv = SvREFCNT_inc (POPs);
1048	}	1172	}
1049	else	1173	else
1050	{	1174	{
1051	AV *av = newAV ();	1175	AV *av = newAV ();
1052	av_push (av, newSVuv (tag));	1176	av_push (av, tag_sv);
1053	av_push (av, sv);	1177	av_push (av, sv);
1054		1178
1055	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	1179	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
1056	? cbor_tagged_stash	1180	? cbor_tagged_stash
1057	: gv_stashpv ("CBOR::XS::Tagged" , 1);	1181	: gv_stashpv ("CBOR::XS::Tagged" , 1);
…		…
1160	}	1284	}
1161		1285
1162	static SV *	1286	static SV *
1163	decode_cbor (SV string, CBOR cbor, char **offset_return)	1287	decode_cbor (SV string, CBOR cbor, char **offset_return)
1164	{	1288	{
1165	dec_t dec = { };	1289	dec_t dec = { 0 };
1166	SV *sv;	1290	SV *sv;
1167	STRLEN len;	1291	STRLEN len;
1168	char *data = SvPVbyte (string, len);	1292	char *data = SvPVbyte (string, len);
1169		1293
1170	if (len > cbor->max_size && cbor->max_size)	1294	if (len > cbor->max_size && cbor->max_size)
…		…
1186		1310
1187	if (dec.err)	1311	if (dec.err)
1188	{	1312	{
1189	if (dec.shareable)	1313	if (dec.shareable)
1190	{	1314	{
1191	// need to break cyclic links, which whould all be in shareable	1315	// need to break cyclic links, which would all be in shareable
1192	int i;	1316	int i;
1193	SV **svp;	1317	SV **svp;
1194		1318
1195	for (i = av_len (dec.shareable) + 1; i--; )	1319	for (i = av_len (dec.shareable) + 1; i--; )
1196	if ((svp = av_fetch (dec.shareable, i, 0)))	1320	if ((svp = av_fetch (dec.shareable, i, 0)))
1197	sv_setsv (*svp, &PL_sv_undef);	1321	sv_setsv (*svp, &PL_sv_undef);
1198	}	1322	}
1199		1323
1200	SvREFCNT_dec (sv);	1324	SvREFCNT_dec (sv);
		1325
		1326	if (dec.err_sv)
		1327	sv_2mortal (dec.err_sv);
		1328
1201	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1329	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);
1202	}	1330	}
1203		1331
1204	sv = sv_2mortal (sv);	1332	sv = sv_2mortal (sv);
1205		1333
…		…
1261		1389
1262	int major = *p >> MAJOR_SHIFT;	1390	int major = *p >> MAJOR_SHIFT;
1263		1391
1264	switch (major)	1392	switch (major)
1265	{	1393	{
		1394	case MAJOR_TAG >> MAJOR_SHIFT:
		1395	++count; // tags merely prefix another value
		1396	break;
		1397
1266	case MAJOR_BYTES >> MAJOR_SHIFT:	1398	case MAJOR_BYTES >> MAJOR_SHIFT:
1267	case MAJOR_TEXT >> MAJOR_SHIFT:	1399	case MAJOR_TEXT >> MAJOR_SHIFT:
1268	case MAJOR_ARRAY >> MAJOR_SHIFT:	1400	case MAJOR_ARRAY >> MAJOR_SHIFT:
1269	case MAJOR_MAP >> MAJOR_SHIFT:	1401	case MAJOR_MAP >> MAJOR_SHIFT:
1270	{	1402	{
…		…
1345		1477
1346	default_filter = newSVpv ("CBOR::XS::default_filter", 0);	1478	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1347		1479
1348	sv_cbor = newSVpv ("CBOR", 0);	1480	sv_cbor = newSVpv ("CBOR", 0);
1349	SvREADONLY_on (sv_cbor);	1481	SvREADONLY_on (sv_cbor);
		1482
		1483	assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1350	}	1484	}
1351		1485
1352	PROTOTYPES: DISABLE	1486	PROTOTYPES: DISABLE
1353		1487
1354	void CLONE (...)	1488	void CLONE (...)
…		…
1374	ALIAS:	1508	ALIAS:
1375	shrink = F_SHRINK	1509	shrink = F_SHRINK
1376	allow_unknown = F_ALLOW_UNKNOWN	1510	allow_unknown = F_ALLOW_UNKNOWN
1377	allow_sharing = F_ALLOW_SHARING	1511	allow_sharing = F_ALLOW_SHARING
1378	allow_cycles = F_ALLOW_CYCLES	1512	allow_cycles = F_ALLOW_CYCLES
		1513	forbid_objects = F_FORBID_OBJECTS
1379	pack_strings = F_PACK_STRINGS	1514	pack_strings = F_PACK_STRINGS
		1515	text_keys = F_TEXT_KEYS
		1516	text_strings = F_TEXT_STRINGS
1380	validate_utf8 = F_VALIDATE_UTF8	1517	validate_utf8 = F_VALIDATE_UTF8
1381	PPCODE:	1518	PPCODE:
1382	{	1519	{
1383	if (enable)	1520	if (enable)
1384	self->flags \|= ix;	1521	self->flags \|= ix;
…		…
1392	ALIAS:	1529	ALIAS:
1393	get_shrink = F_SHRINK	1530	get_shrink = F_SHRINK
1394	get_allow_unknown = F_ALLOW_UNKNOWN	1531	get_allow_unknown = F_ALLOW_UNKNOWN
1395	get_allow_sharing = F_ALLOW_SHARING	1532	get_allow_sharing = F_ALLOW_SHARING
1396	get_allow_cycles = F_ALLOW_CYCLES	1533	get_allow_cycles = F_ALLOW_CYCLES
		1534	get_forbid_objects = F_FORBID_OBJECTS
1397	get_pack_strings = F_PACK_STRINGS	1535	get_pack_strings = F_PACK_STRINGS
		1536	get_text_keys = F_TEXT_KEYS
		1537	get_text_strings = F_TEXT_STRINGS
1398	get_validate_utf8 = F_VALIDATE_UTF8	1538	get_validate_utf8 = F_VALIDATE_UTF8
1399	PPCODE:	1539	PPCODE:
1400	XPUSHs (boolSV (self->flags & ix));	1540	XPUSHs (boolSV (self->flags & ix));
1401		1541
1402	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1542	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing CBOR-XS/XS.xs (file contents): Revision 1.45 by root, Sun Dec 14 05:48:39 2014 UTC vs. Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.45 by root, Sun Dec 14 05:48:39 2014 UTC vs.
Revision 1.61 by root, Sat Nov 26 02:10:19 2016 UTC