[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.54 by root, Sun Apr 24 20:08:41 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);
…		…
627	U8 m = *dec->cur & MINOR_MASK;	678	U8 m = *dec->cur & MINOR_MASK;
628	++dec->cur;	679	++dec->cur;
629		680
630	if (ecb_expect_true (m < LENGTH_EXT1))	681	if (ecb_expect_true (m < LENGTH_EXT1))
631	return m;	682	return m;
632		683	else if (ecb_expect_true (m == LENGTH_EXT1))
633	switch (m)
634	{	684	{
635	case LENGTH_EXT1:
636	WANT (1);	685	WANT (1);
637	dec->cur += 1;	686	dec->cur += 1;
638	return dec->cur[-1];	687	return dec->cur[-1];
639		688	}
640	case LENGTH_EXT2:	689	else if (ecb_expect_true (m == LENGTH_EXT2))
		690	{
641	WANT (2);	691	WANT (2);
642	dec->cur += 2;	692	dec->cur += 2;
643	return (((UV)dec->cur[-2]) << 8)	693	return (((UV)dec->cur[-2]) << 8)
644	\| ((UV)dec->cur[-1]);	694	\| ((UV)dec->cur[-1]);
645		695	}
646	case LENGTH_EXT4:	696	else if (ecb_expect_true (m == LENGTH_EXT4))
		697	{
647	WANT (4);	698	WANT (4);
648	dec->cur += 4;	699	dec->cur += 4;
649	return (((UV)dec->cur[-4]) << 24)	700	return (((UV)dec->cur[-4]) << 24)
650	\| (((UV)dec->cur[-3]) << 16)	701	\| (((UV)dec->cur[-3]) << 16)
651	\| (((UV)dec->cur[-2]) << 8)	702	\| (((UV)dec->cur[-2]) << 8)
652	\| ((UV)dec->cur[-1]);	703	\| ((UV)dec->cur[-1]);
653		704	}
654	case LENGTH_EXT8:	705	else if (ecb_expect_true (m == LENGTH_EXT8))
		706	{
655	WANT (8);	707	WANT (8);
656	dec->cur += 8;	708	dec->cur += 8;
657		709
658	return	710	return
659	#if UVSIZE < 8	711	#if UVSIZE < 8
660	0	712	0
661	#else	713	#else
662	(((UV)dec->cur[-8]) << 56)	714	(((UV)dec->cur[-8]) << 56)
663	\| (((UV)dec->cur[-7]) << 48)	715	\| (((UV)dec->cur[-7]) << 48)
664	\| (((UV)dec->cur[-6]) << 40)	716	\| (((UV)dec->cur[-6]) << 40)
665	\| (((UV)dec->cur[-5]) << 32)	717	\| (((UV)dec->cur[-5]) << 32)
666	#endif	718	#endif
667	\| (((UV)dec->cur[-4]) << 24)	719	\| (((UV)dec->cur[-4]) << 24)
668	\| (((UV)dec->cur[-3]) << 16)	720	\| (((UV)dec->cur[-3]) << 16)
669	\| (((UV)dec->cur[-2]) << 8)	721	\| (((UV)dec->cur[-2]) << 8)
670	\| ((UV)dec->cur[-1]);	722	\| ((UV)dec->cur[-1]);
671		723	}
672	default:	724	else
673	ERR ("corrupted CBOR data (unsupported integer minor encoding)");	725	ERR ("corrupted CBOR data (unsupported integer minor encoding)");
674	}
675		726
676	fail:	727	fail:
677	return 0;	728	return 0;
678	}	729	}
679		730
…		…
705	}	756	}
706	else	757	else
707	{	758	{
708	int i, len = decode_uint (dec);	759	int i, len = decode_uint (dec);
709		760
		761	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);	762	av_fill (av, len - 1);
711		763
712	for (i = 0; i < len; ++i)	764	for (i = 0; i < len; ++i)
713	AvARRAY (av)[i] = decode_sv (dec);	765	AvARRAY (av)[i] = decode_sv (dec);
714	}	766	}
…		…
727	{	779	{
728	// for speed reasons, we specialcase single-string	780	// for speed reasons, we specialcase single-string
729	// byte or utf-8 strings as keys, but only when !stringref	781	// byte or utf-8 strings as keys, but only when !stringref
730		782
731	if (ecb_expect_true (!dec->stringref))	783	if (ecb_expect_true (!dec->stringref))
732	if ((*dec->cur - MAJOR_BYTES) <= 27)	784	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
733	{	785	{
734	I32 len = decode_uint (dec);	786	I32 len = decode_uint (dec);
735	char key = (char )dec->cur;	787	char key = (char )dec->cur;
736		788
		789	WANT (len);
737	dec->cur += len;	790	dec->cur += len;
738		791
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);	792	hv_store (hv, key, len, decode_sv (dec), 0);
743		793
744	return;	794	return;
745	}	795	}
746	else if ((*dec->cur - MAJOR_TEXT) <= 27)	796	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
747	{	797	{
748	I32 len = decode_uint (dec);	798	I32 len = decode_uint (dec);
749	char key = (char )dec->cur;	799	char key = (char )dec->cur;
750		800
		801	WANT (len);
751	dec->cur += len;	802	dec->cur += len;
752		803
753	if (ecb_expect_false (dec->stringref))	804	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
754	av_push (dec->stringref, newSVpvn_utf8 (key, len, 1));	805	if (!is_utf8_string (key, len))
		806	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
755		807
756	hv_store (hv, key, -len, decode_sv (dec), 0);	808	hv_store (hv, key, -len, decode_sv (dec), 0);
757		809
758	return;	810	return;
759	}	811	}
…		…
761	SV *k = decode_sv (dec);	813	SV *k = decode_sv (dec);
762	SV *v = decode_sv (dec);	814	SV *v = decode_sv (dec);
763		815
764	hv_store_ent (hv, k, v, 0);	816	hv_store_ent (hv, k, v, 0);
765	SvREFCNT_dec (k);	817	SvREFCNT_dec (k);
		818
		819	fail:
		820	;
766	}	821	}
767		822
768	static SV *	823	static SV *
769	decode_hv (dec_t *dec)	824	decode_hv (dec_t *dec)
770	{	825	{
…		…
852	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))	907	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
853	av_push (dec->stringref, SvREFCNT_inc_NN (sv));	908	av_push (dec->stringref, SvREFCNT_inc_NN (sv));
854	}	909	}
855		910
856	if (utf8)	911	if (utf8)
		912	{
		913	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
		914	if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
		915	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
		916
857	SvUTF8_on (sv);	917	SvUTF8_on (sv);
		918	}
