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

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.43 by root, Sun Jan 5 14:24:54 2014 UTC vs.
Revision 1.80 by root, Fri Sep 8 20:03:06 2023 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
		13	#define ECB_NO_THREADS 1
12	#include "ecb.h"	14	#include "ecb.h"
13		15
14	// compatibility with perl <5.18	16	// compatibility with perl <5.18
15	#ifndef HvNAMELEN_get	17	#ifndef HvNAMELEN_get
16	# define HvNAMELEN_get(hv) strlen (HvNAME (hv))	18	# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
…		…
19	# define HvNAMELEN(hv) HvNAMELEN_get (hv)	21	# define HvNAMELEN(hv) HvNAMELEN_get (hv)
20	#endif	22	#endif
21	#ifndef HvNAMEUTF8	23	#ifndef HvNAMEUTF8
22	# define HvNAMEUTF8(hv) 0	24	# define HvNAMEUTF8(hv) 0
23	#endif	25	#endif
		26	#ifndef SvREFCNT_inc_NN
		27	# define SvREFCNT_inc_NN(sv) SvREFCNT_inc (sv)
		28	#endif
24	#ifndef SvREFCNT_dec_NN	29	#ifndef SvREFCNT_dec_NN
25	# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)	30	# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
26	#endif	31	#endif
		32
		33	// perl's is_utf8_string interprets len=0 as "calculate len", but we want it to mean 0
		34	#define cbor_is_utf8_string(str,len) (!(len) \|\| is_utf8_string ((str), (len)))
27		35
28	// known major and minor types	36	// known major and minor types
29	enum cbor_type	37	enum cbor_type
30	{	38	{
31	MAJOR_SHIFT = 5,	39	MAJOR_SHIFT = 5,
…		…
94	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8	102	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
95		103
96	CBOR_TAG_MAGIC = 55799, // self-describe cbor	104	CBOR_TAG_MAGIC = 55799, // self-describe cbor
97	};	105	};
98		106
		107	// known forced types, also hardcoded in CBOR.pm
		108	enum
		109	{
		110	AS_CBOR = 0,
		111	AS_INT = 1,
		112	AS_BYTES = 2,
		113	AS_TEXT = 3,
		114	AS_FLOAT16 = 4,
		115	AS_FLOAT32 = 5,
		116	AS_FLOAT64 = 6,
		117	AS_MAP = 7,
		118	// possibly future enhancements: (generic) float, (generic) string
		119	};
		120
99	#define F_SHRINK 0x00000001UL	121	#define F_SHRINK 0x00000001UL
100	#define F_ALLOW_UNKNOWN 0x00000002UL	122	#define F_ALLOW_UNKNOWN 0x00000002UL
101	#define F_ALLOW_SHARING 0x00000004UL	123	#define F_ALLOW_SHARING 0x00000004UL
102	#define F_ALLOW_CYCLES 0x00000008UL	124	#define F_ALLOW_CYCLES 0x00000008UL
		125	#define F_ALLOW_WEAK_CYCLES 0x00000010UL
		126	#define F_FORBID_OBJECTS 0x00000020UL
103	#define F_PACK_STRINGS 0x00000010UL	127	#define F_PACK_STRINGS 0x00000040UL
		128	#define F_TEXT_KEYS 0x00000080UL
		129	#define F_TEXT_STRINGS 0x00000100UL
104	#define F_VALIDATE_UTF8 0x00000020UL	130	#define F_VALIDATE_UTF8 0x00000200UL
105		131
106	#define INIT_SIZE 32 // initial scalar size to be allocated	132	#define INIT_SIZE 32 // initial scalar size to be allocated
107		133
108	#define SB do {	134	#define SB do {
109	#define SE } while (0)	135	#define SE } while (0)
…		…
179	#endif	205	#endif
180	}	206	}
181	}	207	}
182		208
183	// minimum length of a string to be registered for stringref	209	// minimum length of a string to be registered for stringref
184	ecb_inline int	210	ecb_inline STRLEN
185	minimum_string_length (UV idx)	211	minimum_string_length (UV idx)
186	{	212	{
187	return idx > 23	213	return idx <= 23 ? 3
188	? idx > 0xffU	214	: idx <= 0xffU ? 4
189	? idx > 0xffffU	215	: idx <= 0xffffU ? 5
190	? idx > 0xffffffffU	216	: idx <= 0xffffffffU ? 7
191	? 11	217	: 11;
192	: 7
193	: 5
194	: 4
195	: 3;
196	}	218	}
197		219
198	/////////////////////////////////////////////////////////////////////////////	220	/////////////////////////////////////////////////////////////////////////////
199	// encoder	221	// encoder
200		222
…		…
213	} enc_t;	235	} enc_t;
214		236
215	ecb_inline void	237	ecb_inline void
216	need (enc_t *enc, STRLEN len)	238	need (enc_t *enc, STRLEN len)
217	{	239	{
218	if (ecb_expect_false (enc->cur + len >= enc->end))	240	if (ecb_expect_false ((uintptr_t)(enc->end - enc->cur) < len))
219	{	241	{
220	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);	242	STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
221	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);	243	SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
222	enc->cur = SvPVX (enc->sv) + cur;	244	enc->cur = SvPVX (enc->sv) + cur;
223	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;	245	enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
224	}	246	}
225	}	247	}
226		248
		249	static void encode_sv (enc_t enc, SV sv);
		250
227	ecb_inline void	251	ecb_inline void
228	encode_ch (enc_t *enc, char ch)	252	encode_ch (enc_t *enc, char ch)
229	{	253	{
230	need (enc, 1);	254	need (enc, 1);
231	*enc->cur++ = ch;	255	*enc->cur++ = ch;
232	}	256	}
233		257
		258	// used for tags, intregers, element counts and so on
234	static void	259	static void
235	encode_uint (enc_t *enc, int major, UV len)	260	encode_uint (enc_t *enc, int major, UV len)
236	{	261	{
237	need (enc, 9);	262	need (enc, 9);
238		263
…		…
269	*enc->cur++ = len >> 8;	294	*enc->cur++ = len >> 8;
270	*enc->cur++ = len;	295	*enc->cur++ = len;
271	}	296	}
272	}	297	}
273		298
		299	// encodes a perl value into a CBOR integer
		300	ecb_inline void
		301	encode_int (enc_t enc, SV sv)
		302	{
		303	if (SvIsUV (sv))
		304	encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
		305	else if (SvIVX (sv) >= 0)
		306	encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
		307	else
		308	encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
		309	}
		310
274	ecb_inline void	311	ecb_inline void
275	encode_tag (enc_t *enc, UV tag)	312	encode_tag (enc_t *enc, UV tag)
276	{	313	{
277	encode_uint (enc, MAJOR_TAG, tag);	314	encode_uint (enc, MAJOR_TAG, tag);
278	}	315	}
279		316
		317	// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
		318	ecb_noinline static void
		319	encode_str_utf8 (enc_t enc, int utf8, char str, STRLEN len)
		320	{
		321	STRLEN ulen = len;
		322	U8 p, pend = (U8 *)str + len;
		323
		324	for (p = (U8 *)str; p < pend; ++p)
		325	ulen += *p >> 7; // count set high bits
		326
		327	encode_uint (enc, MAJOR_TEXT, ulen);
		328
		329	need (enc, ulen);
		330	for (p = (U8 *)str; p < pend; ++p)
		331	if (*p < 0x80)
		332	enc->cur++ = p;
		333	else
		334	{
		335	enc->cur++ = 0xc0 + (p >> 6);
		336	enc->cur++ = 0x80 + (p & 63);
		337	}
		338	}
		339
280	ecb_inline void	340	ecb_inline void
281	encode_str (enc_t enc, int utf8, char str, STRLEN len)	341	encode_str (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
282	{	342	{
		343	if (ecb_expect_false (upgrade_utf8))
		344	if (!utf8)
		345	{
		346	encode_str_utf8 (enc, utf8, str, len);
		347	return;
		348	}
		349
283	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);	350	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
284	need (enc, len);	351	need (enc, len);
285	memcpy (enc->cur, str, len);	352	memcpy (enc->cur, str, len);
286	enc->cur += len;	353	enc->cur += len;
287	}	354	}
288		355
289	static void	356	ecb_inline void
290	encode_strref (enc_t enc, int utf8, char str, STRLEN len)	357	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
291	{	358	{
292	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))	359	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
293	{	360	{
294	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);	361	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
295		362
…		…
306	sv_setuv (*svp, enc->stringref_idx);	373	sv_setuv (*svp, enc->stringref_idx);
307	++enc->stringref_idx;	374	++enc->stringref_idx;
308	}	375	}
309	}	376	}
310		377
311	encode_str (enc, utf8, str, len);	378	encode_str (enc, upgrade_utf8, utf8, str, len);
312	}	379	}
313		380
314	static void encode_sv (enc_t enc, SV sv);	381	ecb_inline void
		382	encode_float16 (enc_t *enc, NV nv)
		383	{
		384	need (enc, 1+2);
		385
		386	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT16;
		387
		388	uint16_t fp = ecb_float_to_binary16 (nv);
		389
		390	if (!ecb_big_endian ())
		391	fp = ecb_bswap16 (fp);
		392
		393	memcpy (enc->cur, &fp, 2);
		394	enc->cur += 2;
		395	}
		396
		397	ecb_inline void
		398	encode_float32 (enc_t *enc, NV nv)
		399	{
		400	need (enc, 1+4);
		401
		402	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT32;
		403
		404	uint32_t fp = ecb_float_to_binary32 (nv);
		405
		406	if (!ecb_big_endian ())
		407	fp = ecb_bswap32 (fp);
		408
		409	memcpy (enc->cur, &fp, 4);
		410	enc->cur += 4;
		411	}
		412
		413	ecb_inline void
		414	encode_float64 (enc_t *enc, NV nv)
		415	{
		416	need (enc, 1+8);
		417
		418	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT64;
		419
		420	uint64_t fp = ecb_double_to_binary64 (nv);
		421
		422	if (!ecb_big_endian ())
		423	fp = ecb_bswap64 (fp);
		424
		425	memcpy (enc->cur, &fp, 8);
		426	enc->cur += 8;
		427	}
		428
		429	ecb_inline void
		430	encode_bool (enc_t *enc, int istrue)
		431	{
		432	encode_ch (enc, istrue ? MAJOR_MISC \| SIMPLE_TRUE : MAJOR_MISC \| SIMPLE_FALSE);
		433	}
		434
		435	// encodes an arrayref containing key-value pairs as CBOR map
		436	ecb_inline void
		437	encode_array_as_map (enc_t enc, SV sv)
		438	{
		439	if (enc->depth >= enc->cbor.max_depth)
		440	croak (ERR_NESTING_EXCEEDED);
		441
		442	++enc->depth;
		443
		444	// as_map does error checking for us, but we re-check in case
		445	// things have changed.
		446
		447	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
		448	croak ("CBOR::XS::as_map requires an array reference (did you change the array after calling as_map?)");
		449
		450	AV av = (AV )SvRV (sv);
		451	int i, len = av_len (av);
		452
		453	if (!(len & 1))
		454	croak ("CBOR::XS::as_map requires an even number of elements (did you change the array after calling as_map?)");
		455
		456	encode_uint (enc, MAJOR_MAP, (len + 1) >> 1);
		457
		458	for (i = 0; i <= len; ++i)
		459	{
		460	SV **svp = av_fetch (av, i, 0);
		461	encode_sv (enc, svp ? *svp : &PL_sv_undef);
		462	}
		463
		464	--enc->depth;
		465	}
		466
		467	ecb_inline void
		468	encode_forced (enc_t enc, UV type, SV sv)
		469	{
		470	switch (type)
		471	{
		472	case AS_CBOR:
		473	{
		474	STRLEN len;
		475	char *str = SvPVbyte (sv, len);
		476
		477	need (enc, len);
		478	memcpy (enc->cur, str, len);
		479	enc->cur += len;
		480	}
		481	break;
		482
		483	case AS_BYTES:
		484	{
		485	STRLEN len;
		486	char *str = SvPVbyte (sv, len);
		487	encode_strref (enc, 0, 0, str, len);
		488	}
		489	break;
		490
		491	case AS_TEXT:
		492	{
		493	STRLEN len;
		494	char *str = SvPVutf8 (sv, len);
		495	encode_strref (enc, 1, 1, str, len);
		496	}
		497	break;
		498
		499	case AS_INT: encode_int (enc, sv); break;
		500
		501	case AS_FLOAT16: encode_float16 (enc, SvNV (sv)); break;
		502	case AS_FLOAT32: encode_float32 (enc, SvNV (sv)); break;
		503	case AS_FLOAT64: encode_float64 (enc, SvNV (sv)); break;
		504
		505	case AS_MAP: encode_array_as_map (enc, sv); break;
		506
		507	default:
		508	croak ("encountered malformed CBOR::XS::Tagged object");
		509	}
		510	}
