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.1 by root, Fri Oct 25 23:09:45 2013 UTC vs.
Revision 1.51 by root, Sun Apr 24 13:15:19 2016 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines