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

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.35 by root, Sat Nov 30 17:19:34 2013 UTC vs.
Revision 1.59 by root, Fri Nov 25 23:37:27 2016 UTC

…		…
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		11
		12	#define ECB_NO_THREADS 1
12	#include "ecb.h"	13	#include "ecb.h"
13		14
14	// compatibility with perl <5.18	15	// compatibility with perl <5.18
15	#ifndef HvNAMELEN_get	16	#ifndef HvNAMELEN_get
16	# define HvNAMELEN_get(hv) strlen (HvNAME (hv))	17	# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
…		…
97	};	98	};
98		99
99	#define F_SHRINK 0x00000001UL	100	#define F_SHRINK 0x00000001UL
100	#define F_ALLOW_UNKNOWN 0x00000002UL	101	#define F_ALLOW_UNKNOWN 0x00000002UL
101	#define F_ALLOW_SHARING 0x00000004UL	102	#define F_ALLOW_SHARING 0x00000004UL
		103	#define F_ALLOW_CYCLES 0x00000008UL
102	#define F_PACK_STRINGS 0x00000008UL	104	#define F_PACK_STRINGS 0x00000010UL
		105	#define F_TEXT_KEYS 0x00000020UL
		106	#define F_TEXT_STRINGS 0x00000040UL
		107	#define F_VALIDATE_UTF8 0x00000080UL
