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.26 by root, Fri Nov 22 09:40:13 2013 UTC vs.
Revision 1.33 by root, Sat Nov 30 15:23:59 2013 UTC

… …
19# define HvNAMELEN(hv) HvNAMELEN_get (hv) 19# define HvNAMELEN(hv) HvNAMELEN_get (hv)
20#endif 20#endif
21#ifndef HvNAMEUTF8 21#ifndef HvNAMEUTF8
22# define HvNAMEUTF8(hv) 0 22# define HvNAMEUTF8(hv) 0
23#endif 23#endif
24#ifndef SvREFCNT_dec_NN
25# define SvREFCNT_dec_NN(sv) SvREFCNT_dec (sv)
26#endif
24 27
25// known tags 28// known tags
26enum cbor_tag 29enum cbor_tag
27{ 30{
28 // inofficial extensions (pending iana registration) 31 // extensions
32 CBOR_TAG_STRINGREF = 25, // http://cbor.schmorp.de/stringref
29 CBOR_TAG_PERL_OBJECT = 24, // http://cbor.schmorp.de/perl-object 33 CBOR_TAG_PERL_OBJECT = 26, // http://cbor.schmorp.de/perl-object
30 CBOR_TAG_GENERIC_OBJECT = 25, // http://cbor.schmorp.de/generic-object 34 CBOR_TAG_GENERIC_OBJECT = 27, // http://cbor.schmorp.de/generic-object
31 CBOR_TAG_VALUE_SHAREABLE = 26, // http://cbor.schmorp.de/value-sharing 35 CBOR_TAG_VALUE_SHAREABLE = 28, // http://cbor.schmorp.de/value-sharing
32 CBOR_TAG_VALUE_SHAREDREF = 27, // http://cbor.schmorp.de/value-sharing 36 CBOR_TAG_VALUE_SHAREDREF = 29, // http://cbor.schmorp.de/value-sharing
33 CBOR_TAG_STRINGREF_NAMESPACE = 65537, // http://cbor.schmorp.de/stringref 37 CBOR_TAG_STRINGREF_NAMESPACE = 256, // http://cbor.schmorp.de/stringref
34 CBOR_TAG_STRINGREF = 28, // http://cbor.schmorp.de/stringref
35 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection 38 CBOR_TAG_INDIRECTION = 22098, // http://cbor.schmorp.de/indirection
36 39
37 // rfc7049 40 // rfc7049
38 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8 41 CBOR_TAG_DATETIME = 0, // rfc4287, utf-8
39 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any 42 CBOR_TAG_TIMESTAMP = 1, // unix timestamp, any
… …
56 CBOR_TAG_MAGIC = 55799 // self-describe cbor 59 CBOR_TAG_MAGIC = 55799 // self-describe cbor
57}; 60};
58 61
59#define F_SHRINK 0x00000001UL 62#define F_SHRINK 0x00000001UL
60#define F_ALLOW_UNKNOWN 0x00000002UL 63#define F_ALLOW_UNKNOWN 0x00000002UL
61#define F_ALLOW_SHARING 0x00000004UL //TODO 64#define F_ALLOW_SHARING 0x00000004UL
62#define F_ALLOW_STRINGREF 0x00000008UL //TODO 65#define F_PACK_STRINGS 0x00000008UL
63 66
64#define INIT_SIZE 32 // initial scalar size to be allocated 67#define INIT_SIZE 32 // initial scalar size to be allocated
65 68
66#define SB do { 69#define SB do {
67#define SE } while (0) 70#define SE } while (0)
… …
79# define CBOR_SLOW 0 82# define CBOR_SLOW 0
80# define CBOR_STASH cbor_stash 83# define CBOR_STASH cbor_stash
81#endif 84#endif
82 85
83static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS:: 86static HV *cbor_stash, *types_boolean_stash, *types_error_stash, *cbor_tagged_stash; // CBOR::XS::
84static SV *types_true, *types_false, *types_error, *sv_cbor; 87static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
85 88
86typedef struct { 89typedef struct {
87 U32 flags; 90 U32 flags;
88 U32 max_depth; 91 U32 max_depth;
89 STRLEN max_size; 92 STRLEN max_size;
93 SV *filter;
90} CBOR; 94} CBOR;
91 95
92ecb_inline void 96ecb_inline void
93cbor_init (CBOR *cbor) 97cbor_init (CBOR *cbor)
94{ 98{
95 Zero (cbor, 1, CBOR); 99 Zero (cbor, 1, CBOR);
96 cbor->max_depth = 512; 100 cbor->max_depth = 512;
101}
102
103ecb_inline void
104cbor_free (CBOR *cbor)
105{
106 SvREFCNT_dec (cbor->filter);
97} 107}
98 108
99///////////////////////////////////////////////////////////////////////////// 109/////////////////////////////////////////////////////////////////////////////
100// utility functions 110// utility functions
101 111
… …
131{ 141{
132 return idx > 23 142 return idx > 23
133 ? idx > 0xffU 143 ? idx > 0xffU
134 ? idx > 0xffffU 144 ? idx > 0xffffU
135 ? idx > 0xffffffffU 145 ? idx > 0xffffffffU
146 ? 11
136 ? 7 147 : 7
137 : 6
138 : 5 148 : 5
139 : 4 149 : 4
140 : 3; 150 : 3;
141} 151}
142 152
… …
179static void 189static void
180encode_uint (enc_t *enc, int major, UV len) 190encode_uint (enc_t *enc, int major, UV len)
181{ 191{
182 need (enc, 9); 192 need (enc, 9);
183 193
184 if (len < 24) 194 if (ecb_expect_true (len < 24))
185 *enc->cur++ = major | len; 195 *enc->cur++ = major | len;
186 else if (len <= 0xff) 196 else if (ecb_expect_true (len <= 0xff))
187 { 197 {
188 *enc->cur++ = major | 24; 198 *enc->cur++ = major | 24;
189 *enc->cur++ = len; 199 *enc->cur++ = len;
190 } 200 }
191 else if (len <= 0xffff) 201 else if (len <= 0xffff)
… …
220encode_tag (enc_t *enc, UV tag) 230encode_tag (enc_t *enc, UV tag)
221{ 231{
222 encode_uint (enc, 0xc0, tag); 232 encode_uint (enc, 0xc0, tag);
223} 233}
224 234
235ecb_inline void
236encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
237{
238 encode_uint (enc, utf8 ? 0x60 : 0x40, len);
239 need (enc, len);
240 memcpy (enc->cur, str, len);
241 enc->cur += len;
242}
243
225static void 244static void
226encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 245encode_strref (enc_t *enc, int utf8, char *str, STRLEN len)
227{ 246{
228 if (ecb_expect_false (enc->cbor.flags & F_ALLOW_STRINGREF)) 247 if (ecb_expect_false (enc->cbor.flags & F_PACK_STRINGS))
229 { 248 {
230 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1); 249 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
231 250
232 if (SvOK (*svp)) 251 if (SvOK (*svp))
233 { 252 {
… …
242 sv_setuv (*svp, enc->stringref_idx); 261 sv_setuv (*svp, enc->stringref_idx);
243 ++enc->stringref_idx; 262 ++enc->stringref_idx;
244 } 263 }
245 } 264 }
246 265
247 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 266 encode_str (enc, utf8, str, len);
248 need (enc, len);
249 memcpy (enc->cur, str, len);
250 enc->cur += len;
251} 267}
252 268
253static void encode_sv (enc_t *enc, SV *sv); 269static void encode_sv (enc_t *enc, SV *sv);
254 270
255static void 271static void
… …
294 while ((he = hv_iternext (hv))) 310 while ((he = hv_iternext (hv)))
295 { 311 {
296 if (HeKLEN (he) == HEf_SVKEY) 312 if (HeKLEN (he) == HEf_SVKEY)
297 encode_sv (enc, HeSVKEY (he)); 313 encode_sv (enc, HeSVKEY (he));
298 else 314 else
299 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 315 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
300 316
301 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he)); 317 encode_sv (enc, ecb_expect_false (mg) ? hv_iterval (hv, he) : HeVAL (he));
302 } 318 }
303 319
304 if (mg) 320 if (mg)
… …
310// encode objects, arrays and special \0=false and \1=true values. 326// encode objects, arrays and special \0=false and \1=true values.
311static void 327static void
312encode_rv (enc_t *enc, SV *sv) 328encode_rv (enc_t *enc, SV *sv)
313{ 329{
314 SvGETMAGIC (sv); 330 SvGETMAGIC (sv);
315
316 if (ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING)
317 && ecb_expect_false (SvREFCNT (sv) > 1))
318 {
319 if (!enc->shareable)
320 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
321
322 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
323
324 if (SvOK (*svp))
325 {
326 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
327 encode_uint (enc, 0x00, SvUV (*svp));
328 return;
329 }
330 else
331 {
332 sv_setuv (*svp, enc->shareable_idx);
333 ++enc->shareable_idx;
334 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
335 }
336 }
337 331
338 svtype svt = SvTYPE (sv); 332 svtype svt = SvTYPE (sv);
339 333
340 if (ecb_expect_false (SvOBJECT (sv))) 334 if (ecb_expect_false (SvOBJECT (sv)))
341 { 335 {
… …
405 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 399 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
406 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash)); 400 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
407 401
408 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 402 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
409 encode_uint (enc, 0x80, count + 1); 403 encode_uint (enc, 0x80, count + 1);
410 encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 404 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
411 405
412 while (count) 406 while (count)
413 encode_sv (enc, SP[1 - count--]); 407 encode_sv (enc, SP[1 - count--]);
414 408
415 PUTBACK; 409 PUTBACK;
… …
424 encode_hv (enc, (HV *)sv); 418 encode_hv (enc, (HV *)sv);
425 else if (svt == SVt_PVAV) 419 else if (svt == SVt_PVAV)
426 encode_av (enc, (AV *)sv); 420 encode_av (enc, (AV *)sv);
427 else 421 else
428 { 422 {
423 if (ecb_expect_false (SvREFCNT (sv) > 1)
424 && ecb_expect_false (enc->cbor.flags & F_ALLOW_SHARING))
425 {
426 if (!enc->shareable)
427 enc->shareable = (HV *)sv_2mortal ((SV *)newHV ());
428
429 SV **svp = hv_fetch (enc->shareable, (char *)&sv, sizeof (sv), 1);
430
431 if (SvOK (*svp))
432 {
433 encode_tag (enc, CBOR_TAG_VALUE_SHAREDREF);
434 encode_uint (enc, 0x00, SvUV (*svp));
435 return;
436 }
437 else
438 {
439 sv_setuv (*svp, enc->shareable_idx);
440 ++enc->shareable_idx;
441 encode_tag (enc, CBOR_TAG_VALUE_SHAREABLE);
442 }
443 }
444
429 encode_tag (enc, CBOR_TAG_INDIRECTION); 445 encode_tag (enc, CBOR_TAG_INDIRECTION);
430 encode_sv (enc, sv); 446 encode_sv (enc, sv);
431 } 447 }
432} 448}
433 449
… …
474 490
475 if (SvPOKp (sv)) 491 if (SvPOKp (sv))
476 { 492 {
477 STRLEN len; 493 STRLEN len;
478 char *str = SvPV (sv, len); 494 char *str = SvPV (sv, len);
479 encode_str (enc, SvUTF8 (sv), str, len); 495 encode_strref (enc, SvUTF8 (sv), str, len);
480 } 496 }
481 else if (SvNOKp (sv)) 497 else if (SvNOKp (sv))
482 encode_nv (enc, sv); 498 encode_nv (enc, sv);
483 else if (SvIOKp (sv)) 499 else if (SvIOKp (sv))
484 { 500 {
… …
510 enc.cur = SvPVX (enc.sv); 526 enc.cur = SvPVX (enc.sv);
511 enc.end = SvEND (enc.sv); 527 enc.end = SvEND (enc.sv);
512 528
513 SvPOK_only (enc.sv); 529 SvPOK_only (enc.sv);
514 530
515 if (cbor->flags & F_ALLOW_STRINGREF) 531 if (cbor->flags & F_PACK_STRINGS)
516 { 532 {
517 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE); 533 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
518 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ()); 534 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
519 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ()); 535 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
520 } 536 }
… …
542 CBOR cbor; 558 CBOR cbor;
543 U32 depth; // recursion depth 559 U32 depth; // recursion depth
544 U32 maxdepth; // recursion depth limit 560 U32 maxdepth; // recursion depth limit
545 AV *shareable; 561 AV *shareable;
546 AV *stringref; 562 AV *stringref;
563 SV *decode_tagged;
547} dec_t; 564} dec_t;
548 565
549#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE 566#define ERR(reason) SB if (!dec->err) dec->err = reason; goto fail; SE
550 567
551#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data") 568#define WANT(len) if (ecb_expect_false (dec->cur + len > dec->end)) ERR ("unexpected end of CBOR data")
… …
736{ 753{
737 SV *sv = 0; 754 SV *sv = 0;
738 755
739 if ((*dec->cur & 31) == 31) 756 if ((*dec->cur & 31) == 31)
740 { 757 {
758 // indefinite length strings
741 ++dec->cur; 759 ++dec->cur;
742 760
761 unsigned char major = *dec->cur & 0xe0;
762
743 sv = newSVpvn ("", 0); 763 sv = newSVpvn ("", 0);
744 764
745 // not very fast, and certainly not robust against illegal input
746 for (;;) 765 for (;;)
747 { 766 {
748 WANT (1); 767 WANT (1);
749 768
769 if ((*dec->cur ^ major) >= 31)
750 if (*dec->cur == (0xe0 | 31)) 770 if (*dec->cur == (0xe0 | 31))
751 { 771 {
752 ++dec->cur; 772 ++dec->cur;
753 break; 773 break;
754 } 774 }
775 else
776 ERR ("corrupted CBOR data (invalid chunks in indefinite length string)");
755 777
756 sv_catsv (sv, decode_sv (dec)); 778 STRLEN len = decode_uint (dec);
779
780 WANT (len);
781 sv_catpvn (sv, dec->cur, len);
782 dec->cur += len;
757 } 783 }
758 } 784 }
759 else 785 else
760 { 786 {
761 STRLEN len = decode_uint (dec); 787 STRLEN len = decode_uint (dec);
… …
905 931
906 default: 932 default:
907 { 933 {
908 sv = decode_sv (dec); 934 sv = decode_sv (dec);
909 935
936 dSP;
937 ENTER; SAVETMPS; PUSHMARK (SP);
938 EXTEND (SP, 2);
939 PUSHs (newSVuv (tag));
940 PUSHs (sv);
941
942 PUTBACK;
943 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
944 SPAGAIN;
945
946 if (SvTRUE (ERRSV))
947 {
948 FREETMPS; LEAVE;
949 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
950 }
951
952 if (count)
953 {
954 SvREFCNT_dec (sv);
955 sv = SvREFCNT_inc (POPs);
956 }
957 else
958 {
910 AV *av = newAV (); 959 AV *av = newAV ();
911 av_push (av, newSVuv (tag)); 960 av_push (av, newSVuv (tag));
912 av_push (av, sv); 961 av_push (av, sv);
913 962
914 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 963 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
915 ? cbor_tagged_stash 964 ? cbor_tagged_stash
916 : gv_stashpv ("CBOR::XS::Tagged" , 1); 965 : gv_stashpv ("CBOR::XS::Tagged" , 1);
917
918 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash); 966 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
967 }
968
969 PUTBACK;
970
971 FREETMPS; LEAVE;
919 } 972 }
920 break; 973 break;
921 } 974 }
922 975
923 return sv; 976 return sv;
… …
1069 1122
1070 types_true = get_bool ("Types::Serialiser::true" ); 1123 types_true = get_bool ("Types::Serialiser::true" );
1071 types_false = get_bool ("Types::Serialiser::false"); 1124 types_false = get_bool ("Types::Serialiser::false");
1072 types_error = get_bool ("Types::Serialiser::error"); 1125 types_error = get_bool ("Types::Serialiser::error");
1073 1126
1127 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1128
1074 sv_cbor = newSVpv ("CBOR", 0); 1129 sv_cbor = newSVpv ("CBOR", 0);
1075 SvREADONLY_on (sv_cbor); 1130 SvREADONLY_on (sv_cbor);
1076} 1131}
1077 1132
1078PROTOTYPES: DISABLE 1133PROTOTYPES: DISABLE
… …
1099void shrink (CBOR *self, int enable = 1) 1154void shrink (CBOR *self, int enable = 1)
1100 ALIAS: 1155 ALIAS:
1101 shrink = F_SHRINK 1156 shrink = F_SHRINK
1102 allow_unknown = F_ALLOW_UNKNOWN 1157 allow_unknown = F_ALLOW_UNKNOWN
1103 allow_sharing = F_ALLOW_SHARING 1158 allow_sharing = F_ALLOW_SHARING
1104 allow_stringref = F_ALLOW_STRINGREF 1159 pack_strings = F_PACK_STRINGS
1105 PPCODE: 1160 PPCODE:
1106{ 1161{
1107 if (enable) 1162 if (enable)
1108 self->flags |= ix; 1163 self->flags |= ix;
1109 else 1164 else
… …
1115void get_shrink (CBOR *self) 1170void get_shrink (CBOR *self)
1116 ALIAS: 1171 ALIAS:
1117 get_shrink = F_SHRINK 1172 get_shrink = F_SHRINK
1118 get_allow_unknown = F_ALLOW_UNKNOWN 1173 get_allow_unknown = F_ALLOW_UNKNOWN
1119 get_allow_sharing = F_ALLOW_SHARING 1174 get_allow_sharing = F_ALLOW_SHARING
1120 get_allow_stringref = F_ALLOW_STRINGREF 1175 get_pack_strings = F_PACK_STRINGS
1121 PPCODE: 1176 PPCODE:
1122 XPUSHs (boolSV (self->flags & ix)); 1177 XPUSHs (boolSV (self->flags & ix));
1123 1178
1124void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1179void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1125 PPCODE: 1180 PPCODE:
… …
1138 XPUSHs (ST (0)); 1193 XPUSHs (ST (0));
1139 1194
1140int get_max_size (CBOR *self) 1195int get_max_size (CBOR *self)
1141 CODE: 1196 CODE:
1142 RETVAL = self->max_size; 1197 RETVAL = self->max_size;
1198 OUTPUT:
1199 RETVAL
1200
1201void filter (CBOR *self, SV *filter = 0)
1202 PPCODE:
1203 SvREFCNT_dec (self->filter);
1204 self->filter = filter ? newSVsv (filter) : filter;
1205 XPUSHs (ST (0));
1206
1207SV *get_filter (CBOR *self)
1208 CODE:
1209 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
1143 OUTPUT: 1210 OUTPUT:
1144 RETVAL 1211 RETVAL
1145 1212
1146void encode (CBOR *self, SV *scalar) 1213void encode (CBOR *self, SV *scalar)
1147 PPCODE: 1214 PPCODE:
… …
1162 EXTEND (SP, 2); 1229 EXTEND (SP, 2);
1163 PUSHs (sv); 1230 PUSHs (sv);
1164 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1231 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1165} 1232}
1166 1233
1234void DESTROY (CBOR *self)
1235 PPCODE:
1236 cbor_free (self);
1237
1167PROTOTYPES: ENABLE 1238PROTOTYPES: ENABLE
1168 1239
1169void encode_cbor (SV *scalar) 1240void encode_cbor (SV *scalar)
1170 PPCODE: 1241 PPCODE:
1171{ 1242{

Diff Legend

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