315		511
316	static void	512	static void
317	encode_av (enc_t enc, AV av)	513	encode_av (enc_t enc, AV av)
318	{	514	{
319	int i, len = av_len (av);	515	int i, len = av_len (av);
…		…
323		519
324	++enc->depth;	520	++enc->depth;
325		521
326	encode_uint (enc, MAJOR_ARRAY, len + 1);	522	encode_uint (enc, MAJOR_ARRAY, len + 1);
327		523
		524	if (ecb_expect_false (SvMAGICAL (av)))
328	for (i = 0; i <= len; ++i)	525	for (i = 0; i <= len; ++i)
329	{	526	{
330	SV **svp = av_fetch (av, i, 0);	527	SV **svp = av_fetch (av, i, 0);
331	encode_sv (enc, svp ? *svp : &PL_sv_undef);	528	encode_sv (enc, svp ? *svp : &PL_sv_undef);
332	}	529	}
		530	else
		531	for (i = 0; i <= len; ++i)
		532	{
		533	SV *sv = AvARRAY (av)[i];
		534	encode_sv (enc, sv ? sv : &PL_sv_undef);
		535	}
333		536
334	--enc->depth;	537	--enc->depth;
335	}	538	}
336		539
337	static void	540	static void
…		…
345	++enc->depth;	548	++enc->depth;
346		549
347	int pairs = hv_iterinit (hv);	550	int pairs = hv_iterinit (hv);
348	int mg = SvMAGICAL (hv);	551	int mg = SvMAGICAL (hv);
349		552
350	if (mg)	553	if (ecb_expect_false (mg))
351	encode_ch (enc, MAJOR_MAP \| MINOR_INDEF);	554	encode_ch (enc, MAJOR_MAP \| MINOR_INDEF);
352	else	555	else
353	encode_uint (enc, MAJOR_MAP, pairs);	556	encode_uint (enc, MAJOR_MAP, pairs);
354		557
355	while ((he = hv_iternext (hv)))	558	while ((he = hv_iternext (hv)))
356	{	559	{
357	if (HeKLEN (he) == HEf_SVKEY)	560	if (HeKLEN (he) == HEf_SVKEY)
358	encode_sv (enc, HeSVKEY (he));	561	encode_sv (enc, HeSVKEY (he));
359	else	562	else
360	encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	563	encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS \| F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
361		564
362	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	565	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
363	}	566	}
364		567
365	if (mg)	568	if (ecb_expect_false (mg))
366	encode_ch (enc, MAJOR_MISC \| MINOR_INDEF);	569	encode_ch (enc, MAJOR_MISC \| MINOR_INDEF);
367		570
368	--enc->depth;	571	--enc->depth;
369	}	572	}
370		573
…		…
390		593
391	HV *stash = SvSTASH (sv);	594	HV *stash = SvSTASH (sv);
392		595
393	if (stash == boolean_stash)	596	if (stash == boolean_stash)
394	{	597	{
395	encode_ch (enc, SvIV (sv) ? MAJOR_MISC \| SIMPLE_TRUE : MAJOR_MISC \| SIMPLE_FALSE);	598	encode_bool (enc, SvIV (sv));
396	return;	599	return;
397	}	600	}
398	else if (stash == error_stash)	601	else if (stash == error_stash)
399	{	602	{
400	encode_ch (enc, MAJOR_MISC \| SIMPLE_UNDEF);	603	encode_ch (enc, MAJOR_MISC \| SIMPLE_UNDEF);
…		…
403	else if (stash == tagged_stash)	606	else if (stash == tagged_stash)
404	{	607	{
405	if (svt != SVt_PVAV)	608	if (svt != SVt_PVAV)
406	croak ("encountered CBOR::XS::Tagged object that isn't an array");	609	croak ("encountered CBOR::XS::Tagged object that isn't an array");
407		610
		611	switch (av_len ((AV *)sv))
		612	{
		613	case 2-1:
		614	// actually a tagged value
408	encode_uint (enc, MAJOR_TAG, SvUV (av_fetch ((AV )sv, 0, 1)));	615	encode_uint (enc, MAJOR_TAG, SvUV (av_fetch ((AV )sv, 0, 1)));
409	encode_sv (enc, av_fetch ((AV )sv, 1, 1));	616	encode_sv (enc, av_fetch ((AV )sv, 1, 1));
		617	break;
		618
		619	case 3-1:
		620	// a forced type [value, type, undef]
		621	encode_forced (enc, SvUV (av_fetch ((AV )sv, 1, 1)), av_fetch ((AV )sv, 0, 1));
		622	break;
		623
		624	default:
		625	croak ("encountered malformed CBOR::XS::Tagged object");
		626	}
410		627
411	return;	628	return;
412	}	629	}
413	}	630	}
414		631
415	if (ecb_expect_false (SvREFCNT (sv) > 1)	632	if (ecb_expect_false (SvREFCNT (sv) > 1)
416	&& ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))	633	&& ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
417	{	634	{
418	if (!enc->shareable)	635	if (ecb_expect_false (!enc->shareable))
419	enc->shareable = (HV )sv_2mortal ((SV )newHV ());	636	enc->shareable = (HV )sv_2mortal ((SV )newHV ());
420		637
421	SV *svp = hv_fetch (enc->shareable, (char )&sv, sizeof (sv), 1);	638	SV *svp = hv_fetch (enc->shareable, (char )&sv, sizeof (sv), 1);
422		639
423	if (SvOK (*svp))	640	if (SvOK (*svp))
…		…
437	if (ecb_expect_false (SvOBJECT (sv)))	654	if (ecb_expect_false (SvOBJECT (sv)))
438	{	655	{
439	HV *stash = SvSTASH (sv);	656	HV *stash = SvSTASH (sv);
440	GV *method;	657	GV *method;
441		658
		659	if (enc->cbor.flags & F_FORBID_OBJECTS)
		660	croak ("encountered object '%s', but forbid_objects is enabled",
		661	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
442	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))	662	else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
443	{	663	{
444	dSP;	664	dSP;
445		665
446	ENTER; SAVETMPS; PUSHMARK (SP);	666	ENTER; SAVETMPS;
		667	PUSHMARK (SP);
447	// we re-bless the reference to get overload and other niceties right	668	// we re-bless the reference to get overload and other niceties right
448	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	669	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
449		670
450	PUTBACK;	671	PUTBACK;
451	// G_SCALAR ensures that return value is 1	672	// G_SCALAR ensures that return value is 1
…		…
464	}	685	}
465	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)	686	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
466	{	687	{
467	dSP;	688	dSP;
468		689
469	ENTER; SAVETMPS; PUSHMARK (SP);	690	ENTER; SAVETMPS;
		691	PUSHMARK (SP);
470	EXTEND (SP, 2);	692	EXTEND (SP, 2);
471	// we re-bless the reference to get overload and other niceties right	693	// we re-bless the reference to get overload and other niceties right
472	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	694	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
473	PUSHs (sv_cbor);	695	PUSHs (sv_cbor);
474		696
…		…
480	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)	702	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
481	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));	703	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
482		704
483	encode_tag (enc, CBOR_TAG_PERL_OBJECT);	705	encode_tag (enc, CBOR_TAG_PERL_OBJECT);
484	encode_uint (enc, MAJOR_ARRAY, count + 1);	706	encode_uint (enc, MAJOR_ARRAY, count + 1);
485	encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));	707	encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
486		708
487	while (count)	709	{
		710	int i;
		711
		712	for (i = 0; i < count; ++i)
488	encode_sv (enc, SP[1 - count--]);	713	encode_sv (enc, SP[i + 1 - count]);
		714
		715	SP -= count;
		716	}