103		108
104	#define INIT_SIZE 32 // initial scalar size to be allocated	109	#define INIT_SIZE 32 // initial scalar size to be allocated
105		110
106	#define SB do {	111	#define SB do {
107	#define SE } while (0)	112	#define SE } while (0)
…		…
126	typedef struct {	131	typedef struct {
127	U32 flags;	132	U32 flags;
128	U32 max_depth;	133	U32 max_depth;
129	STRLEN max_size;	134	STRLEN max_size;
130	SV *filter;	135	SV *filter;
		136
		137	// for the incremental parser
		138	STRLEN incr_pos; // the current offset into the text
		139	STRLEN incr_need; // minimum bytes needed to decode
		140	AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
131	} CBOR;	141	} CBOR;
132		142
133	ecb_inline void	143	ecb_inline void
134	cbor_init (CBOR *cbor)	144	cbor_init (CBOR *cbor)
135	{	145	{
…		…
139		149
140	ecb_inline void	150	ecb_inline void
141	cbor_free (CBOR *cbor)	151	cbor_free (CBOR *cbor)
142	{	152	{
143	SvREFCNT_dec (cbor->filter);	153	SvREFCNT_dec (cbor->filter);
		154	SvREFCNT_dec (cbor->incr_count);
144	}	155	}
145		156
146	/////////////////////////////////////////////////////////////////////////////	157	/////////////////////////////////////////////////////////////////////////////
147	// utility functions	158	// utility functions
148		159
…		…
228	{	239	{
229	need (enc, 9);	240	need (enc, 9);
230		241
231	if (ecb_expect_true (len < LENGTH_EXT1))	242	if (ecb_expect_true (len < LENGTH_EXT1))
232	*enc->cur++ = major \| len;	243	*enc->cur++ = major \| len;
233	else if (ecb_expect_true (len <= 0xff))	244	else if (ecb_expect_true (len <= 0xffU))
234	{	245	{
235	*enc->cur++ = major \| LENGTH_EXT1;	246	*enc->cur++ = major \| LENGTH_EXT1;
236	*enc->cur++ = len;	247	*enc->cur++ = len;
237	}	248	}
238	else if (len <= 0xffff)	249	else if (len <= 0xffffU)
239	{	250	{
240	*enc->cur++ = major \| LENGTH_EXT2;	251	*enc->cur++ = major \| LENGTH_EXT2;
241	*enc->cur++ = len >> 8;	252	*enc->cur++ = len >> 8;
242	*enc->cur++ = len;	253	*enc->cur++ = len;
243	}	254	}
244	else if (len <= 0xffffffff)	255	else if (len <= 0xffffffffU)
245	{	256	{
246	*enc->cur++ = major \| LENGTH_EXT4;	257	*enc->cur++ = major \| LENGTH_EXT4;
247	*enc->cur++ = len >> 24;	258	*enc->cur++ = len >> 24;
248	*enc->cur++ = len >> 16;	259	*enc->cur++ = len >> 16;
249	*enc->cur++ = len >> 8;	260	*enc->cur++ = len >> 8;
…		…
267	encode_tag (enc_t *enc, UV tag)	278	encode_tag (enc_t *enc, UV tag)
268	{	279	{
269	encode_uint (enc, MAJOR_TAG, tag);	280	encode_uint (enc, MAJOR_TAG, tag);
270	}	281	}
271		282
		283	// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
		284	ecb_noinline static void
		285	encode_str_utf8 (enc_t enc, int utf8, char str, STRLEN len)
		286	{
		287	STRLEN ulen = len;
		288	U8 p, pend = (U8 *)str + len;
		289
		290	for (p = (U8 *)str; p < pend; ++p)
		291	ulen += *p >> 7; // count set high bits
		292
		293	encode_uint (enc, MAJOR_TEXT, ulen);
		294
		295	need (enc, ulen);
		296	for (p = (U8 *)str; p < pend; ++p)
		297	if (*p < 0x80)
		298	enc->cur++ = p;
		299	else
		300	{
		301	enc->cur++ = 0xc0 + (p >> 6);
		302	enc->cur++ = 0x80 + (p & 63);
		303	}
		304	}
		305
272	ecb_inline void	306	ecb_inline void
273	encode_str (enc_t enc, int utf8, char str, STRLEN len)	307	encode_str (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
274	{	308	{
		309	if (ecb_expect_false (upgrade_utf8))
		310	if (!utf8)
		311	{
		312	encode_str_utf8 (enc, utf8, str, len);
		313	return;
		314	}
		315
275	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);	316	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
276	need (enc, len);	317	need (enc, len);
277	memcpy (enc->cur, str, len);	318	memcpy (enc->cur, str, len);
278	enc->cur += len;	319	enc->cur += len;
279	}	320	}
280		321
281	static void	322	ecb_inline void
282	encode_strref (enc_t enc, int utf8, char str, STRLEN len)	323	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
283	{	324	{
284	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))	325	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
285	{	326	{
286	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);	327	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
287		328
…		…
298	sv_setuv (*svp, enc->stringref_idx);	339	sv_setuv (*svp, enc->stringref_idx);
299	++enc->stringref_idx;	340	++enc->stringref_idx;
300	}	341	}
301	}	342	}
302		343
303	encode_str (enc, utf8, str, len);	344	encode_str (enc, upgrade_utf8, utf8, str, len);
304	}	345	}
305		346
306	static void encode_sv (enc_t enc, SV sv);	347	static void encode_sv (enc_t enc, SV sv);
307		348
308	static void	349	static void
…		…
315		356
316	++enc->depth;	357	++enc->depth;
317		358
318	encode_uint (enc, MAJOR_ARRAY, len + 1);	359	encode_uint (enc, MAJOR_ARRAY, len + 1);
319		360
		361	if (SvMAGICAL (av))
320	for (i = 0; i <= len; ++i)	362	for (i = 0; i <= len; ++i)
321	{	363	{
322	SV **svp = av_fetch (av, i, 0);	364	SV **svp = av_fetch (av, i, 0);
323	encode_sv (enc, svp ? *svp : &PL_sv_undef);	365	encode_sv (enc, svp ? *svp : &PL_sv_undef);
324	}	366	}
		367	else
		368	for (i = 0; i <= len; ++i)
		369	{
		370	SV *sv = AvARRAY (av)[i];
		371	encode_sv (enc, sv ? sv : &PL_sv_undef);
		372	}
325		373
326	--enc->depth;	374	--enc->depth;
327	}	375	}
328		376
329	static void	377	static void
…		…
347	while ((he = hv_iternext (hv)))	395	while ((he = hv_iternext (hv)))
348	{	396	{
349	if (HeKLEN (he) == HEf_SVKEY)	397	if (HeKLEN (he) == HEf_SVKEY)
350	encode_sv (enc, HeSVKEY (he));	398	encode_sv (enc, HeSVKEY (he));
351	else	399	else
352	encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	400	encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS \| F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
353		401
354	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	402	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
355	}	403	}
356		404
357	if (mg)	405	if (mg)
…		…
433		481
434	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))	482	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
435	{	483	{
436	dSP;	484	dSP;
437		485
438	ENTER; SAVETMPS; PUSHMARK (SP);	486	ENTER; SAVETMPS;
		487	PUSHMARK (SP);
439	// we re-bless the reference to get overload and other niceties right	488	// we re-bless the reference to get overload and other niceties right
440	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	489	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
441		490
442	PUTBACK;	491	PUTBACK;
443	// G_SCALAR ensures that return value is 1	492	// G_SCALAR ensures that return value is 1
…		…
456	}	505	}
457	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)	506	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
458	{	507	{
459	dSP;	508	dSP;
460		509
461	ENTER; SAVETMPS; PUSHMARK (SP);	510	ENTER; SAVETMPS;
		511	SAVESTACK_POS ();
		512	PUSHMARK (SP);
462	EXTEND (SP, 2);	513	EXTEND (SP, 2);
463	// we re-bless the reference to get overload and other niceties right	514	// we re-bless the reference to get overload and other niceties right
464	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	515	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
465	PUSHs (sv_cbor);	516	PUSHs (sv_cbor);
466		517
…		…
472	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)	523	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
473	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));	524	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
474		525
475	encode_tag (enc, CBOR_TAG_PERL_OBJECT);	526	encode_tag (enc, CBOR_TAG_PERL_OBJECT);
476	encode_uint (enc, MAJOR_ARRAY, count + 1);	527	encode_uint (enc, MAJOR_ARRAY, count + 1);
477	encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));	528	encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
478		529
479	while (count)	530	while (count)
480	encode_sv (enc, SP[1 - count--]);	531	encode_sv (enc, SP[1 - count--]);
481		532
482	PUTBACK;	533	PUTBACK;
…		…
541		592
542	if (SvPOKp (sv))	593	if (SvPOKp (sv))
543	{	594	{
544	STRLEN len;	595	STRLEN len;
545	char *str = SvPV (sv, len);	596	char *str = SvPV (sv, len);
546	encode_strref (enc, SvUTF8 (sv), str, len);	597	encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
547	}	598	}
548	else if (SvNOKp (sv))	599	else if (SvNOKp (sv))
549	encode_nv (enc, sv);	600	encode_nv (enc, sv);
550	else if (SvIOKp (sv))	601	else if (SvIOKp (sv))
551	{	602	{
…		…
568	}	619	}
569		620
570	static SV *	621	static SV *
571	encode_cbor (SV scalar, CBOR cbor)	622	encode_cbor (SV scalar, CBOR cbor)
572	{	623	{
573	enc_t enc = { };	624	enc_t enc = { 0 };
574		625
575	enc.cbor = *cbor;	626	enc.cbor = *cbor;
576	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));	627	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
577	enc.cur = SvPVX (enc.sv);	628	enc.cur = SvPVX (enc.sv);
578	enc.end = SvEND (enc.sv);	629	enc.end = SvEND (enc.sv);
…		…
610	U32 depth; // recursion depth	661	U32 depth; // recursion depth
611	U32 maxdepth; // recursion depth limit	662	U32 maxdepth; // recursion depth limit
612	AV *shareable;	663	AV *shareable;
613	AV *stringref;	664	AV *stringref;
614	SV *decode_tagged;	665	SV *decode_tagged;
		666	SV *err_sv; // optional sv for error, needs to be freed