858		919
859	return sv;	920	return sv;
860		921
861	fail:	922	fail:
862	SvREFCNT_dec (sv);	923	SvREFCNT_dec (sv);
…		…
911	case CBOR_TAG_VALUE_SHAREABLE:	972	case CBOR_TAG_VALUE_SHAREABLE:
912	{	973	{
913	if (ecb_expect_false (!dec->shareable))	974	if (ecb_expect_false (!dec->shareable))
914	dec->shareable = (AV )sv_2mortal ((SV )newAV ());	975	dec->shareable = (AV )sv_2mortal ((SV )newAV ());
915		976
		977	if (dec->cbor.flags & F_ALLOW_CYCLES)
		978	{
916	sv = newSV (0);	979	sv = newSV (0);
917	av_push (dec->shareable, SvREFCNT_inc_NN (sv));	980	av_push (dec->shareable, SvREFCNT_inc_NN (sv));
918		981
919	SV *osv = decode_sv (dec);	982	SV *osv = decode_sv (dec);
920	sv_setsv (sv, osv);	983	sv_setsv (sv, osv);
921	SvREFCNT_dec_NN (osv);	984	SvREFCNT_dec_NN (osv);
		985	}
		986	else
		987	{
		988	av_push (dec->shareable, &PL_sv_undef);
		989	int idx = AvFILLp (dec->shareable);
		990	sv = decode_sv (dec);
		991	av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
		992	}
922	}	993	}
923	break;	994	break;
924		995
925	case CBOR_TAG_VALUE_SHAREDREF:	996	case CBOR_TAG_VALUE_SHAREDREF:
926	{	997	{
…		…
931		1002
932	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))	1003	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))
933	ERR ("corrupted CBOR data (sharedref index out of bounds)");	1004	ERR ("corrupted CBOR data (sharedref index out of bounds)");
934		1005
935	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);	1006	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
		1007
		1008	if (sv == &PL_sv_undef)
		1009	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
