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.21 by root, Wed Nov 20 14:59:06 2013 UTC vs.
Revision 1.43 by root, Sun Jan 5 14:24:54 2014 UTC

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

Diff Legend

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