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

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.28 by root, Sat Nov 23 18:30:59 2013 UTC vs.
Revision 1.60 by root, Sat Nov 26 00:47:02 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))
…		…
23	#endif	24	#endif
24	#ifndef SvREFCNT_dec_NN	25	#ifndef SvREFCNT_dec_NN
25	# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)	26	# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
26	#endif	27	#endif
27		28
		29	// known major and minor types
		30	enum cbor_type
		31	{
		32	MAJOR_SHIFT = 5,
		33	MINOR_MASK = 0x1f,
		34
		35	MAJOR_POS_INT = 0 << MAJOR_SHIFT,
		36	MAJOR_NEG_INT = 1 << MAJOR_SHIFT,
		37	MAJOR_BYTES = 2 << MAJOR_SHIFT,
		38	MAJOR_TEXT = 3 << MAJOR_SHIFT,
		39	MAJOR_ARRAY = 4 << MAJOR_SHIFT,
		40	MAJOR_MAP = 5 << MAJOR_SHIFT,
		41	MAJOR_TAG = 6 << MAJOR_SHIFT,
		42	MAJOR_MISC = 7 << MAJOR_SHIFT,
		43
		44	// INT/STRING/ARRAY/MAP subtypes
		45	LENGTH_EXT1 = 24,
		46	LENGTH_EXT2 = 25,
		47	LENGTH_EXT4 = 26,
		48	LENGTH_EXT8 = 27,
		49
		50	// SIMPLE types (effectively MISC subtypes)
		51	SIMPLE_FALSE = 20,
		52	SIMPLE_TRUE = 21,
		53	SIMPLE_NULL = 22,
		54	SIMPLE_UNDEF = 23,
		55
		56	// MISC subtype (unused)
		57	MISC_EXT1 = 24,
		58	MISC_FLOAT16 = 25,
		59	MISC_FLOAT32 = 26,
		60	MISC_FLOAT64 = 27,
		61
		62	// BYTES/TEXT/ARRAY/MAP
		63	MINOR_INDEF = 31,
		64	};
		65
28	// known tags	66	// known tags
29	enum cbor_tag	67	enum cbor_tag
30	{	68	{
31	// inofficial extensions (pending iana registration)	69	// extensions
		70	CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
32	CBOR_TAG_PERL_OBJECT = 24, // http://cbor.schmorp.de/perl-object	71	CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
33	CBOR_TAG_GENERIC_OBJECT = 25, // http://cbor.schmorp.de/generic-object	72	CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
34	CBOR_TAG_VALUE_SHAREABLE = 26, // http://cbor.schmorp.de/value-sharing	73	CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
35	CBOR_TAG_VALUE_SHAREDREF = 27, // http://cbor.schmorp.de/value-sharing	74	CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
36	CBOR_TAG_STRINGREF_NAMESPACE = 65537, // http://cbor.schmorp.de/stringref	75	CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
37	CBOR_TAG_STRINGREF = 28, // http://cbor.schmorp.de/stringref
38	CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection	76	CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
39		77
40	// rfc7049	78	// rfc7049
41	CBOR_TAG_DATETIME = 0, // rfc4287, utf-8	79	CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
42	CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any	80	CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
43	CBOR_TAG_POS_BIGNUM = 2, // byte string	81	CBOR_TAG_POS_BIGNUM = 2, // byte string
44	CBOR_TAG_NEG_BIGNUM = 3, // byte string	82	CBOR_TAG_NEG_BIGNUM = 3, // byte string
45	CBOR_TAG_DECIMAL = 4, // decimal fraction, array	83	CBOR_TAG_DECIMAL = 4, // decimal fraction, array
46	CBOR_TAG_BIGFLOAT = 5, // array	84	CBOR_TAG_BIGFLOAT = 5, // array
47		85
48	CBOR_TAG_CONV_B64U = 21, // base64url, any	86	CBOR_TAG_CONV_B64U = 21, // base64url, any
49	CBOR_TAG_CONV_B64 = 22, // base64, any	87	CBOR_TAG_CONV_B64 = 22, // base64, any
50	CBOR_TAG_CONV_HEX = 23, // base16, any	88	CBOR_TAG_CONV_HEX = 23, // base16, any
51	CBOR_TAG_CBOR = 24, // embedded cbor, byte string	89	CBOR_TAG_CBOR = 24, // embedded cbor, byte string
52		90
53	CBOR_TAG_URI = 32, // URI rfc3986, utf-8	91	CBOR_TAG_URI = 32, // URI rfc3986, utf-8
54	CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8	92	CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
55	CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8	93	CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
56	CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8	94	CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
57	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8	95	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
58		96
59	CBOR_TAG_MAGIC = 55799 // self-describe cbor	97	CBOR_TAG_MAGIC = 55799, // self-describe cbor
60	};	98	};
61		99
62	#define F_SHRINK 0x00000001UL	100	#define F_SHRINK 0x00000001UL
63	#define F_ALLOW_UNKNOWN 0x00000002UL	101	#define F_ALLOW_UNKNOWN 0x00000002UL
64	#define F_ALLOW_SHARING 0x00000004UL //TODO	102	#define F_ALLOW_SHARING 0x00000004UL
65	#define F_ALLOW_STRINGREF 0x00000008UL //TODO	103	#define F_ALLOW_CYCLES 0x00000008UL
		104	#define F_FORBID_OBJECTS 0x00000010UL
		105	#define F_PACK_STRINGS 0x00000020UL
		106	#define F_TEXT_KEYS 0x00000040UL
		107	#define F_TEXT_STRINGS 0x00000080UL
		108	#define F_VALIDATE_UTF8 0x00000100UL