615	} dec_t;	667	} dec_t;
616		668
617	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	669	// set dec->err to ERRSV
		670	ecb_cold static void
		671	err_errsv (dec_t *dec)
		672	{
		673	if (!dec->err)
		674	{
		675	dec->err_sv = newSVsv (ERRSV);
618		676
619	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	677	// chop off the trailing \n
		678	SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
		679	*SvEND (dec->err_sv) = 0;
620		680
		681	dec->err = SvPVutf8_nolen (dec->err_sv);
		682	}
		683	}
		684
		685	// the following functions are used to reduce code size and help the compiler to optimise
		686	ecb_cold static void
		687	err_set (dec_t dec, const char reason)
		688	{
		689	if (!dec->err)
		690	dec->err = reason;
		691	}
		692
		693	ecb_cold static void
		694	err_unexpected_end (dec_t *dec)
		695	{
		696	err_set (dec, "unexpected end of CBOR data");
		697	}
		698
		699	ecb_cold static void
		700	err_nesting_exceeded (dec_t *dec)
		701	{
		702	err_set (dec, ERR_NESTING_EXCEEDED);
		703	}
		704
		705	#define ERR_DO(do) SB do; goto fail; SE
		706	#define ERR(reason) ERR_DO (err_set (dec, reason))
		707	#define ERR_ERRSV ERR_DO (err_errsv (dec))
		708
		709	#define WANT(len) if (ecb_expect_false ((UV)(dec->end - dec->cur) < (UV)len)) ERR_DO (err_unexpected_end (dec))
		710
621	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	711	#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
622	#define DEC_DEC_DEPTH --dec->depth	712	#define DEC_DEC_DEPTH --dec->depth
623		713
624	static UV	714	static UV
625	decode_uint (dec_t *dec)	715	decode_uint (dec_t *dec)
626	{	716	{
627	U8 m = *dec->cur & MINOR_MASK;	717	U8 m = *dec->cur & MINOR_MASK;
628	++dec->cur;	718	++dec->cur;
629		719
630	if (ecb_expect_true (m < LENGTH_EXT1))	720	if (ecb_expect_true (m < LENGTH_EXT1))
631	return m;	721	return m;
632		722	else if (ecb_expect_true (m == LENGTH_EXT1))
633	switch (m)
634	{	723	{
635	case LENGTH_EXT1:
636	WANT (1);	724	WANT (1);
637	dec->cur += 1;	725	dec->cur += 1;
638	return dec->cur[-1];	726	return dec->cur[-1];
639		727	}
640	case LENGTH_EXT2:	728	else if (ecb_expect_true (m == LENGTH_EXT2))
		729	{
641	WANT (2);	730	WANT (2);
642	dec->cur += 2;	731	dec->cur += 2;
643	return (((UV)dec->cur[-2]) << 8)	732	return (((UV)dec->cur[-2]) << 8)
644	\| ((UV)dec->cur[-1]);	733	\| ((UV)dec->cur[-1]);
645		734	}
646	case LENGTH_EXT4:	735	else if (ecb_expect_true (m == LENGTH_EXT4))
		736	{
647	WANT (4);	737	WANT (4);
648	dec->cur += 4;	738	dec->cur += 4;
649	return (((UV)dec->cur[-4]) << 24)	739	return (((UV)dec->cur[-4]) << 24)
650	\| (((UV)dec->cur[-3]) << 16)	740	\| (((UV)dec->cur[-3]) << 16)
651	\| (((UV)dec->cur[-2]) << 8)	741	\| (((UV)dec->cur[-2]) << 8)
652	\| ((UV)dec->cur[-1]);	742	\| ((UV)dec->cur[-1]);
653		743	}
654	case LENGTH_EXT8:	744	else if (ecb_expect_true (m == LENGTH_EXT8))
		745	{
655	WANT (8);	746	WANT (8);
656	dec->cur += 8;	747	dec->cur += 8;
657		748
658	return	749	return
659	#if UVSIZE < 8	750	#if UVSIZE < 8
660	0	751	0
661	#else	752	#else
662	(((UV)dec->cur[-8]) << 56)	753	(((UV)dec->cur[-8]) << 56)
663	\| (((UV)dec->cur[-7]) << 48)	754	\| (((UV)dec->cur[-7]) << 48)
664	\| (((UV)dec->cur[-6]) << 40)	755	\| (((UV)dec->cur[-6]) << 40)
665	\| (((UV)dec->cur[-5]) << 32)	756	\| (((UV)dec->cur[-5]) << 32)
666	#endif	757	#endif
667	\| (((UV)dec->cur[-4]) << 24)	758	\| (((UV)dec->cur[-4]) << 24)
668	\| (((UV)dec->cur[-3]) << 16)	759	\| (((UV)dec->cur[-3]) << 16)
669	\| (((UV)dec->cur[-2]) << 8)	760	\| (((UV)dec->cur[-2]) << 8)
670	\| ((UV)dec->cur[-1]);	761	\| ((UV)dec->cur[-1]);
671		762	}
672	default:	763	else
673	ERR ("corrupted CBOR data (unsupported integer minor encoding)");	764	ERR ("corrupted CBOR data (unsupported integer minor encoding)");
674	}
675		765
676	fail:	766	fail:
677	return 0;	767	return 0;
678	}	768	}
679		769
…		…
703	av_push (av, decode_sv (dec));	793	av_push (av, decode_sv (dec));
704	}	794	}
705	}	795	}
706	else	796	else
707	{	797	{
708	int i, len = decode_uint (dec);	798	UV i, len = decode_uint (dec);
709		799
		800	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
710	av_fill (av, len - 1);	801	av_fill (av, len - 1);
711		802
712	for (i = 0; i < len; ++i)	803	for (i = 0; i < len; ++i)
713	AvARRAY (av)[i] = decode_sv (dec);	804	AvARRAY (av)[i] = decode_sv (dec);
714	}	805	}
…		…
727	{	818	{
728	// for speed reasons, we specialcase single-string	819	// for speed reasons, we specialcase single-string
729	// byte or utf-8 strings as keys, but only when !stringref	820	// byte or utf-8 strings as keys, but only when !stringref
730		821
731	if (ecb_expect_true (!dec->stringref))	822	if (ecb_expect_true (!dec->stringref))
732	if ((*dec->cur - MAJOR_BYTES) <= 27)	823	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
733	{	824	{
734	I32 len = decode_uint (dec);	825	STRLEN len = decode_uint (dec);
735	char key = (char )dec->cur;	826	char key = (char )dec->cur;
736		827
		828	WANT (len);
737	dec->cur += len;	829	dec->cur += len;
738		830
739	if (ecb_expect_false (dec->stringref))
740	av_push (dec->stringref, newSVpvn (key, len));
741
742	hv_store (hv, key, len, decode_sv (dec), 0);	831	hv_store (hv, key, len, decode_sv (dec), 0);
743		832
744	return;	833	return;
745	}	834	}
746	else if ((*dec->cur - MAJOR_TEXT) <= 27)	835	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
747	{	836	{
748	I32 len = decode_uint (dec);	837	STRLEN len = decode_uint (dec);
749	char key = (char )dec->cur;	838	char key = (char )dec->cur;
750		839
		840	WANT (len);
751	dec->cur += len;	841	dec->cur += len;
752		842
753	if (ecb_expect_false (dec->stringref))	843	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
754	av_push (dec->stringref, newSVpvn_utf8 (key, len, 1));	844	if (!is_utf8_string (key, len))
		845	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
755		846
756	hv_store (hv, key, -len, decode_sv (dec), 0);	847	hv_store (hv, key, -len, decode_sv (dec), 0);
757		848
758	return;	849	return;
759	}	850	}
760		851
761	SV *k = decode_sv (dec);	852	SV *k = decode_sv (dec);
762	SV *v = decode_sv (dec);	853	SV *v = decode_sv (dec);
763		854
		855	// we leak memory if uncaught exceptions are thrown by random magical
		856	// methods, and this is hopefully the only place where it can happen,
		857	// so if there is a chance of an exception, take the very slow path.
		858	// since catching exceptions is "undocumented/internal/forbidden" by
		859	// the new p5p powers, we need to call out to a perl function :/
		860	if (ecb_expect_false (SvAMAGIC (k)))
		861	{
		862	dSP;
		863
		864	ENTER; SAVETMPS;
		865	PUSHMARK (SP);
		866	EXTEND (SP, 3);
		867	PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
		868	PUSHs (sv_2mortal (k));
		869	PUSHs (sv_2mortal (v));
		870
		871	PUTBACK;
		872	call_pv ("CBOR::XS::_hv_store", G_VOID \| G_DISCARD \| G_EVAL);
		873	SPAGAIN;
		874
		875	FREETMPS; LEAVE;
		876
		877	if (SvTRUE (ERRSV))
		878	ERR_ERRSV;
		879
		880	return;
		881	}
		882
764	hv_store_ent (hv, k, v, 0);	883	hv_store_ent (hv, k, v, 0);
765	SvREFCNT_dec (k);	884	SvREFCNT_dec (k);
		885
		886	fail:
		887	;
766	}	888	}
767		889
768	static SV *	890	static SV *
769	decode_hv (dec_t *dec)	891	decode_hv (dec_t *dec)
770	{	892	{
…		…
789	decode_he (dec, hv);	911	decode_he (dec, hv);
790	}	912	}
791	}	913	}
792	else	914	else
793	{	915	{
794	int pairs = decode_uint (dec);	916	UV pairs = decode_uint (dec);
		917
		918	WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
795		919
796	while (pairs--)	920	while (pairs--)
797	decode_he (dec, hv);	921	decode_he (dec, hv);
798	}	922	}
799		923
…		…
852	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))	976	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
853	av_push (dec->stringref, SvREFCNT_inc_NN (sv));	977	av_push (dec->stringref, SvREFCNT_inc_NN (sv));
854	}	978	}
855		979
856	if (utf8)	980	if (utf8)
		981	{
		982	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
		983	if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
		984	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
		985
857	SvUTF8_on (sv);	986	SvUTF8_on (sv);
		987	}
858		988
859	return sv;	989	return sv;
860		990
861	fail:	991	fail:
862	SvREFCNT_dec (sv);	992	SvREFCNT_dec (sv);
…		…
881	sv = newRV_noinc (decode_sv (dec));	1011	sv = newRV_noinc (decode_sv (dec));
882	break;	1012	break;
883		1013
884	case CBOR_TAG_STRINGREF_NAMESPACE:	1014	case CBOR_TAG_STRINGREF_NAMESPACE:
885	{	1015	{
		1016	// do nmot use SAVETMPS/FREETMPS, as these will
		1017	// erase mortalised caches, e.g. "shareable"
886	ENTER; SAVETMPS;	1018	ENTER;
887		1019
888	SAVESPTR (dec->stringref);	1020	SAVESPTR (dec->stringref);
889	dec->stringref = (AV )sv_2mortal ((SV )newAV ());	1021	dec->stringref = (AV )sv_2mortal ((SV )newAV ());
890		1022
891	sv = decode_sv (dec);	1023	sv = decode_sv (dec);
892		1024
893	FREETMPS; LEAVE;	1025	LEAVE;
894	}	1026	}
895	break;	1027	break;
896		1028
897	case CBOR_TAG_STRINGREF:	1029	case CBOR_TAG_STRINGREF:
898	{	1030	{
…		…
911	case CBOR_TAG_VALUE_SHAREABLE:	1043	case CBOR_TAG_VALUE_SHAREABLE:
912	{	1044	{
913	if (ecb_expect_false (!dec->shareable))	1045	if (ecb_expect_false (!dec->shareable))
914	dec->shareable = (AV )sv_2mortal ((SV )newAV ());	1046	dec->shareable = (AV )sv_2mortal ((SV )newAV ());
915		1047
		1048	if (dec->cbor.flags & F_ALLOW_CYCLES)
		1049	{
916	sv = newSV (0);	1050	sv = newSV (0);
917	av_push (dec->shareable, SvREFCNT_inc_NN (sv));	1051	av_push (dec->shareable, SvREFCNT_inc_NN (sv));
918		1052
919	SV *osv = decode_sv (dec);	1053	SV *osv = decode_sv (dec);
920	sv_setsv (sv, osv);	1054	sv_setsv (sv, osv);
921	SvREFCNT_dec_NN (osv);	1055	SvREFCNT_dec_NN (osv);
		1056	}
		1057	else
		1058	{
		1059	av_push (dec->shareable, &PL_sv_undef);
		1060	int idx = AvFILLp (dec->shareable);
		1061	sv = decode_sv (dec);
		1062	av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
		1063	}
922	}	1064	}
923	break;	1065	break;
924		1066
925	case CBOR_TAG_VALUE_SHAREDREF:	1067	case CBOR_TAG_VALUE_SHAREDREF:
926	{	1068	{
…		…
931		1073
932	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))	1074	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))
933	ERR ("corrupted CBOR data (sharedref index out of bounds)");	1075	ERR ("corrupted CBOR data (sharedref index out of bounds)");
934		1076
935	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);	1077	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
		1078
		1079	if (sv == &PL_sv_undef)
		1080	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
