ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/CBOR-XS/XS.xs

Comparing CBOR-XS/XS.xs (file contents):
Revision 1.8 by root, Sun Oct 27 10:12:01 2013 UTC vs.
Revision 1.46 by root, Sun Dec 14 05:57:22 2014 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	// known tags, rfc7049	15	// compatibility with perl <5.18
		16	#ifndef HvNAMELEN_get
		17	# define HvNAMELEN_get(hv) strlen (HvNAME (hv))
		18	#endif
		19	#ifndef HvNAMELEN
		20	# define HvNAMELEN(hv) HvNAMELEN_get (hv)
		21	#endif
		22	#ifndef HvNAMEUTF8
		23	# define HvNAMEUTF8(hv) 0
		24	#endif
		25	#ifndef SvREFCNT_dec_NN
		26	# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
		27	#endif
		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
		66	// known tags
15	enum cbor_tag	67	enum cbor_tag
16	{	68	{
		69	// extensions
		70	CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
		71	CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
		72	CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
		73	CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
		74	CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
		75	CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
		76	CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
		77
		78	// rfc7049
17	CBOR_TAG_DATETIME = 0, // rfc4287, utf-8	79	CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
18	CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any	80	CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
19	CBOR_TAG_POS_BIGNUM = 2, // byte string	81	CBOR_TAG_POS_BIGNUM = 2, // byte string
20	CBOR_TAG_NEG_BIGNUM = 3, // byte string	82	CBOR_TAG_NEG_BIGNUM = 3, // byte string
21	CBOR_TAG_DECIMAL = 4, // decimal fraction, array	83	CBOR_TAG_DECIMAL = 4, // decimal fraction, array
22	CBOR_TAG_BIGFLOAT = 5, // array	84	CBOR_TAG_BIGFLOAT = 5, // array
23		85
24	CBOR_TAG_CONV_B64U = 21, // base64url, any	86	CBOR_TAG_CONV_B64U = 21, // base64url, any
25	CBOR_TAG_CONV_B64 = 22, // base64, any	87	CBOR_TAG_CONV_B64 = 22, // base64, any
26	CBOR_TAG_CONV_HEX = 23, // base16, any	88	CBOR_TAG_CONV_HEX = 23, // base16, any
27	CBOR_TAG_CBOR = 24, // embedded cbor, byte string	89	CBOR_TAG_CBOR = 24, // embedded cbor, byte string
28		90
29	CBOR_TAG_URI = 32, // URI rfc3986, utf-8	91	CBOR_TAG_URI = 32, // URI rfc3986, utf-8
30	CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8	92	CBOR_TAG_B64U = 33, // base64url rfc4648, utf-8
31	CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8	93	CBOR_TAG_B64 = 34, // base6 rfc46484, utf-8
32	CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8	94	CBOR_TAG_REGEX = 35, // regex pcre/ecma262, utf-8
33	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8	95	CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
34		96
35	CBOR_TAG_MAGIC = 55799	97	CBOR_TAG_MAGIC = 55799, // self-describe cbor
36	};	98	};
37		99
38	#define F_SHRINK 0x00000200UL	100	#define F_SHRINK 0x00000001UL
39	#define F_ALLOW_UNKNOWN 0x00002000UL	101	#define F_ALLOW_UNKNOWN 0x00000002UL
		102	#define F_ALLOW_SHARING 0x00000004UL
		103	#define F_ALLOW_CYCLES 0x00000008UL
		104	#define F_PACK_STRINGS 0x00000010UL
		105	#define F_VALIDATE_UTF8 0x00000020UL
40		106
41	#define INIT_SIZE 32 // initial scalar size to be allocated	107	#define INIT_SIZE 32 // initial scalar size to be allocated
42		108
43	#define SB do {	109	#define SB do {
44	#define SE } while (0)	110	#define SE } while (0)
…		…
55	#else	121	#else
56	# define CBOR_SLOW 0	122	# define CBOR_SLOW 0
57	# define CBOR_STASH cbor_stash	123	# define CBOR_STASH cbor_stash
58	#endif	124	#endif
59		125
60	static HV *cbor_stash, *cbor_boolean_stash, *cbor_tagged_stash; // CBOR::XS::	126	static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS::
61	static SV *cbor_true, *cbor_false;	127	static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
62		128
63	typedef struct {	129	typedef struct {
64	U32 flags;	130	U32 flags;
65	U32 max_depth;	131	U32 max_depth;
66	STRLEN max_size;	132	STRLEN max_size;
		133	SV *filter;
		134
		135	// for the incremental parser
		136	STRLEN incr_pos; // the current offset into the text
		137	STRLEN incr_need; // minimum bytes needed to decode
		138	AV *incr_count; // for every nesting level, the number of outstanding values, or -1 for indef.
67	} CBOR;	139	} CBOR;
68		140
69	ecb_inline void	141	ecb_inline void
70	cbor_init (CBOR *cbor)	142	cbor_init (CBOR *cbor)
71	{	143	{
72	Zero (cbor, 1, CBOR);	144	Zero (cbor, 1, CBOR);
73	cbor->max_depth = 512;	145	cbor->max_depth = 512;
		146	}
		147
		148	ecb_inline void
		149	cbor_free (CBOR *cbor)
		150	{
		151	SvREFCNT_dec (cbor->filter);
		152	SvREFCNT_dec (cbor->incr_count);
74	}	153	}
75		154
76	/////////////////////////////////////////////////////////////////////////////	155	/////////////////////////////////////////////////////////////////////////////
77	// utility functions	156	// utility functions
78		157
…		…
100	SvPV_renew (sv, SvCUR (sv) + 1);	179	SvPV_renew (sv, SvCUR (sv) + 1);
101	#endif	180	#endif
102	}	181	}
103	}	182	}
104		183
105	/////////////////////////////////////////////////////////////////////////////	184	// minimum length of a string to be registered for stringref
106	// fp hell	185	ecb_inline int
107		186	minimum_string_length (UV idx)
108	//TODO	187	{
		188	return idx > 23
		189	? idx > 0xffU
		190	? idx > 0xffffU
		191	? idx > 0xffffffffU
		192	? 11
		193	: 7
		194	: 5
		195	: 4
		196	: 3;
		197	}
109		198
110	/////////////////////////////////////////////////////////////////////////////	199	/////////////////////////////////////////////////////////////////////////////
111	// encoder	200	// encoder
112		201
113	// structure used for encoding CBOR	202	// structure used for encoding CBOR
…		…
116	char *cur; // SvPVX (sv) + current output position	205	char *cur; // SvPVX (sv) + current output position
117	char *end; // SvEND (sv)	206	char *end; // SvEND (sv)
118	SV *sv; // result scalar	207	SV *sv; // result scalar
119	CBOR cbor;	208	CBOR cbor;
120	U32 depth; // recursion level	209	U32 depth; // recursion level
		210	HV *stringref[2]; // string => index, or 0 ([0] = bytes, [1] = utf-8)
		211	UV stringref_idx;
		212	HV *shareable; // ptr => index, or 0
		213	UV shareable_idx;