66		109
67	#define INIT_SIZE 32 // initial scalar size to be allocated	110	#define INIT_SIZE 32 // initial scalar size to be allocated
68		111
69	#define SB do {	112	#define SB do {
70	#define SE } while (0)	113	#define SE } while (0)
…		…
89	typedef struct {	132	typedef struct {
90	U32 flags;	133	U32 flags;
91	U32 max_depth;	134	U32 max_depth;
92	STRLEN max_size;	135	STRLEN max_size;
93	SV *filter;	136	SV *filter;
		137
		138	// for the incremental parser
		139	STRLEN incr_pos; // the current offset into the text
		140	STRLEN incr_need; // minimum bytes needed to decode
		141	AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
94	} CBOR;	142	} CBOR;
95		143
96	ecb_inline void	144	ecb_inline void
97	cbor_init (CBOR *cbor)	145	cbor_init (CBOR *cbor)
98	{	146	{
…		…
102		150
103	ecb_inline void	151	ecb_inline void
104	cbor_free (CBOR *cbor)	152	cbor_free (CBOR *cbor)
105	{	153	{
106	SvREFCNT_dec (cbor->filter);	154	SvREFCNT_dec (cbor->filter);
		155	SvREFCNT_dec (cbor->incr_count);
107	}	156	}
108		157
109	/////////////////////////////////////////////////////////////////////////////	158	/////////////////////////////////////////////////////////////////////////////
110	// utility functions	159	// utility functions
111		160
…		…
141	{	190	{
142	return idx > 23	191	return idx > 23
143	? idx > 0xffU	192	? idx > 0xffU
144	? idx > 0xffffU	193	? idx > 0xffffU
145	? idx > 0xffffffffU	194	? idx > 0xffffffffU
		195	? 11
146	? 7	196	: 7
147	: 6
148	: 5	197	: 5
149	: 4	198	: 4
150	: 3;	199	: 3;
151	}	200	}
152		201
…		…
189	static void	238	static void
190	encode_uint (enc_t *enc, int major, UV len)	239	encode_uint (enc_t *enc, int major, UV len)
191	{	240	{
192	need (enc, 9);	241	need (enc, 9);
193		242
194	if (len < 24)	243	if (ecb_expect_true (len < LENGTH_EXT1))
195	*enc->cur++ = major \| len;	244	*enc->cur++ = major \| len;
196	else if (len <= 0xff)	245	else if (ecb_expect_true (len <= 0xffU))
197	{	246	{
198	*enc->cur++ = major \| 24;	247	*enc->cur++ = major \| LENGTH_EXT1;
199	*enc->cur++ = len;	248	*enc->cur++ = len;
200	}	249	}
201	else if (len <= 0xffff)	250	else if (len <= 0xffffU)
202	{	251	{
203	*enc->cur++ = major \| 25;	252	*enc->cur++ = major \| LENGTH_EXT2;
204	*enc->cur++ = len >> 8;	253	*enc->cur++ = len >> 8;
205	*enc->cur++ = len;	254	*enc->cur++ = len;
206	}	255	}
207	else if (len <= 0xffffffff)	256	else if (len <= 0xffffffffU)
208	{	257	{
209	*enc->cur++ = major \| 26;	258	*enc->cur++ = major \| LENGTH_EXT4;
210	*enc->cur++ = len >> 24;	259	*enc->cur++ = len >> 24;
211	*enc->cur++ = len >> 16;	260	*enc->cur++ = len >> 16;
212	*enc->cur++ = len >> 8;	261	*enc->cur++ = len >> 8;
213	*enc->cur++ = len;	262	*enc->cur++ = len;
214	}	263	}
215	else	264	else
216	{	265	{
217	*enc->cur++ = major \| 27;	266	*enc->cur++ = major \| LENGTH_EXT8;
218	*enc->cur++ = len >> 56;	267	*enc->cur++ = len >> 56;
219	*enc->cur++ = len >> 48;	268	*enc->cur++ = len >> 48;
220	*enc->cur++ = len >> 40;	269	*enc->cur++ = len >> 40;
221	*enc->cur++ = len >> 32;	270	*enc->cur++ = len >> 32;
222	*enc->cur++ = len >> 24;	271	*enc->cur++ = len >> 24;
…		…
227	}	276	}
228		277
229	ecb_inline void	278	ecb_inline void
230	encode_tag (enc_t *enc, UV tag)	279	encode_tag (enc_t *enc, UV tag)
231	{	280	{
232	encode_uint (enc, 0xc0, tag);	281	encode_uint (enc, MAJOR_TAG, tag);
233	}	282	}
234		283
235	static void	284	// exceptional (hopefully) slow path for byte strings that need to be utf8-encoded
		285	ecb_noinline static void
236	encode_str (enc_t enc, int utf8, char str, STRLEN len)	286	encode_str_utf8 (enc_t enc, int utf8, char str, STRLEN len)
237	{	287	{
		288	STRLEN ulen = len;
		289	U8 p, pend = (U8 *)str + len;
		290
		291	for (p = (U8 *)str; p < pend; ++p)
		292	ulen += *p >> 7; // count set high bits
		293
		294	encode_uint (enc, MAJOR_TEXT, ulen);
		295
		296	need (enc, ulen);
		297	for (p = (U8 *)str; p < pend; ++p)
		298	if (*p < 0x80)
		299	enc->cur++ = p;
		300	else
		301	{
		302	enc->cur++ = 0xc0 + (p >> 6);
		303	enc->cur++ = 0x80 + (p & 63);
		304	}
		305	}
		306
		307	ecb_inline void
		308	encode_str (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
		309	{
		310	if (ecb_expect_false (upgrade_utf8))
		311	if (!utf8)
		312	{
		313	encode_str_utf8 (enc, utf8, str, len);
		314	return;
		315	}
		316
		317	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
		318	need (enc, len);
		319	memcpy (enc->cur, str, len);
		320	enc->cur += len;
		321	}
		322
		323	ecb_inline void
		324	encode_strref (enc_t enc, int upgrade_utf8, int utf8, char str, STRLEN len)
		325	{
238	if (ecb_expect_false (enc->cbor.flags & F_ALLOW_STRINGREF))	326	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
239	{	327	{
240	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);	328	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
241		329
242	if (SvOK (*svp))	330	if (SvOK (*svp))
243	{	331	{
244	// already registered, use stringref	332	// already registered, use stringref
245	encode_tag (enc, CBOR_TAG_STRINGREF);	333	encode_tag (enc, CBOR_TAG_STRINGREF);
246	encode_uint (enc, 0x00, SvUV (*svp));	334	encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
247	return;	335	return;
248	}	336	}
249	else if (len >= minimum_string_length (enc->stringref_idx))	337	else if (len >= minimum_string_length (enc->stringref_idx))
250	{	338	{
251	// register only	339	// register only
252	sv_setuv (*svp, enc->stringref_idx);	340	sv_setuv (*svp, enc->stringref_idx);
253	++enc->stringref_idx;	341	++enc->stringref_idx;
254	}	342	}
255	}	343	}
256		344
257	encode_uint (enc, utf8 ? 0x60 : 0x40, len);	345	encode_str (enc, upgrade_utf8, utf8, str, len);
258	need (enc, len);
259	memcpy (enc->cur, str, len);
260	enc->cur += len;
261	}	346	}
262		347
263	static void encode_sv (enc_t enc, SV sv);	348	static void encode_sv (enc_t enc, SV sv);
264		349
265	static void	350	static void
…		…
270	if (enc->depth >= enc->cbor.max_depth)	355	if (enc->depth >= enc->cbor.max_depth)
271	croak (ERR_NESTING_EXCEEDED);	356	croak (ERR_NESTING_EXCEEDED);
272		357
273	++enc->depth;	358	++enc->depth;
274		359
275	encode_uint (enc, 0x80, len + 1);	360	encode_uint (enc, MAJOR_ARRAY, len + 1);
276		361
		362	if (SvMAGICAL (av))
277	for (i = 0; i <= len; ++i)	363	for (i = 0; i <= len; ++i)
278	{	364	{
279	SV **svp = av_fetch (av, i, 0);	365	SV **svp = av_fetch (av, i, 0);
280	encode_sv (enc, svp ? *svp : &PL_sv_undef);	366	encode_sv (enc, svp ? *svp : &PL_sv_undef);
281	}	367	}
		368	else
		369	for (i = 0; i <= len; ++i)
		370	{
		371	SV *sv = AvARRAY (av)[i];
		372	encode_sv (enc, sv ? sv : &PL_sv_undef);
		373	}
282		374
283	--enc->depth;	375	--enc->depth;
284	}	376	}
285		377
286	static void	378	static void
…		…
295		387
296	int pairs = hv_iterinit (hv);	388	int pairs = hv_iterinit (hv);
297	int mg = SvMAGICAL (hv);	389	int mg = SvMAGICAL (hv);
298		390
299	if (mg)	391	if (mg)
300	encode_ch (enc, 0xa0 \| 31);	392	encode_ch (enc, MAJOR_MAP \| MINOR_INDEF);
301	else	393	else
302	encode_uint (enc, 0xa0, pairs);	394	encode_uint (enc, MAJOR_MAP, pairs);
303		395
304	while ((he = hv_iternext (hv)))	396	while ((he = hv_iternext (hv)))
305	{	397	{
306	if (HeKLEN (he) == HEf_SVKEY)	398	if (HeKLEN (he) == HEf_SVKEY)
307	encode_sv (enc, HeSVKEY (he));	399	encode_sv (enc, HeSVKEY (he));
308	else	400	else
309	encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	401	encode_strref (enc, enc->cbor.flags & (F_TEXT_KEYS \| F_TEXT_STRINGS), HeKUTF8 (he), HeKEY (he), HeKLEN (he));
310		402
311	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	403	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
312	}	404	}
313		405
314	if (mg)	406	if (mg)
315	encode_ch (enc, 0xe0 \| 31);	407	encode_ch (enc, MAJOR_MISC \| MINOR_INDEF);
316		408
317	--enc->depth;	409	--enc->depth;
318	}	410	}
319		411
320	// encode objects, arrays and special \0=false and \1=true values.	412	// encode objects, arrays and special \0=false and \1=true values.
321	static void	413	static void
322	encode_rv (enc_t enc, SV sv)	414	encode_rv (enc_t enc, SV sv)
323	{	415	{
324	SvGETMAGIC (sv);	416	SvGETMAGIC (sv);
325
326	if (ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING)
327	&& ecb_expect_false (SvREFCNT (sv) > 1))
328	{
329	if (!enc->shareable)
330	enc->shareable = (HV )sv_2mortal ((SV )newHV ());
331
332	SV *svp = hv_fetch (enc->shareable, (char )&sv, sizeof (sv), 1);
333
334	if (SvOK (*svp))
335	{
336	encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
337	encode_uint (enc, 0x00, SvUV (*svp));
338	return;
339	}
340	else
341	{
342	sv_setuv (*svp, enc->shareable_idx);
343	++enc->shareable_idx;
344	encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
345	}
346	}
347		417
348	svtype svt = SvTYPE (sv);	418	svtype svt = SvTYPE (sv);
349		419
350	if (ecb_expect_false (SvOBJECT (sv)))	420	if (ecb_expect_false (SvOBJECT (sv)))
351	{	421	{
…		…
358	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	428	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
359	? cbor_tagged_stash	429	? cbor_tagged_stash
360	: gv_stashpv ("CBOR::XS::Tagged" , 1);	430	: gv_stashpv ("CBOR::XS::Tagged" , 1);
361		431
362	HV *stash = SvSTASH (sv);	432	HV *stash = SvSTASH (sv);
363	GV *method;
364		433
365	if (stash == boolean_stash)	434	if (stash == boolean_stash)
366	encode_ch (enc, SvIV (sv) ? 0xe0 \| 21 : 0xe0 \| 20);	435	{
		436	encode_ch (enc, SvIV (sv) ? MAJOR_MISC \| SIMPLE_TRUE : MAJOR_MISC \| SIMPLE_FALSE);
		437	return;
		438	}
367	else if (stash == error_stash)	439	else if (stash == error_stash)
368	encode_ch (enc, 0xe0 \| 23);	440	{
		441	encode_ch (enc, MAJOR_MISC \| SIMPLE_UNDEF);
		442	return;
		443	}
369	else if (stash == tagged_stash)	444	else if (stash == tagged_stash)
370	{	445	{
371	if (svt != SVt_PVAV)	446	if (svt != SVt_PVAV)
372	croak ("encountered CBOR::XS::Tagged object that isn't an array");	447	croak ("encountered CBOR::XS::Tagged object that isn't an array");
373		448
374	encode_uint (enc, 0xc0, SvUV (av_fetch ((AV )sv, 0, 1)));	449	encode_uint (enc, MAJOR_TAG, SvUV (av_fetch ((AV )sv, 0, 1)));
375	encode_sv (enc, av_fetch ((AV )sv, 1, 1));	450	encode_sv (enc, av_fetch ((AV )sv, 1, 1));
		451
		452	return;
		453	}
		454	}
		455
		456	if (ecb_expect_false (SvREFCNT (sv) > 1)
		457	&& ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
		458	{
		459	if (!enc->shareable)
		460	enc->shareable = (HV )sv_2mortal ((SV )newHV ());
		461
		462	SV *svp = hv_fetch (enc->shareable, (char )&sv, sizeof (sv), 1);
		463
		464	if (SvOK (*svp))
376	}	465	{
		466	encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
		467	encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
		468	return;
		469	}
		470	else
		471	{
		472	sv_setuv (*svp, enc->shareable_idx);
		473	++enc->shareable_idx;
		474	encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
		475	}
		476	}
		477
		478	if (ecb_expect_false (SvOBJECT (sv)))
		479	{
		480	HV *stash = SvSTASH (sv);
		481	GV *method;
		482
		483	if (enc->cbor.flags & F_FORBID_OBJECTS)
		484	croak ("encountered object '%s', but forbid_objects is enabled",
		485	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
377	else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))	486	else if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
378	{	487	{
379	dSP;	488	dSP;
380		489
381	ENTER; SAVETMPS; PUSHMARK (SP);	490	ENTER; SAVETMPS;
		491	PUSHMARK (SP);
382	// we re-bless the reference to get overload and other niceties right	492	// we re-bless the reference to get overload and other niceties right
383	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	493	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
384		494
385	PUTBACK;	495	PUTBACK;
386	// G_SCALAR ensures that return value is 1	496	// G_SCALAR ensures that return value is 1
…		…
399	}	509	}
400	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)	510	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
401	{	511	{
402	dSP;	512	dSP;
403		513
404	ENTER; SAVETMPS; PUSHMARK (SP);	514	ENTER; SAVETMPS;
		515	SAVESTACK_POS ();
		516	PUSHMARK (SP);
405	EXTEND (SP, 2);	517	EXTEND (SP, 2);
406	// we re-bless the reference to get overload and other niceties right	518	// we re-bless the reference to get overload and other niceties right
407	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));	519	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
408	PUSHs (sv_cbor);	520	PUSHs (sv_cbor);
409		521
…		…
414	// catch this surprisingly common error	526	// catch this surprisingly common error
415	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)	527	if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
416	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));	528	croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
417		529
418	encode_tag (enc, CBOR_TAG_PERL_OBJECT);	530	encode_tag (enc, CBOR_TAG_PERL_OBJECT);
419	encode_uint (enc, 0x80, count + 1);	531	encode_uint (enc, MAJOR_ARRAY, count + 1);
420	encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));	532	encode_strref (enc, 0, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
421		533
422	while (count)	534	while (count)
423	encode_sv (enc, SP[1 - count--]);	535	encode_sv (enc, SP[1 - count--]);
424		536
425	PUTBACK;	537	PUTBACK;
…		…
446	{	558	{
447	double nv = SvNVX (sv);	559	double nv = SvNVX (sv);
448		560
449	need (enc, 9);	561	need (enc, 9);
450		562
451	if (ecb_expect_false (nv == (U32)nv))	563	if (ecb_expect_false (nv == (NV)(U32)nv))
452	encode_uint (enc, 0x00, (U32)nv);	564	encode_uint (enc, MAJOR_POS_INT, (U32)nv);
453	//TODO: maybe I32?	565	//TODO: maybe I32?
454	else if (ecb_expect_false (nv == (float)nv))	566	else if (ecb_expect_false (nv == (float)nv))
455	{	567	{
456	uint32_t fp = ecb_float_to_binary32 (nv);	568	uint32_t fp = ecb_float_to_binary32 (nv);
457		569
458	*enc->cur++ = 0xe0 \| 26;	570	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT32;
459		571
460	if (!ecb_big_endian ())	572	if (!ecb_big_endian ())
461	fp = ecb_bswap32 (fp);	573	fp = ecb_bswap32 (fp);
462		574
463	memcpy (enc->cur, &fp, 4);	575	memcpy (enc->cur, &fp, 4);
…		…
465	}	577	}
466	else	578	else
467	{	579	{
468	uint64_t fp = ecb_double_to_binary64 (nv);	580	uint64_t fp = ecb_double_to_binary64 (nv);
469		581
470	*enc->cur++ = 0xe0 \| 27;	582	*enc->cur++ = MAJOR_MISC \| MISC_FLOAT64;
471		583
472	if (!ecb_big_endian ())	584	if (!ecb_big_endian ())
473	fp = ecb_bswap64 (fp);	585	fp = ecb_bswap64 (fp);
474		586
475	memcpy (enc->cur, &fp, 8);	587	memcpy (enc->cur, &fp, 8);
…		…
484		596
485	if (SvPOKp (sv))	597	if (SvPOKp (sv))
486	{	598	{
487	STRLEN len;	599	STRLEN len;
488	char *str = SvPV (sv, len);	600	char *str = SvPV (sv, len);
489	encode_str (enc, SvUTF8 (sv), str, len);	601	encode_strref (enc, enc->cbor.flags & F_TEXT_STRINGS, SvUTF8 (sv), str, len);
490	}	602	}
491	else if (SvNOKp (sv))	603	else if (SvNOKp (sv))
492	encode_nv (enc, sv);	604	encode_nv (enc, sv);
493	else if (SvIOKp (sv))	605	else if (SvIOKp (sv))
494	{	606	{
495	if (SvIsUV (sv))	607	if (SvIsUV (sv))
496	encode_uint (enc, 0x00, SvUVX (sv));	608	encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
497	else if (SvIVX (sv) >= 0)	609	else if (SvIVX (sv) >= 0)
498	encode_uint (enc, 0x00, SvIVX (sv));	610	encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
499	else	611	else
500	encode_uint (enc, 0x20, -(SvIVX (sv) + 1));	612	encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
501	}	613	}
502	else if (SvROK (sv))	614	else if (SvROK (sv))
503	encode_rv (enc, SvRV (sv));	615	encode_rv (enc, SvRV (sv));
504	else if (!SvOK (sv))	616	else if (!SvOK (sv))
505	encode_ch (enc, 0xe0 \| 22);	617	encode_ch (enc, MAJOR_MISC \| SIMPLE_NULL);
506	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)	618	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
507	encode_ch (enc, 0xe0 \| 23);	619	encode_ch (enc, MAJOR_MISC \| SIMPLE_UNDEF);
508	else	620	else
509	croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",	621	croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
510	SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));	622	SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
511	}	623	}
512		624
513	static SV *	625	static SV *
514	encode_cbor (SV scalar, CBOR cbor)	626	encode_cbor (SV scalar, CBOR cbor)
515	{	627	{
516	enc_t enc = { };	628	enc_t enc = { 0 };
517		629
518	enc.cbor = *cbor;	630	enc.cbor = *cbor;
519	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));	631	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
520	enc.cur = SvPVX (enc.sv);	632	enc.cur = SvPVX (enc.sv);
521	enc.end = SvEND (enc.sv);	633	enc.end = SvEND (enc.sv);
522		634
523	SvPOK_only (enc.sv);	635	SvPOK_only (enc.sv);
524		636
525	if (cbor->flags & F_ALLOW_STRINGREF)	637	if (cbor->flags & F_PACK_STRINGS)
526	{	638	{
527	encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);	639	encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
528	enc.stringref[0]= (HV )sv_2mortal ((SV )newHV ());	640	enc.stringref[0]= (HV )sv_2mortal ((SV )newHV ());
529	enc.stringref[1]= (HV )sv_2mortal ((SV )newHV ());	641	enc.stringref[1]= (HV )sv_2mortal ((SV )newHV ());
530	}	642	}
…		…
553	U32 depth; // recursion depth	665	U32 depth; // recursion depth
554	U32 maxdepth; // recursion depth limit	666	U32 maxdepth; // recursion depth limit
555	AV *shareable;	667	AV *shareable;
556	AV *stringref;	668	AV *stringref;
557	SV *decode_tagged;	669	SV *decode_tagged;
		670	SV *err_sv; // optional sv for error, needs to be freed
558	} dec_t;	671	} dec_t;
559		672
560	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	673	// set dec->err to ERRSV
		674	ecb_cold static void
		675	err_errsv (dec_t *dec)
		676	{
		677	if (!dec->err)
		678	{
		679	dec->err_sv = newSVsv (ERRSV);
561		680
562	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	681	// chop off the trailing \n
		682	SvCUR_set (dec->err_sv, SvCUR (dec->err_sv) - 1);
		683	*SvEND (dec->err_sv) = 0;
563		684
		685	dec->err = SvPVutf8_nolen (dec->err_sv);
		686	}
		687	}
		688
		689	// the following functions are used to reduce code size and help the compiler to optimise
		690	ecb_cold static void
		691	err_set (dec_t dec, const char reason)
		692	{
		693	if (!dec->err)
		694	dec->err = reason;
		695	}
		696
		697	ecb_cold static void
		698	err_unexpected_end (dec_t *dec)
		699	{
		700	err_set (dec, "unexpected end of CBOR data");
		701	}
		702
		703	ecb_cold static void
		704	err_nesting_exceeded (dec_t *dec)
		705	{
		706	err_set (dec, ERR_NESTING_EXCEEDED);
		707	}
		708
		709	#define ERR_DO(do) SB do; goto fail; SE
		710	#define ERR(reason) ERR_DO (err_set (dec, reason))
		711	#define ERR_ERRSV ERR_DO (err_errsv (dec))
		712
		713	#define WANT(len) if (ecb_expect_false ((UV)(dec->end - dec->cur) < (UV)len)) ERR_DO (err_unexpected_end (dec))
		714