489		717
490	PUTBACK;	718	PUTBACK;
491		719
492	FREETMPS; LEAVE;	720	FREETMPS; LEAVE;
493	}	721	}
…		…
515		743
516	if (ecb_expect_false (nv == (NV)(U32)nv))	744	if (ecb_expect_false (nv == (NV)(U32)nv))
517	encode_uint (enc, MAJOR_POS_INT, (U32)nv);	745	encode_uint (enc, MAJOR_POS_INT, (U32)nv);
518	//TODO: maybe I32?	746	//TODO: maybe I32?
519	else if (ecb_expect_false (nv == (float)nv))	747	else if (ecb_expect_false (nv == (float)nv))
520	{	748	encode_float32 (enc, nv);
521	uint32_t fp = ecb_float_to_binary32 (nv);
522
523	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT32;
524
525	if (!ecb_big_endian ())
526	fp = ecb_bswap32 (fp);
527
528	memcpy (enc->cur, &fp, 4);
529	enc->cur += 4;
530	}
531	else	749	else
532	{	750	encode_float64 (enc, nv);
533	uint64_t fp = ecb_double_to_binary64 (nv);
534
535	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT64;
536
537	if (!ecb_big_endian ())
538	fp = ecb_bswap64 (fp);
539
540	memcpy (enc->cur, &fp, 8);
541	enc->cur += 8;
542	}
543	}	751	}
544		752
545	static void	753	static void
546	encode_sv (enc_t enc, SV sv)	754	encode_sv (enc_t enc, SV sv)
547	{	755	{
…		…
549		757
550	if (SvPOKp (sv))	758	if (SvPOKp (sv))
551	{	759	{
552	STRLEN len;	760	STRLEN len;
553	char *str = SvPV (sv, len);	761	char *str = SvPV (sv, len);
554	encode_strref (enc, SvUTF8 (sv), str, len);	762	encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
555	}	763	}
556	else if (SvNOKp (sv))	764	else if (SvNOKp (sv))
557	encode_nv (enc, sv);	765	encode_nv (enc, sv);
558	else if (SvIOKp (sv))	766	else if (SvIOKp (sv))
559	{	767	encode_int (enc, sv);
560	if (SvIsUV (sv))
561	encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
562	else if (SvIVX (sv) >= 0)
563	encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
564	else
565	encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
566	}
567	else if (SvROK (sv))	768	else if (SvROK (sv))
568	encode_rv (enc, SvRV (sv));	769	encode_rv (enc, SvRV (sv));
569	else if (!SvOK (sv))	770	else if (!SvOK (sv))
570	encode_ch (enc, MAJOR_MISC \| SIMPLE_NULL);	771	encode_ch (enc, MAJOR_MISC \| SIMPLE_NULL);
571	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)	772	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
…		…
576	}	777	}
577		778
578	static SV *	779	static SV *
579	encode_cbor (SV scalar, CBOR cbor)	780	encode_cbor (SV scalar, CBOR cbor)
580	{	781	{
581	enc_t enc = { };	782	enc_t enc = { 0 };
582		783
583	enc.cbor = *cbor;	784	enc.cbor = *cbor;
584	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));	785	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
585	enc.cur = SvPVX (enc.sv);	786	enc.cur = SvPVX (enc.sv);
586	enc.end = SvEND (enc.sv);	787	enc.end = SvEND (enc.sv);
587		788
588	SvPOK_only (enc.sv);	789	SvPOK_only (enc.sv);
589		790
590	if (cbor->flags & F_PACK_STRINGS)	791	if (cbor->flags & F_PACK_STRINGS)
591	{	792	{
…		…
618	U32 depth; // recursion depth	819	U32 depth; // recursion depth
619	U32 maxdepth; // recursion depth limit	820	U32 maxdepth; // recursion depth limit
620	AV *shareable;	821	AV *shareable;
621	AV *stringref;	822	AV *stringref;
622	SV *decode_tagged;	823	SV *decode_tagged;
		824	SV *err_sv; // optional sv for error, needs to be freed
623	} dec_t;	825	} dec_t;
624		826
625	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	827	// set dec->err to ERRSV
		828	ecb_cold static void
		829	err_errsv (dec_t *dec)
		830	{
		831	if (!dec->err)
		832	{
		833	dec->err_sv = newSVsv (ERRSV);
626		834
627	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	835	// chop off the trailing \n
		836	SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
		837	*SvEND (dec->err_sv) = 0;
628		838
		839	dec->err = SvPVutf8_nolen (dec->err_sv);
		840	}
		841	}
		842
		843	// the following functions are used to reduce code size and help the compiler to optimise
		844	ecb_cold static void
		845	err_set (dec_t dec, const char reason)
		846	{
		847	if (!dec->err)
		848	dec->err = reason;
		849	}
		850
		851	ecb_cold static void
		852	err_unexpected_end (dec_t *dec)
		853	{
		854	err_set (dec, "unexpected end of CBOR data");
		855	}
		856
		857	#define ERR_DO(do) SB do; goto fail; SE
		858	#define ERR(reason) ERR_DO (err_set (dec, reason))
		859	#define ERR_ERRSV ERR_DO (err_errsv (dec))
		860
		861	#define WANT(len) if (ecb_expect_false ((uintptr_t)(dec->end - dec->cur) < (STRLEN)len)) ERR_DO (err_unexpected_end (dec))
		862
