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

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

Diff Legend

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

Comparing CBOR-XS/XS.xs (file contents): Revision 1.49 by root, Mon Feb 8 04:11:11 2016 UTC vs. Revision 1.77 by root, Fri Sep 8 05:47:10 2023 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.49 by root, Mon Feb 8 04:11:11 2016 UTC vs.
Revision 1.77 by root, Fri Sep 8 05:47:10 2023 UTC