564	#define DEC_INC_DEPTH if (++dec->depth > dec->cbor.max_depth) ERR (ERR_NESTING_EXCEEDED)	715	#define DEC_INC_DEPTH if (ecb_expect_false (++dec->depth > dec->cbor.max_depth)) ERR (ERR_NESTING_EXCEEDED)
565	#define DEC_DEC_DEPTH --dec->depth	716	#define DEC_DEC_DEPTH --dec->depth
566		717
567	static UV	718	static UV
568	decode_uint (dec_t *dec)	719	decode_uint (dec_t *dec)
569	{	720	{
570	switch (*dec->cur & 31)	721	U8 m = *dec->cur & MINOR_MASK;
571	{	722	++dec->cur;
572	case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
573	case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
574	case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
575	return *dec->cur++ & 31;
576		723
577	case 24:	724	if (ecb_expect_true (m < LENGTH_EXT1))
		725	return m;
		726	else if (ecb_expect_true (m == LENGTH_EXT1))
		727	{
578	WANT (2);	728	WANT (1);
579	dec->cur += 2;	729	dec->cur += 1;
580	return dec->cur[-1];	730	return dec->cur[-1];
581		731	}
582	case 25:	732	else if (ecb_expect_true (m == LENGTH_EXT2))
		733	{
583	WANT (3);	734	WANT (2);
584	dec->cur += 3;	735	dec->cur += 2;
585	return (((UV)dec->cur[-2]) << 8)	736	return (((UV)dec->cur[-2]) << 8)
586	\| ((UV)dec->cur[-1]);	737	\| ((UV)dec->cur[-1]);
587		738	}
588	case 26:	739	else if (ecb_expect_true (m == LENGTH_EXT4))
		740	{
589	WANT (5);	741	WANT (4);
590	dec->cur += 5;	742	dec->cur += 4;
591	return (((UV)dec->cur[-4]) << 24)	743	return (((UV)dec->cur[-4]) << 24)
592	\| (((UV)dec->cur[-3]) << 16)	744	\| (((UV)dec->cur[-3]) << 16)
593	\| (((UV)dec->cur[-2]) << 8)	745	\| (((UV)dec->cur[-2]) << 8)
594	\| ((UV)dec->cur[-1]);	746	\| ((UV)dec->cur[-1]);
595		747	}
596	case 27:	748	else if (ecb_expect_true (m == LENGTH_EXT8))
		749	{
597	WANT (9);	750	WANT (8);
598	dec->cur += 9;	751	dec->cur += 8;
		752
		753	return
		754	#if UVSIZE < 8
		755	0
		756	#else
599	return (((UV)dec->cur[-8]) << 56)	757	(((UV)dec->cur[-8]) << 56)
600	\| (((UV)dec->cur[-7]) << 48)	758	\| (((UV)dec->cur[-7]) << 48)
601	\| (((UV)dec->cur[-6]) << 40)	759	\| (((UV)dec->cur[-6]) << 40)
602	\| (((UV)dec->cur[-5]) << 32)	760	\| (((UV)dec->cur[-5]) << 32)
		761	#endif
603	\| (((UV)dec->cur[-4]) << 24)	762	\| (((UV)dec->cur[-4]) << 24)
604	\| (((UV)dec->cur[-3]) << 16)	763	\| (((UV)dec->cur[-3]) << 16)
605	\| (((UV)dec->cur[-2]) << 8)	764	\| (((UV)dec->cur[-2]) << 8)
606	\| ((UV)dec->cur[-1]);	765	\| ((UV)dec->cur[-1]);
607		766	}
608	default:	767	else
609	ERR ("corrupted CBOR data (unsupported integer minor encoding)");	768	ERR ("corrupted CBOR data (unsupported integer minor encoding)");
610	}
611		769
612	fail:	770	fail:
613	return 0;	771	return 0;
614	}	772	}
615		773
…		…
620	{	778	{
621	AV *av = newAV ();	779	AV *av = newAV ();
622		780
623	DEC_INC_DEPTH;	781	DEC_INC_DEPTH;
624		782
625	if ((*dec->cur & 31) == 31)	783	if (*dec->cur == (MAJOR_ARRAY \| MINOR_INDEF))
626	{	784	{
627	++dec->cur;	785	++dec->cur;
628		786
629	for (;;)	787	for (;;)
630	{	788	{
631	WANT (1);	789	WANT (1);
632		790
633	if (*dec->cur == (0xe0 \| 31))	791	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF))
634	{	792	{
635	++dec->cur;	793	++dec->cur;
636	break;	794	break;
637	}	795	}
638		796
639	av_push (av, decode_sv (dec));	797	av_push (av, decode_sv (dec));
640	}	798	}
641	}	799	}
642	else	800	else
643	{	801	{
644	int i, len = decode_uint (dec);	802	UV i, len = decode_uint (dec);
645		803
		804	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
646	av_fill (av, len - 1);	805	av_fill (av, len - 1);
647		806
648	for (i = 0; i < len; ++i)	807	for (i = 0; i < len; ++i)
649	AvARRAY (av)[i] = decode_sv (dec);	808	AvARRAY (av)[i] = decode_sv (dec);
650	}	809	}
…		…
663	{	822	{
664	// for speed reasons, we specialcase single-string	823	// for speed reasons, we specialcase single-string
665	// byte or utf-8 strings as keys, but only when !stringref	824	// byte or utf-8 strings as keys, but only when !stringref
666		825
667	if (ecb_expect_true (!dec->stringref))	826	if (ecb_expect_true (!dec->stringref))
668	if (dec->cur >= 0x40 && dec->cur <= 0x40 + 27)	827	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
669	{	828	{
670	I32 len = decode_uint (dec);	829	STRLEN len = decode_uint (dec);
671	char key = (char )dec->cur;	830	char key = (char )dec->cur;
672		831
		832	WANT (len);
673	dec->cur += len;	833	dec->cur += len;
674		834
675	if (ecb_expect_false (dec->stringref))
676	av_push (dec->stringref, newSVpvn (key, len));
677
678	hv_store (hv, key, len, decode_sv (dec), 0);	835	hv_store (hv, key, len, decode_sv (dec), 0);
679		836
680	return;	837	return;
681	}	838	}
682	else if (dec->cur >= 0x60 && dec->cur <= 0x60 + 27)	839	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
683	{	840	{
684	I32 len = decode_uint (dec);	841	STRLEN len = decode_uint (dec);
685	char key = (char )dec->cur;	842	char key = (char )dec->cur;
686		843
		844	WANT (len);
687	dec->cur += len;	845	dec->cur += len;
688		846
689	if (ecb_expect_false (dec->stringref))	847	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
690	av_push (dec->stringref, newSVpvn_utf8 (key, len, 1));	848	if (!is_utf8_string (key, len))
		849	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
691		850
692	hv_store (hv, key, -len, decode_sv (dec), 0);	851	hv_store (hv, key, -len, decode_sv (dec), 0);
693		852
694	return;	853	return;
695	}	854	}
696		855
697	SV *k = decode_sv (dec);	856	SV *k = decode_sv (dec);
698	SV *v = decode_sv (dec);	857	SV *v = decode_sv (dec);
699		858
		859	// we leak memory if uncaught exceptions are thrown by random magical
		860	// methods, and this is hopefully the only place where it can happen,
		861	// so if there is a chance of an exception, take the very slow path.
		862	// since catching exceptions is "undocumented/internal/forbidden" by
		863	// the new p5p powers, we need to call out to a perl function :/
		864	if (ecb_expect_false (SvAMAGIC (k)))
		865	{
		866	dSP;
		867
		868	ENTER; SAVETMPS;
		869	PUSHMARK (SP);
		870	EXTEND (SP, 3);
		871	PUSHs (sv_2mortal (newRV_inc ((SV *)hv)));
		872	PUSHs (sv_2mortal (k));
		873	PUSHs (sv_2mortal (v));
		874
		875	PUTBACK;
		876	call_pv ("CBOR::XS::_hv_store", G_VOID \| G_DISCARD \| G_EVAL);
		877	SPAGAIN;
		878
		879	FREETMPS; LEAVE;
		880
		881	if (SvTRUE (ERRSV))
		882	ERR_ERRSV;
		883
		884	return;
		885	}
		886
700	hv_store_ent (hv, k, v, 0);	887	hv_store_ent (hv, k, v, 0);
701	SvREFCNT_dec (k);	888	SvREFCNT_dec (k);
		889
		890	fail:
		891	;
702	}	892	}
703		893
704	static SV *	894	static SV *
705	decode_hv (dec_t *dec)	895	decode_hv (dec_t *dec)
706	{	896	{
707	HV *hv = newHV ();	897	HV *hv = newHV ();
708		898
709	DEC_INC_DEPTH;	899	DEC_INC_DEPTH;
710		900
711	if ((*dec->cur & 31) == 31)	901	if (*dec->cur == (MAJOR_MAP \| MINOR_INDEF))
712	{	902	{
713	++dec->cur;	903	++dec->cur;
714		904
715	for (;;)	905	for (;;)
716	{	906	{
717	WANT (1);	907	WANT (1);
718		908
719	if (*dec->cur == (0xe0 \| 31))	909	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF))
720	{	910	{
721	++dec->cur;	911	++dec->cur;
722	break;	912	break;
723	}	913	}
724		914
725	decode_he (dec, hv);	915	decode_he (dec, hv);
726	}	916	}
727	}	917	}
728	else	918	else
729	{	919	{
730	int pairs = decode_uint (dec);	920	UV pairs = decode_uint (dec);
		921
		922	WANT (pairs); // complexity check - need at least one byte per value, do not allow supersize hashes
731		923
732	while (pairs--)	924	while (pairs--)
733	decode_he (dec, hv);	925	decode_he (dec, hv);
734	}	926	}
735		927
…		…
745	static SV *	937	static SV *
746	decode_str (dec_t *dec, int utf8)	938	decode_str (dec_t *dec, int utf8)
747	{	939	{
748	SV *sv = 0;	940	SV *sv = 0;
749		941
750	if ((*dec->cur & 31) == 31)	942	if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
751	{	943	{
		944	// indefinite length strings
752	++dec->cur;	945	++dec->cur;
753		946
		947	U8 major = *dec->cur & MAJOR_MISC;
		948
754	sv = newSVpvn ("", 0);	949	sv = newSVpvn ("", 0);
755		950
756	// not very fast, and certainly not robust against illegal input
757	for (;;)	951	for (;;)
758	{	952	{
759	WANT (1);	953	WANT (1);
760		954
761	if (*dec->cur == (0xe0 \| 31))	955	if ((*dec->cur - major) > LENGTH_EXT8)
		956	if (*dec->cur == (MAJOR_MISC \| MINOR_INDEF))
762	{	957	{
763	++dec->cur;	958	++dec->cur;
764	break;	959	break;
765	}	960	}
		961	else
		962	ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
766		963
767	sv_catsv (sv, decode_sv (dec));	964	STRLEN len = decode_uint (dec);
		965
		966	WANT (len);
		967	sv_catpvn (sv, dec->cur, len);
		968	dec->cur += len;
768	}	969	}
769	}	970	}
770	else	971	else
771	{	972	{
772	STRLEN len = decode_uint (dec);	973	STRLEN len = decode_uint (dec);
…		…
779	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))	980	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
780	av_push (dec->stringref, SvREFCNT_inc_NN (sv));	981	av_push (dec->stringref, SvREFCNT_inc_NN (sv));
781	}	982	}
782		983
783	if (utf8)	984	if (utf8)
		985	{
		986	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
		987	if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
		988	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
		989
784	SvUTF8_on (sv);	990	SvUTF8_on (sv);
		991	}