629	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	863	#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
630	#define DEC_DEC_DEPTH --dec->depth	864	#define DEC_DEC_DEPTH --dec->depth
631		865
632	static UV	866	static UV
633	decode_uint (dec_t *dec)	867	decode_uint (dec_t *dec)
634	{	868	{
…		…
700		934
701	for (;;)	935	for (;;)
702	{	936	{
703	WANT (1);	937	WANT (1);
704		938
705	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF))	939	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF) \|\| dec->err)
706	{	940	{
707	++dec->cur;	941	++dec->cur;
708	break;	942	break;
709	}	943	}
710		944
711	av_push (av, decode_sv (dec));	945	av_push (av, decode_sv (dec));
712	}	946	}
713	}	947	}
714	else	948	else
715	{	949	{
716	int i, len = decode_uint (dec);	950	UV i, len = decode_uint (dec);
717		951
718	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays	952	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
719	av_fill (av, len - 1);	953	av_fill (av, len - 1);
720		954
721	for (i = 0; i < len; ++i)	955	for (i = 0; i < len; ++i)
…		…
724		958
725	DEC_DEC_DEPTH;	959	DEC_DEC_DEPTH;
726	return newRV_noinc ((SV *)av);	960	return newRV_noinc ((SV *)av);
727		961
728	fail:	962	fail:
729	SvREFCNT_dec (av);	963	SvREFCNT_dec_NN (av);
730	DEC_DEC_DEPTH;	964	DEC_DEC_DEPTH;
731	return &PL_sv_undef;	965	return &PL_sv_undef;
732	}	966	}
733		967
734	static void	968	static void
…		…
738	// byte or utf-8 strings as keys, but only when !stringref	972	// byte or utf-8 strings as keys, but only when !stringref
739		973
740	if (ecb_expect_true (!dec->stringref))	974	if (ecb_expect_true (!dec->stringref))
741	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))	975	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
742	{	976	{
743	I32 len = decode_uint (dec);	977	STRLEN len = decode_uint (dec);
744	char key = (char )dec->cur;	978	char key = (char )dec->cur;
745		979
		980	WANT (len);
746	dec->cur += len;	981	dec->cur += len;
747		982
748	hv_store (hv, key, len, decode_sv (dec), 0);	983	hv_store (hv, key, len, decode_sv (dec), 0);
749		984
750	return;	985	return;
751	}	986	}
752	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))	987	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
753	{	988	{
754	I32 len = decode_uint (dec);	989	STRLEN len = decode_uint (dec);
755	char key = (char )dec->cur;	990	char key = (char )dec->cur;
756		991
		992	WANT (len);
757	dec->cur += len;	993	dec->cur += len;
758		994
759	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))	995	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
760	if (!is_utf8_string (key, len))	996	if (!cbor_is_utf8_string ((U8 *)key, len))
761	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");	997	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
762		998
763	hv_store (hv, key, -len, decode_sv (dec), 0);	999	hv_store (hv, key, -len, decode_sv (dec), 0);
764		1000
765	return;	1001	return;
766	}	1002	}
767		1003
768	SV *k = decode_sv (dec);	1004	SV *k = decode_sv (dec);
769	SV *v = decode_sv (dec);	1005	SV *v = decode_sv (dec);
770		1006
		1007	// we leak memory if uncaught exceptions are thrown by random magical
		1008	// methods, and this is hopefully the only place where it can happen,
		1009	// so if there is a chance of an exception, take the very slow path.
		1010	// since catching exceptions is "undocumented/internal/forbidden" by
		1011	// the new p5p powers, we need to call out to a perl function :/
		1012	if (ecb_expect_false (SvAMAGIC (k)))
		1013	{
		1014	dSP;
		1015
		1016	ENTER; SAVETMPS;
		1017	PUSHMARK (SP);
		1018	EXTEND (SP, 3);
		1019	PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
		1020	PUSHs (sv_2mortal (k));
		1021	PUSHs (sv_2mortal (v));
		1022
		1023	PUTBACK;
		1024	call_pv ("CBOR::XS::_hv_store", G_VOID \| G_DISCARD \| G_EVAL);
		1025	SPAGAIN;
		1026
		1027	FREETMPS; LEAVE;
		1028
		1029	if (SvTRUE (ERRSV))
		1030	ERR_ERRSV;
		1031
		1032	return;
		1033	}
		1034
771	hv_store_ent (hv, k, v, 0);	1035	hv_store_ent (hv, k, v, 0);
772	SvREFCNT_dec (k);	1036	SvREFCNT_dec_NN (k);
773		1037
774	fail:	1038	fail:
775	;	1039	;
776	}	1040	}
777		1041
…		…
788		1052
789	for (;;)	1053	for (;;)
790	{	1054	{
791	WANT (1);	1055	WANT (1);
792		1056
793	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF))	1057	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF) \|\| dec->err)
794	{	1058	{
795	++dec->cur;	1059	++dec->cur;
796	break;	1060	break;
797	}	1061	}
798		1062
799	decode_he (dec, hv);	1063	decode_he (dec, hv);
800	}	1064	}
801	}	1065	}
802	else	1066	else
803	{	1067	{
804	int pairs = decode_uint (dec);	1068	UV pairs = decode_uint (dec);
		1069
		1070	WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
805		1071
806	while (pairs--)	1072	while (pairs--)
807	decode_he (dec, hv);	1073	decode_he (dec, hv);
808	}	1074	}
809		1075
810	DEC_DEC_DEPTH;	1076	DEC_DEC_DEPTH;
811	return newRV_noinc ((SV *)hv);	1077	return newRV_noinc ((SV *)hv);
812		1078
813	fail:	1079	fail:
814	SvREFCNT_dec (hv);	1080	SvREFCNT_dec_NN (hv);
815	DEC_DEC_DEPTH;	1081	DEC_DEC_DEPTH;
816	return &PL_sv_undef;	1082	return &PL_sv_undef;
817	}	1083	}
818		1084
819	static SV *	1085	static SV *
820	decode_str (dec_t *dec, int utf8)	1086	decode_str (dec_t *dec, int utf8)
821	{	1087	{
822	SV *sv = 0;	1088	SV *sv = 0;
823		1089
824	if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)	1090	if (ecb_expect_false ((*dec->cur & MINOR_MASK) == MINOR_INDEF))
825	{	1091	{
826	// indefinite length strings	1092	// indefinite length strings
827	++dec->cur;	1093	++dec->cur;
828		1094
829	U8 major = *dec->cur & MAJOR_MISC;	1095	U8 major = *dec->cur & MAJOR_MISC;
…		…
864	}	1130	}
865		1131
866	if (utf8)	1132	if (utf8)
867	{	1133	{
868	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))	1134	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
869	if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))	1135	if (!cbor_is_utf8_string (SvPVX (sv), SvCUR (sv)))
870	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");	1136	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
871		1137
872	SvUTF8_on (sv);	1138	SvUTF8_on (sv);
873	}	1139	}
874		1140
…		…
897	sv = newRV_noinc (decode_sv (dec));	1163	sv = newRV_noinc (decode_sv (dec));
898	break;	1164	break;
899		1165
900	case CBOR_TAG_STRINGREF_NAMESPACE:	1166	case CBOR_TAG_STRINGREF_NAMESPACE:
901	{	1167	{
		1168	// do not use SAVETMPS/FREETMPS, as these will
		1169	// erase mortalised caches, e.g. "shareable"
902	ENTER; SAVETMPS;	1170	ENTER;
903		1171
904	SAVESPTR (dec->stringref);	1172	SAVESPTR (dec->stringref);
905	dec->stringref = (AV )sv_2mortal ((SV )newAV ());	1173	dec->stringref = (AV )sv_2mortal ((SV )newAV ());
906		1174
907	sv = decode_sv (dec);	1175	sv = decode_sv (dec);
908		1176
909	FREETMPS; LEAVE;	1177	LEAVE;
910	}	1178	}
911	break;	1179	break;
912		1180
913	case CBOR_TAG_STRINGREF:	1181	case CBOR_TAG_STRINGREF:
914	{	1182	{
915	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))	1183	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
916	ERR ("corrupted CBOR data (stringref index not an unsigned integer)");	1184	ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
917		1185
918	UV idx = decode_uint (dec);	1186	UV idx = decode_uint (dec);
919		1187
920	if (!dec->stringref \|\| (int)idx > AvFILLp (dec->stringref))	1188	if (!dec->stringref \|\| idx >= (UV)(1 + AvFILLp (dec->stringref)))
921	ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");	1189	ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
922		1190
923	sv = newSVsv (AvARRAY (dec->stringref)[idx]);	1191	sv = newSVsv (AvARRAY (dec->stringref)[idx]);
924	}	1192	}
925	break;	1193	break;
…		…
927	case CBOR_TAG_VALUE_SHAREABLE:	1195	case CBOR_TAG_VALUE_SHAREABLE:
928	{	1196	{
929	if (ecb_expect_false (!dec->shareable))	1197	if (ecb_expect_false (!dec->shareable))
930	dec->shareable = (AV )sv_2mortal ((SV )newAV ());	1198	dec->shareable = (AV )sv_2mortal ((SV )newAV ());
931		1199
932	if (dec->cbor.flags & F_ALLOW_CYCLES)	1200	if (ecb_expect_false (dec->cbor.flags & (F_ALLOW_CYCLES \| F_ALLOW_WEAK_CYCLES)))
933	{	1201	{
		1202	// if cycles are allowed, then we store an AV as value
		1203	// while it is being decoded, and gather unresolved
		1204	// references in it, to be re4solved after decoding.
		1205	int idx, i;
934	sv = newSV (0);	1206	AV *av = newAV ();
935	av_push (dec->shareable, SvREFCNT_inc_NN (sv));	1207	av_push (dec->shareable, (SV *)av);
		1208	idx = AvFILLp (dec->shareable);
936		1209
937	SV *osv = decode_sv (dec);	1210	sv = decode_sv (dec);
938	sv_setsv (sv, osv);	1211
		1212	// the AV now contains \undef for all unresolved references,
		1213	// so we fix them up here.
		1214	for (i = 0; i <= AvFILLp (av); ++i)
		1215	SvRV_set (AvARRAY (av)[i], SvREFCNT_inc_NN (SvRV (sv)));
		1216
		1217	// weaken all recursive references
		1218	if (dec->cbor.flags & F_ALLOW_WEAK_CYCLES)
		1219	for (i = 0; i <= AvFILLp (av); ++i)
		1220	sv_rvweaken (AvARRAY (av)[i]);
		1221
		1222	// now replace the AV by a reference to the completed value
939	SvREFCNT_dec_NN (osv);	1223	SvREFCNT_dec_NN ((SV *)av);
		1224	AvARRAY (dec->shareable)[idx] = SvREFCNT_inc_NN (sv);
940	}	1225	}
941	else	1226	else
942	{	1227	{
943	av_push (dec->shareable, &PL_sv_undef);	1228	av_push (dec->shareable, &PL_sv_undef);
944	int idx = AvFILLp (dec->shareable);	1229	int idx = AvFILLp (dec->shareable);
945	sv = decode_sv (dec);	1230	sv = decode_sv (dec);
946	av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));	1231	AvARRAY (dec->shareable)[idx] = SvREFCNT_inc_NN (sv);
947	}	1232	}
948	}	1233	}
949	break;	1234	break;
950		1235
951	case CBOR_TAG_VALUE_SHAREDREF:	1236	case CBOR_TAG_VALUE_SHAREDREF:
…		…
953	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))	1238	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
954	ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");	1239	ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
955		1240
956	UV idx = decode_uint (dec);	1241	UV idx = decode_uint (dec);
957		1242
958	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))	1243	if (!dec->shareable \|\| idx >= (UV)(1 + AvFILLp (dec->shareable)))
959	ERR ("corrupted CBOR data (sharedref index out of bounds)");	1244	ERR ("corrupted CBOR data (sharedref index out of bounds)");
960		1245
961	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);	1246	sv = AvARRAY (dec->shareable)[idx];
962		1247
963	if (sv == &PL_sv_undef)	1248	// reference to cycle, we create a new \undef and use that, and also
		1249	// registerr it in the AV for later fixing
		1250	if (ecb_expect_false (SvTYPE (sv) == SVt_PVAV))
		1251	{
		1252	AV av = (AV )sv;
		1253	sv = newRV_noinc (&PL_sv_undef);
		1254	av_push (av, SvREFCNT_inc_NN (sv));
		1255	}
		1256	else if (ecb_expect_false (sv == &PL_sv_undef)) // not yet decoded, but cycles not allowed