936	}	1010	}
937	break;	1011	break;
938		1012
939	case CBOR_TAG_PERL_OBJECT:	1013	case CBOR_TAG_PERL_OBJECT:
940	{	1014	{
…		…
955	if (!method)	1029	if (!method)
956	ERR ("cannot decode perl-object (package does not have a THAW method)");	1030	ERR ("cannot decode perl-object (package does not have a THAW method)");
957		1031
958	dSP;	1032	dSP;
959		1033
960	ENTER; SAVETMPS; PUSHMARK (SP);	1034	ENTER; SAVETMPS;
		1035	PUSHMARK (SP);
961	EXTEND (SP, len + 1);	1036	EXTEND (SP, len + 1);
962	// we re-bless the reference to get overload and other niceties right	1037	// we re-bless the reference to get overload and other niceties right
963	PUSHs (*av_fetch (av, 0, 1));	1038	PUSHs (*av_fetch (av, 0, 1));
964	PUSHs (sv_cbor);	1039	PUSHs (sv_cbor);
965		1040
…		…
990	default:	1065	default:
991	{	1066	{
992	sv = decode_sv (dec);	1067	sv = decode_sv (dec);
993		1068
994	dSP;	1069	dSP;
995	ENTER; SAVETMPS; PUSHMARK (SP);	1070	ENTER; SAVETMPS;
		1071	SAVESTACK_POS ();
		1072	PUSHMARK (SP);
996	EXTEND (SP, 2);	1073	EXTEND (SP, 2);
997	PUSHs (newSVuv (tag));	1074	PUSHs (newSVuv (tag));
998	PUSHs (sv);	1075	PUSHs (sv);
999		1076
1000	PUTBACK;	1077	PUTBACK;
…		…
1109		1186
1110	return newSVnv (ecb_binary64_to_double (fp));	1187	return newSVnv (ecb_binary64_to_double (fp));
1111	}	1188	}
1112		1189
1113	// 0..19 unassigned simple	1190	// 0..19 unassigned simple
1114	// 24 reserved + unassigned (reserved values are not encodable)	1191	// 24 reserved + unassigned simple (reserved values are not encodable)
		1192	// 28-30 unassigned misc
		1193	// 31 break code
1115	default:	1194	default:
1116	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");	1195	ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1117	}	1196	}
1118		1197
1119	break;	1198	break;
1120	}	1199	}
1121		1200
…		…
1124	}	1203	}
1125		1204
1126	static SV *	1205	static SV *
1127	decode_cbor (SV string, CBOR cbor, char **offset_return)	1206	decode_cbor (SV string, CBOR cbor, char **offset_return)
1128	{	1207	{
1129	dec_t dec = { };	1208	dec_t dec = { 0 };
1130	SV *sv;	1209	SV *sv;
1131	STRLEN len;	1210	STRLEN len;
1132	char *data = SvPVbyte (string, len);	1211	char *data = SvPVbyte (string, len);
1133		1212
1134	if (len > cbor->max_size && cbor->max_size)	1213	if (len > cbor->max_size && cbor->max_size)
…		…
1148	if (dec.cur != dec.end && !dec.err)	1227	if (dec.cur != dec.end && !dec.err)
1149	dec.err = "garbage after CBOR object";	1228	dec.err = "garbage after CBOR object";
1150		1229
1151	if (dec.err)	1230	if (dec.err)
1152	{	1231	{
		1232	if (dec.shareable)
		1233	{
		1234	// need to break cyclic links, which whould all be in shareable
		1235	int i;
		1236	SV **svp;
		1237
		1238	for (i = av_len (dec.shareable) + 1; i--; )
		1239	if ((svp = av_fetch (dec.shareable, i, 0)))
		1240	sv_setsv (*svp, &PL_sv_undef);
		1241	}
		1242
1153	SvREFCNT_dec (sv);	1243	SvREFCNT_dec (sv);
1154	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1244	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);
1155	}	1245	}
1156		1246
1157	sv = sv_2mortal (sv);	1247	sv = sv_2mortal (sv);
1158		1248
1159	return sv;	1249	return sv;
1160	}	1250	}
1161		1251
		1252	/////////////////////////////////////////////////////////////////////////////
		1253	// incremental parser
		1254
		1255	#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
		1256
		1257	// returns 0 for notyet, 1 for success or error
		1258	static int
		1259	incr_parse (CBOR self, SV cborstr)
		1260	{
		1261	STRLEN cur;
		1262	SvPV (cborstr, cur);
		1263
		1264	while (ecb_expect_true (self->incr_need <= cur))
		1265	{
		1266	// table of integer count bytes
		1267	static I8 incr_len[MINOR_MASK + 1] = {
		1268	0, 0, 0, 0, 0, 0, 0, 0,
		1269	0, 0, 0, 0, 0, 0, 0, 0,
		1270	0, 0, 0, 0, 0, 0, 0, 0,
		1271	1, 2, 4, 8,-1,-1,-1,-2
		1272	};
		1273
		1274	const U8 *p = SvPVX (cborstr) + self->incr_pos;
		1275	U8 m = *p & MINOR_MASK;
		1276	IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1277	I8 ilen = incr_len[m];
		1278
		1279	self->incr_need = self->incr_pos + 1;
		1280
		1281	if (ecb_expect_false (ilen < 0))
		1282	{
		1283	if (m != MINOR_INDEF)
		1284	return 1; // error
		1285
		1286	if (*p == (MAJOR_MISC \| MINOR_INDEF))
		1287	{
		1288	if (count >= 0)
		1289	return 1; // error
		1290
		1291	count = 1;
		1292	}
		1293	else
		1294	{
		1295	av_push (self->incr_count, newSViv (-1)); //TODO: nest
		1296	count = -1;
		1297	}
		1298	}
		1299	else
		1300	{
		1301	self->incr_need += ilen;
		1302	if (ecb_expect_false (self->incr_need > cur))
		1303	return 0;
		1304
		1305	int major = *p >> MAJOR_SHIFT;
		1306
		1307	switch (major)
		1308	{
		1309	case MAJOR_TAG >> MAJOR_SHIFT:
		1310	++count; // tags merely prefix another value
		1311	break;
		1312
		1313	case MAJOR_BYTES >> MAJOR_SHIFT:
		1314	case MAJOR_TEXT >> MAJOR_SHIFT:
		1315	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1316	case MAJOR_MAP >> MAJOR_SHIFT:
		1317	{
		1318	UV len;
		1319
		1320	if (ecb_expect_false (ilen))
		1321	{
		1322	len = 0;
		1323
		1324	do {
		1325	len = (len << 8) \| *++p;
		1326	} while (--ilen);
		1327	}
		1328	else
		1329	len = m;
		1330
		1331	switch (major)
		1332	{
		1333	case MAJOR_BYTES >> MAJOR_SHIFT:
		1334	case MAJOR_TEXT >> MAJOR_SHIFT:
		1335	self->incr_need += len;
		1336	if (ecb_expect_false (self->incr_need > cur))
		1337	return 0;
		1338
		1339	break;
		1340
		1341	case MAJOR_MAP >> MAJOR_SHIFT:
		1342	len <<= 1;
		1343	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1344	if (len)
		1345	{
		1346	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
		1347	count = len + 1;
		1348	}
		1349	break;
		1350	}
		1351	}
		1352	}
		1353	}
		1354
		1355	self->incr_pos = self->incr_need;
		1356
		1357	if (count > 0)
		1358	{
		1359	while (!--count)
		1360	{
		1361	if (!AvFILLp (self->incr_count))
		1362	return 1; // done
		1363
		1364	SvREFCNT_dec_NN (av_pop (self->incr_count));
		1365	count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1366	}
		1367
		1368	SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
		1369	}
		1370	}
		1371
		1372	return 0;
		1373	}
		1374
		1375