785		992
786	return sv;	993	return sv;
787		994
788	fail:	995	fail:
789	SvREFCNT_dec (sv);	996	SvREFCNT_dec (sv);
…		…
808	sv = newRV_noinc (decode_sv (dec));	1015	sv = newRV_noinc (decode_sv (dec));
809	break;	1016	break;
810		1017
811	case CBOR_TAG_STRINGREF_NAMESPACE:	1018	case CBOR_TAG_STRINGREF_NAMESPACE:
812	{	1019	{
		1020	// do nmot use SAVETMPS/FREETMPS, as these will
		1021	// erase mortalised caches, e.g. "shareable"
813	ENTER; SAVETMPS;	1022	ENTER;
814		1023
815	SAVESPTR (dec->stringref);	1024	SAVESPTR (dec->stringref);
816	dec->stringref = (AV )sv_2mortal ((SV )newAV ());	1025	dec->stringref = (AV )sv_2mortal ((SV )newAV ());
817		1026
818	sv = decode_sv (dec);	1027	sv = decode_sv (dec);
819		1028
820	FREETMPS; LEAVE;	1029	LEAVE;
821	}	1030	}
822	break;	1031	break;
823		1032
824	case CBOR_TAG_STRINGREF:	1033	case CBOR_TAG_STRINGREF:
825	{	1034	{
826	if ((*dec->cur >> 5) != 0)	1035	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
827	ERR ("corrupted CBOR data (stringref index not an unsigned integer)");	1036	ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
828		1037
829	UV idx = decode_uint (dec);	1038	UV idx = decode_uint (dec);
830		1039
831	if (!dec->stringref \|\| (int)idx > AvFILLp (dec->stringref))	1040	if (!dec->stringref \|\| (int)idx > AvFILLp (dec->stringref))
…		…
838	case CBOR_TAG_VALUE_SHAREABLE:	1047	case CBOR_TAG_VALUE_SHAREABLE:
839	{	1048	{
840	if (ecb_expect_false (!dec->shareable))	1049	if (ecb_expect_false (!dec->shareable))
841	dec->shareable = (AV )sv_2mortal ((SV )newAV ());	1050	dec->shareable = (AV )sv_2mortal ((SV )newAV ());
842		1051
		1052	if (dec->cbor.flags & F_ALLOW_CYCLES)
		1053	{
843	sv = newSV (0);	1054	sv = newSV (0);
844	av_push (dec->shareable, SvREFCNT_inc_NN (sv));	1055	av_push (dec->shareable, SvREFCNT_inc_NN (sv));
845		1056
846	SV *osv = decode_sv (dec);	1057	SV *osv = decode_sv (dec);
847	sv_setsv (sv, osv);	1058	sv_setsv (sv, osv);
848	SvREFCNT_dec_NN (osv);	1059	SvREFCNT_dec_NN (osv);
		1060	}
		1061	else
		1062	{
		1063	av_push (dec->shareable, &PL_sv_undef);
		1064	int idx = AvFILLp (dec->shareable);
		1065	sv = decode_sv (dec);
		1066	av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
		1067	}
849	}	1068	}
850	break;	1069	break;
851		1070
852	case CBOR_TAG_VALUE_SHAREDREF:	1071	case CBOR_TAG_VALUE_SHAREDREF:
853	{	1072	{
854	if ((*dec->cur >> 5) != 0)	1073	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
855	ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");	1074	ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
856		1075
857	UV idx = decode_uint (dec);	1076	UV idx = decode_uint (dec);
858		1077
859	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))	1078	if (!dec->shareable \|\| (int)idx > AvFILLp (dec->shareable))
860	ERR ("corrupted CBOR data (sharedref index out of bounds)");	1079	ERR ("corrupted CBOR data (sharedref index out of bounds)");
861		1080
862	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);	1081	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
		1082
		1083	if (sv == &PL_sv_undef)
		1084	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
863	}	1085	}
864	break;	1086	break;
865		1087
866	case CBOR_TAG_PERL_OBJECT:	1088	case CBOR_TAG_PERL_OBJECT:
867	{	1089	{
		1090	if (dec->cbor.flags & F_FORBID_OBJECTS)
		1091	goto filter;
		1092
868	sv = decode_sv (dec);	1093	sv = decode_sv (dec);
869		1094
870	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)	1095	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
871	ERR ("corrupted CBOR data (non-array perl object)");	1096	ERR ("corrupted CBOR data (non-array perl object)");
872		1097
…		…
882	if (!method)	1107	if (!method)
883	ERR ("cannot decode perl-object (package does not have a THAW method)");	1108	ERR ("cannot decode perl-object (package does not have a THAW method)");
884		1109
885	dSP;	1110	dSP;
886		1111
887	ENTER; SAVETMPS; PUSHMARK (SP);	1112	ENTER; SAVETMPS;
		1113	PUSHMARK (SP);
888	EXTEND (SP, len + 1);	1114	EXTEND (SP, len + 1);
889	// we re-bless the reference to get overload and other niceties right	1115	// we re-bless the reference to get overload and other niceties right
890	PUSHs (*av_fetch (av, 0, 1));	1116	PUSHs (*av_fetch (av, 0, 1));
891	PUSHs (sv_cbor);	1117	PUSHs (sv_cbor);
892		1118
…		…
900	SPAGAIN;	1126	SPAGAIN;
901		1127
902	if (SvTRUE (ERRSV))	1128	if (SvTRUE (ERRSV))
903	{	1129	{
904	FREETMPS; LEAVE;	1130	FREETMPS; LEAVE;
905	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1131	ERR_ERRSV;
906	}	1132	}
907		1133
908	SvREFCNT_dec (sv);	1134	SvREFCNT_dec (sv);
909	sv = SvREFCNT_inc (POPs);	1135	sv = SvREFCNT_inc (POPs);
910		1136
…		…
913	FREETMPS; LEAVE;	1139	FREETMPS; LEAVE;
914	}	1140	}
915	break;	1141	break;
916		1142
917	default:	1143	default:
		1144	filter:
918	{	1145	{
		1146	SV *tag_sv = newSVuv (tag);
		1147
919	sv = decode_sv (dec);	1148	sv = decode_sv (dec);
920		1149
921	dSP;	1150	dSP;
922	ENTER; SAVETMPS; PUSHMARK (SP);	1151	ENTER; SAVETMPS;
		1152	SAVESTACK_POS ();
		1153	PUSHMARK (SP);
923	EXTEND (SP, 2);	1154	EXTEND (SP, 2);
924	PUSHs (newSVuv (tag));	1155	PUSHs (tag_sv);
925	PUSHs (sv);	1156	PUSHs (sv);
926		1157
927	PUTBACK;	1158	PUTBACK;
928	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);	1159	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY \| G_EVAL);
929	SPAGAIN;	1160	SPAGAIN;
930		1161
931	if (SvTRUE (ERRSV))	1162	if (SvTRUE (ERRSV))
932	{	1163	{
		1164	SvREFCNT_dec (tag_sv);
933	FREETMPS; LEAVE;	1165	FREETMPS; LEAVE;
934	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));	1166	ERR_ERRSV;
935	}	1167	}
936		1168
937	if (count)	1169	if (count)
938	{	1170	{
		1171	SvREFCNT_dec (tag_sv);
939	SvREFCNT_dec (sv);	1172	SvREFCNT_dec (sv);
940	sv = SvREFCNT_inc (POPs);	1173	sv = SvREFCNT_inc (POPs);
941	}	1174	}
942	else	1175	else
943	{	1176	{
944	AV *av = newAV ();	1177	AV *av = newAV ();
945	av_push (av, newSVuv (tag));	1178	av_push (av, tag_sv);
946	av_push (av, sv);	1179	av_push (av, sv);
947		1180
948	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash	1181	HV *tagged_stash = !CBOR_SLOW \|\| cbor_tagged_stash
949	? cbor_tagged_stash	1182	? cbor_tagged_stash
950	: gv_stashpv ("CBOR::XS::Tagged" , 1);	1183	: gv_stashpv ("CBOR::XS::Tagged" , 1);
…		…
968	static SV *	1201	static SV *
969	decode_sv (dec_t *dec)	1202	decode_sv (dec_t *dec)
970	{	1203	{
971	WANT (1);	1204	WANT (1);
972		1205
973	switch (*dec->cur >> 5)	1206	switch (*dec->cur >> MAJOR_SHIFT)
974	{	1207	{
975	case 0: // unsigned int	1208	case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
976	return newSVuv (decode_uint (dec));	1209	case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
977	case 1: // negative int	1210	case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
978	return newSViv (-1 - (IV)decode_uint (dec));	1211	case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
979	case 2: // octet string	1212	case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
980	return decode_str (dec, 0);	1213	case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
981	case 3: // utf-8 string	1214	case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
982	return decode_str (dec, 1);	1215
983	case 4: // array	1216	case MAJOR_MISC >> MAJOR_SHIFT:
984	return decode_av (dec);
985	case 5: // map
986	return decode_hv (dec);
987	case 6: // tag
988	return decode_tagged (dec);
989	case 7: // misc
990	switch (*dec->cur++ & 31)	1217	switch (*dec->cur++ & MINOR_MASK)
991	{	1218	{
992	case 20:	1219	case SIMPLE_FALSE:
993	#if CBOR_SLOW	1220	#if CBOR_SLOW
994	types_false = get_bool ("Types::Serialiser::false");	1221	types_false = get_bool ("Types::Serialiser::false");
995	#endif	1222	#endif
996	return newSVsv (types_false);	1223	return newSVsv (types_false);
997	case 21:	1224	case SIMPLE_TRUE:
998	#if CBOR_SLOW	1225	#if CBOR_SLOW
999	types_true = get_bool ("Types::Serialiser::true");	1226	types_true = get_bool ("Types::Serialiser::true");
1000	#endif	1227	#endif
1001	return newSVsv (types_true);	1228	return newSVsv (types_true);
1002	case 22:	1229	case SIMPLE_NULL:
1003	return newSVsv (&PL_sv_undef);	1230	return newSVsv (&PL_sv_undef);
1004	case 23:	1231	case SIMPLE_UNDEF:
1005	#if CBOR_SLOW	1232	#if CBOR_SLOW
1006	types_error = get_bool ("Types::Serialiser::error");	1233	types_error = get_bool ("Types::Serialiser::error");
1007	#endif	1234	#endif
1008	return newSVsv (types_error);	1235	return newSVsv (types_error);
1009		1236
1010	case 25:	1237	case MISC_FLOAT16:
1011	{	1238	{
1012	WANT (2);	1239	WANT (2);
1013		1240
1014	uint16_t fp = (dec->cur[0] << 8) \| dec->cur[1];	1241	uint16_t fp = (dec->cur[0] << 8) \| dec->cur[1];
1015	dec->cur += 2;	1242	dec->cur += 2;
1016		1243
1017	return newSVnv (ecb_binary16_to_float (fp));	1244	return newSVnv (ecb_binary16_to_float (fp));
1018	}	1245	}
1019		1246
1020	case 26:	1247	case MISC_FLOAT32:
1021	{	1248	{
1022	uint32_t fp;	1249	uint32_t fp;
1023	WANT (4);	1250	WANT (4);
1024	memcpy (&fp, dec->cur, 4);	1251	memcpy (&fp, dec->cur, 4);
1025	dec->cur += 4;	1252	dec->cur += 4;
…		…
1028	fp = ecb_bswap32 (fp);	1255	fp = ecb_bswap32 (fp);
1029		1256
1030	return newSVnv (ecb_binary32_to_float (fp));	1257	return newSVnv (ecb_binary32_to_float (fp));
1031	}	1258	}
1032		1259
1033	case 27:	1260	case MISC_FLOAT64:
1034	{	1261	{
1035	uint64_t fp;	1262	uint64_t fp;
1036	WANT (8);	1263	WANT (8);
1037	memcpy (&fp, dec->cur, 8);	1264	memcpy (&fp, dec->cur, 8);
1038	dec->cur += 8;	1265	dec->cur += 8;
…		…
1041	fp = ecb_bswap64 (fp);	1268	fp = ecb_bswap64 (fp);
1042		1269
1043	return newSVnv (ecb_binary64_to_double (fp));	1270	return newSVnv (ecb_binary64_to_double (fp));
1044	}	1271	}
1045		1272
1046	// 0..19 unassigned	1273	// 0..19 unassigned simple
1047	// 24 reserved + unassigned (reserved values are not encodable)	1274	// 24 reserved + unassigned simple (reserved values are not encodable)
		1275	// 28-30 unassigned misc
		1276	// 31 break code
1048	default:	1277	default:
1049	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");	1278	ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
1050	}	1279	}
1051		1280
1052	break;	1281	break;
1053	}	1282	}
1054		1283
…		…
1057	}	1286	}
1058		1287
1059	static SV *	1288	static SV *
1060	decode_cbor (SV string, CBOR cbor, char **offset_return)	1289	decode_cbor (SV string, CBOR cbor, char **offset_return)
1061	{	1290	{
1062	dec_t dec = { };	1291	dec_t dec = { 0 };
1063	SV *sv;	1292	SV *sv;
1064	STRLEN len;	1293	STRLEN len;
1065	char *data = SvPVbyte (string, len);	1294	char *data = SvPVbyte (string, len);
1066		1295
1067	if (len > cbor->max_size && cbor->max_size)	1296	if (len > cbor->max_size && cbor->max_size)
…		…
1081	if (dec.cur != dec.end && !dec.err)	1310	if (dec.cur != dec.end && !dec.err)
1082	dec.err = "garbage after CBOR object";	1311	dec.err = "garbage after CBOR object";
1083		1312
1084	if (dec.err)	1313	if (dec.err)
1085	{	1314	{
		1315	if (dec.shareable)
		1316	{
		1317	// need to break cyclic links, which would all be in shareable
		1318	int i;
		1319	SV **svp;
		1320
		1321	for (i = av_len (dec.shareable) + 1; i--; )
		1322	if ((svp = av_fetch (dec.shareable, i, 0)))
		1323	sv_setsv (*svp, &PL_sv_undef);
		1324	}
		1325
1086	SvREFCNT_dec (sv);	1326	SvREFCNT_dec (sv);
		1327
		1328	if (dec.err_sv)
		1329	sv_2mortal (dec.err_sv);
		1330
1087	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);	1331	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 )data, (int)(uint8_t)dec.cur);
1088	}	1332	}
1089		1333
1090	sv = sv_2mortal (sv);	1334	sv = sv_2mortal (sv);
1091		1335
1092	return sv;	1336	return sv;
1093	}	1337	}
1094		1338
		1339	/////////////////////////////////////////////////////////////////////////////
		1340	// incremental parser
		1341
		1342	#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
		1343
		1344	// returns 0 for notyet, 1 for success or error
		1345	static int
		1346	incr_parse (CBOR self, SV cborstr)
		1347	{
		1348	STRLEN cur;
		1349	SvPV (cborstr, cur);
		1350
		1351	while (ecb_expect_true (self->incr_need <= cur))
		1352	{
		1353	// table of integer count bytes
		1354	static I8 incr_len[MINOR_MASK + 1] = {
		1355	0, 0, 0, 0, 0, 0, 0, 0,
		1356	0, 0, 0, 0, 0, 0, 0, 0,
		1357	0, 0, 0, 0, 0, 0, 0, 0,
		1358	1, 2, 4, 8,-1,-1,-1,-2
		1359	};
		1360
		1361	const U8 *p = SvPVX (cborstr) + self->incr_pos;
		1362	U8 m = *p & MINOR_MASK;
		1363	IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1364	I8 ilen = incr_len[m];
		1365
		1366	self->incr_need = self->incr_pos + 1;
		1367
		1368	if (ecb_expect_false (ilen < 0))
		1369	{
		1370	if (m != MINOR_INDEF)
		1371	return 1; // error
		1372
		1373	if (*p == (MAJOR_MISC \| MINOR_INDEF))
		1374	{
		1375	if (count >= 0)
		1376	return 1; // error
		1377
		1378	count = 1;
		1379	}
		1380	else
		1381	{
		1382	av_push (self->incr_count, newSViv (-1)); //TODO: nest
		1383	count = -1;
		1384	}
		1385	}
		1386	else
		1387	{
		1388	self->incr_need += ilen;
		1389	if (ecb_expect_false (self->incr_need > cur))
		1390	return 0;
		1391
		1392	int major = *p >> MAJOR_SHIFT;
		1393
		1394	switch (major)
		1395	{
		1396	case MAJOR_TAG >> MAJOR_SHIFT:
		1397	++count; // tags merely prefix another value
		1398	break;
		1399
		1400	case MAJOR_BYTES >> MAJOR_SHIFT:
		1401	case MAJOR_TEXT >> MAJOR_SHIFT:
		1402	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1403	case MAJOR_MAP >> MAJOR_SHIFT:
		1404	{
		1405	UV len;
		1406
		1407	if (ecb_expect_false (ilen))
		1408	{
		1409	len = 0;
		1410
		1411	do {
		1412	len = (len << 8) \| *++p;
		1413	} while (--ilen);
		1414	}
		1415	else
		1416	len = m;
		1417
		1418	switch (major)
		1419	{
		1420	case MAJOR_BYTES >> MAJOR_SHIFT:
		1421	case MAJOR_TEXT >> MAJOR_SHIFT:
		1422	self->incr_need += len;
		1423	if (ecb_expect_false (self->incr_need > cur))
		1424	return 0;
		1425
		1426	break;
		1427
		1428	case MAJOR_MAP >> MAJOR_SHIFT:
		1429	len <<= 1;
		1430	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1431	if (len)
		1432	{
		1433	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
		1434	count = len + 1;
		1435	}
		1436	break;
		1437	}
		1438	}
		1439	}
		1440	}
		1441
		1442	self->incr_pos = self->incr_need;
		1443
		1444	if (count > 0)
		1445	{
		1446	while (!--count)
		1447	{
		1448	if (!AvFILLp (self->incr_count))
		1449	return 1; // done
		1450
		1451	SvREFCNT_dec_NN (av_pop (self->incr_count));
		1452	count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1453	}
		1454
		1455	SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
		1456	}
		1457	}
		1458
		1459	return 0;
		1460	}
		1461
		1462
1095	/////////////////////////////////////////////////////////////////////////////	1463	/////////////////////////////////////////////////////////////////////////////
1096	// XS interface functions	1464	// XS interface functions
1097		1465
1098	MODULE = CBOR::XS PACKAGE = CBOR::XS	1466	MODULE = CBOR::XS PACKAGE = CBOR::XS
1099		1467
…		…
1111		1479
1112	default_filter = newSVpv ("CBOR::XS::default_filter", 0);	1480	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1113		1481
1114	sv_cbor = newSVpv ("CBOR", 0);	1482	sv_cbor = newSVpv ("CBOR", 0);
1115	SvREADONLY_on (sv_cbor);	1483	SvREADONLY_on (sv_cbor);
		1484
		1485	assert (("STRLEN must be an unsigned type", 0 <= (STRLEN)-1));
1116	}	1486	}
1117		1487
1118	PROTOTYPES: DISABLE	1488	PROTOTYPES: DISABLE
1119		1489
1120	void CLONE (...)	1490	void CLONE (...)
…		…
1139	void shrink (CBOR *self, int enable = 1)	1509	void shrink (CBOR *self, int enable = 1)
1140	ALIAS:	1510	ALIAS:
1141	shrink = F_SHRINK	1511	shrink = F_SHRINK
1142	allow_unknown = F_ALLOW_UNKNOWN	1512	allow_unknown = F_ALLOW_UNKNOWN
1143	allow_sharing = F_ALLOW_SHARING	1513	allow_sharing = F_ALLOW_SHARING
1144	allow_stringref = F_ALLOW_STRINGREF	1514	allow_cycles = F_ALLOW_CYCLES
		1515	forbid_objects = F_FORBID_OBJECTS
		1516	pack_strings = F_PACK_STRINGS
		1517	text_keys = F_TEXT_KEYS
		1518	text_strings = F_TEXT_STRINGS
		1519	validate_utf8 = F_VALIDATE_UTF8