964	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");	1257	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
		1258	else // we decoded the object earlier, no cycle
		1259	sv = newSVsv (sv);
965	}	1260	}
966	break;	1261	break;
967		1262
968	case CBOR_TAG_PERL_OBJECT:	1263	case CBOR_TAG_PERL_OBJECT:
969	{	1264	{
		1265	if (dec->cbor.flags & F_FORBID_OBJECTS)
		1266	goto filter;
		1267
970	sv = decode_sv (dec);	1268	sv = decode_sv (dec);
971		1269
972	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)	1270	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
973	ERR ("corrupted CBOR data (non-array perl object)");	1271	ERR ("corrupted CBOR data (non-array perl object)");
974		1272
…		…
984	if (!method)	1282	if (!method)
985	ERR ("cannot decode perl-object (package does not have a THAW method)");	1283	ERR ("cannot decode perl-object (package does not have a THAW method)");
986		1284
987	dSP;	1285	dSP;
988		1286
989	ENTER; SAVETMPS; PUSHMARK (SP);	1287	ENTER; SAVETMPS;
		1288	PUSHMARK (SP);
990	EXTEND (SP, len + 1);	1289	EXTEND (SP, len + 1);
991	// we re-bless the reference to get overload and other niceties right	1290	// we re-bless the reference to get overload and other niceties right
992	PUSHs (*av_fetch (av, 0, 1));	1291	PUSHs (*av_fetch (av, 0, 1));
993	PUSHs (sv_cbor);	1292	PUSHs (sv_cbor);
994		1293
…		…
1002	SPAGAIN;	1301	SPAGAIN;
1003		1302
1004	if (SvTRUE (ERRSV))	1303	if (SvTRUE (ERRSV))
1005	{	1304	{
1006	FREETMPS; LEAVE;	1305	FREETMPS; LEAVE;
1007	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1306	ERR_ERRSV;
1008	}	1307	}
1009		1308
1010	SvREFCNT_dec (sv);	1309	SvREFCNT_dec_NN (sv);
1011	sv = SvREFCNT_inc (POPs);	1310	sv = SvREFCNT_inc (POPs);
1012		1311
1013	PUTBACK;	1312	PUTBACK;
1014		1313
1015	FREETMPS; LEAVE;	1314	FREETMPS; LEAVE;
1016	}	1315	}
1017	break;	1316	break;
1018		1317
1019	default:	1318	default:
		1319	filter:
1020	{	1320	{
		1321	SV *tag_sv = newSVuv (tag);
		1322
1021	sv = decode_sv (dec);	1323	sv = decode_sv (dec);
1022		1324
1023	dSP;	1325	dSP;
1024	ENTER; SAVETMPS; PUSHMARK (SP);	1326	ENTER; SAVETMPS;
		1327	PUSHMARK (SP);
1025	EXTEND (SP, 2);	1328	EXTEND (SP, 2);
1026	PUSHs (newSVuv (tag));	1329	PUSHs (tag_sv);
1027	PUSHs (sv);	1330	PUSHs (sv);
1028		1331
1029	PUTBACK;	1332	PUTBACK;
1030	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);	1333	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);
1031	SPAGAIN;	1334	SPAGAIN;
1032		1335
1033	if (SvTRUE (ERRSV))	1336	if (SvTRUE (ERRSV))
1034	{	1337	{
		1338	SvREFCNT_dec_NN (tag_sv);
1035	FREETMPS; LEAVE;	1339	FREETMPS; LEAVE;
1036	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1340	ERR_ERRSV;
1037	}	1341	}
1038		1342
1039	if (count)	1343	if (count)
1040	{	1344	{
		1345	SvREFCNT_dec_NN (tag_sv);
1041	SvREFCNT_dec (sv);	1346	SvREFCNT_dec_NN (sv);
1042	sv = SvREFCNT_inc (POPs);	1347	sv = SvREFCNT_inc_NN (TOPs);
		1348	SP -= count;
1043	}	1349	}
1044	else	1350	else
1045	{	1351	{
1046	AV *av = newAV ();	1352	AV *av = newAV ();
1047	av_push (av, newSVuv (tag));	1353	av_push (av, tag_sv);
1048	av_push (av, sv);	1354	av_push (av, sv);
1049		1355
1050	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	1356	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
1051	? cbor_tagged_stash	1357	? cbor_tagged_stash
1052	: gv_stashpv ("CBOR::XS::Tagged" , 1);	1358	: gv_stashpv ("CBOR::XS::Tagged" , 1);
…		…
1155	}	1461	}
1156		1462
1157	static SV *	1463	static SV *
1158	decode_cbor (SV string, CBOR cbor, char **offset_return)	1464	decode_cbor (SV string, CBOR cbor, char **offset_return)
1159	{	1465	{
1160	dec_t dec = { };	1466	dec_t dec = { 0 };
1161	SV *sv;	1467	SV *sv;
1162	STRLEN len;	1468	STRLEN len;
1163	char *data = SvPVbyte (string, len);	1469	char *data = SvPVbyte (string, len);
1164		1470
1165	if (len > cbor->max_size && cbor->max_size)	1471	if (len > cbor->max_size && cbor->max_size)
…		…
1181		1487
1182	if (dec.err)	1488	if (dec.err)
1183	{	1489	{
1184	if (dec.shareable)	1490	if (dec.shareable)
1185	{	1491	{
1186	// need to break cyclic links, which whould all be in shareable	1492	// need to break cyclic links, which would all be in shareable
1187	int i;	1493	int i;
1188	SV **svp;	1494	SV **svp;
1189		1495
1190	for (i = av_len (dec.shareable) + 1; i--; )	1496	for (i = av_len (dec.shareable) + 1; i--; )
1191	if ((svp = av_fetch (dec.shareable, i, 0)))	1497	if ((svp = av_fetch (dec.shareable, i, 0)))
1192	sv_setsv (*svp, &PL_sv_undef);	1498	sv_setsv (*svp, &PL_sv_undef);
1193	}	1499	}
1194		1500
1195	SvREFCNT_dec (sv);	1501	SvREFCNT_dec_NN (sv);
		1502
		1503	if (dec.err_sv)
		1504	sv_2mortal (dec.err_sv);
		1505
1196	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1506	croak ("%s, at offset %ld (octet 0x%02x)", dec.err, (long)(dec.cur - (U8 )data), (int)(uint8_t)dec.cur);
1197	}	1507	}
1198		1508
1199	sv = sv_2mortal (sv);	1509	sv = sv_2mortal (sv);
1200		1510
1201	return sv;	1511	return sv;
…		…
1256		1566
1257	int major = *p >> MAJOR_SHIFT;	1567	int major = *p >> MAJOR_SHIFT;
1258		1568
1259	switch (major)	1569	switch (major)
1260	{	1570	{
		1571	case MAJOR_TAG >> MAJOR_SHIFT:
		1572	++count; // tags merely prefix another value
		1573	break;
		1574
1261	case MAJOR_BYTES >> MAJOR_SHIFT:	1575	case MAJOR_BYTES >> MAJOR_SHIFT:
1262	case MAJOR_TEXT >> MAJOR_SHIFT:	1576	case MAJOR_TEXT >> MAJOR_SHIFT:
1263	case MAJOR_ARRAY >> MAJOR_SHIFT:	1577	case MAJOR_ARRAY >> MAJOR_SHIFT:
1264	case MAJOR_MAP >> MAJOR_SHIFT:	1578	case MAJOR_MAP >> MAJOR_SHIFT:
1265	{	1579	{
…		…
1286		1600
1287	break;	1601	break;
1288		1602
1289	case MAJOR_MAP >> MAJOR_SHIFT:	1603	case MAJOR_MAP >> MAJOR_SHIFT:
1290	len <<= 1;	1604	len <<= 1;
		1605	/* FALLTHROUGH */
1291	case MAJOR_ARRAY >> MAJOR_SHIFT:	1606	case MAJOR_ARRAY >> MAJOR_SHIFT:
1292	if (len)	1607	if (len)
1293	{	1608	{
1294	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest	1609	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
1295	count = len + 1;	1610	count = len + 1;
…		…
1340		1655
1341	default_filter = newSVpv ("CBOR::XS::default_filter", 0);	1656	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1342		1657
1343	sv_cbor = newSVpv ("CBOR", 0);	1658	sv_cbor = newSVpv ("CBOR", 0);
1344	SvREADONLY_on (sv_cbor);	1659	SvREADONLY_on (sv_cbor);
		1660
		1661	assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1345	}	1662	}
1346		1663
1347	PROTOTYPES: DISABLE	1664	PROTOTYPES: DISABLE
1348		1665
1349	void CLONE (...)	1666	void CLONE (...)
…		…
1365	)));	1682	)));
1366	}	1683	}
1367		1684
1368	void shrink (CBOR *self, int enable = 1)	1685	void shrink (CBOR *self, int enable = 1)
1369	ALIAS:	1686	ALIAS:
1370	shrink = F_SHRINK	1687	shrink = F_SHRINK
1371	allow_unknown = F_ALLOW_UNKNOWN	1688	allow_unknown = F_ALLOW_UNKNOWN
1372	allow_sharing = F_ALLOW_SHARING	1689	allow_sharing = F_ALLOW_SHARING
1373	allow_cycles = F_ALLOW_CYCLES	1690	allow_cycles = F_ALLOW_CYCLES
		1691	allow_weak_cycles = F_ALLOW_WEAK_CYCLES
		1692	forbid_objects = F_FORBID_OBJECTS