936	}	1081	}
937	break;	1082	break;
938		1083
939	case CBOR_TAG_PERL_OBJECT:	1084	case CBOR_TAG_PERL_OBJECT:
940	{	1085	{
…		…
955	if (!method)	1100	if (!method)
956	ERR ("cannot decode perl-object (package does not have a THAW method)");	1101	ERR ("cannot decode perl-object (package does not have a THAW method)");
957		1102
958	dSP;	1103	dSP;
959		1104
960	ENTER; SAVETMPS; PUSHMARK (SP);	1105	ENTER; SAVETMPS;
		1106	PUSHMARK (SP);
961	EXTEND (SP, len + 1);	1107	EXTEND (SP, len + 1);
962	// we re-bless the reference to get overload and other niceties right	1108	// we re-bless the reference to get overload and other niceties right
963	PUSHs (*av_fetch (av, 0, 1));	1109	PUSHs (*av_fetch (av, 0, 1));
964	PUSHs (sv_cbor);	1110	PUSHs (sv_cbor);
965		1111
…		…
973	SPAGAIN;	1119	SPAGAIN;
974		1120
975	if (SvTRUE (ERRSV))	1121	if (SvTRUE (ERRSV))
976	{	1122	{
977	FREETMPS; LEAVE;	1123	FREETMPS; LEAVE;
978	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1124	ERR_ERRSV;
979	}	1125	}
980		1126
981	SvREFCNT_dec (sv);	1127	SvREFCNT_dec (sv);
982	sv = SvREFCNT_inc (POPs);	1128	sv = SvREFCNT_inc (POPs);
983		1129
…		…
987	}	1133	}
988	break;	1134	break;
989		1135
990	default:	1136	default:
991	{	1137	{
		1138	SV *tag_sv = newSVuv (tag);
		1139
992	sv = decode_sv (dec);	1140	sv = decode_sv (dec);
993		1141
994	dSP;	1142	dSP;
995	ENTER; SAVETMPS; PUSHMARK (SP);	1143	ENTER; SAVETMPS;
		1144	SAVESTACK_POS ();
		1145	PUSHMARK (SP);
996	EXTEND (SP, 2);	1146	EXTEND (SP, 2);
997	PUSHs (newSVuv (tag));	1147	PUSHs (tag_sv);
998	PUSHs (sv);	1148	PUSHs (sv);
999		1149
1000	PUTBACK;	1150	PUTBACK;
1001	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);	1151	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);
1002	SPAGAIN;	1152	SPAGAIN;
1003		1153
1004	if (SvTRUE (ERRSV))	1154	if (SvTRUE (ERRSV))
1005	{	1155	{
		1156	SvREFCNT_dec (tag_sv);
1006	FREETMPS; LEAVE;	1157	FREETMPS; LEAVE;
1007	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1158	ERR_ERRSV;
1008	}	1159	}
1009		1160
1010	if (count)	1161	if (count)
1011	{	1162	{
		1163	SvREFCNT_dec (tag_sv);
1012	SvREFCNT_dec (sv);	1164	SvREFCNT_dec (sv);
1013	sv = SvREFCNT_inc (POPs);	1165	sv = SvREFCNT_inc (POPs);
1014	}	1166	}
1015	else	1167	else
1016	{	1168	{
1017	AV *av = newAV ();	1169	AV *av = newAV ();
1018	av_push (av, newSVuv (tag));	1170	av_push (av, tag_sv);
1019	av_push (av, sv);	1171	av_push (av, sv);
1020		1172
1021	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	1173	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
1022	? cbor_tagged_stash	1174	? cbor_tagged_stash
1023	: gv_stashpv ("CBOR::XS::Tagged" , 1);	1175	: gv_stashpv ("CBOR::XS::Tagged" , 1);
…		…
1109		1261
1110	return newSVnv (ecb_binary64_to_double (fp));	1262	return newSVnv (ecb_binary64_to_double (fp));
1111	}	1263	}
1112		1264
1113	// 0..19 unassigned simple	1265	// 0..19 unassigned simple
1114	// 24 reserved + unassigned (reserved values are not encodable)	1266	// 24 reserved + unassigned simple (reserved values are not encodable)
		1267	// 28-30 unassigned misc
		1268	// 31 break code
