ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/CBOR-XS/XS.xs
(Generate patch)

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines