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.19 by root, Wed Nov 20 02:03:09 2013 UTC vs.
Revision 1.30 by root, Thu Nov 28 11:36:53 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
… …
54 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8 57 CBOR_TAG_MIME = 36, // mime message rfc2045, utf-8
55 58
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 //TODO
62#define F_DEDUP_STRINGS 0x00000008UL //TODO 65#define F_ALLOW_STRINGREF 0x00000008UL //TODO
63#define F_DEDUP_KEYS 0x00000010UL //TODO
64 66
65#define INIT_SIZE 32 // initial scalar size to be allocated 67#define INIT_SIZE 32 // initial scalar size to be allocated
66 68
67#define SB do { 69#define SB do {
68#define SE } while (0) 70#define SE } while (0)
… …
80# define CBOR_SLOW 0 82# define CBOR_SLOW 0
81# define CBOR_STASH cbor_stash 83# define CBOR_STASH cbor_stash
82#endif 84#endif
83 85
84static 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::
85static SV *types_true, *types_false, *types_error, *sv_cbor; 87static SV *types_true, *types_false, *types_error, *sv_cbor, *default_filter;
86 88
87typedef struct { 89typedef struct {
88 U32 flags; 90 U32 flags;
89 U32 max_depth; 91 U32 max_depth;
90 STRLEN max_size; 92 STRLEN max_size;
93 SV *filter;
91} CBOR; 94} CBOR;
92 95
93ecb_inline void 96ecb_inline void
94cbor_init (CBOR *cbor) 97cbor_init (CBOR *cbor)
95{ 98{
96 Zero (cbor, 1, CBOR); 99 Zero (cbor, 1, CBOR);
97 cbor->max_depth = 512; 100 cbor->max_depth = 512;
101}
102
103ecb_inline void
104cbor_free (CBOR *cbor)
105{
106 SvREFCNT_dec (cbor->filter);
98} 107}
99 108
100///////////////////////////////////////////////////////////////////////////// 109/////////////////////////////////////////////////////////////////////////////
101// utility functions 110// utility functions
102 111
… …
124 SvPV_renew (sv, SvCUR (sv) + 1); 133 SvPV_renew (sv, SvCUR (sv) + 1);
125#endif 134#endif
126 } 135 }
127} 136}
128 137
138// minimum length of a string to be registered for stringref
139ecb_inline int
140minimum_string_length (UV idx)
141{
142 return idx > 23
143 ? idx > 0xffU
144 ? idx > 0xffffU
145 ? idx > 0xffffffffU
146 ? 11
147 : 7
148 : 5
149 : 4
150 : 3;
151}
152
129///////////////////////////////////////////////////////////////////////////// 153/////////////////////////////////////////////////////////////////////////////
130// encoder 154// encoder
131 155
132// structure used for encoding CBOR 156// structure used for encoding CBOR
133typedef struct 157typedef struct
… …
135 char *cur; // SvPVX (sv) + current output position 159 char *cur; // SvPVX (sv) + current output position
136 char *end; // SvEND (sv) 160 char *end; // SvEND (sv)
137 SV *sv; // result scalar 161 SV *sv; // result scalar
138 CBOR cbor; 162 CBOR cbor;
139 U32 depth; // recursion level 163 U32 depth; // recursion level
140 HV *stringref; // string => index, or 0 164 HV *stringref[2]; // string => index, or 0 ([0] = bytes, [1] = utf-8)
165 UV stringref_idx;
141 HV *shareable; // ptr => index, or 0 166 HV *shareable; // ptr => index, or 0
142 UV shareable_idx; 167 UV shareable_idx;
143} enc_t; 168} enc_t;
144 169
145ecb_inline void 170ecb_inline void
… …
199 *enc->cur++ = len >> 8; 224 *enc->cur++ = len >> 8;
200 *enc->cur++ = len; 225 *enc->cur++ = len;
201 } 226 }
202} 227}
203 228
204static void 229ecb_inline void
230encode_tag (enc_t *enc, UV tag)
231{
232 encode_uint (enc, 0xc0, tag);
233}
234
235ecb_inline void
205encode_str (enc_t *enc, int utf8, char *str, STRLEN len) 236encode_str (enc_t *enc, int utf8, char *str, STRLEN len)
206{ 237{
207 encode_uint (enc, utf8 ? 0x60 : 0x40, len); 238 encode_uint (enc, utf8 ? 0x60 : 0x40, len);
208 need (enc, len); 239 need (enc, len);
209 memcpy (enc->cur, str, len); 240 memcpy (enc->cur, str, len);
210 enc->cur += len; 241 enc->cur += len;
211} 242}
212 243
213ecb_inline void 244static void
214encode_tag (enc_t *enc, UV tag) 245encode_strref (enc_t *enc, int utf8, char *str, STRLEN len)
215{ 246{
216 encode_uint (enc, 0xc0, tag); 247 if (ecb_expect_false (enc->cbor.flags & F_ALLOW_STRINGREF))
248 {
249 SV **svp = hv_fetch (enc->stringref[!!utf8], str, len, 1);
250
251 if (SvOK (*svp))
252 {
253 // already registered, use stringref
254 encode_tag (enc, CBOR_TAG_STRINGREF);
255 encode_uint (enc, 0x00, SvUV (*svp));
256 return;
257 }
258 else if (len >= minimum_string_length (enc->stringref_idx))
259 {
260 // register only
261 sv_setuv (*svp, enc->stringref_idx);
262 ++enc->stringref_idx;
263 }
264 }
265
266 encode_str (enc, utf8, str, len);
217} 267}
218 268
219static void encode_sv (enc_t *enc, SV *sv); 269static void encode_sv (enc_t *enc, SV *sv);
220 270
221static void 271static void
… …
260 while ((he = hv_iternext (hv))) 310 while ((he = hv_iternext (hv)))
261 { 311 {
262 if (HeKLEN (he) == HEf_SVKEY) 312 if (HeKLEN (he) == HEf_SVKEY)
263 encode_sv (enc, HeSVKEY (he)); 313 encode_sv (enc, HeSVKEY (he));
264 else 314 else
265 encode_str (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he)); 315 encode_strref (enc, HeKUTF8 (he), HeKEY (he), HeKLEN (he));
266 316
267 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));
268 } 318 }
269 319
270 if (mg) 320 if (mg)
… …
371 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv) 421 if (count == 1 && SvROK (TOPs) && SvRV (TOPs) == sv)
372 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash)); 422 croak ("%s::FREEZE(CBOR) method returned same object as was passed instead of a new one", HvNAME (stash));
373 423
374 encode_tag (enc, CBOR_TAG_PERL_OBJECT); 424 encode_tag (enc, CBOR_TAG_PERL_OBJECT);
375 encode_uint (enc, 0x80, count + 1); 425 encode_uint (enc, 0x80, count + 1);
376 encode_str (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash)); 426 encode_strref (enc, HvNAMEUTF8 (stash), HvNAME (stash), HvNAMELEN (stash));
377 427
378 while (count) 428 while (count)
379 encode_sv (enc, SP[1 - count--]); 429 encode_sv (enc, SP[1 - count--]);
380 430
381 PUTBACK; 431 PUTBACK;
… …
440 490
441 if (SvPOKp (sv)) 491 if (SvPOKp (sv))
442 { 492 {
443 STRLEN len; 493 STRLEN len;
444 char *str = SvPV (sv, len); 494 char *str = SvPV (sv, len);
445 encode_str (enc, SvUTF8 (sv), str, len); 495 encode_strref (enc, SvUTF8 (sv), str, len);
446 } 496 }
447 else if (SvNOKp (sv)) 497 else if (SvNOKp (sv))
448 encode_nv (enc, sv); 498 encode_nv (enc, sv);
449 else if (SvIOKp (sv)) 499 else if (SvIOKp (sv))
450 { 500 {
… …
475 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE)); 525 enc.sv = sv_2mortal (NEWSV (0, INIT_SIZE));
476 enc.cur = SvPVX (enc.sv); 526 enc.cur = SvPVX (enc.sv);
477 enc.end = SvEND (enc.sv); 527 enc.end = SvEND (enc.sv);
478 528
479 SvPOK_only (enc.sv); 529 SvPOK_only (enc.sv);
530
531 if (cbor->flags & F_ALLOW_STRINGREF)
532 {
533 encode_tag (&enc, CBOR_TAG_STRINGREF_NAMESPACE);
534 enc.stringref[0]= (HV *)sv_2mortal ((SV *)newHV ());
535 enc.stringref[1]= (HV *)sv_2mortal ((SV *)newHV ());
536 }
537
480 encode_sv (&enc, scalar); 538 encode_sv (&enc, scalar);
481 539
482 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv)); 540 SvCUR_set (enc.sv, enc.cur - SvPVX (enc.sv));
483 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings 541 *SvEND (enc.sv) = 0; // many xs functions expect a trailing 0 for text strings
484 542
… …
499 const char *err; // parse error, if != 0 557 const char *err; // parse error, if != 0
500 CBOR cbor; 558 CBOR cbor;
501 U32 depth; // recursion depth 559 U32 depth; // recursion depth
502 U32 maxdepth; // recursion depth limit 560 U32 maxdepth; // recursion depth limit
503 AV *shareable; 561 AV *shareable;
562 AV *stringref;
563 SV *decode_tagged;
504} dec_t; 564} dec_t;
505 565
506#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
507 567
508#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")
… …
606 666
607static void 667static void
608decode_he (dec_t *dec, HV *hv) 668decode_he (dec_t *dec, HV *hv)
609{ 669{
610 // for speed reasons, we specialcase single-string 670 // for speed reasons, we specialcase single-string
611 // byte or utf-8 strings as keys. 671 // byte or utf-8 strings as keys, but only when !stringref
612 672
673 if (ecb_expect_true (!dec->stringref))
613 if (*dec->cur >= 0x40 && *dec->cur <= 0x40 + 27) 674 if (*dec->cur >= 0x40 && *dec->cur <= 0x40 + 27)
614 { 675 {
615 I32 len = decode_uint (dec); 676 I32 len = decode_uint (dec);
616 char *key = (char *)dec->cur; 677 char *key = (char *)dec->cur;
617 678
618 dec->cur += len; 679 dec->cur += len;
619 680
681 if (ecb_expect_false (dec->stringref))
682 av_push (dec->stringref, newSVpvn (key, len));
683
620 hv_store (hv, key, len, decode_sv (dec), 0); 684 hv_store (hv, key, len, decode_sv (dec), 0);
685
686 return;
621 } 687 }
622 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27) 688 else if (*dec->cur >= 0x60 && *dec->cur <= 0x60 + 27)
623 { 689 {
624 I32 len = decode_uint (dec); 690 I32 len = decode_uint (dec);
625 char *key = (char *)dec->cur; 691 char *key = (char *)dec->cur;
626 692
627 dec->cur += len; 693 dec->cur += len;
628 694
695 if (ecb_expect_false (dec->stringref))
696 av_push (dec->stringref, newSVpvn_utf8 (key, len, 1));
697
629 hv_store (hv, key, -len, decode_sv (dec), 0); 698 hv_store (hv, key, -len, decode_sv (dec), 0);
699
700 return;
630 } 701 }
631 else 702
632 {
633 SV *k = decode_sv (dec); 703 SV *k = decode_sv (dec);
634 SV *v = decode_sv (dec); 704 SV *v = decode_sv (dec);
635 705
636 hv_store_ent (hv, k, v, 0); 706 hv_store_ent (hv, k, v, 0);
637 SvREFCNT_dec (k); 707 SvREFCNT_dec (k);
638 }
639} 708}
640 709
641static SV * 710static SV *
642decode_hv (dec_t *dec) 711decode_hv (dec_t *dec)
643{ 712{
… …
709 STRLEN len = decode_uint (dec); 778 STRLEN len = decode_uint (dec);
710 779
711 WANT (len); 780 WANT (len);
712 sv = newSVpvn (dec->cur, len); 781 sv = newSVpvn (dec->cur, len);
713 dec->cur += len; 782 dec->cur += len;
783
784 if (ecb_expect_false (dec->stringref)
785 && SvCUR (sv) >= minimum_string_length (AvFILLp (dec->stringref) + 1))
786 av_push (dec->stringref, SvREFCNT_inc_NN (sv));
714 } 787 }
715 788
716 if (utf8) 789 if (utf8)
717 SvUTF8_on (sv); 790 SvUTF8_on (sv);
718 791
… …
732 WANT (1); 805 WANT (1);
733 806
734 switch (tag) 807 switch (tag)
735 { 808 {
736 case CBOR_TAG_MAGIC: 809 case CBOR_TAG_MAGIC:
737 return decode_sv (dec); 810 sv = decode_sv (dec);
811 break;
738 812
739 case CBOR_TAG_INDIRECTION: 813 case CBOR_TAG_INDIRECTION:
740 return newRV_noinc (decode_sv (dec)); 814 sv = newRV_noinc (decode_sv (dec));
815 break;
816
817 case CBOR_TAG_STRINGREF_NAMESPACE:
818 {
819 ENTER; SAVETMPS;
820
821 SAVESPTR (dec->stringref);
822 dec->stringref = (AV *)sv_2mortal ((SV *)newAV ());
823
824 sv = decode_sv (dec);
825
826 FREETMPS; LEAVE;
827 }
828 break;
829
830 case CBOR_TAG_STRINGREF:
831 {
832 if ((*dec->cur >> 5) != 0)
833 ERR ("corrupted CBOR data (stringref index not an unsigned integer)");
834
835 UV idx = decode_uint (dec);
836
837 if (!dec->stringref || (int)idx > AvFILLp (dec->stringref))
838 ERR ("corrupted CBOR data (stringref index out of bounds or outside namespace)");
839
840 sv = newSVsv (AvARRAY (dec->stringref)[idx]);
841 }
842 break;
741 843
742 case CBOR_TAG_VALUE_SHAREABLE: 844 case CBOR_TAG_VALUE_SHAREABLE:
743 { 845 {
744 if (ecb_expect_false (!dec->shareable)) 846 if (ecb_expect_false (!dec->shareable))
745 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ()); 847 dec->shareable = (AV *)sv_2mortal ((SV *)newAV ());
… …
749 851
750 SV *osv = decode_sv (dec); 852 SV *osv = decode_sv (dec);
751 sv_setsv (sv, osv); 853 sv_setsv (sv, osv);
752 SvREFCNT_dec_NN (osv); 854 SvREFCNT_dec_NN (osv);
753 } 855 }
754 856 break;
755 return sv;
756 857
757 case CBOR_TAG_VALUE_SHAREDREF: 858 case CBOR_TAG_VALUE_SHAREDREF:
758 { 859 {
759 if ((*dec->cur >> 5) != 0) 860 if ((*dec->cur >> 5) != 0)
760 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)"); 861 ERR ("corrupted CBOR data (sharedref index not an unsigned integer)");
761 862
762 UV idx = decode_uint (dec); 863 UV idx = decode_uint (dec);
763 864
764 if (!dec->shareable || idx > AvFILLp (dec->shareable)) 865 if (!dec->shareable || (int)idx > AvFILLp (dec->shareable))
765 ERR ("corrupted CBOR data (sharedref index out of bounds)"); 866 ERR ("corrupted CBOR data (sharedref index out of bounds)");
766 867
767 return SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]); 868 sv = SvREFCNT_inc_NN (AvARRAY (dec->shareable)[idx]);
768 } 869 }
870 break;
769 871
770 case CBOR_TAG_PERL_OBJECT: 872 case CBOR_TAG_PERL_OBJECT:
771 { 873 {
772 sv = decode_sv (dec); 874 sv = decode_sv (dec);
773 875
… …
813 sv = SvREFCNT_inc (POPs); 915 sv = SvREFCNT_inc (POPs);
814 916
815 PUTBACK; 917 PUTBACK;
816 918
817 FREETMPS; LEAVE; 919 FREETMPS; LEAVE;
818
819 return sv;
820 } 920 }
921 break;
821 922
822 default: 923 default:
823 { 924 {
824 sv = decode_sv (dec); 925 sv = decode_sv (dec);
825 926
927 dSP;
928 ENTER; SAVETMPS; PUSHMARK (SP);
929 EXTEND (SP, 2);
930 PUSHs (newSVuv (tag));
931 PUSHs (sv);
932
933 PUTBACK;
934 int count = call_sv (dec->cbor.filter ? dec->cbor.filter : default_filter, G_ARRAY | G_EVAL);
935 SPAGAIN;
936
937 if (SvTRUE (ERRSV))
938 {
939 FREETMPS; LEAVE;
940 ERR (SvPVutf8_nolen (sv_2mortal (SvREFCNT_inc (ERRSV))));
941 }
942
943 if (count)
944 {
945 SvREFCNT_dec (sv);
946 sv = SvREFCNT_inc (POPs);
947 }
948 else
949 {
826 AV *av = newAV (); 950 AV *av = newAV ();
827 av_push (av, newSVuv (tag)); 951 av_push (av, newSVuv (tag));
828 av_push (av, sv); 952 av_push (av, sv);
829 953
830 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash 954 HV *tagged_stash = !CBOR_SLOW || cbor_tagged_stash
831 ? cbor_tagged_stash 955 ? cbor_tagged_stash
832 : gv_stashpv ("CBOR::XS::Tagged" , 1); 956 : gv_stashpv ("CBOR::XS::Tagged" , 1);
833
834 return sv_bless (newRV_noinc ((SV *)av), tagged_stash); 957 sv = sv_bless (newRV_noinc ((SV *)av), tagged_stash);
835 } 958 }
959
960 PUTBACK;
961
962 FREETMPS; LEAVE;
963 }
964 break;
836 } 965 }
966
967 return sv;
837 968
838fail: 969fail:
839 SvREFCNT_dec (sv); 970 SvREFCNT_dec (sv);
840 return &PL_sv_undef; 971 return &PL_sv_undef;
841} 972}
… …
982 1113
983 types_true = get_bool ("Types::Serialiser::true" ); 1114 types_true = get_bool ("Types::Serialiser::true" );
984 types_false = get_bool ("Types::Serialiser::false"); 1115 types_false = get_bool ("Types::Serialiser::false");
985 types_error = get_bool ("Types::Serialiser::error"); 1116 types_error = get_bool ("Types::Serialiser::error");
986 1117
1118 default_filter = newSVpv ("CBOR::XS::default_filter", 0);
1119
987 sv_cbor = newSVpv ("CBOR", 0); 1120 sv_cbor = newSVpv ("CBOR", 0);
988 SvREADONLY_on (sv_cbor); 1121 SvREADONLY_on (sv_cbor);
989} 1122}
990 1123
991PROTOTYPES: DISABLE 1124PROTOTYPES: DISABLE
… …
1012void shrink (CBOR *self, int enable = 1) 1145void shrink (CBOR *self, int enable = 1)
1013 ALIAS: 1146 ALIAS:
1014 shrink = F_SHRINK 1147 shrink = F_SHRINK
1015 allow_unknown = F_ALLOW_UNKNOWN 1148 allow_unknown = F_ALLOW_UNKNOWN
1016 allow_sharing = F_ALLOW_SHARING 1149 allow_sharing = F_ALLOW_SHARING
1017 dedup_keys = F_DEDUP_KEYS 1150 allow_stringref = F_ALLOW_STRINGREF
1018 dedup_strings = F_DEDUP_STRINGS
1019 PPCODE: 1151 PPCODE:
1020{ 1152{
1021 if (enable) 1153 if (enable)
1022 self->flags |= ix; 1154 self->flags |= ix;
1023 else 1155 else
… …
1029void get_shrink (CBOR *self) 1161void get_shrink (CBOR *self)
1030 ALIAS: 1162 ALIAS:
1031 get_shrink = F_SHRINK 1163 get_shrink = F_SHRINK
1032 get_allow_unknown = F_ALLOW_UNKNOWN 1164 get_allow_unknown = F_ALLOW_UNKNOWN
1033 get_allow_sharing = F_ALLOW_SHARING 1165 get_allow_sharing = F_ALLOW_SHARING
1034 get_dedup_keys = F_DEDUP_KEYS 1166 get_allow_stringref = F_ALLOW_STRINGREF
1035 get_dedup_strings = F_DEDUP_STRINGS
1036 PPCODE: 1167 PPCODE:
1037 XPUSHs (boolSV (self->flags & ix)); 1168 XPUSHs (boolSV (self->flags & ix));
1038 1169
1039void max_depth (CBOR *self, U32 max_depth = 0x80000000UL) 1170void max_depth (CBOR *self, U32 max_depth = 0x80000000UL)
1040 PPCODE: 1171 PPCODE:
… …
1053 XPUSHs (ST (0)); 1184 XPUSHs (ST (0));
1054 1185
1055int get_max_size (CBOR *self) 1186int get_max_size (CBOR *self)
1056 CODE: 1187 CODE:
1057 RETVAL = self->max_size; 1188 RETVAL = self->max_size;
1189 OUTPUT:
1190 RETVAL
1191
1192void filter (CBOR *self, SV *filter = 0)
1193 PPCODE:
1194 SvREFCNT_dec (self->filter);
1195 self->filter = filter ? newSVsv (filter) : filter;
1196 XPUSHs (ST (0));
1197
1198SV *get_filter (CBOR *self)
1199 CODE:
1200 RETVAL = self->filter ? self->filter : NEWSV (0, 0);
1058 OUTPUT: 1201 OUTPUT:
1059 RETVAL 1202 RETVAL
1060 1203
1061void encode (CBOR *self, SV *scalar) 1204void encode (CBOR *self, SV *scalar)
1062 PPCODE: 1205 PPCODE:
… …
1077 EXTEND (SP, 2); 1220 EXTEND (SP, 2);
1078 PUSHs (sv); 1221 PUSHs (sv);
1079 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr)))); 1222 PUSHs (sv_2mortal (newSVuv (offset - SvPVX (cborstr))));
1080} 1223}
1081 1224
1225void DESTROY (CBOR *self)
1226 PPCODE:
1227 cbor_free (self);
1228
1082PROTOTYPES: ENABLE 1229PROTOTYPES: ENABLE
1083 1230
1084void encode_cbor (SV *scalar) 1231void encode_cbor (SV *scalar)
1085 PPCODE: 1232 PPCODE:
1086{ 1233{

Diff Legend

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