121	} enc_t;	214	} enc_t;
122		215
123	ecb_inline void	216	ecb_inline void
124	need (enc_t *enc, STRLEN len)	217	need (enc_t *enc, STRLEN len)
125	{	218	{
…		…
142	static void	235	static void
143	encode_uint (enc_t *enc, int major, UV len)	236	encode_uint (enc_t *enc, int major, UV len)
144	{	237	{
145	need (enc, 9);	238	need (enc, 9);
146		239
147	if (len < 24)	240	if (ecb_expect_true (len < LENGTH_EXT1))
148	*enc->cur++ = major | len;	241	*enc->cur++ = major | len;
149	else if (len <= 0xff)	242	else if (ecb_expect_true (len <= 0xffU))
150	{	243	{
151	*enc->cur++ = major | 24;	244	*enc->cur++ = major | LENGTH_EXT1;
152	*enc->cur++ = len;	245	*enc->cur++ = len;
153	}	246	}
154	else if (len <= 0xffff)	247	else if (len <= 0xffffU)
155	{	248	{
156	*enc->cur++ = major | 25;	249	*enc->cur++ = major | LENGTH_EXT2;
157	*enc->cur++ = len >> 8;	250	*enc->cur++ = len >> 8;
158	*enc->cur++ = len;	251	*enc->cur++ = len;
159	}	252	}
160	else if (len <= 0xffffffff)	253	else if (len <= 0xffffffffU)
161	{	254	{
162	*enc->cur++ = major | 26;	255	*enc->cur++ = major | LENGTH_EXT4;
163	*enc->cur++ = len >> 24;	256	*enc->cur++ = len >> 24;
164	*enc->cur++ = len >> 16;	257	*enc->cur++ = len >> 16;
165	*enc->cur++ = len >> 8;	258	*enc->cur++ = len >> 8;
166	*enc->cur++ = len;	259	*enc->cur++ = len;
167	}	260	}
168	else	261	else
169	{	262	{
170	*enc->cur++ = major | 27;	263	*enc->cur++ = major | LENGTH_EXT8;
171	*enc->cur++ = len >> 56;	264	*enc->cur++ = len >> 56;
172	*enc->cur++ = len >> 48;	265	*enc->cur++ = len >> 48;
173	*enc->cur++ = len >> 40;	266	*enc->cur++ = len >> 40;
174	*enc->cur++ = len >> 32;	267	*enc->cur++ = len >> 32;
175	*enc->cur++ = len >> 24;	268	*enc->cur++ = len >> 24;
…		…
177	*enc->cur++ = len >> 8;	270	*enc->cur++ = len >> 8;
178	*enc->cur++ = len;	271	*enc->cur++ = len;
179	}	272	}
180	}	273	}
181		274
182	static void	275	ecb_inline void
		276	encode_tag (enc_t *enc, UV tag)
		277	{
		278	encode_uint (enc, MAJOR_TAG, tag);
		279	}
		280
		281	ecb_inline void
183	encode_str (enc_t *enc, int utf8, char *str, STRLEN len)	282	encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
184	{	283	{
185	encode_uint (enc, utf8 ? 0x60 : 0x40, len);	284	encode_uint (enc, utf8 ? MAJOR_TEXT : MAJOR_BYTES, len);
186	need (enc, len);	285	need (enc, len);
187	memcpy (enc->cur, str, len);	286	memcpy (enc->cur, str, len);
188	enc->cur += len;	287	enc->cur += len;
189	}	288	}
190		289
		290	static void
		291	encode_strref (enc_t *enc, int utf8, char *str, STRLEN len)
		292	{
		293	if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
		294	{
		295	SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
		296
		297	if (SvOK (*svp))
		298	{
		299	// already registered, use stringref
		300	encode_tag (enc, CBOR_TAG_STRINGREF);
		301	encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
		302	return;
		303	}
		304	else if (len >= minimum_string_length (enc->stringref_idx))
		305	{
		306	// register only
		307	sv_setuv (*svp, enc->stringref_idx);
		308	++enc->stringref_idx;
		309	}
		310	}
		311
		312	encode_str (enc, utf8, str, len);
		313	}
		314
191	static void encode_sv (enc_t *enc, SV *sv);	315	static void encode_sv (enc_t *enc, SV *sv);
192		316
193	static void	317	static void
194	encode_av (enc_t *enc, AV *av)	318	encode_av (enc_t *enc, AV *av)
195	{	319	{
…		…
198	if (enc->depth >= enc->cbor.max_depth)	322	if (enc->depth >= enc->cbor.max_depth)
199	croak (ERR_NESTING_EXCEEDED);	323	croak (ERR_NESTING_EXCEEDED);
200		324
201	++enc->depth;	325	++enc->depth;
202		326
203	encode_uint (enc, 0x80, len + 1);	327	encode_uint (enc, MAJOR_ARRAY, len + 1);
204		328
		329	if (SvMAGICAL (av))
205	for (i = 0; i <= len; ++i)	330	for (i = 0; i <= len; ++i)
206	{	331	{
207	SV **svp = av_fetch (av, i, 0);	332	SV **svp = av_fetch (av, i, 0);
208	encode_sv (enc, svp ? *svp : &PL_sv_undef);	333	encode_sv (enc, svp ? *svp : &PL_sv_undef);
209	}	334	}
		335	else
		336	for (i = 0; i <= len; ++i)
		337	{
		338	SV *sv = AvARRAY (av)[i];
		339	encode_sv (enc, sv ? sv : &PL_sv_undef);
		340	}
210		341
211	--enc->depth;	342	--enc->depth;
212	}	343	}
213		344
214	static void	345	static void
…		…
223		354
224	int pairs = hv_iterinit (hv);	355	int pairs = hv_iterinit (hv);
225	int mg = SvMAGICAL (hv);	356	int mg = SvMAGICAL (hv);
226		357
227	if (mg)	358	if (mg)
228	encode_ch (enc, 0xa0 | 31);	359	encode_ch (enc, MAJOR_MAP | MINOR_INDEF);
229	else	360	else
230	encode_uint (enc, 0xa0, pairs);	361	encode_uint (enc, MAJOR_MAP, pairs);
231		362
232	while ((he = hv_iternext (hv)))	363	while ((he = hv_iternext (hv)))
233	{	364	{
234	if (HeKLEN (he) == HEf_SVKEY)	365	if (HeKLEN (he) == HEf_SVKEY)
235	encode_sv (enc, HeSVKEY (he));	366	encode_sv (enc, HeSVKEY (he));
236	else	367	else
237	encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));	368	encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
238		369
239	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));	370	encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
240	}	371	}
241		372
242	if (mg)	373	if (mg)
243	encode_ch (enc, 0xe0 | 31);	374	encode_ch (enc, MAJOR_MISC | MINOR_INDEF);
244		375
245	--enc->depth;	376	--enc->depth;
246	}	377	}
247		378
248	// encode objects, arrays and special \0=false and \1=true values.	379	// encode objects, arrays and special \0=false and \1=true values.
249	static void	380	static void
250	encode_rv (enc_t *enc, SV *sv)	381	encode_rv (enc_t *enc, SV *sv)
251	{	382	{
252	svtype svt;
253
254	SvGETMAGIC (sv);	383	SvGETMAGIC (sv);
		384
255	svt = SvTYPE (sv);	385	svtype svt = SvTYPE (sv);
256		386
257	if (ecb_expect_false (SvOBJECT (sv)))	387	if (ecb_expect_false (SvOBJECT (sv)))
258	{	388	{
259	HV *boolean_stash = !CBOR_SLOW || cbor_boolean_stash	389	HV *boolean_stash = !CBOR_SLOW || types_boolean_stash
260	? cbor_boolean_stash	390	? types_boolean_stash
261	: gv_stashpv ("CBOR::XS::Boolean", 1);	391	: gv_stashpv ("Types::Serialiser::Boolean", 1);
		392	HV *error_stash = !CBOR_SLOW || types_error_stash
		393	? types_error_stash
		394	: gv_stashpv ("Types::Serialiser::Error", 1);
262	HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash	395	HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
263	? cbor_tagged_stash	396	? cbor_tagged_stash
264	: gv_stashpv ("CBOR::XS::Tagged" , 1);	397	: gv_stashpv ("CBOR::XS::Tagged" , 1);
265		398
		399	HV *stash = SvSTASH (sv);
		400
266	if (SvSTASH (sv) == boolean_stash)	401	if (stash == boolean_stash)
267	encode_ch (enc, SvIV (sv) ? 0xe0 | 21 : 0xe0 | 20);	402	{
		403	encode_ch (enc, SvIV (sv) ? MAJOR_MISC | SIMPLE_TRUE : MAJOR_MISC | SIMPLE_FALSE);
		404	return;
		405	}
		406	else if (stash == error_stash)
		407	{
		408	encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
		409	return;
		410	}
268	else if (SvSTASH (sv) == tagged_stash)	411	else if (stash == tagged_stash)
269	{	412	{
270	if (svt != SVt_PVAV)	413	if (svt != SVt_PVAV)
271	croak ("encountered CBOR::XS::Tagged object that isn't an array");	414	croak ("encountered CBOR::XS::Tagged object that isn't an array");
272		415
273	encode_uint (enc, 0xc0, SvUV (*av_fetch ((AV *)sv, 0, 1)));	416	encode_uint (enc, MAJOR_TAG, SvUV (*av_fetch ((AV *)sv, 0, 1)));
274	encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));	417	encode_sv (enc, *av_fetch ((AV *)sv, 1, 1));
		418
		419	return;
		420	}
		421	}
		422
		423	if (ecb_expect_false (SvREFCNT (sv) > 1)
		424	&& ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
		425	{
		426	if (!enc->shareable)
		427	enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
		428
		429	SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
		430
		431	if (SvOK (*svp))
		432	{
		433	encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
		434	encode_uint (enc, MAJOR_POS_INT, SvUV (*svp));
		435	return;
275	}	436	}
276	else	437	else
277	{	438	{
		439	sv_setuv (*svp, enc->shareable_idx);
		440	++enc->shareable_idx;
		441	encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
		442	}
		443	}
		444
		445	if (ecb_expect_false (SvOBJECT (sv)))
		446	{
		447	HV *stash = SvSTASH (sv);
		448	GV *method;
		449
		450	if ((method = gv_fetchmethod_autoload (stash, "TO_CBOR", 0)))
		451	{
		452	dSP;
		453
		454	ENTER; SAVETMPS; PUSHMARK (SP);
278	// we re-bless the reference to get overload and other niceties right	455	// we re-bless the reference to get overload and other niceties right
279	GV *to_cbor = gv_fetchmethod_autoload (SvSTASH (sv), "TO_CBOR", 0);
280
281	if (to_cbor)
282	{
283	dSP;
284
285	ENTER; SAVETMPS; PUSHMARK (SP);
286	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), SvSTASH (sv)));	456	XPUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
287		457
288	// calling with G_SCALAR ensures that we always get a 1 return value
289	PUTBACK;	458	PUTBACK;
		459	// G_SCALAR ensures that return value is 1
290	call_sv ((SV *)GvCV (to_cbor), G_SCALAR);	460	call_sv ((SV *)GvCV (method), G_SCALAR);
291	SPAGAIN;	461	SPAGAIN;
292		462
293	// catch this surprisingly common error	463	// catch this surprisingly common error
294	if (SvROK (TOPs) && SvRV (TOPs) == sv)	464	if (SvROK (TOPs) && SvRV (TOPs) == sv)
295	croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (SvSTASH (sv)));	465	croak ("%s::TO_CBOR method returned same object as was passed instead of a new one", HvNAME (stash));
296		466
297	sv = POPs;	467	encode_sv (enc, POPs);
		468
298	PUTBACK;	469	PUTBACK;
299		470
300	encode_sv (enc, sv);
301
302	FREETMPS; LEAVE;	471	FREETMPS; LEAVE;
303	}	472	}
		473	else if ((method = gv_fetchmethod_autoload (stash, "FREEZE", 0)) != 0)
		474	{
		475	dSP;
		476
		477	ENTER; SAVETMPS; PUSHMARK (SP);
		478	EXTEND (SP, 2);
		479	// we re-bless the reference to get overload and other niceties right
		480	PUSHs (sv_bless (sv_2mortal (newRV_inc (sv)), stash));
		481	PUSHs (sv_cbor);
		482
		483	PUTBACK;
		484	int count = call_sv ((SV *)GvCV (method), G_ARRAY);
		485	SPAGAIN;
		486
		487	// catch this surprisingly common error
		488	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));
		490
		491	encode_tag (enc, CBOR_TAG_PERL_OBJECT);
		492	encode_uint (enc, MAJOR_ARRAY, count + 1);
		493	encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
		494
		495	while (count)
		496	encode_sv (enc, SP[1 - count--]);
		497
		498	PUTBACK;
		499
		500	FREETMPS; LEAVE;
		501	}
304	else	502	else
305	croak ("encountered object '%s', but no TO_CBOR method available on it",	503	croak ("encountered object '%s', but no TO_CBOR or FREEZE methods available on it",
306	SvPV_nolen (sv_2mortal (newRV_inc (sv))));	504	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
307	}
308	}	505	}
309	else if (svt == SVt_PVHV)	506	else if (svt == SVt_PVHV)
310	encode_hv (enc, (HV *)sv);	507	encode_hv (enc, (HV *)sv);
311	else if (svt == SVt_PVAV)	508	else if (svt == SVt_PVAV)
312	encode_av (enc, (AV *)sv);	509	encode_av (enc, (AV *)sv);
313	else if (svt < SVt_PVAV)
314	{
315	STRLEN len = 0;
316	char *pv = svt ? SvPV (sv, len) : 0;
317
318	if (len == 1 && *pv == '1')
319	encode_ch (enc, 0xe0 | 21);
320	else if (len == 1 && *pv == '0')
321	encode_ch (enc, 0xe0 | 20);
322	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
323	encode_ch (enc, 0xe0 | 23);
324	else
325	croak ("cannot encode reference to scalar '%s' unless the scalar is 0 or 1",
326	SvPV_nolen (sv_2mortal (newRV_inc (sv))));
327	}
328	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
329	encode_ch (enc, 0xe0 | 23);
330	else	510	else
331	croak ("encountered %s, but CBOR can only represent references to arrays or hashes",	511	{
332	SvPV_nolen (sv_2mortal (newRV_inc (sv))));	512	encode_tag (enc, CBOR_TAG_INDIRECTION);
		513	encode_sv (enc, sv);
		514	}
333	}	515	}
334		516
335	static void	517	static void
336	encode_nv (enc_t *enc, SV *sv)	518	encode_nv (enc_t *enc, SV *sv)
337	{	519	{
338	double nv = SvNVX (sv);	520	double nv = SvNVX (sv);
339		521
340	need (enc, 9);	522	need (enc, 9);
341		523
342	if (ecb_expect_false (nv == (U32)nv))	524	if (ecb_expect_false (nv == (NV)(U32)nv))
343	encode_uint (enc, 0x00, (U32)nv);	525	encode_uint (enc, MAJOR_POS_INT, (U32)nv);
344	//TODO: maybe I32?	526	//TODO: maybe I32?
345	else if (ecb_expect_false (nv == (float)nv))	527	else if (ecb_expect_false (nv == (float)nv))
346	{	528	{
347	uint32_t fp = ecb_float_to_binary32 (nv);	529	uint32_t fp = ecb_float_to_binary32 (nv);
348		530
349	*enc->cur++ = 0xe0 | 26;	531	*enc->cur++ = MAJOR_MISC | MISC_FLOAT32;
350		532
351	if (!ecb_big_endian ())	533	if (!ecb_big_endian ())
352	fp = ecb_bswap32 (fp);	534	fp = ecb_bswap32 (fp);
353		535
354	memcpy (enc->cur, &fp, 4);	536	memcpy (enc->cur, &fp, 4);
…		…
356	}	538	}
357	else	539	else
358	{	540	{
359	uint64_t fp = ecb_double_to_binary64 (nv);	541	uint64_t fp = ecb_double_to_binary64 (nv);
360		542
361	*enc->cur++ = 0xe0 | 27;	543	*enc->cur++ = MAJOR_MISC | MISC_FLOAT64;
362		544
363	if (!ecb_big_endian ())	545	if (!ecb_big_endian ())
364	fp = ecb_bswap64 (fp);	546	fp = ecb_bswap64 (fp);
365		547
366	memcpy (enc->cur, &fp, 8);	548	memcpy (enc->cur, &fp, 8);
…		…
375		557
376	if (SvPOKp (sv))	558	if (SvPOKp (sv))
377	{	559	{
378	STRLEN len;	560	STRLEN len;
379	char *str = SvPV (sv, len);	561	char *str = SvPV (sv, len);
380	encode_str (enc, SvUTF8 (sv), str, len);	562	encode_strref (enc, SvUTF8 (sv), str, len);
381	}	563	}
382	else if (SvNOKp (sv))	564	else if (SvNOKp (sv))
383	encode_nv (enc, sv);	565	encode_nv (enc, sv);
384	else if (SvIOKp (sv))	566	else if (SvIOKp (sv))
385	{	567	{
386	if (SvIsUV (sv))	568	if (SvIsUV (sv))
387	encode_uint (enc, 0x00, SvUVX (sv));	569	encode_uint (enc, MAJOR_POS_INT, SvUVX (sv));
388	else if (SvIVX (sv) >= 0)	570	else if (SvIVX (sv) >= 0)
389	encode_uint (enc, 0x00, SvIVX (sv));	571	encode_uint (enc, MAJOR_POS_INT, SvIVX (sv));
390	else	572	else
391	encode_uint (enc, 0x20, -(SvIVX (sv) + 1));	573	encode_uint (enc, MAJOR_NEG_INT, -(SvIVX (sv) + 1));
392	}	574	}
393	else if (SvROK (sv))	575	else if (SvROK (sv))
394	encode_rv (enc, SvRV (sv));	576	encode_rv (enc, SvRV (sv));
395	else if (!SvOK (sv))	577	else if (!SvOK (sv))
396	encode_ch (enc, 0xe0 | 22);	578	encode_ch (enc, MAJOR_MISC | SIMPLE_NULL);
397	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)	579	else if (enc->cbor.flags & F_ALLOW_UNKNOWN)
398	encode_ch (enc, 0xe0 | 23);	580	encode_ch (enc, MAJOR_MISC | SIMPLE_UNDEF);
399	else	581	else
400	croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",	582	croak ("encountered perl type (%s,0x%x) that CBOR cannot handle, check your input data",
401	SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));	583	SvPV_nolen (sv), (unsigned int)SvFLAGS (sv));
402	}	584	}
403		585
404	static SV *	586	static SV *
405	encode_cbor (SV *scalar, CBOR *cbor)	587	encode_cbor (SV *scalar, CBOR *cbor)
406	{	588	{
407	enc_t enc;	589	enc_t enc = { };
408		590
409	enc.cbor = *cbor;	591	enc.cbor = *cbor;
410	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));	592	enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
411	enc.cur = SvPVX (enc.sv);	593	enc.cur = SvPVX (enc.sv);
412	enc.end = SvEND (enc.sv);	594	enc.end = SvEND (enc.sv);
413	enc.depth = 0;
414		595
415	SvPOK_only (enc.sv);	596	SvPOK_only (enc.sv);
		597
		598	if (cbor->flags & F_PACK_STRINGS)
		599	{
		600	encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
		601	enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
		602	enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
		603	}
		604
416	encode_sv (&enc, scalar);	605	encode_sv (&enc, scalar);
417		606
418	SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));	607	SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
419	*SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings	608	*SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
420		609
…		…
434	U8 *end; // end of input string	623	U8 *end; // end of input string
435	const char *err; // parse error, if != 0	624	const char *err; // parse error, if != 0
436	CBOR cbor;	625	CBOR cbor;
437	U32 depth; // recursion depth	626	U32 depth; // recursion depth
438	U32 maxdepth; // recursion depth limit	627	U32 maxdepth; // recursion depth limit
		628	AV *shareable;
		629	AV *stringref;
		630	SV *decode_tagged;
439	} dec_t;	631	} dec_t;
440		632
441	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE	633	#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE
442		634
443	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")	635	#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")
…		…
446	#define DEC_DEC_DEPTH --dec->depth	638	#define DEC_DEC_DEPTH --dec->depth
447		639
448	static UV	640	static UV
449	decode_uint (dec_t *dec)	641	decode_uint (dec_t *dec)
450	{	642	{
451	switch (*dec->cur & 31)	643	U8 m = *dec->cur & MINOR_MASK;
452	{	644	++dec->cur;
453	case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
454	case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
455	case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23:
456	return *dec->cur++ & 31;
457		645
458	case 24:	646	if (ecb_expect_true (m < LENGTH_EXT1))
		647	return m;
		648	else if (ecb_expect_true (m == LENGTH_EXT1))
		649	{
459	WANT (2);	650	WANT (1);
460	dec->cur += 2;	651	dec->cur += 1;
461	return dec->cur[-1];	652	return dec->cur[-1];
462		653	}
463	case 25:	654	else if (ecb_expect_true (m == LENGTH_EXT2))
		655	{
464	WANT (3);	656	WANT (2);
465	dec->cur += 3;	657	dec->cur += 2;
466	return (((UV)dec->cur[-2]) << 8)	658	return (((UV)dec->cur[-2]) << 8)
467	| ((UV)dec->cur[-1]);	659	| ((UV)dec->cur[-1]);
468		660	}
469	case 26:	661	else if (ecb_expect_true (m == LENGTH_EXT4))
		662	{
470	WANT (5);	663	WANT (4);
471	dec->cur += 5;	664	dec->cur += 4;
472	return (((UV)dec->cur[-4]) << 24)	665	return (((UV)dec->cur[-4]) << 24)
473	| (((UV)dec->cur[-3]) << 16)	666	| (((UV)dec->cur[-3]) << 16)
474	| (((UV)dec->cur[-2]) << 8)	667	| (((UV)dec->cur[-2]) << 8)
475	| ((UV)dec->cur[-1]);	668	| ((UV)dec->cur[-1]);
476		669	}
477	case 27:	670	else if (ecb_expect_true (m == LENGTH_EXT8))
		671	{
478	WANT (9);	672	WANT (8);
479	dec->cur += 9;	673	dec->cur += 8;
		674
		675	return
		676	#if UVSIZE < 8
		677	0
		678	#else
480	return (((UV)dec->cur[-8]) << 56)	679	(((UV)dec->cur[-8]) << 56)
481	| (((UV)dec->cur[-7]) << 48)	680	| (((UV)dec->cur[-7]) << 48)
482	| (((UV)dec->cur[-6]) << 40)	681	| (((UV)dec->cur[-6]) << 40)
483	| (((UV)dec->cur[-5]) << 32)	682	| (((UV)dec->cur[-5]) << 32)
		683	#endif
484	| (((UV)dec->cur[-4]) << 24)	684	| (((UV)dec->cur[-4]) << 24)
485	| (((UV)dec->cur[-3]) << 16)	685	| (((UV)dec->cur[-3]) << 16)
486	| (((UV)dec->cur[-2]) << 8)	686	| (((UV)dec->cur[-2]) << 8)
487	| ((UV)dec->cur[-1]);	687	| ((UV)dec->cur[-1]);
488		688	}
489	default:	689	else
490	ERR ("corrupted CBOR data (unsupported integer minor encoding)");	690	ERR ("corrupted CBOR data (unsupported integer minor encoding)");
491	}
492		691
493	fail:	692	fail:
494	return 0;	693	return 0;
495	}	694	}
496		695
…		…
501	{	700	{
502	AV *av = newAV ();	701	AV *av = newAV ();
503		702
504	DEC_INC_DEPTH;	703	DEC_INC_DEPTH;
505		704
506	if ((*dec->cur & 31) == 31)	705	if (*dec->cur == (MAJOR_ARRAY | MINOR_INDEF))
507	{	706	{
508	++dec->cur;	707	++dec->cur;
509		708
510	for (;;)	709	for (;;)
511	{	710	{
512	WANT (1);	711	WANT (1);
513		712
514	if (*dec->cur == (0xe0 | 31))	713	if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
515	{	714	{
516	++dec->cur;	715	++dec->cur;
517	break;	716	break;
518	}	717	}
519		718
…		…
522	}	721	}
523	else	722	else
524	{	723	{
525	int i, len = decode_uint (dec);	724	int i, len = decode_uint (dec);
526		725
		726	WANT (len); // complexity check for av_fill - need at least one byte per value, do not allow supersize arrays
527	av_fill (av, len - 1);	727	av_fill (av, len - 1);
528		728
529	for (i = 0; i < len; ++i)	729	for (i = 0; i < len; ++i)
530	AvARRAY (av)[i] = decode_sv (dec);	730	AvARRAY (av)[i] = decode_sv (dec);
531	}	731	}
…		…
537	SvREFCNT_dec (av);	737	SvREFCNT_dec (av);
538	DEC_DEC_DEPTH;	738	DEC_DEC_DEPTH;
539	return &PL_sv_undef;	739	return &PL_sv_undef;
540	}	740	}
541		741
		742	static void
		743	decode_he (dec_t *dec, HV *hv)
		744	{
		745	// for speed reasons, we specialcase single-string
		746	// byte or utf-8 strings as keys, but only when !stringref
		747
		748	if (ecb_expect_true (!dec->stringref))
		749	if (ecb_expect_true ((U8)(*dec->cur - MAJOR_BYTES) <= LENGTH_EXT8))
		750	{
		751	I32 len = decode_uint (dec);
		752	char *key = (char *)dec->cur;
		753
		754	dec->cur += len;
		755
		756	hv_store (hv, key, len, decode_sv (dec), 0);
		757
		758	return;
		759	}
		760	else if (ecb_expect_true ((U8)(*dec->cur - MAJOR_TEXT) <= LENGTH_EXT8))
		761	{
		762	I32 len = decode_uint (dec);
		763	char *key = (char *)dec->cur;
		764
		765	dec->cur += len;
		766
		767	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
		768	if (!is_utf8_string (key, len))
		769	ERR ("corrupted CBOR data (invalid UTF-8 in map key)");
		770
		771	hv_store (hv, key, -len, decode_sv (dec), 0);
		772
		773	return;
		774	}
		775
		776	SV *k = decode_sv (dec);
		777	SV *v = decode_sv (dec);
		778
		779	hv_store_ent (hv, k, v, 0);
		780	SvREFCNT_dec (k);
		781
		782	fail:
		783	;
		784	}
		785
542	static SV *	786	static SV *
543	decode_hv (dec_t *dec)	787	decode_hv (dec_t *dec)
544	{	788	{
545	HV *hv = newHV ();	789	HV *hv = newHV ();
546		790
547	DEC_INC_DEPTH;	791	DEC_INC_DEPTH;
548		792
549	if ((*dec->cur & 31) == 31)	793	if (*dec->cur == (MAJOR_MAP | MINOR_INDEF))
550	{	794	{
551	++dec->cur;	795	++dec->cur;
552		796
553	for (;;)	797	for (;;)
554	{	798	{
555	WANT (1);	799	WANT (1);
556		800
557	if (*dec->cur == (0xe0 | 31))	801	if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
558	{	802	{
559	++dec->cur;	803	++dec->cur;
560	break;	804	break;
561	}	805	}
562		806
563	SV *k = decode_sv (dec);	807	decode_he (dec, hv);
564	SV *v = decode_sv (dec);
565
566	hv_store_ent (hv, k, v, 0);
567	}	808	}
568	}	809	}
569	else	810	else
570	{	811	{
571	int len = decode_uint (dec);	812	int pairs = decode_uint (dec);
572		813
573	while (len--)	814	while (pairs--)
574	{	815	decode_he (dec, hv);
575	SV *k = decode_sv (dec);
576	SV *v = decode_sv (dec);
577
578	hv_store_ent (hv, k, v, 0);
579	}
580	}	816	}
581		817
582	DEC_DEC_DEPTH;	818	DEC_DEC_DEPTH;
583	return newRV_noinc ((SV *)hv);	819	return newRV_noinc ((SV *)hv);
584		820
…		…
591	static SV *	827	static SV *
592	decode_str (dec_t *dec, int utf8)	828	decode_str (dec_t *dec, int utf8)
593	{	829	{
594	SV *sv = 0;	830	SV *sv = 0;
595		831
596	if ((*dec->cur & 31) == 31)	832	if ((*dec->cur & MINOR_MASK) == MINOR_INDEF)
597	{	833	{
		834	// indefinite length strings
598	++dec->cur;	835	++dec->cur;
599		836
		837	U8 major = *dec->cur & MAJOR_MISC;
		838
600	sv = newSVpvn ("", 0);	839	sv = newSVpvn ("", 0);
601		840
602	// not very fast, and certainly not robust against illegal input
603	for (;;)	841	for (;;)
604	{	842	{
605	WANT (1);	843	WANT (1);
606		844
607	if (*dec->cur == (0xe0 | 31))	845	if ((*dec->cur - major) > LENGTH_EXT8)
		846	if (*dec->cur == (MAJOR_MISC | MINOR_INDEF))
608	{	847	{
609	++dec->cur;	848	++dec->cur;
610	break;	849	break;
611	}	850	}
		851	else
		852	ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
612		853
613	sv_catsv (sv, decode_sv (dec));	854	STRLEN len = decode_uint (dec);
		855
		856	WANT (len);
		857	sv_catpvn (sv, dec->cur, len);
		858	dec->cur += len;
614	}	859	}
615	}	860	}
616	else	861	else
617	{	862	{
618	STRLEN len = decode_uint (dec);	863	STRLEN len = decode_uint (dec);
619		864
620	WANT (len);	865	WANT (len);
621	sv = newSVpvn (dec->cur, len);	866	sv = newSVpvn (dec->cur, len);
622	dec->cur += len;	867	dec->cur += len;
		868
		869	if (ecb_expect_false (dec->stringref)
		870	&& SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
		871	av_push (dec->stringref, SvREFCNT_inc_NN (sv));
623	}	872	}
624		873
625	if (utf8)	874	if (utf8)
		875	{
		876	if (ecb_expect_false (dec->cbor.flags & F_VALIDATE_UTF8))
		877	if (!is_utf8_string (SvPVX (sv), SvCUR (sv)))
		878	ERR ("corrupted CBOR data (invalid UTF-8 in text string)");
		879
626	SvUTF8_on (sv);	880	SvUTF8_on (sv);
		881	}
627		882
628	return sv;	883	return sv;
629		884
630	fail:	885	fail:
631	SvREFCNT_dec (sv);	886	SvREFCNT_dec (sv);
…		…
633	}	888	}
634		889
635	static SV *	890	static SV *
636	decode_tagged (dec_t *dec)	891	decode_tagged (dec_t *dec)
637	{	892	{
		893	SV *sv = 0;
638	UV tag = decode_uint (dec);	894	UV tag = decode_uint (dec);
		895
		896	WANT (1);
		897
		898	switch (tag)
		899	{
		900	case CBOR_TAG_MAGIC:
639	SV *sv = decode_sv (dec);	901	sv = decode_sv (dec);
		902	break;
640		903
641	if (tag == CBOR_TAG_MAGIC) // 2.4.5 Self-Describe CBOR	904	case CBOR_TAG_INDIRECTION:
		905	sv = newRV_noinc (decode_sv (dec));
		906	break;
		907
		908	case CBOR_TAG_STRINGREF_NAMESPACE:
		909	{
		910	ENTER; SAVETMPS;
		911
		912	SAVESPTR (dec->stringref);
		913	dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
		914
		915	sv = decode_sv (dec);
		916
		917	FREETMPS; LEAVE;
		918	}
		919	break;
		920
		921	case CBOR_TAG_STRINGREF:
		922	{
		923	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
		924	ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
		925
		926	UV idx = decode_uint (dec);
		927
		928	if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
		929	ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
		930
		931	sv = newSVsv (AvARRAY (dec->stringref)[idx]);
		932	}
		933	break;
		934
		935	case CBOR_TAG_VALUE_SHAREABLE:
		936	{
		937	if (ecb_expect_false (!dec->shareable))
		938	dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
		939
		940	if (dec->cbor.flags & F_ALLOW_CYCLES)
		941	{
		942	sv = newSV (0);
		943	av_push (dec->shareable, SvREFCNT_inc_NN (sv));
		944
		945	SV *osv = decode_sv (dec);
		946	sv_setsv (sv, osv);
		947	SvREFCNT_dec_NN (osv);
		948	}
		949	else
		950	{
		951	av_push (dec->shareable, &PL_sv_undef);
		952	int idx = AvFILLp (dec->shareable);
		953	sv = decode_sv (dec);
		954	av_store (dec->shareable, idx, SvREFCNT_inc_NN (sv));
		955	}
		956	}
		957	break;
		958
		959	case CBOR_TAG_VALUE_SHAREDREF:
		960	{
		961	if ((*dec->cur >> MAJOR_SHIFT) != (MAJOR_POS_INT >> MAJOR_SHIFT))
		962	ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
		963
		964	UV idx = decode_uint (dec);
		965
		966	if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
		967	ERR ("corrupted CBOR data (sharedref index out of bounds)");
		968
		969	sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
		970
		971	if (sv == &PL_sv_undef)
		972	ERR ("cyclic CBOR data structure found, but allow_cycles is not enabled");
		973	}
		974	break;
		975
		976	case CBOR_TAG_PERL_OBJECT:
		977	{
		978	sv = decode_sv (dec);
		979
		980	if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
		981	ERR ("corrupted CBOR data (non-array perl object)");
		982
		983	AV *av = (AV *)SvRV (sv);
		984	int len = av_len (av) + 1;
		985	HV *stash = gv_stashsv (*av_fetch (av, 0, 1), 0);
		986
		987	if (!stash)
		988	ERR ("cannot decode perl-object (package does not exist)");
		989
		990	GV *method = gv_fetchmethod_autoload (stash, "THAW", 0);
		991
		992	if (!method)
		993	ERR ("cannot decode perl-object (package does not have a THAW method)");
		994
		995	dSP;
		996
		997	ENTER; SAVETMPS; PUSHMARK (SP);
		998	EXTEND (SP, len + 1);
		999	// we re-bless the reference to get overload and other niceties right
		1000	PUSHs (*av_fetch (av, 0, 1));
		1001	PUSHs (sv_cbor);
		1002
		1003	int i;
		1004
		1005	for (i = 1; i < len; ++i)
		1006	PUSHs (*av_fetch (av, i, 1));
		1007
		1008	PUTBACK;
		1009	call_sv ((SV *)GvCV (method), G_SCALAR | G_EVAL);
		1010	SPAGAIN;
		1011
		1012	if (SvTRUE (ERRSV))
		1013	{
		1014	FREETMPS; LEAVE;
		1015	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
		1016	}
		1017
		1018	SvREFCNT_dec (sv);
		1019	sv = SvREFCNT_inc (POPs);
		1020
		1021	PUTBACK;
		1022
		1023	FREETMPS; LEAVE;
		1024	}
		1025	break;
		1026
		1027	default:
		1028	{
		1029	sv = decode_sv (dec);
		1030
		1031	dSP;
		1032	ENTER; SAVETMPS; PUSHMARK (SP);
		1033	EXTEND (SP, 2);
		1034	PUSHs (newSVuv (tag));
		1035	PUSHs (sv);
		1036
		1037	PUTBACK;
		1038	int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
		1039	SPAGAIN;
		1040
		1041	if (SvTRUE (ERRSV))
		1042	{
		1043	FREETMPS; LEAVE;
		1044	ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
		1045	}
		1046
		1047	if (count)
		1048	{
		1049	SvREFCNT_dec (sv);
		1050	sv = SvREFCNT_inc (POPs);
		1051	}
		1052	else
		1053	{
		1054	AV *av = newAV ();
		1055	av_push (av, newSVuv (tag));
		1056	av_push (av, sv);
		1057
		1058	HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
		1059	? cbor_tagged_stash
		1060	: gv_stashpv ("CBOR::XS::Tagged" , 1);
		1061	sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
		1062	}
		1063
		1064	PUTBACK;
		1065
		1066	FREETMPS; LEAVE;
		1067	}
		1068	break;
		1069	}
		1070
642	return sv;	1071	return sv;
643		1072
644	AV *av = newAV ();	1073	fail:
645	av_push (av, newSVuv (tag));	1074	SvREFCNT_dec (sv);
646	av_push (av, sv);	1075	return &PL_sv_undef;
647
648	HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
649	? cbor_tagged_stash
650	: gv_stashpv ("CBOR::XS::Tagged" , 1);
651
652	return sv_bless (newRV_noinc ((SV *)av), tagged_stash);
653	}	1076	}
654		1077
655	static SV *	1078	static SV *
656	decode_sv (dec_t *dec)	1079	decode_sv (dec_t *dec)
657	{	1080	{
658	WANT (1);	1081	WANT (1);
659		1082
660	switch (*dec->cur >> 5)	1083	switch (*dec->cur >> MAJOR_SHIFT)
661	{	1084	{
662	case 0: // unsigned int	1085	case MAJOR_POS_INT >> MAJOR_SHIFT: return newSVuv (decode_uint (dec));
663	return newSVuv (decode_uint (dec));	1086	case MAJOR_NEG_INT >> MAJOR_SHIFT: return newSViv (-1 - (IV)decode_uint (dec));
664	case 1: // negative int	1087	case MAJOR_BYTES >> MAJOR_SHIFT: return decode_str (dec, 0);
665	return newSViv (-1 - (IV)decode_uint (dec));	1088	case MAJOR_TEXT >> MAJOR_SHIFT: return decode_str (dec, 1);
666	case 2: // octet string	1089	case MAJOR_ARRAY >> MAJOR_SHIFT: return decode_av (dec);
667	return decode_str (dec, 0);	1090	case MAJOR_MAP >> MAJOR_SHIFT: return decode_hv (dec);
668	case 3: // utf-8 string	1091	case MAJOR_TAG >> MAJOR_SHIFT: return decode_tagged (dec);
669	return decode_str (dec, 1);	1092
670	case 4: // array	1093	case MAJOR_MISC >> MAJOR_SHIFT:
671	return decode_av (dec);
672	case 5: // map
673	return decode_hv (dec);
674	case 6: // tag
675	return decode_tagged (dec);
676	case 7: // misc
677	switch (*dec->cur++ & 31)	1094	switch (*dec->cur++ & MINOR_MASK)
678	{	1095	{
679	case 20:	1096	case SIMPLE_FALSE:
680	#if CBOR_SLOW	1097	#if CBOR_SLOW
681	cbor_false = get_bool ("CBOR::XS::false");	1098	types_false = get_bool ("Types::Serialiser::false");
682	#endif	1099	#endif
683	return newSVsv (cbor_false);	1100	return newSVsv (types_false);
684	case 21:	1101	case SIMPLE_TRUE:
685	#if CBOR_SLOW	1102	#if CBOR_SLOW
686	cbor_true = get_bool ("CBOR::XS::true");	1103	types_true = get_bool ("Types::Serialiser::true");
687	#endif	1104	#endif
688	return newSVsv (cbor_true);	1105	return newSVsv (types_true);
689	case 22:	1106	case SIMPLE_NULL:
690	return newSVsv (&PL_sv_undef);	1107	return newSVsv (&PL_sv_undef);
		1108	case SIMPLE_UNDEF:
		1109	#if CBOR_SLOW
		1110	types_error = get_bool ("Types::Serialiser::error");
		1111	#endif
		1112	return newSVsv (types_error);
691		1113
692	case 25:	1114	case MISC_FLOAT16:
693	{	1115	{
694	WANT (2);	1116	WANT (2);
695		1117
696	uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];	1118	uint16_t fp = (dec->cur[0] << 8) | dec->cur[1];
697	dec->cur += 2;	1119	dec->cur += 2;
698		1120
699	return newSVnv (ecb_binary16_to_float (fp));	1121	return newSVnv (ecb_binary16_to_float (fp));
700	}	1122	}
701		1123
702	case 26:	1124	case MISC_FLOAT32:
703	{	1125	{
704	uint32_t fp;	1126	uint32_t fp;
705	WANT (4);	1127	WANT (4);
706	memcpy (&fp, dec->cur, 4);	1128	memcpy (&fp, dec->cur, 4);
707	dec->cur += 4;	1129	dec->cur += 4;
…		…
710	fp = ecb_bswap32 (fp);	1132	fp = ecb_bswap32 (fp);
711		1133
712	return newSVnv (ecb_binary32_to_float (fp));	1134	return newSVnv (ecb_binary32_to_float (fp));
713	}	1135	}
714		1136
715	case 27:	1137	case MISC_FLOAT64:
716	{	1138	{
717	uint64_t fp;	1139	uint64_t fp;
718	WANT (8);	1140	WANT (8);
719	memcpy (&fp, dec->cur, 8);	1141	memcpy (&fp, dec->cur, 8);
720	dec->cur += 8;	1142	dec->cur += 8;
…		…
723	fp = ecb_bswap64 (fp);	1145	fp = ecb_bswap64 (fp);
724		1146
725	return newSVnv (ecb_binary64_to_double (fp));	1147	return newSVnv (ecb_binary64_to_double (fp));
726	}	1148	}
727		1149
728	// 0..19 unassigned	1150	// 0..19 unassigned simple
729	// 24 reserved + unassigned (reserved values are not encodable)	1151	// 24 reserved + unassigned simple (reserved values are not encodable)
		1152	// 28-30 unassigned misc
		1153	// 31 break code
730	default:	1154	default:
731	ERR ("corrupted CBOR data (reserved/unassigned major 7 value)");	1155	ERR ("corrupted CBOR data (reserved/unassigned/unexpected major 7 value)");
732	}	1156	}
733		1157
734	break;	1158	break;
735	}	1159	}
736		1160
…		…
739	}	1163	}
740		1164
741	static SV *	1165	static SV *
742	decode_cbor (SV *string, CBOR *cbor, char **offset_return)	1166	decode_cbor (SV *string, CBOR *cbor, char **offset_return)
743	{	1167	{
744	dec_t dec;	1168	dec_t dec = { };
745	SV *sv;	1169	SV *sv;
		1170	STRLEN len;
		1171	char *data = SvPVbyte (string, len);
746		1172
747	/* work around bugs in 5.10 where manipulating magic values
748	* makes perl ignore the magic in subsequent accesses.
749	* also make a copy of non-PV values, to get them into a clean
750	* state (SvPV should do that, but it's buggy, see below).
751	*/
752	/*SvGETMAGIC (string);*/
753	if (SvMAGICAL (string) || !SvPOK (string))
754	string = sv_2mortal (newSVsv (string));
755
756	SvUPGRADE (string, SVt_PV);
757
758	/* work around a bug in perl 5.10, which causes SvCUR to fail an
759	* assertion with -DDEBUGGING, although SvCUR is documented to
760	* return the xpv_cur field which certainly exists after upgrading.
761	* according to nicholas clark, calling SvPOK fixes this.
762	* But it doesn't fix it, so try another workaround, call SvPV_nolen
763	* and hope for the best.
764	* Damnit, SvPV_nolen still trips over yet another assertion. This
765	* assertion business is seriously broken, try yet another workaround
766	* for the broken -DDEBUGGING.
767	*/
768	{
769	#ifdef DEBUGGING
770	STRLEN offset = SvOK (string) ? sv_len (string) : 0;
771	#else
772	STRLEN offset = SvCUR (string);
773	#endif
774
775	if (offset > cbor->max_size && cbor->max_size)	1173	if (len > cbor->max_size && cbor->max_size)
776	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",	1174	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
777	(unsigned long)SvCUR (string), (unsigned long)cbor->max_size);	1175	(unsigned long)len, (unsigned long)cbor->max_size);
778	}
779
780	sv_utf8_downgrade (string, 0);
781		1176
782	dec.cbor = *cbor;	1177	dec.cbor = *cbor;
783	dec.cur = (U8 *)SvPVX (string);	1178	dec.cur = (U8 *)data;
784	dec.end = (U8 *)SvEND (string);	1179	dec.end = (U8 *)data + len;
785	dec.err = 0;
786	dec.depth = 0;
787		1180
788	sv = decode_sv (&dec);	1181	sv = decode_sv (&dec);
789		1182
790	if (offset_return)	1183	if (offset_return)
791	*offset_return = dec.cur;	1184	*offset_return = dec.cur;
…		…
794	if (dec.cur != dec.end && !dec.err)	1187	if (dec.cur != dec.end && !dec.err)
795	dec.err = "garbage after CBOR object";	1188	dec.err = "garbage after CBOR object";
796		1189
797	if (dec.err)	1190	if (dec.err)
798	{	1191	{
		1192	if (dec.shareable)
		1193	{
		1194	// need to break cyclic links, which whould all be in shareable
		1195	int i;
		1196	SV **svp;
		1197
		1198	for (i = av_len (dec.shareable) + 1; i--; )
		1199	if ((svp = av_fetch (dec.shareable, i, 0)))
		1200	sv_setsv (*svp, &PL_sv_undef);
		1201	}
		1202
799	SvREFCNT_dec (sv);	1203	SvREFCNT_dec (sv);
800	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)SvPVX (string), (int)(uint8_t)*dec.cur);	1204	croak ("%s, at offset %d (octet 0x%02x)", dec.err, dec.cur - (U8 *)data, (int)(uint8_t)*dec.cur);
801	}	1205	}
802		1206
803	sv = sv_2mortal (sv);	1207	sv = sv_2mortal (sv);
804		1208
805	return sv;	1209	return sv;
806	}	1210	}
807		1211
		1212	/////////////////////////////////////////////////////////////////////////////
		1213	// incremental parser
		1214
		1215	#define INCR_DONE(cbor) (AvFILLp (cbor->incr_count) < 0)
		1216
		1217	// returns 0 for notyet, 1 for success or error
		1218	static int
		1219	incr_parse (CBOR *self, SV *cborstr)
		1220	{
		1221	STRLEN cur;
		1222	SvPV (cborstr, cur);
		1223
		1224	while (ecb_expect_true (self->incr_need <= cur))
		1225	{
		1226	// table of integer count bytes
		1227	static I8 incr_len[MINOR_MASK + 1] = {
		1228	0, 0, 0, 0, 0, 0, 0, 0,
		1229	0, 0, 0, 0, 0, 0, 0, 0,
		1230	0, 0, 0, 0, 0, 0, 0, 0,
		1231	1, 2, 4, 8,-1,-1,-1,-2
		1232	};
		1233
		1234	const U8 *p = SvPVX (cborstr) + self->incr_pos;
		1235	U8 m = *p & MINOR_MASK;
		1236	IV count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1237	I8 ilen = incr_len[m];
		1238
		1239	self->incr_need = self->incr_pos + 1;
		1240
		1241	if (ecb_expect_false (ilen < 0))
		1242	{
		1243	if (m != MINOR_INDEF)
		1244	return 1; // error
		1245
		1246	if (*p == (MAJOR_MISC | MINOR_INDEF))
		1247	{
		1248	if (count >= 0)
		1249	return 1; // error
		1250
		1251	count = 1;
		1252	}
		1253	else
		1254	{
		1255	av_push (self->incr_count, newSViv (-1)); //TODO: nest
		1256	count = -1;
		1257	}
		1258	}
		1259	else
		1260	{
		1261	self->incr_need += ilen;
		1262	if (ecb_expect_false (self->incr_need > cur))
		1263	return 0;
		1264
		1265	int major = *p >> MAJOR_SHIFT;
		1266
		1267	switch (major)
		1268	{
		1269	case MAJOR_BYTES >> MAJOR_SHIFT:
		1270	case MAJOR_TEXT >> MAJOR_SHIFT:
		1271	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1272	case MAJOR_MAP >> MAJOR_SHIFT:
		1273	{
		1274	UV len;
		1275
		1276	if (ecb_expect_false (ilen))
		1277	{
		1278	len = 0;
		1279
		1280	do {
		1281	len = (len << 8) | *++p;
		1282	} while (--ilen);
		1283	}
		1284	else
		1285	len = m;
		1286
		1287	switch (major)
		1288	{
		1289	case MAJOR_BYTES >> MAJOR_SHIFT:
		1290	case MAJOR_TEXT >> MAJOR_SHIFT:
		1291	self->incr_need += len;
		1292	if (ecb_expect_false (self->incr_need > cur))
		1293	return 0;
		1294
		1295	break;
		1296
		1297	case MAJOR_MAP >> MAJOR_SHIFT:
		1298	len <<= 1;
		1299	case MAJOR_ARRAY >> MAJOR_SHIFT:
		1300	if (len)
		1301	{
		1302	av_push (self->incr_count, newSViv (len + 1)); //TODO: nest
		1303	count = len + 1;
		1304	}
		1305	break;
		1306	}
		1307	}
		1308	}
		1309	}
		1310
		1311	self->incr_pos = self->incr_need;
		1312
		1313	if (count > 0)
		1314	{
		1315	while (!--count)
		1316	{
		1317	if (!AvFILLp (self->incr_count))
		1318	return 1; // done
		1319
		1320	SvREFCNT_dec_NN (av_pop (self->incr_count));
		1321	count = SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]);
		1322	}
		1323
		1324	SvIVX (AvARRAY (self->incr_count)[AvFILLp (self->incr_count)]) = count;
		1325	}
		1326	}
		1327
		1328	return 0;
		1329	}
		1330
		1331
808	/////////////////////////////////////////////////////////////////////////////	1332	/////////////////////////////////////////////////////////////////////////////
809	// XS interface functions	1333	// XS interface functions
810		1334
811	MODULE = CBOR::XS PACKAGE = CBOR::XS	1335	MODULE = CBOR::XS PACKAGE = CBOR::XS
812		1336
813	BOOT:	1337	BOOT:
814	{	1338	{
815	cbor_stash = gv_stashpv ("CBOR::XS" , 1);	1339	cbor_stash = gv_stashpv ("CBOR::XS" , 1);
816	cbor_boolean_stash = gv_stashpv ("CBOR::XS::Boolean", 1);
817	cbor_tagged_stash = gv_stashpv ("CBOR::XS::Tagged" , 1);	1340	cbor_tagged_stash = gv_stashpv ("CBOR::XS::Tagged" , 1);
818		1341
819	cbor_true = get_bool ("CBOR::XS::true");	1342	types_boolean_stash = gv_stashpv ("Types::Serialiser::Boolean", 1);
820	cbor_false = get_bool ("CBOR::XS::false");	1343	types_error_stash = gv_stashpv ("Types::Serialiser::Error" , 1);
		1344
		1345	types_true = get_bool ("Types::Serialiser::true" );
		1346	types_false = get_bool ("Types::Serialiser::false");
		1347	types_error = get_bool ("Types::Serialiser::error");
		1348
		1349	default_filter = newSVpv ("CBOR::XS::default_filter", 0);
		1350
		1351	sv_cbor = newSVpv ("CBOR", 0);
		1352	SvREADONLY_on (sv_cbor);
821	}	1353	}
822		1354
823	PROTOTYPES: DISABLE	1355	PROTOTYPES: DISABLE
824		1356
825	void CLONE (...)	1357	void CLONE (...)
826	CODE:	1358	CODE:
827	cbor_stash = 0;	1359	cbor_stash = 0;
828	cbor_boolean_stash = 0;
829	cbor_tagged_stash = 0;	1360	cbor_tagged_stash = 0;
		1361	types_error_stash = 0;
		1362	types_boolean_stash = 0;
830		1363
831	void new (char *klass)	1364	void new (char *klass)
832	PPCODE:	1365	PPCODE:
833	{	1366	{
834	SV *pv = NEWSV (0, sizeof (CBOR));	1367	SV *pv = NEWSV (0, sizeof (CBOR));
…		…
842		1375
843	void shrink (CBOR *self, int enable = 1)	1376	void shrink (CBOR *self, int enable = 1)
844	ALIAS:	1377	ALIAS:
845	shrink = F_SHRINK	1378	shrink = F_SHRINK
846	allow_unknown = F_ALLOW_UNKNOWN	1379	allow_unknown = F_ALLOW_UNKNOWN
		1380	allow_sharing = F_ALLOW_SHARING
		1381	allow_cycles = F_ALLOW_CYCLES
		1382	pack_strings = F_PACK_STRINGS
		1383	validate_utf8 = F_VALIDATE_UTF8
847	PPCODE:	1384	PPCODE:
848	{	1385	{
849	if (enable)	1386	if (enable)
850	self->flags |= ix;	1387	self->flags |= ix;
851	else	1388	else
…		…
856		1393
857	void get_shrink (CBOR *self)	1394	void get_shrink (CBOR *self)
858	ALIAS:	1395	ALIAS:
859	get_shrink = F_SHRINK	1396	get_shrink = F_SHRINK
860	get_allow_unknown = F_ALLOW_UNKNOWN	1397	get_allow_unknown = F_ALLOW_UNKNOWN
		1398	get_allow_sharing = F_ALLOW_SHARING
		1399	get_allow_cycles = F_ALLOW_CYCLES
		1400	get_pack_strings = F_PACK_STRINGS
		1401	get_validate_utf8 = F_VALIDATE_UTF8
861	PPCODE:	1402	PPCODE:
862	XPUSHs (boolSV (self->flags & ix));	1403	XPUSHs (boolSV (self->flags & ix));
863		1404
864	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)	1405	void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
865	PPCODE:	1406	PPCODE:
…		…
881	CODE:	1422	CODE:
882	RETVAL = self->max_size;	1423	RETVAL = self->max_size;
883	OUTPUT:	1424	OUTPUT:
884	RETVAL	1425	RETVAL
885		1426
886	#if 0 //TODO	1427	void filter (CBOR *self, SV *filter = 0)
887
888	void filter_cbor_object (CBOR *self, SV *cb = &PL_sv_undef)
889	PPCODE:	1428	PPCODE:
890	{
891	SvREFCNT_dec (self->cb_object);	1429	SvREFCNT_dec (self->filter);
892	self->cb_object = SvOK (cb) ? newSVsv (cb) : 0;	1430	self->filter = filter ? newSVsv (filter) : filter;
893
894	XPUSHs (ST (0));	1431	XPUSHs (ST (0));
895	}
896		1432
897	void filter_cbor_single_key_object (CBOR *self, SV *key, SV *cb = &PL_sv_undef)	1433	SV *get_filter (CBOR *self)
898	PPCODE:	1434	CODE:
899	{	1435	RETVAL = self->filter ? self->filter : NEWSV (0, 0);
900	if (!self->cb_sk_object)	1436	OUTPUT:
901	self->cb_sk_object = newHV ();	1437	RETVAL
902
903	if (SvOK (cb))
904	hv_store_ent (self->cb_sk_object, key, newSVsv (cb), 0);
905	else
906	{
907	hv_delete_ent (self->cb_sk_object, key, G_DISCARD, 0);
908
909	if (!HvKEYS (self->cb_sk_object))
910	{
911	SvREFCNT_dec (self->cb_sk_object);
912	self->cb_sk_object = 0;
913	}
914	}
915
916	XPUSHs (ST (0));
917	}
918
919	#endif
920		1438
921	void encode (CBOR *self, SV *scalar)	1439	void encode (CBOR *self, SV *scalar)
922	PPCODE:	1440	PPCODE:
923	PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN;	1441	PUTBACK; scalar = encode_cbor (scalar, self); SPAGAIN;
924	XPUSHs (scalar);	1442	XPUSHs (scalar);
…		…
937	EXTEND (SP, 2);	1455	EXTEND (SP, 2);
938	PUSHs (sv);	1456	PUSHs (sv);
939	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));	1457	PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
940	}	1458	}
941		1459
942	#if 0	1460	void incr_parse (CBOR *self, SV *cborstr)
		1461	ALIAS:
		1462	incr_parse_multiple = 1
		1463	PPCODE:
		1464	{
		1465	if (SvUTF8 (cborstr))
		1466	sv_utf8_downgrade (cborstr, 0);
		1467
		1468	if (!self->incr_count)
		1469	{
		1470	self->incr_count = newAV ();
		1471	self->incr_pos = 0;
		1472	self->incr_need = 1;
		1473
		1474	av_push (self->incr_count, newSViv (1));
		1475	}
		1476
		1477	do
		1478	{
		1479	if (!incr_parse (self, cborstr))
		1480	{
		1481	if (self->incr_need > self->max_size && self->max_size)
		1482	croak ("attempted decode of CBOR text of %lu bytes size, but max_size is set to %lu",
		1483	(unsigned long)self->incr_need, (unsigned long)self->max_size);
		1484
		1485	break;
		1486	}
		1487
		1488	SV *sv;
		1489	char *offset;
		1490
		1491	PUTBACK; sv = decode_cbor (cborstr, self, &offset); SPAGAIN;
		1492	XPUSHs (sv);
		1493
		1494	sv_chop (cborstr, offset);
		1495
		1496	av_clear (self->incr_count);
		1497	av_push (self->incr_count, newSViv (1));
		1498
		1499	self->incr_pos = 0;
		1500	self->incr_need = self->incr_pos + 1;
		1501	}
		1502	while (ix);
		1503	}
		1504
		1505	void incr_reset (CBOR *self)
		1506	CODE:
		1507	{
		1508	SvREFCNT_dec (self->incr_count);
		1509	self->incr_count = 0;
		1510	}
943		1511
944	void DESTROY (CBOR *self)	1512	void DESTROY (CBOR *self)
945	CODE:	1513	PPCODE:
946	SvREFCNT_dec (self->cb_sk_object);	1514	cbor_free (self);
947	SvREFCNT_dec (self->cb_object);
948
949	#endif
950		1515
951	PROTOTYPES: ENABLE	1516	PROTOTYPES: ENABLE
952		1517
953	void encode_cbor (SV *scalar)	1518	void encode_cbor (SV *scalar)
		1519	ALIAS:
		1520	encode_cbor = 0
		1521	encode_cbor_sharing = F_ALLOW_SHARING
954	PPCODE:	1522	PPCODE:
955	{	1523	{
956	CBOR cbor;	1524	CBOR cbor;
957	cbor_init (&cbor);	1525	cbor_init (&cbor);
		1526	cbor.flags |= ix;
958	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;	1527	PUTBACK; scalar = encode_cbor (scalar, &cbor); SPAGAIN;
959	XPUSHs (scalar);	1528	XPUSHs (scalar);
960	}	1529	}
961		1530
962	void decode_cbor (SV *cborstr)	1531	void decode_cbor (SV *cborstr)

Diff Legend

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