1115	default:	1269	default:
1116	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");	1270	ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1117	}	1271	}
1118		1272
1119	break;	1273	break;
1120	}	1274	}
1121		1275
…		…
1124	}	1278	}
1125		1279
1126	static SV *	1280	static SV *
1127	decode_cbor (SV string, CBOR cbor, char **offset_return)	1281	decode_cbor (SV string, CBOR cbor, char **offset_return)
1128	{	1282	{
1129	dec_t dec = { };	1283	dec_t dec = { 0 };
1130	SV *sv;	1284	SV *sv;
1131	STRLEN len;	1285	STRLEN len;
1132	char *data = SvPVbyte (string, len);	1286	char *data = SvPVbyte (string, len);
1133		1287
1134	if (len > cbor->max_size && cbor->max_size)	1288	if (len > cbor->max_size && cbor->max_size)
…		…
1148	if (dec.cur != dec.end && !dec.err)	1302	if (dec.cur != dec.end && !dec.err)
1149	dec.err = "garbage after CBOR object";	1303	dec.err = "garbage after CBOR object";
1150		1304
1151	if (dec.err)	1305	if (dec.err)
1152	{	1306	{
		1307	if (dec.shareable)
		1308	{
		1309	// need to break cyclic links, which would all be in shareable
		1310	int i;
		1311	SV **svp;
		1312
		1313	for (i = av_len (dec.shareable) + 1; i--; )
		1314	if ((svp = av_fetch (dec.shareable, i, 0)))
		1315	sv_setsv (*svp, &PL_sv_undef);
		1316	}
		1317
1153	SvREFCNT_dec (sv);	1318	SvREFCNT_dec (sv);
		1319
		1320	if (dec.err_sv)
		1321	sv_2mortal (dec.err_sv);
		1322
1154	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1323	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);
1155	}	1324	}
1156		1325
1157	sv = sv_2mortal (sv);	1326	sv = sv_2mortal (sv);
1158		1327
1159	return sv;	1328	return sv;
1160	}	1329	}
1161		1330
		1331	/////////////////////////////////////////////////////////////////////////////
		1332	// incremental parser
		1333
		1334	#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
		1335
		1336	// returns 0 for notyet, 1 for success or error
		1337	static int
		1338	incr_parse (CBOR self, SV cborstr)
		1339	{
		1340	STRLEN cur;
		1341	SvPV (cborstr, cur);
		1342
		1343	while (ecb_expect_true (self->incr_need <= cur))
		1344	{
		1345	// table of integer count bytes
		1346	static I8 incr_len[MINOR_MASK + 1] = {
		1347	0, 0, 0, 0, 0, 0, 0, 0,
		1348	0, 0, 0, 0, 0, 0, 0, 0,
		1349	0, 0, 0, 0, 0, 0, 0, 0,
		1350	1, 2, 4, 8,-1,-1,-1,-2
		1351	};
		1352
		1353	const U8 *p = SvPVX (cborstr) + self->incr_pos;
		1354	U8 m = *p & MINOR_MASK;
		1355	IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1356	I8 ilen = incr_len[m];
		1357
		1358	self->incr_need = self->incr_pos + 1;
		1359
		1360	if (ecb_expect_false (ilen < 0))
		1361	{
		1362	if (m != MINOR_INDEF)
		1363	return 1; // error
		1364
		1365	if (*p == (MAJOR_MISC \| MINOR_INDEF))
		1366	{
		1367	if (count >= 0)
		1368	return 1; // error
		1369
		1370	count = 1;
		1371	}
		1372	else
		1373	{
		1374	av_push (self->incr_count, newSViv (-1)); //TODO: nest
		1375	count = -1;
		1376	}
		1377	}
		1378	else
		1379	{
		1380	self->incr_need += ilen;
		1381	if (ecb_expect_false (self->incr_need > cur))
		1382	return 0;
		1383
		1384	int major = *p >> MAJOR_SHIFT;
		1385
		1386	switch (major)
		1387	{
		1388	case MAJOR_TAG >> MAJOR_SHIFT:
		1389	++count; // tags merely prefix another value
		1390	break;
		1391
		1392	case MAJOR_BYTES >> MAJOR_SHIFT:
		1393	case MAJOR_TEXT >> MAJOR_SHIFT:
		1394	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1395	case MAJOR_MAP >> MAJOR_SHIFT:
		1396	{
		1397	UV len;
		1398
		1399	if (ecb_expect_false (ilen))
		1400	{
		1401	len = 0;
		1402
		1403	do {
		1404	len = (len << 8) \| *++p;
		1405	} while (--ilen);
		1406	}
		1407	else
		1408	len = m;
		1409
		1410	switch (major)
		1411	{
		1412	case MAJOR_BYTES >> MAJOR_SHIFT:
		1413	case MAJOR_TEXT >> MAJOR_SHIFT:
		1414	self->incr_need += len;
		1415	if (ecb_expect_false (self->incr_need > cur))
		1416	return 0;
		1417
		1418	break;
		1419
		1420	case MAJOR_MAP >> MAJOR_SHIFT:
		1421	len <<= 1;
		1422	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1423	if (len)
		1424	{
		1425	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
		1426	count = len + 1;
		1427	}
		1428	break;
		1429	}
		1430	}
		1431	}
		1432	}
		1433
		1434	self->incr_pos = self->incr_need;
		1435
		1436	if (count > 0)
		1437	{
		1438	while (!--count)
		1439	{
		1440	if (!AvFILLp (self->incr_count))
		1441	return 1; // done
		1442
		1443	SvREFCNT_dec_NN (av_pop (self->incr_count));
		1444	count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1445	}
		1446
		1447	SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
		1448	}
		1449	}
		1450
		1451	return 0;
		1452	}
		1453
		1454
1162	/////////////////////////////////////////////////////////////////////////////	1455	/////////////////////////////////////////////////////////////////////////////
1163	// XS interface functions	1456	// XS interface functions
1164		1457
1165	MODULE = CBOR::XS PACKAGE = CBOR::XS	1458	MODULE = CBOR::XS PACKAGE = CBOR::XS
1166		1459
…		…
1178		1471
1179	default_filter = newSVpv ("CBOR::XS::default_filter", 0);	1472	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1180		1473
1181	sv_cbor = newSVpv ("CBOR", 0);	1474	sv_cbor = newSVpv ("CBOR", 0);
1182	SvREADONLY_on (sv_cbor);	1475	SvREADONLY_on (sv_cbor);
		1476
		1477	assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1183	}	1478	}
1184		1479
1185	PROTOTYPES: DISABLE	1480	PROTOTYPES: DISABLE
1186		1481
1187	void CLONE (...)	1482	void CLONE (...)
…		…
1206	void shrink (CBOR *self, int enable = 1)	1501	void shrink (CBOR *self, int enable = 1)
1207	ALIAS:	1502	ALIAS:
1208	shrink = F_SHRINK	1503	shrink = F_SHRINK
1209	allow_unknown = F_ALLOW_UNKNOWN	1504	allow_unknown = F_ALLOW_UNKNOWN
1210	allow_sharing = F_ALLOW_SHARING	1505	allow_sharing = F_ALLOW_SHARING
		1506	allow_cycles = F_ALLOW_CYCLES