1145	PPCODE:	1520	PPCODE:
1146	{	1521	{
1147	if (enable)	1522	if (enable)
1148	self->flags \|= ix;	1523	self->flags \|= ix;
1149	else	1524	else
…		…
1155	void get_shrink (CBOR *self)	1530	void get_shrink (CBOR *self)
1156	ALIAS:	1531	ALIAS:
1157	get_shrink = F_SHRINK	1532	get_shrink = F_SHRINK
1158	get_allow_unknown = F_ALLOW_UNKNOWN	1533	get_allow_unknown = F_ALLOW_UNKNOWN
1159	get_allow_sharing = F_ALLOW_SHARING	1534	get_allow_sharing = F_ALLOW_SHARING
1160	get_allow_stringref = F_ALLOW_STRINGREF	1535	get_allow_cycles = F_ALLOW_CYCLES
		1536	get_forbid_objects = F_FORBID_OBJECTS
		1537	get_pack_strings = F_PACK_STRINGS
		1538	get_text_keys = F_TEXT_KEYS
		1539	get_text_strings = F_TEXT_STRINGS
		1540	get_validate_utf8 = F_VALIDATE_UTF8
1161	PPCODE:	1541	PPCODE:
1162	XPUSHs (boolSV (self->flags & ix));	1542	XPUSHs (boolSV (self->flags & ix));
1163		1543
1164	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1544	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1165	PPCODE:	1545	PPCODE:
…		…
1214	EXTEND (SP, 2);	1594	EXTEND (SP, 2);
1215	PUSHs (sv);	1595	PUSHs (sv);
1216	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));	1596	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1217	}	1597	}
1218		1598
		1599	void incr_parse (CBOR self, SV cborstr)
		1600	ALIAS:
		1601	incr_parse_multiple = 1
		1602	PPCODE:
		1603	{
		1604	if (SvUTF8 (cborstr))
		1605	sv_utf8_downgrade (cborstr, 0);
		1606
		1607	if (!self->incr_count)
		1608	{
		1609	self->incr_count = newAV ();
		1610	self->incr_pos = 0;
		1611	self->incr_need = 1;
		1612
		1613	av_push (self->incr_count, newSViv (1));
		1614	}
		1615
		1616	do
		1617	{
		1618	if (!incr_parse (self, cborstr))
		1619	{
		1620	if (self->incr_need > self->max_size && self->max_size)
		1621	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
		1622	(unsigned long)self->incr_need, (unsigned long)self->max_size);
		1623
		1624	break;
		1625	}
		1626
		1627	SV *sv;
		1628	char *offset;
		1629
		1630	PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
		1631	XPUSHs (sv);
		1632
		1633	sv_chop (cborstr, offset);
		1634
		1635	av_clear (self->incr_count);
		1636	av_push (self->incr_count, newSViv (1));
		1637
		1638	self->incr_pos = 0;
		1639	self->incr_need = self->incr_pos + 1;
		1640	}
		1641	while (ix);
		1642	}
		1643
		1644	void incr_reset (CBOR *self)
		1645	CODE:
		1646	{
		1647	SvREFCNT_dec (self->incr_count);
		1648	self->incr_count = 0;
		1649	}
		1650
1219	void DESTROY (CBOR *self)	1651	void DESTROY (CBOR *self)
1220	PPCODE:	1652	PPCODE:
1221	cbor_free (self);	1653	cbor_free (self);
1222		1654
1223	PROTOTYPES: ENABLE	1655	PROTOTYPES: ENABLE
1224		1656
1225	void encode_cbor (SV *scalar)	1657	void encode_cbor (SV *scalar)
		1658	ALIAS:
		1659	encode_cbor = 0
		1660	encode_cbor_sharing = F_ALLOW_SHARING
1226	PPCODE:	1661	PPCODE:
1227	{	1662	{
1228	CBOR cbor;	1663	CBOR cbor;
1229	cbor_init (&cbor);	1664	cbor_init (&cbor);
		1665	cbor.flags \|= ix;
1230	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;	1666	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
1231	XPUSHs (scalar);	1667	XPUSHs (scalar);
1232	}	1668	}
1233		1669
1234	void decode_cbor (SV *cborstr)	1670	void decode_cbor (SV *cborstr)

Diff Legend

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

Comparing CBOR-XS/XS.xs (file contents): Revision 1.28 by root, Sat Nov 23 18:30:59 2013 UTC vs. Revision 1.60 by root, Sat Nov 26 00:47:02 2016 UTC

Diff Legend

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.28 by root, Sat Nov 23 18:30:59 2013 UTC vs.
Revision 1.60 by root, Sat Nov 26 00:47:02 2016 UTC