1374	pack_strings = F_PACK_STRINGS	1693	pack_strings = F_PACK_STRINGS
		1694	text_keys = F_TEXT_KEYS
		1695	text_strings = F_TEXT_STRINGS
1375	validate_utf8 = F_VALIDATE_UTF8	1696	validate_utf8 = F_VALIDATE_UTF8
1376	PPCODE:	1697	PPCODE:
1377	{	1698	{
1378	if (enable)	1699	if (enable)
1379	self->flags \|= ix;	1700	self->flags \|= ix;
1380	else	1701	else
…		…
1383	XPUSHs (ST (0));	1704	XPUSHs (ST (0));
1384	}	1705	}
1385		1706
1386	void get_shrink (CBOR *self)	1707	void get_shrink (CBOR *self)
1387	ALIAS:	1708	ALIAS:
1388	get_shrink = F_SHRINK	1709	get_shrink = F_SHRINK
1389	get_allow_unknown = F_ALLOW_UNKNOWN	1710	get_allow_unknown = F_ALLOW_UNKNOWN
1390	get_allow_sharing = F_ALLOW_SHARING	1711	get_allow_sharing = F_ALLOW_SHARING
1391	get_allow_cycles = F_ALLOW_CYCLES	1712	get_allow_cycles = F_ALLOW_CYCLES
		1713	get_allow_weak_cycles = F_ALLOW_WEAK_CYCLES
		1714	get_forbid_objects = F_FORBID_OBJECTS
1392	get_pack_strings = F_PACK_STRINGS	1715	get_pack_strings = F_PACK_STRINGS
		1716	get_text_keys = F_TEXT_KEYS
		1717	get_text_strings = F_TEXT_STRINGS
1393	get_validate_utf8 = F_VALIDATE_UTF8	1718	get_validate_utf8 = F_VALIDATE_UTF8
1394	PPCODE:	1719	PPCODE:
1395	XPUSHs (boolSV (self->flags & ix));	1720	XPUSHs (boolSV (self->flags & ix));
1396		1721
1397	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1722	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1398	PPCODE:	1723	PPCODE:
…		…
1527	cbor_init (&cbor);	1852	cbor_init (&cbor);
1528	PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN;	1853	PUTBACK; cborstr = decode_cbor (cborstr, &cbor, 0); SPAGAIN;
1529	XPUSHs (cborstr);	1854	XPUSHs (cborstr);
1530	}	1855	}
1531		1856
		1857	#ifdef __AFL_COMPILER
		1858
		1859	void
		1860	afl_init ()
		1861	CODE:
		1862	__AFL_INIT ();
		1863
		1864	int
		1865	afl_loop (unsigned int count = 10000)
		1866	CODE:
		1867	RETVAL = __AFL_LOOP (count);
		1868	OUTPUT:
		1869	RETVAL
		1870
		1871	#endif
		1872

Diff Legend

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

Comparing CBOR-XS/XS.xs (file contents): Revision 1.43 by root, Sun Jan 5 14:24:54 2014 UTC vs. Revision 1.80 by root, Fri Sep 8 20:03:06 2023 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.43 by root, Sun Jan 5 14:24:54 2014 UTC vs.
Revision 1.80 by root, Fri Sep 8 20:03:06 2023 UTC