1162	/////////////////////////////////////////////////////////////////////////////	1376	/////////////////////////////////////////////////////////////////////////////
1163	// XS interface functions	1377	// XS interface functions
1164		1378
1165	MODULE = CBOR::XS PACKAGE = CBOR::XS	1379	MODULE = CBOR::XS PACKAGE = CBOR::XS
1166		1380
…		…
1206	void shrink (CBOR *self, int enable = 1)	1420	void shrink (CBOR *self, int enable = 1)
1207	ALIAS:	1421	ALIAS:
1208	shrink = F_SHRINK	1422	shrink = F_SHRINK
1209	allow_unknown = F_ALLOW_UNKNOWN	1423	allow_unknown = F_ALLOW_UNKNOWN
1210	allow_sharing = F_ALLOW_SHARING	1424	allow_sharing = F_ALLOW_SHARING
		1425	allow_cycles = F_ALLOW_CYCLES
1211	pack_strings = F_PACK_STRINGS	1426	pack_strings = F_PACK_STRINGS
		1427	text_keys = F_TEXT_KEYS
		1428	text_strings = F_TEXT_STRINGS
		1429	validate_utf8 = F_VALIDATE_UTF8
1212	PPCODE:	1430	PPCODE:
1213	{	1431	{
1214	if (enable)	1432	if (enable)
1215	self->flags \|= ix;	1433	self->flags \|= ix;
1216	else	1434	else
…		…
1222	void get_shrink (CBOR *self)	1440	void get_shrink (CBOR *self)
1223	ALIAS:	1441	ALIAS:
1224	get_shrink = F_SHRINK	1442	get_shrink = F_SHRINK
1225	get_allow_unknown = F_ALLOW_UNKNOWN	1443	get_allow_unknown = F_ALLOW_UNKNOWN
1226	get_allow_sharing = F_ALLOW_SHARING	1444	get_allow_sharing = F_ALLOW_SHARING
		1445	get_allow_cycles = F_ALLOW_CYCLES
1227	get_pack_strings = F_PACK_STRINGS	1446	get_pack_strings = F_PACK_STRINGS
		1447	get_text_keys = F_TEXT_KEYS
		1448	get_text_strings = F_TEXT_STRINGS
		1449	get_validate_utf8 = F_VALIDATE_UTF8
1228	PPCODE:	1450	PPCODE:
1229	XPUSHs (boolSV (self->flags & ix));	1451	XPUSHs (boolSV (self->flags & ix));
1230		1452
1231	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1453	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1232	PPCODE:	1454	PPCODE:
…		…
1281	EXTEND (SP, 2);	1503	EXTEND (SP, 2);
1282	PUSHs (sv);	1504	PUSHs (sv);
1283	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));	1505	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1284	}	1506	}
1285		1507
		1508	void incr_parse (CBOR self, SV cborstr)
		1509	ALIAS:
		1510	incr_parse_multiple = 1
		1511	PPCODE:
		1512	{
		1513	if (SvUTF8 (cborstr))
		1514	sv_utf8_downgrade (cborstr, 0);
		1515
		1516	if (!self->incr_count)
		1517	{
		1518	self->incr_count = newAV ();
		1519	self->incr_pos = 0;
		1520	self->incr_need = 1;
		1521
		1522	av_push (self->incr_count, newSViv (1));
		1523	}
		1524
		1525	do
		1526	{
		1527	if (!incr_parse (self, cborstr))
		1528	{
		1529	if (self->incr_need > self->max_size && self->max_size)
		1530	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
		1531	(unsigned long)self->incr_need, (unsigned long)self->max_size);
		1532
		1533	break;
		1534	}
		1535
		1536	SV *sv;
		1537	char *offset;
		1538
		1539	PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
		1540	XPUSHs (sv);
		1541
		1542	sv_chop (cborstr, offset);
		1543
		1544	av_clear (self->incr_count);
		1545	av_push (self->incr_count, newSViv (1));
		1546
		1547	self->incr_pos = 0;
		1548	self->incr_need = self->incr_pos + 1;
		1549	}
		1550	while (ix);
		1551	}
		1552
		1553	void incr_reset (CBOR *self)
		1554	CODE:
		1555	{
		1556	SvREFCNT_dec (self->incr_count);
		1557	self->incr_count = 0;
		1558	}
		1559
1286	void DESTROY (CBOR *self)	1560	void DESTROY (CBOR *self)
1287	PPCODE:	1561	PPCODE:
1288	cbor_free (self);	1562	cbor_free (self);
1289		1563
1290	PROTOTYPES: ENABLE	1564	PROTOTYPES: ENABLE
1291		1565
1292	void encode_cbor (SV *scalar)	1566	void encode_cbor (SV *scalar)
		1567	ALIAS:
		1568	encode_cbor = 0
		1569	encode_cbor_sharing = F_ALLOW_SHARING
1293	PPCODE:	1570	PPCODE:
1294	{	1571	{
1295	CBOR cbor;	1572	CBOR cbor;
1296	cbor_init (&cbor);	1573	cbor_init (&cbor);
		1574	cbor.flags \|= ix;
1297	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;	1575	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1298	XPUSHs (scalar);	1576	XPUSHs (scalar);
1299	}	1577	}
1300		1578
1301	void decode_cbor (SV *cborstr)	1579	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.54 by root, Sun Apr 24 20:08:41 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.54 by root, Sun Apr 24 20:08:41 2016 UTC