Msgpuck.xs

filter: Statementstmt 88.5% 163 / 184 Branchbran 71.4% 60 / 84 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 83.2% 223 / 268 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« msgpuck.h ↑ Summary blib/lib/DR/Msgpuck.pm »
1 #include "EXTERN.h"
2 #include "perl.h"
3 #include "XSUB.h"
4  
5  
6 #define MP_SOURCE 1
7 #include "msgpuck.h"
8  
9 const char *
10 176 _msgunpuck(const char *p, const char *pe, SV **res, int utf)
11 {
12 352 switch(mp_typeof(*p)) {
13 2 case MP_NIL:
14 2 mp_decode_nil(&p);
15 2 *res = newSV(0);
16 2 break;
17  
18 6 case MP_BOOL: {
19 HV *stash;
20 6 ▶ if (mp_decode_bool(&p)) {
Branch: 1 branch
BranchTrueFalseTotal
if (mp_decode_bool(&p)) { 3 3 6
21 3 stash = gv_stashpvn(
22 "DR::Msgpuck::True",
23 sizeof("DR::Msgpuck::True"),
24 GV_ADD|GV_NOINIT
25 );
26 3 *res = newRV_noinc(newSViv(1));
27 3 sv_bless(*res, stash);
28 } else {
29 3 stash = gv_stashpvn(
30 "DR::Msgpuck::False",
31 sizeof("DR::Msgpuck::False"),
32 GV_ADD|GV_NOINIT
33 );
34 3 *res = newRV_noinc(newSViv(0));
35 3 sv_bless(*res, stash);
36 }
37 6 break;
38 }
39  
40 14 case MP_UINT:
41 14 *res = newSViv( mp_decode_uint(&p) );
42 14 break;
43  
44 4 case MP_INT:
45 4 *res = newSViv( mp_decode_int(&p) );
46 4 break;
47  
48 0 case MP_FLOAT:
49 0 *res = newSVnv( mp_decode_float(&p) );
50 0 break;
51  
52 2 case MP_DOUBLE:
53 2 *res = newSVnv( mp_decode_double(&p) );
54 2 break;
55  
56 109 case MP_STR: {
57 const char *s;
58 uint32_t len;
59 109 s = mp_decode_str(&p, &len);
60 109 ▶ if (p > pe)
Branch: 1 branch
BranchTrueFalseTotal
if (p > pe) 0 109 109
61 0 goto UNEXPECTED_EOF;
62 109 ▶ *res = newSVpvn_flags(s, len, utf ? SVf_UTF8 : 0);
Branch: 1 branch
BranchTrueFalseTotal
*res = newSVpvn_flags(s, len, utf ? SVf_UTF8 : 0); 6 103 109
63 109 break;
64 }
65  
66 12 case MP_ARRAY: {
67 uint32_t l, i;
68 12 l = mp_decode_array(&p);
69 12 AV *a = newAV();
70 12 sv_2mortal((SV *)a);
71 36 ▶ for (i = 0; i < l; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < l; i++) { 24 12 36
72 24 SV *item = 0;
73 24 ▶ if (p >= pe)
Branch: 1 branch
BranchTrueFalseTotal
if (p >= pe) 0 24 24
74 0 goto UNEXPECTED_EOF;
75 24 p = _msgunpuck(p, pe, &item, utf);
76 24 av_push(a, item);
77 }
78 12 *res = newRV((SV *)a);
79 12 break;
80 }
81 27 case MP_MAP: {
82 uint32_t l, i;
83 27 l = mp_decode_map(&p);
84 27 HV * h = newHV();
85 27 sv_2mortal((SV *)h);
86 85 ▶ for (i = 0; i < l; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < l; i++) { 58 27 85
87 58 SV *k = 0;
88 58 SV *v = 0;
89 58 ▶ if (p >= pe)
Branch: 1 branch
BranchTrueFalseTotal
if (p >= pe) 0 58 58
90 0 goto UNEXPECTED_EOF;
91 58 p = _msgunpuck(p, pe, &k, utf);
92 58 sv_2mortal(k);
93 58 ▶ if (p >= pe)
Branch: 1 branch
BranchTrueFalseTotal
if (p >= pe) 0 58 58
94 0 goto UNEXPECTED_EOF;
95 58 p = _msgunpuck(p, pe, &v, utf);
96 58 hv_store_ent(h, k, v, 0);
97 }
98 27 *res = newRV((SV *)h);
99 27 break;
100 }
101  
102 0 case MP_EXT:
103 0 croak("Msgpack extencions don't provided yet");
104 0 default:
105 0 croak("Unexpected symbol 0x%02x", 0xFF & (int)(*p));
106 }
107 176 return p;
108 0 UNEXPECTED_EOF:
109 0 croak("Unexpected EOF msgunpack str");
110 }
111  
112 void
113 386 _msgpuck(SV *o, SV *out)
114 {
115 386 STRLEN len = sv_len(out);
116 STRLEN size, olen;
117 char *p;
118  
119  
120 // null
121 386 ▶ if (!SvOK(o)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(o)) { 5 381 386
122 5 size = mp_sizeof_nil();
123 5 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 5 0 5
p = SvGROW(out, len + size); 0 5 5
124 5 SvCUR_set(out, len + size);
125 5 mp_encode_nil(p + len);
126 5 return;
127 }
128  
129 381 ▶ if (SvROK(o)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvROK(o)) { 88 293 381
130 88 o = SvRV(o);
131 88 ▶ if (SvOBJECT(o)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOBJECT(o)) { 14 74 88
132 14 SvGETMAGIC(o);
133 14 HV *stash = SvSTASH(o);
134 14 GV *mtd = gv_fetchmethod_autoload(stash, "TO_MSGPACK", 0);
135 14 ▶ if (!mtd)
Branch: 1 branch
BranchTrueFalseTotal
if (!mtd) 0 14 14
136 0 croak("Object has no method 'msgpack'");
137 14 dSP;
138 14 ENTER;
139 14 SAVETMPS;
140 14 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 14 14
141 14 ▶ XPUSHs (sv_bless (sv_2mortal (newRV_inc(o)), stash));
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs (sv_bless (sv_2mortal (newRV_inc(o)), stash)); 0 14 14
142 14 PUTBACK;
143 14 call_sv((SV *)GvCV(mtd), G_SCALAR);
144 14 SPAGAIN;
145  
146 14 SV *pkt = POPs;
147  
148 14 ▶ if (!SvOK(pkt))
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(pkt)) 0 14 14
149 0 croak("O->msgp[ua]ck returned undef");
150  
151 14 const char *s = SvPV(pkt, size);
152  
153 14 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 14 0 14
p = SvGROW(out, len + size); 0 14 14
154 14 SvCUR_set(out, len + size);
155 14 memcpy(p + len, s, size);
156  
157 14 PUTBACK;
158 14 ▶ FREETMPS;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; 14 0 14
159 14 LEAVE;
160  
161 14 return;
162 }
163  
164 74 switch(SvTYPE(o)) {
165 25 case SVt_PVAV: {
166 25 AV *a = (AV *)o;
167 25 size_t asize = av_len(a) + 1;
168 25 size = mp_sizeof_array(asize);
169 25 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 25 0 25
p = SvGROW(out, len + size); 0 25 25
170 25 SvCUR_set(out, len + size);
171 25 mp_encode_array(p + len, asize);
172  
173 int i;
174 98 ▶ for (i = 0; i < asize; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < asize; i++) { 73 25 98
175 73 SV **item = av_fetch(a, i, 0);
176 73 _msgpuck(*item, out);
177 }
178 25 break;
179 }
180 49 case SVt_PVHV: {
181 49 HV *h = (HV *)o;
182 49 size_t hsize = hv_iterinit(h);
183 49 size = mp_sizeof_map(hsize);
184 49 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 49 0 49
p = SvGROW(out, len + size); 0 49 49
185 49 SvCUR_set(out, len + size);
186 49 mp_encode_map(p + len, hsize);
187  
188 110 for (;;) {
189 159 HE * iter = hv_iternext(h);
190 159 ▶ if (!iter)
Branch: 1 branch
BranchTrueFalseTotal
if (!iter) 49 110 159
191 49 break;
192  
193 110 SV *k = hv_iterkeysv(iter);
194 110 SV *v = HeVAL(iter);
195 110 _msgpuck(k, out);
196 110 _msgpuck(v, out);
197 }
198  
199 49 break;
200 }
201  
202 0 default:
203 0 croak("Can't serialize refs");
204 }
205 74 return;
206 }
207  
208  
209 293 switch(SvTYPE(o)) {
210 222 case SVt_PV:
211 case SVt_PVIV:
212 case SVt_PVNV:
213 case SVt_PVMG:
214 case SVt_REGEXP:
215 222 ▶ if (!looks_like_number(o)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!looks_like_number(o)) { 211 11 222
216 SvPV(o, olen);
217 211 size = mp_sizeof_str(olen);
218 211 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 211 0 211
p = SvGROW(out, len + size); 60 151 211
219 211 SvCUR_set(out, len + size);
220 422 mp_encode_str(p + len, sv_pv(o), olen);
221 211 return;
222 }
223 case SVt_NV: {
224 14 NV v = SvNV(o);
225 14 IV iv = (IV)v;
226 14 ▶ if (v != iv) {
Branch: 1 branch
BranchTrueFalseTotal
if (v != iv) { 7 7 14
227 7 size = mp_sizeof_double(v);
228 7 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 7 0 7
p = SvGROW(out, len + size); 1 6 7
229 7 SvCUR_set(out, len + size);
230 7 mp_encode_double(p + len, v);
231 7 return;
232 }
233 }
234 case SVt_IV: {
235 75 IV v = SvIV(o);
236 75 ▶ if (v >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (v >= 0) { 63 12 75
237 63 size = mp_sizeof_uint(v);
238 63 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 63 0 63
p = SvGROW(out, len + size); 1 62 63
239 63 SvCUR_set(out, len + size);
240 63 mp_encode_uint(p + len, v);
241 } else {
242 12 size = mp_sizeof_int(v);
243 12 ▶ p = SvGROW(out, len + size);
Branch: 2 branches
BranchTrueFalseTotal
p = SvGROW(out, len + size); 12 0 12
p = SvGROW(out, len + size); 0 12 12
244 12 SvCUR_set(out, len + size);
245 12 mp_encode_int(p + len, v);
246 }
247 75 return;
248 }
249 0 default:
250 0 croak("Internal msgpack error %d", SvTYPE(o));
251 }
252 }
253  
254  
255 MODULE = DR::Msgpuck PACKAGE = DR::Msgpuck
256  
257  
258 SV *
259 msgpack(o)
260 SV *o
261  
262 INIT:
263 93 RETVAL = newSVpv("", 0);
264 CODE:
265 93 _msgpuck(o, RETVAL);
266 OUTPUT:
267 RETVAL
268  
269 SV *
270 msgunpack(str)
271 SV *str
272  
273 INIT:
274 size_t size;
275 const char *ptr;
276  
277 CODE:
278 32 ▶ if (!SvOK(str)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(str)) { 0 32 32
279 0 croak("Cant unpack undefined value");
280 }
281 32 ptr = SvPV(str, size);
282 32 _msgunpuck(ptr, ptr + size, &RETVAL, 0);
283 OUTPUT:
284 RETVAL
285  
286 SV *
287 msgunpack_utf8(str)
288 SV *str
289  
290 INIT:
291 size_t size;
292 const char *ptr;
293  
294 CODE:
295 4 ▶ if (!SvOK(str)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(str)) { 0 4 4
296 0 croak("Cant unpack undefined value");
297 }
298 4 ptr = SvPV(str, size);
299 4 _msgunpuck(ptr, ptr + size, &RETVAL, 1);
300 OUTPUT:
301 RETVAL
302  
303 size_t msgunpack_check(str)
304 SV *str
305 PROTOTYPE: $
306 CODE:
307 int res;
308 size_t len;
309 11 ▶ if (SvOK(str)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(str)) { 10 1 11
310 10 const char *p = SvPV(str, len);
311 10 ▶ if (len > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (len > 0) { 9 1 10
312 9 const char *pe = p + len;
313 9 const char *begin = p;
314 9 ▶ if (mp_check(&p, pe) == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (mp_check(&p, pe) == 0) { 5 4 9
315 5 RETVAL = p - begin;
316 } else {
317 4 RETVAL = 0;
318 }
319 } else {
320 1 RETVAL = 0;
321 }
322 } else {
323 1 RETVAL = 0;
324 }
325 OUTPUT:
326 RETVAL
327  
« msgpuck.h ↑ Summary blib/lib/DR/Msgpuck.pm »