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.15 by root, Tue Oct 29 18:37:31 2013 UTC vs.
Revision 1.44 by root, Tue Feb 18 22:12:12 2014 UTC

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

Diff Legend

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