1211	pack_strings = F_PACK_STRINGS	1507	pack_strings = F_PACK_STRINGS
		1508	text_keys = F_TEXT_KEYS
		1509	text_strings = F_TEXT_STRINGS
		1510	validate_utf8 = F_VALIDATE_UTF8
1212	PPCODE:	1511	PPCODE:
1213	{	1512	{
1214	if (enable)	1513	if (enable)
1215	self->flags \|= ix;	1514	self->flags \|= ix;
1216	else	1515	else
…		…
1222	void get_shrink (CBOR *self)	1521	void get_shrink (CBOR *self)
1223	ALIAS:	1522	ALIAS:
1224	get_shrink = F_SHRINK	1523	get_shrink = F_SHRINK
1225	get_allow_unknown = F_ALLOW_UNKNOWN	1524	get_allow_unknown = F_ALLOW_UNKNOWN
1226	get_allow_sharing = F_ALLOW_SHARING	1525	get_allow_sharing = F_ALLOW_SHARING
		1526	get_allow_cycles = F_ALLOW_CYCLES
1227	get_pack_strings = F_PACK_STRINGS	1527	get_pack_strings = F_PACK_STRINGS
		1528	get_text_keys = F_TEXT_KEYS
		1529	get_text_strings = F_TEXT_STRINGS
		1530	get_validate_utf8 = F_VALIDATE_UTF8
1228	PPCODE:	1531	PPCODE:
1229	XPUSHs (boolSV (self->flags & ix));	1532	XPUSHs (boolSV (self->flags & ix));
1230		1533
1231	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1534	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1232	PPCODE:	1535	PPCODE:
…		…
1281	EXTEND (SP, 2);	1584	EXTEND (SP, 2);
1282	PUSHs (sv);	1585	PUSHs (sv);
1283	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));	1586	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1284	}	1587	}
1285		1588
		1589	void incr_parse (CBOR self, SV cborstr)
		1590	ALIAS:
		1591	incr_parse_multiple = 1
		1592	PPCODE:
		1593	{
		1594	if (SvUTF8 (cborstr))
		1595	sv_utf8_downgrade (cborstr, 0);
		1596
		1597	if (!self->incr_count)
		1598	{
		1599	self->incr_count = newAV ();
		1600	self->incr_pos = 0;
		1601	self->incr_need = 1;
		1602
		1603	av_push (self->incr_count, newSViv (1));
		1604	}
		1605
		1606	do
		1607	{
		1608	if (!incr_parse (self, cborstr))
		1609	{
		1610	if (self->incr_need > self->max_size && self->max_size)
		1611	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
		1612	(unsigned long)self->incr_need, (unsigned long)self->max_size);
		1613
		1614	break;
		1615	}
		1616
		1617	SV *sv;
		1618	char *offset;
		1619
		1620	PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
		1621	XPUSHs (sv);
		1622
		1623	sv_chop (cborstr, offset);
		1624
		1625	av_clear (self->incr_count);
		1626	av_push (self->incr_count, newSViv (1));
		1627
		1628	self->incr_pos = 0;
		1629	self->incr_need = self->incr_pos + 1;
		1630	}
		1631	while (ix);
		1632	}
		1633
		1634	void incr_reset (CBOR *self)
		1635	CODE:
		1636	{
		1637	SvREFCNT_dec (self->incr_count);
		1638	self->incr_count = 0;
		1639	}
		1640
1286	void DESTROY (CBOR *self)	1641	void DESTROY (CBOR *self)
1287	PPCODE:	1642	PPCODE:
1288	cbor_free (self);	1643	cbor_free (self);
1289		1644
1290	PROTOTYPES: ENABLE	1645	PROTOTYPES: ENABLE
1291		1646
1292	void encode_cbor (SV *scalar)	1647	void encode_cbor (SV *scalar)
		1648	ALIAS:
		1649	encode_cbor = 0
		1650	encode_cbor_sharing = F_ALLOW_SHARING
1293	PPCODE:	1651	PPCODE:
1294	{	1652	{
1295	CBOR cbor;	1653	CBOR cbor;
1296	cbor_init (&cbor);	1654	cbor_init (&cbor);
		1655	cbor.flags \|= ix;
1297	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;	1656	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1298	XPUSHs (scalar);	1657	XPUSHs (scalar);
1299	}	1658	}
1300		1659
1301	void decode_cbor (SV *cborstr)	1660	void decode_cbor (SV *cborstr)

Diff Legend

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

Comparing CBOR-XS/XS.xs (file contents): Revision 1.35 by root, Sat Nov 30 17:19:34 2013 UTC vs. Revision 1.59 by root, Fri Nov 25 23:37:27 2016 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.35 by root, Sat Nov 30 17:19:34 2013 UTC vs.
Revision 1.59 by root, Fri Nov 25 23:37:27 2016 UTC