💾 Archived View for gmi.noulin.net › gitRepositories › netSerial › file › netSerial.c.gcov.gmi captured on 2024-09-29 at 01:15:12. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2023-01-29)
-=-=-=-=-=-=-
netSerial.c.gcov (297007B)
1 -: 0:Source:/home/remy/git/sw/publicGits/netSerial/netSerial.c
2 -: 0:Graph:netSerial.gcno
3 -: 0:Data:netSerial.gcda
4 -: 0:Runs:7
5 -: 0:Programs:1
6 -: 1:
7 -: 2:#include "libsheepyObject.h"
8 -: 3:#include "netSerial.h"
9 -: 4:#include "netSerialInternal.h"
10 -: 5:
11 -: 6:#include <stdlib.h>
12 -: 7:#include <string.h>
13 -: 8:#include <stdio.h>
14 -: 9:
15 -: 10:#define lv logVarG
16 -: 11:
17 -: 12:void initiateNetSerialLevel0(smallJsont *self);
18 -: 13:void initiateNetSerialLevel1(smallJsont *self);
19 -: 14:void initiateNetSerialLevel2(smallJsont *self);
20 -: 15:void initiateNetSerial(smallJsont *self);
21 -: 16:void registerMethodsNetSerialLevel0(smallJsonFunctionst *f);
22 -: 17:void registerMethodsNetSerialLevel1(smallJsonFunctionst *f);
23 -: 18:void registerMethodsNetSerialLevel2(smallJsonFunctionst *f);
24 -: 19:void registerMethodsNetSerial(smallJsonFunctionst *f);
25 -: 20:void initiateAllocateNetSerialLevel0(smallJsont **self);
26 -: 21:void initiateAllocateNetSerialLevel1(smallJsont **self);
27 -: 22:void initiateAllocateNetSerialLevel2(smallJsont **self);
28 -: 23:void initiateAllocateNetSerial(smallJsont **self);
29 -: 24:void finalizeNetSerial(void);
30 -: 25:smallJsont* allocNetSerialLevel0(void);
31 -: 26:smallJsont* allocNetSerialLevel1(void);
32 -: 27:smallJsont* allocNetSerialLevel2(void);
33 -: 28:smallJsont* allocNetSerial(void);
34 -: 29:internal const char* helpNetSerial(smallJsont *self);
35 -: 30:internal smallBytest* serialNetSerialLevel0(smallJsont *self);
36 -: 31:internal smallBytest* serialNetSerialLevel1(smallJsont *self);
37 -: 32:internal smallBytest* serialNetSerialLevel2(smallJsont *self);
38 -: 33:internal smallBytest* serialNetSerial(smallJsont *self);
39 -: 34:internal smallJsont* deserialNetSerialLevel0(smallJsont *self, smallBytest *data);
40 -: 35:internal smallJsont* deserialNetSerialLevel1(smallJsont *self, smallBytest *data);
41 -: 36:internal smallJsont* deserialNetSerialLevel2(smallJsont *self, smallBytest *data);
42 -: 37:internal smallJsont* deserialNetSerial(smallJsont *self, smallBytest *data);
43 -: 38:
44 -: 39:internal void uintToNetTypeVarint(sBytest **buf, u8 type, u64 value);
45 -: 40:internal void uintToVarint(sBytest **buf, u64 value);
46 -: 41:internal u64 netTypeVarintToUint(u8 **buf);
47 -: 42:internal u64 varintToUint(u8 **buf);
48 -: 43:
49 -: 44:internal sBytest* netSerialLevel0(smallt *o);
50 -: 45:internal void dictNetSerialLevel0(sBytest **r, sDictt *dict);
51 -: 46:internal void arrayNetSerialLevel0(sBytest **r, sArrayt *array);
52 -: 47:internal sBytest* netSerialLevel1(smallt *o);
53 -: 48:internal void dictNetSerialLevel1(sBytest **r, sDictt *dict, contextt *ctx);
54 -: 49:internal void arrayNetSerialLevel1(sBytest **r, sArrayt *array, contextt *ctx);
55 -: 50:internal sBytest* netSerialLevel2(smallt *o);
56 -: 51:internal void dictNetSerialLevel2(sBytest **r, sDictt *dict, contextt *ctx, bool packed);
57 -: 52:internal void arrayNetSerialLevel2(sBytest **r, sArrayt *array, contextt *ctx, bool packed);
58 -: 53:internal sBytest* netSerial(smallt *o);
59 -: 54:internal void dictNetSerial(sBytest **r, sDictt *dict, contextt *ctx, packingT packing);
60 -: 55:internal void arrayNetSerial(sBytest **r, sArrayt *array, contextt *ctx, packingT packing);
61 -: 56:
62 -: 57:internal smallt* netDeserialLevel0(sBytest *obj);
63 -: 58:internal void dictNetDeserialLevel0(sDictt **dict, char **data);
64 -: 59:internal void arrayNetDeserialLevel0(sArrayt **array, char **data);
65 -: 60:internal smallt* netDeserialLevel1(sBytest *obj);
66 -: 61:internal void dictNetDeserialLevel1(sDictt **dict, u8 **data, contextt *ctx);
67 -: 62:internal void arrayNetDeserialLevel1(sArrayt **array, u8 **data, contextt *ctx);
68 -: 63:internal smallt* netDeserialLevel2(sBytest *obj);
69 -: 64:internal void dictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed);
70 -: 65:internal u8 isDictUniform(sDictt *dict);
71 -: 66:internal u8 isArrayUniform(sArrayt *array);
72 -: 67:internal void uniformDictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed);
73 -: 68:internal void arrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed);
74 -: 69:internal void uniformArrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed);
75 -: 70:internal smallt* netDeserial(sBytest *obj);
76 -: 71:internal void dictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed);
77 -: 72:internal void uniformDictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed);
78 -: 73:internal void arrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed);
79 -: 74:internal void uniformArrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed);
80 -: 75:
81 -: 76:/* enable/disable logging */
82 -: 77:/* #undef pLog */
83 -: 78:/* #define pLog(...) */
84 -: 79:
85 function initiateNetSerialLevel0 called 0 returned 0% blocks executed 0%
86 #####: 80:void initiateNetSerialLevel0(smallJsont *self) {
87 -: 81:
88 #####: 82: initiateSmallJson(self);
89 call 0 never executed
90 -: 83:
91 #####: 84: self->type = "netSerial";
92 #####: 85: if (!netSerialF) {
93 branch 0 never executed
94 branch 1 never executed
95 #####: 86: netSerialF = malloc(sizeof(smallJsonFunctionst));
96 #####: 87: registerMethodsNetSerialLevel0(netSerialF);
97 call 0 never executed
98 #####: 88: pErrorNot0(atexit(finalizeNetSerial));
99 call 0 never executed
100 branch 1 never executed
101 branch 2 never executed
102 branch 3 never executed
103 branch 4 never executed
104 call 5 never executed
105 branch 6 never executed
106 branch 7 never executed
107 call 8 never executed
108 branch 9 never executed
109 branch 10 never executed
110 call 11 never executed
111 call 12 never executed
112 call 13 never executed
113 call 14 never executed
114 -: 89: }
115 #####: 90: self->f = netSerialF;
116 #####: 91:}
117 -: 92:
118 function initiateNetSerialLevel1 called 0 returned 0% blocks executed 0%
119 #####: 93:void initiateNetSerialLevel1(smallJsont *self) {
120 -: 94:
121 #####: 95: initiateSmallJson(self);
122 call 0 never executed
123 -: 96:
124 #####: 97: self->type = "netSerial";
125 #####: 98: if (!netSerialF) {
126 branch 0 never executed
127 branch 1 never executed
128 #####: 99: netSerialF = malloc(sizeof(smallJsonFunctionst));
129 #####: 100: registerMethodsNetSerialLevel1(netSerialF);
130 call 0 never executed
131 #####: 101: pErrorNot0(atexit(finalizeNetSerial));
132 call 0 never executed
133 branch 1 never executed
134 branch 2 never executed
135 branch 3 never executed
136 branch 4 never executed
137 call 5 never executed
138 branch 6 never executed
139 branch 7 never executed
140 call 8 never executed
141 branch 9 never executed
142 branch 10 never executed
143 call 11 never executed
144 call 12 never executed
145 call 13 never executed
146 call 14 never executed
147 -: 102: }
148 #####: 103: self->f = netSerialF;
149 #####: 104:}
150 -: 105:
151 function initiateNetSerialLevel2 called 0 returned 0% blocks executed 0%
152 #####: 106:void initiateNetSerialLevel2(smallJsont *self) {
153 -: 107:
154 #####: 108: initiateSmallJson(self);
155 call 0 never executed
156 -: 109:
157 #####: 110: self->type = "netSerial";
158 #####: 111: if (!netSerialF) {
159 branch 0 never executed
160 branch 1 never executed
161 #####: 112: netSerialF = malloc(sizeof(smallJsonFunctionst));
162 #####: 113: registerMethodsNetSerialLevel2(netSerialF);
163 call 0 never executed
164 #####: 114: pErrorNot0(atexit(finalizeNetSerial));
165 call 0 never executed
166 branch 1 never executed
167 branch 2 never executed
168 branch 3 never executed
169 branch 4 never executed
170 call 5 never executed
171 branch 6 never executed
172 branch 7 never executed
173 call 8 never executed
174 branch 9 never executed
175 branch 10 never executed
176 call 11 never executed
177 call 12 never executed
178 call 13 never executed
179 call 14 never executed
180 -: 115: }
181 #####: 116: self->f = netSerialF;
182 #####: 117:}
183 -: 118:
184 function initiateNetSerial called 12 returned 100% blocks executed 40%
185 12: 119:void initiateNetSerial(smallJsont *self) {
186 -: 120:
187 12: 121: initiateSmallJson(self);
188 call 0 returned 100%
189 -: 122:
190 12: 123: self->type = "netSerial";
191 12: 124: if (!netSerialF) {
192 branch 0 taken 50% (fallthrough)
193 branch 1 taken 50%
194 6: 125: netSerialF = malloc(sizeof(smallJsonFunctionst));
195 6: 126: registerMethodsNetSerial(netSerialF);
196 call 0 returned 100%
197 6: 127: pErrorNot0(atexit(finalizeNetSerial));
198 call 0 returned 100%
199 branch 1 taken 0% (fallthrough)
200 branch 2 taken 100%
201 branch 3 never executed
202 branch 4 never executed
203 call 5 never executed
204 branch 6 never executed
205 branch 7 never executed
206 call 8 never executed
207 branch 9 never executed
208 branch 10 never executed
209 call 11 never executed
210 call 12 never executed
211 call 13 never executed
212 call 14 never executed
213 -: 128: }
214 12: 129: self->f = netSerialF;
215 12: 130:}
216 -: 131:
217 function registerMethodsNetSerialLevel0 called 0 returned 0% blocks executed 0%
218 #####: 132:void registerMethodsNetSerialLevel0(smallJsonFunctionst *f) {
219 -: 133:
220 #####: 134: registerMethodsSmallJson(f);
221 call 0 never executed
222 #####: 135: f->help = helpNetSerial;
223 #####: 136: f->serial = serialNetSerialLevel0;
224 #####: 137: f->deserial = deserialNetSerialLevel0;
225 #####: 138:}
226 -: 139:
227 function registerMethodsNetSerialLevel1 called 0 returned 0% blocks executed 0%
228 #####: 140:void registerMethodsNetSerialLevel1(smallJsonFunctionst *f) {
229 -: 141:
230 #####: 142: registerMethodsSmallJson(f);
231 call 0 never executed
232 #####: 143: f->help = helpNetSerial;
233 #####: 144: f->serial = serialNetSerialLevel1;
234 #####: 145: f->deserial = deserialNetSerialLevel1;
235 #####: 146:}
236 -: 147:
237 function registerMethodsNetSerialLevel2 called 0 returned 0% blocks executed 0%
238 #####: 148:void registerMethodsNetSerialLevel2(smallJsonFunctionst *f) {
239 -: 149:
240 #####: 150: registerMethodsSmallJson(f);
241 call 0 never executed
242 #####: 151: f->help = helpNetSerial;
243 #####: 152: f->serial = serialNetSerialLevel2;
244 #####: 153: f->deserial = deserialNetSerialLevel2;
245 #####: 154:}
246 -: 155:
247 function registerMethodsNetSerial called 6 returned 100% blocks executed 100%
248 6: 156:void registerMethodsNetSerial(smallJsonFunctionst *f) {
249 -: 157:
250 6: 158: registerMethodsSmallJson(f);
251 call 0 returned 100%
252 6: 159: f->help = helpNetSerial;
253 6: 160: f->serial = serialNetSerial;
254 6: 161: f->deserial = deserialNetSerial;
255 6: 162:}
256 -: 163:
257 function initiateAllocateNetSerialLevel0 called 0 returned 0% blocks executed 0%
258 #####: 164:void initiateAllocateNetSerialLevel0(smallJsont **self) {
259 -: 165:
260 #####: 166: if (self) {
261 branch 0 never executed
262 branch 1 never executed
263 #####: 167: initiateG(self); // call initiateAllocateSmallJson to initialize the container recycling system
264 call 0 never executed
265 #####: 168: if (*self) {
266 branch 0 never executed
267 branch 1 never executed
268 #####: 169: initiateNetSerialLevel0(*self);
269 call 0 never executed
270 -: 170: }
271 -: 171: }
272 #####: 172:}
273 -: 173:
274 function initiateAllocateNetSerialLevel1 called 0 returned 0% blocks executed 0%
275 #####: 174:void initiateAllocateNetSerialLevel1(smallJsont **self) {
276 -: 175:
277 #####: 176: if (self) {
278 branch 0 never executed
279 branch 1 never executed
280 #####: 177: initiateG(self); // call initiateAllocateSmallJson to initialize the container recycling system
281 call 0 never executed
282 #####: 178: if (*self) {
283 branch 0 never executed
284 branch 1 never executed
285 #####: 179: initiateNetSerialLevel1(*self);
286 call 0 never executed
287 -: 180: }
288 -: 181: }
289 #####: 182:}
290 -: 183:
291 function initiateAllocateNetSerialLevel2 called 0 returned 0% blocks executed 0%
292 #####: 184:void initiateAllocateNetSerialLevel2(smallJsont **self) {
293 -: 185:
294 #####: 186: if (self) {
295 branch 0 never executed
296 branch 1 never executed
297 #####: 187: initiateG(self); // call initiateAllocateSmallJson to initialize the container recycling system
298 call 0 never executed
299 #####: 188: if (*self) {
300 branch 0 never executed
301 branch 1 never executed
302 #####: 189: initiateNetSerialLevel2(*self);
303 call 0 never executed
304 -: 190: }
305 -: 191: }
306 #####: 192:}
307 -: 193:
308 function initiateAllocateNetSerial called 0 returned 0% blocks executed 0%
309 #####: 194:void initiateAllocateNetSerial(smallJsont **self) {
310 -: 195:
311 #####: 196: if (self) {
312 branch 0 never executed
313 branch 1 never executed
314 #####: 197: initiateG(self); // call initiateAllocateSmallJson to initialize the container recycling system
315 call 0 never executed
316 #####: 198: if (*self) {
317 branch 0 never executed
318 branch 1 never executed
319 #####: 199: initiateNetSerial(*self);
320 call 0 never executed
321 -: 200: }
322 -: 201: }
323 #####: 202:}
324 -: 203:
325 function finalizeNetSerial called 6 returned 100% blocks executed 100%
326 6: 204:void finalizeNetSerial(void) {
327 -: 205:
328 6: 206: if (netSerialF) {
329 branch 0 taken 100% (fallthrough)
330 branch 1 taken 0%
331 6: 207: free(netSerialF);
332 6: 208: netSerialF = NULL;
333 -: 209: }
334 6: 210:}
335 -: 211:
336 function allocNetSerialLevel0 called 0 returned 0% blocks executed 0%
337 #####: 212:smallJsont* allocNetSerialLevel0(void) {
338 #####: 213: smallJsont *r = NULL;
339 -: 214:
340 #####: 215: initiateAllocateNetSerialLevel0(&r);
341 call 0 never executed
342 #####: 216: ret r;
343 -: 217:}
344 -: 218:
345 function allocNetSerialLevel1 called 0 returned 0% blocks executed 0%
346 #####: 219:smallJsont* allocNetSerialLevel1(void) {
347 #####: 220: smallJsont *r = NULL;
348 -: 221:
349 #####: 222: initiateAllocateNetSerialLevel1(&r);
350 call 0 never executed
351 #####: 223: ret r;
352 -: 224:}
353 -: 225:
354 function allocNetSerialLevel2 called 0 returned 0% blocks executed 0%
355 #####: 226:smallJsont* allocNetSerialLevel2(void) {
356 #####: 227: smallJsont *r = NULL;
357 -: 228:
358 #####: 229: initiateAllocateNetSerialLevel2(&r);
359 call 0 never executed
360 #####: 230: ret r;
361 -: 231:}
362 -: 232:
363 function allocNetSerial called 0 returned 0% blocks executed 0%
364 #####: 233:smallJsont* allocNetSerial(void) {
365 #####: 234: smallJsont *r = NULL;
366 -: 235:
367 #####: 236: initiateAllocateNetSerial(&r);
368 call 0 never executed
369 #####: 237: ret r;
370 -: 238:}
371 -: 239:
372 -: 240:
373 function helpNetSerial called 0 returned 0% blocks executed 0%
374 #####: 241:internal const char* helpNetSerial(smallJsont UNUSED *self) {
375 #####: 242: ret "TODO helpNetSerial \n" helpTextSmallJson;
376 -: 243:}
377 -: 244:
378 -: 245:/**
379 -: 246: * encode type in lower nibble, uint value in high nibble and next bytes as varuint
380 -: 247: */
381 function uintToNetTypeVarint called 120 returned 100% blocks executed 100%
382 120: 248:internal void uintToNetTypeVarint(sBytest **buf, u8 type, u64 value) {
383 120: 249: u64 c = value;
384 -: 250: /* encode b0..2 */
385 120: 251: u8 b = type + ((c & 0x7) << 4);
386 120: 252: if (c & 0xFFFFFFFFFFFFFFF8) {
387 branch 0 taken 10% (fallthrough)
388 branch 1 taken 90%
389 12: 253: b |= 0x80;
390 12: 254: sBytesPush(buf, b);
391 call 0 returned 100%
392 12: 255: c >>=3;
393 -: 256: /* encode b3..9 ...*/
394 49: 257: while(c) {
395 branch 0 taken 68%
396 branch 1 taken 32%
397 25: 258: b = c & 0x7F;
398 25: 259: if (c & 0xFFFFFFFFFFFFFF80)
399 branch 0 taken 52% (fallthrough)
400 branch 1 taken 48%
401 13: 260: b |= 0x80;
402 25: 261: sBytesPush(buf, b);
403 call 0 returned 100%
404 25: 262: c >>=7;
405 -: 263: }
406 -: 264: }
407 -: 265: else
408 108: 266: sBytesPush(buf, b);
409 call 0 returned 100%
410 120: 267:}
411 -: 268:
412 -: 269:/**
413 -: 270: * encode uint as varuint
414 -: 271: */
415 function uintToVarint called 191 returned 100% blocks executed 90%
416 191: 272:internal void uintToVarint(sBytest **buf, u64 value) {
417 191: 273: u64 c = value;
418 191: 274: u8 b = c & 0x7F;
419 191: 275: if (c & 0xFFFFFFFFFFFFFF80) {
420 branch 0 taken 2% (fallthrough)
421 branch 1 taken 98%
422 3: 276: b |= 0x80;
423 3: 277: sBytesPush(buf, b);
424 call 0 returned 100%
425 3: 278: c >>=7;
426 -: 279: /* encode b7..14 ...*/
427 9: 280: while(c) {
428 branch 0 taken 50%
429 branch 1 taken 50%
430 3: 281: b = c & 0x7F;
431 3: 282: if (c & 0xFFFFFFFFFFFFFF80)
432 branch 0 taken 0% (fallthrough)
433 branch 1 taken 100%
434 #####: 283: b |= 0x80;
435 3: 284: sBytesPush(buf, b);
436 call 0 returned 100%
437 3: 285: c >>=7;
438 -: 286: }
439 -: 287: }
440 -: 288: else
441 188: 289: sBytesPush(buf, b);
442 call 0 returned 100%
443 191: 290:}
444 -: 291:
445 -: 292:/**
446 -: 293: * decode type and varuint to uint
447 -: 294: */
448 function netTypeVarintToUint called 120 returned 100% blocks executed 100%
449 120: 295:internal u64 netTypeVarintToUint(u8 **buf) {
450 120: 296: u64 r = 0;
451 -: 297:
452 120: 298: r = (**buf >> 4) & 0x7;
453 -: 299:
454 120: 300: u8 c = 0;
455 265: 301: while (**buf & 0x80) {
456 branch 0 taken 17%
457 branch 1 taken 83% (fallthrough)
458 25: 302: (*buf)++;
459 -: 303: // note: keep 0x7FUL to use 64 bit shift operation, without UL a 32 bit shift operation is use and then casted to 64 bit
460 25: 304: r |= (**buf & 0x7FUL) << (7*c+3);
461 25: 305: c++;
462 -: 306: }
463 120: 307: (*buf)++;
464 120: 308: ret r;
465 -: 309:}
466 -: 310:
467 -: 311:/**
468 -: 312: * decode varuint to uint
469 -: 313: */
470 function varintToUint called 191 returned 100% blocks executed 100%
471 191: 314:internal u64 varintToUint(u8 **buf) {
472 191: 315: u64 r = 0;
473 -: 316:
474 191: 317: r = (**buf) & 0x7F;
475 191: 318: u8 c = 1;
476 385: 319: while (**buf & 0x80) {
477 branch 0 taken 2%
478 branch 1 taken 98% (fallthrough)
479 3: 320: (*buf)++;
480 -: 321: // note: keep 0x7FUL to use 64 bit shift operation, without UL a 32 bit shift operation is use and then casted to 64 bit
481 3: 322: r |= (**buf & 0x7FUL) << (7*c);
482 3: 323: c++;
483 -: 324: }
484 191: 325: (*buf)++;
485 191: 326: ret r;
486 -: 327:}
487 -: 328:
488 -: 329:// -------------------------------------
489 -: 330:// Serializers
490 -: 331:
491 -: 332:// level 0
492 -: 333:// like smallJson with ints and length encoded as varints
493 -: 334:
494 -: 335:/**
495 -: 336: * serializer top function
496 -: 337: */
497 function netSerialLevel0 called 0 returned 0% blocks executed 0%
498 #####: 338:internal sBytest* netSerialLevel0(smallt *o) {
499 #####: 339: sBytest *r = NULL;
500 #####: 340: sBytest *B = NULL;
501 -: 341:
502 #####: 342: switch(o->type) {
503 branch 0 never executed
504 branch 1 never executed
505 branch 2 never executed
506 branch 3 never executed
507 branch 4 never executed
508 branch 5 never executed
509 branch 6 never executed
510 branch 7 never executed
511 branch 8 never executed
512 branch 9 never executed
513 -: 343: case UNDEFINED:
514 #####: 344: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
515 call 0 never executed
516 #####: 345: break;
517 -: 346: case BOOL: {
518 #####: 347: u8 c = NET_SERIAL_TYPES[(u8)o->type];
519 -: 348: // set bit 4 when true
520 #####: 349: if (((sBoolt *)&(o->type))->value)
521 branch 0 never executed
522 branch 1 never executed
523 #####: 350: c |= (1<<4);
524 #####: 351: sBytesPush(&r, c);
525 call 0 never executed
526 -: 352: }
527 #####: 353: break;
528 -: 354: case CONTAINER:
529 -: 355: // undefined
530 #####: 356: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
531 call 0 never executed
532 #####: 357: break;
533 -: 358: case DICT:
534 #####: 359: dictNetSerialLevel0(&r, (sDictt *)&(o->type));
535 call 0 never executed
536 #####: 360: break;
537 -: 361: case DOUBLE:
538 #####: 362: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
539 call 0 never executed
540 #####: 363: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
541 call 0 never executed
542 #####: 364: break;
543 -: 365: case INT: {
544 -: 366: // encode int to varint
545 -: 367: // v is int64_t to convert to varint
546 #####: 368: i64 v = ((sIntt *)&(o->type))->value;
547 -: 369: // encode v with arithmetic shifts
548 #####: 370: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
549 call 0 never executed
550 -: 371: }
551 #####: 372: break;
552 -: 373: case STRING:
553 #####: 374: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
554 call 0 never executed
555 #####: 375: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
556 call 0 never executed
557 #####: 376: break;
558 -: 377: case ARRAY:
559 #####: 378: arrayNetSerialLevel0(&r, (sArrayt *)&(o->type));
560 call 0 never executed
561 #####: 379: break;
562 -: 380: case BYTES:
563 #####: 381: B = (sBytest *)&(o->type);
564 #####: 382: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
565 call 0 never executed
566 #####: 383: sBytesPushBuffer(&r, &(B->data), B->count);
567 call 0 never executed
568 #####: 384: break;
569 -: 385: }
570 #####: 386: ret r;
571 -: 387:}
572 -: 388:
573 -: 389:/**
574 -: 390: * serialize dictionary
575 -: 391: *
576 -: 392: * the serialized dict is pushed to r.
577 -: 393: * All elements are serialized recursively
578 -: 394: *
579 -: 395: * the data in containers is not serialized
580 -: 396: *
581 -: 397: * \param
582 -: 398: * r small bytes object
583 -: 399: * dict dictionary to serialize
584 -: 400: */
585 function dictNetSerialLevel0 called 0 returned 0% blocks executed 0%
586 #####: 401:internal void dictNetSerialLevel0(sBytest **r, sDictt *dict) {
587 #####: 402: sBytest *B = NULL;
588 -: 403:
589 #####: 404: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
590 call 0 never executed
591 -: 405:
592 #####: 406: forEachSDict(dict, e) {
593 branch 0 never executed
594 branch 1 never executed
595 #####: 407: if (e->key) {
596 branch 0 never executed
597 branch 1 never executed
598 #####: 408: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
599 call 0 never executed
600 -: 409:
601 #####: 410: switch(e->data->type) {
602 branch 0 never executed
603 branch 1 never executed
604 branch 2 never executed
605 branch 3 never executed
606 branch 4 never executed
607 branch 5 never executed
608 branch 6 never executed
609 branch 7 never executed
610 branch 8 never executed
611 branch 9 never executed
612 -: 411: case UNDEFINED:
613 #####: 412: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
614 call 0 never executed
615 #####: 413: break;
616 -: 414: case BOOL: {
617 #####: 415: u8 c = NET_SERIAL_TYPES[(u8)e->data->type];
618 -: 416: // set bit 4 when true
619 #####: 417: if (((sBoolt *)(e->data))->value)
620 branch 0 never executed
621 branch 1 never executed
622 #####: 418: c |= (1<<4);
623 #####: 419: sBytesPush(r, c);
624 call 0 never executed
625 -: 420: }
626 #####: 421: break;
627 -: 422: case CONTAINER:
628 -: 423: // undefined
629 #####: 424: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
630 call 0 never executed
631 #####: 425: break;
632 -: 426: case DICT:
633 #####: 427: dictNetSerialLevel0(r, (sDictt *)(e->data));
634 call 0 never executed
635 #####: 428: break;
636 -: 429: case DOUBLE:
637 #####: 430: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
638 call 0 never executed
639 #####: 431: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
640 call 0 never executed
641 #####: 432: break;
642 -: 433: case INT: {
643 -: 434: // encode int to varint
644 -: 435: // v is int64_t to convert to varint
645 #####: 436: i64 v = ((sIntt *)(e->data))->value;
646 -: 437: // encode v with arithmetic shifts
647 #####: 438: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
648 call 0 never executed
649 -: 439: }
650 #####: 440: break;
651 -: 441: case STRING:
652 #####: 442: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
653 call 0 never executed
654 #####: 443: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
655 call 0 never executed
656 #####: 444: break;
657 -: 445: case ARRAY:
658 #####: 446: arrayNetSerialLevel0(r, (sArrayt *)(e->data));
659 call 0 never executed
660 #####: 447: break;
661 -: 448: case BYTES:
662 #####: 449: B = (sBytest *)(e->data);
663 #####: 450: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
664 call 0 never executed
665 #####: 451: sBytesPushBuffer(r, &(B->data), B->count);
666 call 0 never executed
667 #####: 452: break;
668 -: 453: }
669 -: 454: }
670 -: 455: }
671 #####: 456: ret;
672 -: 457:}
673 -: 458:
674 -: 459:/**
675 -: 460: * serialize array
676 -: 461: *
677 -: 462: * the serialized array is pushed to r.
678 -: 463: * All elements are serialized recursively
679 -: 464: *
680 -: 465: * the data in containers is not serialized
681 -: 466: *
682 -: 467: * \param
683 -: 468: * r small bytes object
684 -: 469: * array to serialize
685 -: 470: */
686 function arrayNetSerialLevel0 called 0 returned 0% blocks executed 0%
687 #####: 471:internal void arrayNetSerialLevel0(sBytest **r, sArrayt *array) {
688 #####: 472: sBytest *B = NULL;
689 -: 473:
690 #####: 474: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
691 call 0 never executed
692 -: 475:
693 #####: 476: forEachSArray(array, e) {
694 branch 0 never executed
695 branch 1 never executed
696 #####: 477: if (!e) {
697 branch 0 never executed
698 branch 1 never executed
699 -: 478: // empty slots are represented as undefined elements
700 #####: 479: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
701 call 0 never executed
702 -: 480: }
703 -: 481: else {
704 #####: 482: switch(e->type) {
705 branch 0 never executed
706 branch 1 never executed
707 branch 2 never executed
708 branch 3 never executed
709 branch 4 never executed
710 branch 5 never executed
711 branch 6 never executed
712 branch 7 never executed
713 branch 8 never executed
714 branch 9 never executed
715 -: 483: case UNDEFINED:
716 #####: 484: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
717 call 0 never executed
718 #####: 485: break;
719 -: 486: case BOOL: {
720 #####: 487: u8 c = NET_SERIAL_TYPES[(u8)e->type];
721 -: 488: // set bit 4 when true
722 #####: 489: if (((sBoolt *)&(e->type))->value)
723 branch 0 never executed
724 branch 1 never executed
725 #####: 490: c |= (1<<4);
726 #####: 491: sBytesPush(r, c);
727 call 0 never executed
728 -: 492: }
729 #####: 493: break;
730 -: 494: case CONTAINER:
731 -: 495: // undefined
732 #####: 496: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
733 call 0 never executed
734 #####: 497: break;
735 -: 498: case DICT:
736 #####: 499: dictNetSerialLevel0(r, (sDictt *)e);
737 call 0 never executed
738 #####: 500: break;
739 -: 501: case DOUBLE:
740 #####: 502: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
741 call 0 never executed
742 #####: 503: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
743 call 0 never executed
744 #####: 504: break;
745 -: 505: case INT: {
746 -: 506: // encode int to varint
747 -: 507: // v is int64_t to convert to varint
748 #####: 508: i64 v = ((sIntt *)&(e->type))->value;
749 -: 509: // encode v with arithmetic shifts
750 #####: 510: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
751 call 0 never executed
752 -: 511: }
753 #####: 512: break;
754 -: 513: case STRING:
755 #####: 514: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
756 call 0 never executed
757 #####: 515: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
758 call 0 never executed
759 #####: 516: break;
760 -: 517: case ARRAY:
761 #####: 518: arrayNetSerialLevel0(r, (sArrayt *)e);
762 call 0 never executed
763 #####: 519: break;
764 -: 520: case BYTES:
765 #####: 521: B = (sBytest *)e;
766 #####: 522: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
767 call 0 never executed
768 #####: 523: sBytesPushBuffer(r, &(B->data), B->count);
769 call 0 never executed
770 #####: 524: break;
771 -: 525: }
772 -: 526: }
773 -: 527: }
774 #####: 528: ret;
775 -: 529:}
776 -: 530:
777 function serialNetSerialLevel0 called 0 returned 0% blocks executed 0%
778 #####: 531:internal smallBytest* serialNetSerialLevel0(smallJsont *self) {
779 -: 532:
780 #####: 533: smallt *o = getsoG(self);
781 call 0 never executed
782 -: 534:
783 #####: 535: if (o == NULL)
784 branch 0 never executed
785 branch 1 never executed
786 #####: 536: ret NULL;
787 -: 537:
788 #####: 538: sBytest *B = netSerialLevel0(o);
789 call 0 never executed
790 -: 539:
791 #####: 540: if (!B) {
792 branch 0 never executed
793 branch 1 never executed
794 #####: 541: ret NULL;
795 -: 542: }
796 -: 543:
797 #####: 544: createAllocateSmallBytes(r);
798 call 0 never executed
799 #####: 545: r->B = B;
800 #####: 546: ret r;
801 -: 547:}
802 -: 548:
803 -: 549:// level 1
804 -: 550:// like level 0 with type encoded in nibbles and bools are packed
805 -: 551:
806 -: 552:/**
807 -: 553: * serializer top function
808 -: 554: */
809 function netSerialLevel1 called 0 returned 0% blocks executed 0%
810 #####: 555:internal sBytest* netSerialLevel1(smallt *o) {
811 #####: 556: sBytest *r = NULL;
812 #####: 557: sBytest *B = NULL;
813 #####: 558: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
814 -: 559:
815 #####: 560: switch(o->type) {
816 branch 0 never executed
817 branch 1 never executed
818 branch 2 never executed
819 branch 3 never executed
820 branch 4 never executed
821 branch 5 never executed
822 branch 6 never executed
823 branch 7 never executed
824 branch 8 never executed
825 -: 561: case UNDEFINED:
826 -: 562: case CONTAINER:
827 #####: 563: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
828 call 0 never executed
829 #####: 564: break;
830 -: 565: case BOOL: {
831 #####: 566: u8 c = NET_SERIAL_TYPES[(u8)o->type];
832 -: 567: // set bit 4 when true
833 #####: 568: if (((sBoolt *)&(o->type))->value)
834 branch 0 never executed
835 branch 1 never executed
836 #####: 569: c |= (1<<4);
837 #####: 570: sBytesPush(&r, c);
838 call 0 never executed
839 -: 571: }
840 #####: 572: break;
841 -: 573: case DICT:
842 #####: 574: dictNetSerialLevel1(&r, (sDictt *)&(o->type), &ctx);
843 call 0 never executed
844 #####: 575: break;
845 -: 576: case DOUBLE:
846 #####: 577: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
847 call 0 never executed
848 #####: 578: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
849 call 0 never executed
850 #####: 579: break;
851 -: 580: case INT: {
852 -: 581: // encode int to varint
853 -: 582: // v is int64_t to convert to varint
854 #####: 583: i64 v = ((sIntt *)&(o->type))->value;
855 -: 584: // encode v with arithmetic shifts
856 #####: 585: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
857 call 0 never executed
858 -: 586: }
859 #####: 587: break;
860 -: 588: case STRING:
861 #####: 589: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
862 call 0 never executed
863 #####: 590: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
864 call 0 never executed
865 #####: 591: break;
866 -: 592: case ARRAY:
867 #####: 593: arrayNetSerialLevel1(&r, (sArrayt *)&(o->type), &ctx);
868 call 0 never executed
869 #####: 594: break;
870 -: 595: case BYTES:
871 #####: 596: B = (sBytest *)&(o->type);
872 #####: 597: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
873 call 0 never executed
874 #####: 598: sBytesPushBuffer(&r, &(B->data), B->count);
875 call 0 never executed
876 #####: 599: break;
877 -: 600: }
878 #####: 601: ret r;
879 -: 602:}
880 -: 603:
881 -: 604:/**
882 -: 605: * serialize dictionary
883 -: 606: *
884 -: 607: * the serialized dict is pushed to r.
885 -: 608: * All elements are serialized recursively
886 -: 609: *
887 -: 610: * the data in containers is not serialized
888 -: 611: *
889 -: 612: * \param
890 -: 613: * r small bytes object
891 -: 614: * dict dictionary to serialize
892 -: 615: */
893 function dictNetSerialLevel1 called 0 returned 0% blocks executed 0%
894 #####: 616:internal void dictNetSerialLevel1(sBytest **r, sDictt *dict, contextt *ctx) {
895 #####: 617: sBytest *B = NULL;
896 #####: 618: char *data = NULL;
897 -: 619:
898 #####: 620: if (ctx->nibble == lowNbl) {
899 branch 0 never executed
900 branch 1 never executed
901 #####: 621: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
902 call 0 never executed
903 -: 622: }
904 -: 623: else {
905 -: 624: // high nibble
906 -: 625: #define storeTypeInHighNbl(o)\
907 -: 626: ctx->nibble = lowNbl;\
908 -: 627: data = (char *)&((*r)->data) + ctx->nblOffset;\
909 -: 628: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
910 #####: 629: storeTypeInHighNbl(dict);
911 #####: 630: uintToVarint(r, dict->count);
912 call 0 never executed
913 -: 631: }
914 -: 632:
915 #####: 633: forEachSDict(dict, e) {
916 branch 0 never executed
917 branch 1 never executed
918 #####: 634: if (e->key) {
919 branch 0 never executed
920 branch 1 never executed
921 #####: 635: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
922 call 0 never executed
923 -: 636:
924 #####: 637: switch(e->data->type) {
925 branch 0 never executed
926 branch 1 never executed
927 branch 2 never executed
928 branch 3 never executed
929 branch 4 never executed
930 branch 5 never executed
931 branch 6 never executed
932 branch 7 never executed
933 branch 8 never executed
934 -: 638: case UNDEFINED:
935 -: 639: case CONTAINER:
936 #####: 640: if (ctx->nibble == lowNbl) {
937 branch 0 never executed
938 branch 1 never executed
939 -: 641: #define storeTypeOnly(o)\
940 -: 642: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
941 -: 643: ctx->nibble = highNbl;\
942 -: 644: ctx->nblOffset = (*r)->count -1
943 #####: 645: storeTypeOnly(e->data);
944 call 0 never executed
945 -: 646: }
946 -: 647: else {
947 #####: 648: storeTypeInHighNbl(e->data);
948 -: 649: }
949 #####: 650: break;
950 -: 651: case BOOL:
951 #####: 652: if (!ctx->boolOffset) {
952 branch 0 never executed
953 branch 1 never executed
954 -: 653: // new packed bools
955 #####: 654: if (ctx->nibble == lowNbl) {
956 branch 0 never executed
957 branch 1 never executed
958 -: 655: #define storeNew4bPackedBool(o)\
959 -: 656: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
960 -: 657: /* set bit 4 when true */\
961 -: 658: if (((sBoolt *)(o))->value)\
962 -: 659: c |= (1<<4);\
963 -: 660: sBytesPush(r, c);\
964 -: 661: ctx->boolShift = 5;\
965 -: 662: ctx->boolOffset = (*r)->count -1
966 #####: 663: storeNew4bPackedBool(e->data);
967 branch 0 never executed
968 branch 1 never executed
969 call 2 never executed
970 -: 664: }
971 -: 665: else {
972 -: 666: // high nibble, next byte is packed bools
973 #####: 667: storeTypeInHighNbl(e->data);
974 -: 668: #define storeNew8bPackedBool(o)\
975 -: 669: u8 c = 0;\
976 -: 670: if (((sBoolt *)(o))->value)\
977 -: 671: c = 1;\
978 -: 672: sBytesPush(r, c);\
979 -: 673: ctx->boolShift = 1;\
980 -: 674: ctx->boolOffset = (*r)->count -1
981 #####: 675: storeNew8bPackedBool(e->data);
982 branch 0 never executed
983 branch 1 never executed
984 call 2 never executed
985 -: 676: }
986 -: 677: }
987 -: 678: else {
988 -: 679: // there was a bool before this one, fill bits in nibbles
989 #####: 680: if (ctx->nibble == lowNbl) {
990 branch 0 never executed
991 branch 1 never executed
992 #####: 681: if (ctx->boolShift == 8) {
993 branch 0 never executed
994 branch 1 never executed
995 -: 682: // previous packed bool is full
996 -: 683: // this byte is the new packed bools
997 #####: 684: storeNew4bPackedBool(e->data);
998 branch 0 never executed
999 branch 1 never executed
1000 call 2 never executed
1001 -: 685: }
1002 -: 686: else {
1003 #####: 687: storeTypeOnly(e->data);
1004 call 0 never executed
1005 -: 688: #define storeBool(o)\
1006 -: 689: data = (char *)&((*r)->data) + ctx->boolOffset;\
1007 -: 690: if (((sBoolt *)(o))->value)\
1008 -: 691: *data |= 1 << ctx->boolShift;\
1009 -: 692: ctx->boolShift++
1010 #####: 693: storeBool(e->data);
1011 branch 0 never executed
1012 branch 1 never executed
1013 -: 694: }
1014 -: 695: }
1015 -: 696: else {
1016 -: 697: // high nibble
1017 #####: 698: storeTypeInHighNbl(e->data);
1018 #####: 699: if (ctx->boolShift == 8) {
1019 branch 0 never executed
1020 branch 1 never executed
1021 -: 700: // previous packed bool is full
1022 -: 701: // next byte is the new packed bools
1023 #####: 702: storeNew8bPackedBool(e->data);
1024 branch 0 never executed
1025 branch 1 never executed
1026 call 2 never executed
1027 -: 703: }
1028 -: 704: else {
1029 #####: 705: storeBool(e->data);
1030 branch 0 never executed
1031 branch 1 never executed
1032 -: 706: }
1033 -: 707: }
1034 -: 708: }
1035 #####: 709: break;
1036 -: 710: case DICT:
1037 #####: 711: dictNetSerialLevel1(r, (sDictt *)(e->data), ctx);
1038 call 0 never executed
1039 #####: 712: break;
1040 -: 713: case DOUBLE:
1041 #####: 714: if (ctx->nibble == lowNbl) {
1042 branch 0 never executed
1043 branch 1 never executed
1044 #####: 715: storeTypeOnly(e->data);
1045 call 0 never executed
1046 -: 716: }
1047 -: 717: else {
1048 -: 718: // high nibble
1049 #####: 719: storeTypeInHighNbl(e->data);
1050 -: 720: }
1051 #####: 721: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
1052 call 0 never executed
1053 #####: 722: break;
1054 -: 723: case INT: {
1055 -: 724: // encode int to varint
1056 -: 725: // v is int64_t to convert to varint
1057 #####: 726: i64 v = ((sIntt *)(e->data))->value;
1058 #####: 727: if (ctx->nibble == lowNbl) {
1059 branch 0 never executed
1060 branch 1 never executed
1061 -: 728: // encode v with arithmetic shifts
1062 #####: 729: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
1063 call 0 never executed
1064 -: 730: }
1065 -: 731: else {
1066 -: 732: // high nibble
1067 #####: 733: storeTypeInHighNbl(e->data);
1068 #####: 734: uintToVarint(r, (v << 1) ^ (v >> 63));
1069 call 0 never executed
1070 -: 735: }
1071 -: 736: }
1072 #####: 737: break;
1073 -: 738: case STRING:
1074 #####: 739: if (ctx->nibble == lowNbl) {
1075 branch 0 never executed
1076 branch 1 never executed
1077 #####: 740: storeTypeOnly(e->data);
1078 call 0 never executed
1079 -: 741: }
1080 -: 742: else {
1081 -: 743: // high nibble
1082 #####: 744: storeTypeInHighNbl(e->data);
1083 -: 745: }
1084 #####: 746: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
1085 call 0 never executed
1086 #####: 747: break;
1087 -: 748: case ARRAY:
1088 #####: 749: arrayNetSerialLevel1(r, (sArrayt *)(e->data), ctx);
1089 call 0 never executed
1090 #####: 750: break;
1091 -: 751: case BYTES:
1092 #####: 752: B = (sBytest *)(e->data);
1093 #####: 753: if (ctx->nibble == lowNbl) {
1094 branch 0 never executed
1095 branch 1 never executed
1096 #####: 754: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
1097 call 0 never executed
1098 -: 755: }
1099 -: 756: else {
1100 -: 757: // high nibble
1101 #####: 758: storeTypeInHighNbl(e->data);
1102 #####: 759: uintToVarint(r, B->count);
1103 call 0 never executed
1104 -: 760: }
1105 #####: 761: sBytesPushBuffer(r, &(B->data), B->count);
1106 call 0 never executed
1107 #####: 762: break;
1108 -: 763: }
1109 -: 764: }
1110 -: 765: }
1111 #####: 766: ret;
1112 -: 767:}
1113 -: 768:
1114 -: 769:/**
1115 -: 770: * serialize array
1116 -: 771: *
1117 -: 772: * the serialized array is pushed to r.
1118 -: 773: * All elements are serialized recursively
1119 -: 774: *
1120 -: 775: * the data in containers is not serialized
1121 -: 776: *
1122 -: 777: * \param
1123 -: 778: * r small bytes object
1124 -: 779: * array to serialize
1125 -: 780: */
1126 function arrayNetSerialLevel1 called 0 returned 0% blocks executed 0%
1127 #####: 781:internal void arrayNetSerialLevel1(sBytest **r, sArrayt *array, contextt *ctx) {
1128 #####: 782: sBytest *B = NULL;
1129 #####: 783: char *data = NULL;
1130 -: 784:
1131 #####: 785: if (ctx->nibble == lowNbl) {
1132 branch 0 never executed
1133 branch 1 never executed
1134 #####: 786: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
1135 call 0 never executed
1136 -: 787: }
1137 -: 788: else {
1138 -: 789: // high nibble
1139 #####: 790: storeTypeInHighNbl(array);
1140 #####: 791: uintToVarint(r, array->count);
1141 call 0 never executed
1142 -: 792: }
1143 -: 793:
1144 #####: 794: forEachSArray(array, e) {
1145 branch 0 never executed
1146 branch 1 never executed
1147 #####: 795: if (!e) {
1148 branch 0 never executed
1149 branch 1 never executed
1150 -: 796: // empty slots are represented as undefined elements
1151 #####: 797: if (ctx->nibble == lowNbl) {
1152 branch 0 never executed
1153 branch 1 never executed
1154 #####: 798: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
1155 call 0 never executed
1156 #####: 799: ctx->nibble = highNbl;
1157 #####: 800: ctx->nblOffset = (*r)->count -1;
1158 -: 801: }
1159 -: 802: else {
1160 -: 803: // high nibble
1161 #####: 804: ctx->nibble = lowNbl;
1162 #####: 805: data = (char *)&((*r)->data) + ctx->nblOffset;
1163 #####: 806: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
1164 -: 807: }
1165 -: 808: }
1166 -: 809: else {
1167 #####: 810: switch(e->type) {
1168 branch 0 never executed
1169 branch 1 never executed
1170 branch 2 never executed
1171 branch 3 never executed
1172 branch 4 never executed
1173 branch 5 never executed
1174 branch 6 never executed
1175 branch 7 never executed
1176 branch 8 never executed
1177 -: 811: case UNDEFINED:
1178 -: 812: case CONTAINER:
1179 #####: 813: if (ctx->nibble == lowNbl) {
1180 branch 0 never executed
1181 branch 1 never executed
1182 #####: 814: storeTypeOnly(e);
1183 call 0 never executed
1184 -: 815: }
1185 -: 816: else {
1186 -: 817: // high nibble
1187 #####: 818: storeTypeInHighNbl(e);
1188 -: 819: }
1189 #####: 820: break;
1190 -: 821: case BOOL:
1191 #####: 822: if (!ctx->boolOffset) {
1192 branch 0 never executed
1193 branch 1 never executed
1194 -: 823: // new packed bools
1195 #####: 824: if (ctx->nibble == lowNbl) {
1196 branch 0 never executed
1197 branch 1 never executed
1198 #####: 825: storeNew4bPackedBool(e);
1199 branch 0 never executed
1200 branch 1 never executed
1201 call 2 never executed
1202 -: 826: }
1203 -: 827: else {
1204 -: 828: // high nibble, next byte is packed bools
1205 #####: 829: storeTypeInHighNbl(e);
1206 #####: 830: storeNew8bPackedBool(e);
1207 branch 0 never executed
1208 branch 1 never executed
1209 call 2 never executed
1210 -: 831: }
1211 -: 832: }
1212 -: 833: else {
1213 -: 834: // there was a bool before this one, fill bits in nibbles
1214 #####: 835: if (ctx->nibble == lowNbl) {
1215 branch 0 never executed
1216 branch 1 never executed
1217 #####: 836: if (ctx->boolShift == 8) {
1218 branch 0 never executed
1219 branch 1 never executed
1220 -: 837: // previous packed bool is full
1221 -: 838: // this byte is the new packed bools
1222 #####: 839: storeNew4bPackedBool(e);
1223 branch 0 never executed
1224 branch 1 never executed
1225 call 2 never executed
1226 -: 840: }
1227 -: 841: else {
1228 #####: 842: storeTypeOnly(e);
1229 call 0 never executed
1230 #####: 843: storeBool(e);
1231 branch 0 never executed
1232 branch 1 never executed
1233 -: 844: }
1234 -: 845: }
1235 -: 846: else {
1236 -: 847: // high nibble
1237 #####: 848: storeTypeInHighNbl(e);
1238 #####: 849: if (ctx->boolShift == 8) {
1239 branch 0 never executed
1240 branch 1 never executed
1241 -: 850: // previous packed bool is full
1242 -: 851: // next byte is the new packed bools
1243 #####: 852: storeNew8bPackedBool(e);
1244 branch 0 never executed
1245 branch 1 never executed
1246 call 2 never executed
1247 -: 853: }
1248 -: 854: else {
1249 #####: 855: storeBool(e);
1250 branch 0 never executed
1251 branch 1 never executed
1252 -: 856: }
1253 -: 857: }
1254 -: 858: }
1255 #####: 859: break;
1256 -: 860: case DICT:
1257 #####: 861: dictNetSerialLevel1(r, (sDictt *)e, ctx);
1258 call 0 never executed
1259 #####: 862: break;
1260 -: 863: case DOUBLE:
1261 #####: 864: if (ctx->nibble == lowNbl) {
1262 branch 0 never executed
1263 branch 1 never executed
1264 #####: 865: storeTypeOnly(e);
1265 call 0 never executed
1266 -: 866: }
1267 -: 867: else {
1268 -: 868: // high nibble
1269 #####: 869: storeTypeInHighNbl(e);
1270 -: 870: }
1271 #####: 871: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
1272 call 0 never executed
1273 #####: 872: break;
1274 -: 873: case INT: {
1275 -: 874: // encode int to varint
1276 -: 875: // v is int64_t to convert to varint
1277 #####: 876: i64 v = ((sIntt *)&(e->type))->value;
1278 #####: 877: if (ctx->nibble == lowNbl) {
1279 branch 0 never executed
1280 branch 1 never executed
1281 -: 878: // encode v with arithmetic shifts
1282 #####: 879: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
1283 call 0 never executed
1284 -: 880: }
1285 -: 881: else {
1286 -: 882: // high nibble
1287 #####: 883: storeTypeInHighNbl(e);
1288 #####: 884: uintToVarint(r, (v << 1) ^ (v >> 63));
1289 call 0 never executed
1290 -: 885: }
1291 -: 886: }
1292 #####: 887: break;
1293 -: 888: case STRING:
1294 #####: 889: if (ctx->nibble == lowNbl) {
1295 branch 0 never executed
1296 branch 1 never executed
1297 #####: 890: storeTypeOnly(e);
1298 call 0 never executed
1299 -: 891: }
1300 -: 892: else {
1301 -: 893: // high nibble
1302 #####: 894: storeTypeInHighNbl(e);
1303 -: 895: }
1304 #####: 896: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
1305 call 0 never executed
1306 #####: 897: break;
1307 -: 898: case ARRAY:
1308 #####: 899: arrayNetSerialLevel1(r, (sArrayt *)e, ctx);
1309 call 0 never executed
1310 #####: 900: break;
1311 -: 901: case BYTES:
1312 #####: 902: B = (sBytest *)e;
1313 #####: 903: if (ctx->nibble == lowNbl) {
1314 branch 0 never executed
1315 branch 1 never executed
1316 #####: 904: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
1317 call 0 never executed
1318 -: 905: }
1319 -: 906: else {
1320 -: 907: // high nibble
1321 #####: 908: storeTypeInHighNbl(e);
1322 #####: 909: uintToVarint(r, B->count);
1323 call 0 never executed
1324 -: 910: }
1325 #####: 911: sBytesPushBuffer(r, &(B->data), B->count);
1326 call 0 never executed
1327 #####: 912: break;
1328 -: 913: }
1329 -: 914: }
1330 -: 915: }
1331 #####: 916: ret;
1332 -: 917:}
1333 -: 918:
1334 function serialNetSerialLevel1 called 0 returned 0% blocks executed 0%
1335 #####: 919:internal smallBytest* serialNetSerialLevel1(smallJsont *self) {
1336 -: 920:
1337 #####: 921: smallt *o = getsoG(self);
1338 call 0 never executed
1339 -: 922:
1340 #####: 923: if (o == NULL)
1341 branch 0 never executed
1342 branch 1 never executed
1343 #####: 924: ret NULL;
1344 -: 925:
1345 #####: 926: sBytest *B = netSerialLevel1(o);
1346 call 0 never executed
1347 -: 927:
1348 #####: 928: if (!B) {
1349 branch 0 never executed
1350 branch 1 never executed
1351 #####: 929: ret NULL;
1352 -: 930: }
1353 -: 931:
1354 #####: 932: createAllocateSmallBytes(r);
1355 call 0 never executed
1356 #####: 933: r->B = B;
1357 #####: 934: ret r;
1358 -: 935:}
1359 -: 936:
1360 -: 937:// level 2
1361 -: 938:// like level 1, arrays are set to uniform when all elements are same type
1362 -: 939:
1363 -: 940:/**
1364 -: 941: * serializer top function
1365 -: 942: */
1366 function netSerialLevel2 called 0 returned 0% blocks executed 0%
1367 #####: 943:internal sBytest* netSerialLevel2(smallt *o) {
1368 #####: 944: sBytest *r = NULL;
1369 #####: 945: sBytest *B = NULL;
1370 #####: 946: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
1371 -: 947:
1372 #####: 948: switch(o->type) {
1373 branch 0 never executed
1374 branch 1 never executed
1375 branch 2 never executed
1376 branch 3 never executed
1377 branch 4 never executed
1378 branch 5 never executed
1379 branch 6 never executed
1380 branch 7 never executed
1381 branch 8 never executed
1382 -: 949: case UNDEFINED:
1383 -: 950: case CONTAINER:
1384 #####: 951: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
1385 call 0 never executed
1386 #####: 952: break;
1387 -: 953: case BOOL: {
1388 #####: 954: u8 c = NET_SERIAL_TYPES[(u8)o->type];
1389 -: 955: // set bit 4 when true
1390 #####: 956: if (((sBoolt *)&(o->type))->value)
1391 branch 0 never executed
1392 branch 1 never executed
1393 #####: 957: c |= (1<<4);
1394 #####: 958: sBytesPush(&r, c);
1395 call 0 never executed
1396 -: 959: }
1397 #####: 960: break;
1398 -: 961: case DICT:
1399 #####: 962: dictNetSerialLevel2(&r, (sDictt *)&(o->type), &ctx, /*packed=*/false);
1400 call 0 never executed
1401 #####: 963: break;
1402 -: 964: case DOUBLE:
1403 #####: 965: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
1404 call 0 never executed
1405 #####: 966: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
1406 call 0 never executed
1407 #####: 967: break;
1408 -: 968: case INT: {
1409 -: 969: // encode int to varint
1410 -: 970: // v is int64_t to convert to varint
1411 #####: 971: i64 v = ((sIntt *)&(o->type))->value;
1412 -: 972: // encode v with arithmetic shifts
1413 #####: 973: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
1414 call 0 never executed
1415 -: 974: }
1416 #####: 975: break;
1417 -: 976: case STRING:
1418 #####: 977: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
1419 call 0 never executed
1420 #####: 978: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
1421 call 0 never executed
1422 #####: 979: break;
1423 -: 980: case ARRAY:
1424 #####: 981: arrayNetSerialLevel2(&r, (sArrayt *)&(o->type), &ctx, /*packed=*/false);
1425 call 0 never executed
1426 #####: 982: break;
1427 -: 983: case BYTES:
1428 #####: 984: B = (sBytest *)&(o->type);
1429 #####: 985: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
1430 call 0 never executed
1431 #####: 986: sBytesPushBuffer(&r, &(B->data), B->count);
1432 call 0 never executed
1433 #####: 987: break;
1434 -: 988: }
1435 #####: 989: ret r;
1436 -: 990:}
1437 -: 991:
1438 function isDictUniform called 33 returned 100% blocks executed 69%
1439 33: 992:internal u8 isDictUniform(sDictt *dict) {
1440 33: 993: bool allElementsHaveSameType = true;
1441 33: 994: bool foundFirstType = false;
1442 33: 995: u8 type = 0;
1443 66: 996: forEachSDict(dict, e) {
1444 branch 0 taken 67%
1445 branch 1 taken 33% (fallthrough)
1446 44: 997: if (e->key) {
1447 branch 0 taken 100% (fallthrough)
1448 branch 1 taken 0%
1449 44: 998: if (foundFirstType) {
1450 branch 0 taken 39% (fallthrough)
1451 branch 1 taken 61%
1452 -: 999: u8 nextType;
1453 17: 1000: switch(e->data->type) {
1454 branch 0 taken 0%
1455 branch 1 taken 0%
1456 branch 2 taken 100%
1457 -: 1001: case DICT:
1458 #####: 1002: nextType = isDictUniform((sDictt*)e->data);
1459 call 0 never executed
1460 #####: 1003: break;
1461 -: 1004: case ARRAY:
1462 #####: 1005: nextType = isArrayUniform((sArrayt*)e->data);
1463 call 0 never executed
1464 #####: 1006: break;
1465 -: 1007: default:
1466 17: 1008: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
1467 -: 1009: }
1468 17: 1010: if (nextType != type) {
1469 branch 0 taken 65% (fallthrough)
1470 branch 1 taken 35%
1471 11: 1011: allElementsHaveSameType = false;
1472 11: 1012: break;
1473 -: 1013: }
1474 -: 1014: }
1475 -: 1015: else {
1476 27: 1016: switch(e->data->type) {
1477 branch 0 taken 0%
1478 branch 1 taken 0%
1479 branch 2 taken 100%
1480 -: 1017: case DICT:
1481 #####: 1018: type = isDictUniform((sDictt*)e->data);
1482 call 0 never executed
1483 #####: 1019: break;
1484 -: 1020: case ARRAY:
1485 #####: 1021: type = isArrayUniform((sArrayt*)e->data);
1486 call 0 never executed
1487 #####: 1022: break;
1488 -: 1023: default:
1489 27: 1024: type = NET_SERIAL_TYPES[(u8)e->data->type];
1490 -: 1025: }
1491 27: 1026: foundFirstType = true;
1492 -: 1027: }
1493 -: 1028: }
1494 -: 1029: }
1495 33: 1030: if (allElementsHaveSameType)
1496 branch 0 taken 67% (fallthrough)
1497 branch 1 taken 33%
1498 22: 1031: type = UNIFORM_DICT;
1499 -: 1032: else
1500 11: 1033: type = S_DICT;
1501 33: 1034: ret type;
1502 -: 1035:}
1503 -: 1036:
1504 function isArrayUniform called 30 returned 100% blocks executed 65%
1505 30: 1037:internal u8 isArrayUniform(sArrayt *array) {
1506 30: 1038: bool allElementsHaveSameType = true;
1507 30: 1039: bool foundFirstType = false;
1508 30: 1040: char type = 0;
1509 83: 1041: forEachSArray(array, e) {
1510 branch 0 taken 75%
1511 branch 1 taken 25% (fallthrough)
1512 62: 1042: if (!e) {
1513 branch 0 taken 0% (fallthrough)
1514 branch 1 taken 100%
1515 #####: 1043: if (foundFirstType) {
1516 branch 0 never executed
1517 branch 1 never executed
1518 #####: 1044: if (type != S_UNDEFINED) {
1519 branch 0 never executed
1520 branch 1 never executed
1521 #####: 1045: allElementsHaveSameType = false;
1522 #####: 1046: break;
1523 -: 1047: }
1524 -: 1048: }
1525 -: 1049: else {
1526 #####: 1050: type = S_UNDEFINED;
1527 #####: 1051: foundFirstType = true;
1528 -: 1052: }
1529 -: 1053: }
1530 -: 1054: else {
1531 62: 1055: if (foundFirstType) {
1532 branch 0 taken 56% (fallthrough)
1533 branch 1 taken 44%
1534 -: 1056: u8 nextType;
1535 35: 1057: switch(e->type) {
1536 branch 0 taken 0%
1537 branch 1 taken 0%
1538 branch 2 taken 100%
1539 -: 1058: case DICT:
1540 #####: 1059: nextType = isDictUniform((sDictt*)e);
1541 call 0 never executed
1542 #####: 1060: break;
1543 -: 1061: case ARRAY:
1544 #####: 1062: nextType = isArrayUniform((sArrayt*)e);
1545 call 0 never executed
1546 #####: 1063: break;
1547 -: 1064: default:
1548 35: 1065: nextType = NET_SERIAL_TYPES[(u8)e->type];
1549 -: 1066: }
1550 35: 1067: if (nextType != type) {
1551 branch 0 taken 26% (fallthrough)
1552 branch 1 taken 74%
1553 9: 1068: allElementsHaveSameType = false;
1554 9: 1069: break;
1555 -: 1070: }
1556 -: 1071: }
1557 -: 1072: else {
1558 27: 1073: switch(e->type) {
1559 branch 0 taken 4%
1560 branch 1 taken 0%
1561 branch 2 taken 96%
1562 -: 1074: case DICT:
1563 1: 1075: type = isDictUniform((sDictt*)e);
1564 call 0 returned 100%
1565 1: 1076: break;
1566 -: 1077: case ARRAY:
1567 #####: 1078: type = isArrayUniform((sArrayt*)e);
1568 call 0 never executed
1569 #####: 1079: break;
1570 -: 1080: default:
1571 26: 1081: type = NET_SERIAL_TYPES[(u8)e->type];
1572 -: 1082: }
1573 27: 1083: foundFirstType = true;
1574 -: 1084: }
1575 -: 1085: }
1576 -: 1086: }
1577 30: 1087: if (allElementsHaveSameType)
1578 branch 0 taken 70% (fallthrough)
1579 branch 1 taken 30%
1580 21: 1088: type = UNIFORM_ARRAY;
1581 -: 1089: else
1582 9: 1090: type = S_ARRAY;
1583 30: 1091: ret type;
1584 -: 1092:}
1585 -: 1093:
1586 -: 1094:/**
1587 -: 1095: * serialize dictionary
1588 -: 1096: *
1589 -: 1097: * the serialized dict is pushed to r.
1590 -: 1098: * All elements are serialized recursively
1591 -: 1099: *
1592 -: 1100: * the data in containers is not serialized
1593 -: 1101: *
1594 -: 1102: * \param
1595 -: 1103: * r small bytes object
1596 -: 1104: * dict dictionary to serialize
1597 -: 1105: */
1598 function dictNetSerialLevel2 called 0 returned 0% blocks executed 0%
1599 #####: 1106:internal void dictNetSerialLevel2(sBytest **r, sDictt *dict, contextt *ctx, bool packed) {
1600 #####: 1107: sBytest *B = NULL;
1601 #####: 1108: char *data = NULL;
1602 -: 1109:
1603 -: 1110: // check if all elements have same type
1604 #####: 1111: bool allElementsHaveSameType = true;
1605 #####: 1112: bool foundFirstType = false;
1606 #####: 1113: char type = 0;
1607 #####: 1114: {forEachSDict(dict, e) {
1608 branch 0 never executed
1609 branch 1 never executed
1610 #####: 1115: if (e->key) {
1611 branch 0 never executed
1612 branch 1 never executed
1613 #####: 1116: if (foundFirstType) {
1614 branch 0 never executed
1615 branch 1 never executed
1616 -: 1117: u8 nextType;
1617 #####: 1118: switch(e->data->type) {
1618 branch 0 never executed
1619 branch 1 never executed
1620 branch 2 never executed
1621 -: 1119: case DICT:
1622 #####: 1120: nextType = isDictUniform((sDictt*)e->data);
1623 call 0 never executed
1624 #####: 1121: break;
1625 -: 1122: case ARRAY:
1626 #####: 1123: nextType = isArrayUniform((sArrayt*)e->data);
1627 call 0 never executed
1628 #####: 1124: break;
1629 -: 1125: default:
1630 #####: 1126: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
1631 -: 1127: }
1632 #####: 1128: if (nextType != type) {
1633 branch 0 never executed
1634 branch 1 never executed
1635 #####: 1129: allElementsHaveSameType = false;
1636 #####: 1130: break;
1637 -: 1131: }
1638 -: 1132: }
1639 -: 1133: else {
1640 #####: 1134: switch(e->data->type) {
1641 branch 0 never executed
1642 branch 1 never executed
1643 branch 2 never executed
1644 -: 1135: case DICT:
1645 #####: 1136: type = isDictUniform((sDictt*)e->data);
1646 call 0 never executed
1647 #####: 1137: break;
1648 -: 1138: case ARRAY:
1649 #####: 1139: type = isArrayUniform((sArrayt*)e->data);
1650 call 0 never executed
1651 #####: 1140: break;
1652 -: 1141: default:
1653 #####: 1142: type = NET_SERIAL_TYPES[(u8)e->data->type];
1654 -: 1143: }
1655 #####: 1144: foundFirstType = true;
1656 -: 1145: }
1657 -: 1146: }
1658 -: 1147: }}
1659 -: 1148:
1660 #####: 1149: if (allElementsHaveSameType) {
1661 branch 0 never executed
1662 branch 1 never executed
1663 -: 1150: // pack dictionary
1664 #####: 1151: if (packed) {
1665 branch 0 never executed
1666 branch 1 never executed
1667 #####: 1152: uintToNetTypeVarint(r, type, dict->count);
1668 call 0 never executed
1669 -: 1153: }
1670 -: 1154: else {
1671 #####: 1155: if (ctx->nibble == lowNbl) {
1672 branch 0 never executed
1673 branch 1 never executed
1674 #####: 1156: sBytesPush(r, (type << 4) + UNIFORM_DICT);
1675 call 0 never executed
1676 #####: 1157: uintToVarint(r, dict->count);
1677 call 0 never executed
1678 -: 1158: }
1679 -: 1159: else {
1680 -: 1160: // high nibble
1681 #####: 1161: ctx->nibble = lowNbl;
1682 #####: 1162: data = (char *)&((*r)->data) + ctx->nblOffset;
1683 #####: 1163: *data |= UNIFORM_DICT << 4;
1684 #####: 1164: uintToNetTypeVarint(r, type, dict->count);
1685 call 0 never executed
1686 -: 1165: }
1687 -: 1166: }
1688 -: 1167:
1689 #####: 1168: switch(type) {
1690 branch 0 never executed
1691 branch 1 never executed
1692 branch 2 never executed
1693 branch 3 never executed
1694 branch 4 never executed
1695 branch 5 never executed
1696 branch 6 never executed
1697 branch 7 never executed
1698 branch 8 never executed
1699 -: 1169: case S_UNDEFINED:
1700 #####: 1170: {forEachSDict(dict, e) {
1701 branch 0 never executed
1702 branch 1 never executed
1703 #####: 1171: if (e->key) {
1704 branch 0 never executed
1705 branch 1 never executed
1706 #####: 1172: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1707 call 0 never executed
1708 -: 1173: }
1709 -: 1174: }}
1710 -: 1175:
1711 #####: 1176: break;
1712 -: 1177: case S_BOOL:
1713 #####: 1178: {forEachSDict(dict, e) {
1714 branch 0 never executed
1715 branch 1 never executed
1716 #####: 1179: if (e->key) {
1717 branch 0 never executed
1718 branch 1 never executed
1719 #####: 1180: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1720 call 0 never executed
1721 -: 1181:
1722 #####: 1182: if (!ctx->boolOffset) {
1723 branch 0 never executed
1724 branch 1 never executed
1725 -: 1183: // new packed bools
1726 #####: 1184: storeNew8bPackedBool(e->data);
1727 branch 0 never executed
1728 branch 1 never executed
1729 call 2 never executed
1730 -: 1185: }
1731 -: 1186: else {
1732 -: 1187: // there was a bool before this one, fill bits in nibbles
1733 #####: 1188: if (ctx->boolShift == 8) {
1734 branch 0 never executed
1735 branch 1 never executed
1736 -: 1189: // previous packed bool is full
1737 -: 1190: // next byte is the new packed bools
1738 #####: 1191: storeNew8bPackedBool(e->data);
1739 branch 0 never executed
1740 branch 1 never executed
1741 call 2 never executed
1742 -: 1192: }
1743 -: 1193: else {
1744 #####: 1194: storeBool(e->data);
1745 branch 0 never executed
1746 branch 1 never executed
1747 -: 1195: }
1748 -: 1196: }
1749 -: 1197: }
1750 -: 1198: }}
1751 #####: 1199: break;
1752 -: 1200: case S_DICT:
1753 -: 1201: case UNIFORM_DICT:
1754 #####: 1202: {forEachSDict(dict, e) {
1755 branch 0 never executed
1756 branch 1 never executed
1757 #####: 1203: if (e->key) {
1758 branch 0 never executed
1759 branch 1 never executed
1760 #####: 1204: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1761 call 0 never executed
1762 #####: 1205: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/true);
1763 call 0 never executed
1764 -: 1206: }
1765 -: 1207: }}
1766 #####: 1208: break;
1767 -: 1209: case S_DOUBLE:
1768 #####: 1210: {forEachSDict(dict, e) {
1769 branch 0 never executed
1770 branch 1 never executed
1771 #####: 1211: if (e->key) {
1772 branch 0 never executed
1773 branch 1 never executed
1774 #####: 1212: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1775 call 0 never executed
1776 #####: 1213: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
1777 call 0 never executed
1778 -: 1214: }
1779 -: 1215: }}
1780 #####: 1216: break;
1781 -: 1217: case S_INT:
1782 #####: 1218: {forEachSDict(dict, e) {
1783 branch 0 never executed
1784 branch 1 never executed
1785 #####: 1219: if (e->key) {
1786 branch 0 never executed
1787 branch 1 never executed
1788 #####: 1220: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1789 call 0 never executed
1790 #####: 1221: i64 v = ((sIntt *)(e->data))->value;
1791 #####: 1222: uintToVarint(r, (v << 1) ^ (v >> 63));
1792 call 0 never executed
1793 -: 1223: }
1794 -: 1224: }}
1795 #####: 1225: break;
1796 -: 1226: case S_STRING:
1797 #####: 1227: {forEachSDict(dict, e) {
1798 branch 0 never executed
1799 branch 1 never executed
1800 #####: 1228: if (e->key) {
1801 branch 0 never executed
1802 branch 1 never executed
1803 #####: 1229: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1804 call 0 never executed
1805 #####: 1230: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
1806 call 0 never executed
1807 -: 1231: }
1808 -: 1232: }}
1809 #####: 1233: break;
1810 -: 1234: case S_ARRAY:
1811 -: 1235: case UNIFORM_ARRAY:
1812 #####: 1236: {forEachSDict(dict, e) {
1813 branch 0 never executed
1814 branch 1 never executed
1815 #####: 1237: if (e->key) {
1816 branch 0 never executed
1817 branch 1 never executed
1818 #####: 1238: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1819 call 0 never executed
1820 #####: 1239: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/true);
1821 call 0 never executed
1822 -: 1240: }
1823 -: 1241: }}
1824 #####: 1242: break;
1825 -: 1243: case S_BYTES:
1826 #####: 1244: {forEachSDict(dict, e) {
1827 branch 0 never executed
1828 branch 1 never executed
1829 #####: 1245: if (e->key) {
1830 branch 0 never executed
1831 branch 1 never executed
1832 #####: 1246: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1833 call 0 never executed
1834 #####: 1247: B = (sBytest *)(e->data);
1835 #####: 1248: uintToVarint(r, B->count);
1836 call 0 never executed
1837 #####: 1249: sBytesPushBuffer(r, &(B->data), B->count);
1838 call 0 never executed
1839 -: 1250: }
1840 -: 1251: }}
1841 #####: 1252: break;
1842 -: 1253: }
1843 #####: 1254: ret;
1844 -: 1255: }
1845 -: 1256:
1846 #####: 1257: if (packed) {
1847 branch 0 never executed
1848 branch 1 never executed
1849 #####: 1258: uintToVarint(r, dict->count);
1850 call 0 never executed
1851 -: 1259: }
1852 -: 1260: else {
1853 #####: 1261: if (ctx->nibble == lowNbl) {
1854 branch 0 never executed
1855 branch 1 never executed
1856 #####: 1262: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
1857 call 0 never executed
1858 -: 1263: }
1859 -: 1264: else {
1860 -: 1265: // high nibble
1861 -: 1266:#define storeTypeInHighNbl(o)\
1862 -: 1267: ctx->nibble = lowNbl;\
1863 -: 1268: data = (char *)&((*r)->data) + ctx->nblOffset;\
1864 -: 1269: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
1865 #####: 1270: storeTypeInHighNbl(dict);
1866 #####: 1271: uintToVarint(r, dict->count);
1867 call 0 never executed
1868 -: 1272: }
1869 -: 1273: }
1870 -: 1274:
1871 #####: 1275: forEachSDict(dict, e) {
1872 branch 0 never executed
1873 branch 1 never executed
1874 #####: 1276: if (e->key) {
1875 branch 0 never executed
1876 branch 1 never executed
1877 #####: 1277: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
1878 call 0 never executed
1879 -: 1278:
1880 #####: 1279: switch(e->data->type) {
1881 branch 0 never executed
1882 branch 1 never executed
1883 branch 2 never executed
1884 branch 3 never executed
1885 branch 4 never executed
1886 branch 5 never executed
1887 branch 6 never executed
1888 branch 7 never executed
1889 branch 8 never executed
1890 -: 1280: case UNDEFINED:
1891 -: 1281: case CONTAINER:
1892 #####: 1282: if (ctx->nibble == lowNbl) {
1893 branch 0 never executed
1894 branch 1 never executed
1895 -: 1283: #define storeTypeOnly(o)\
1896 -: 1284: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
1897 -: 1285: ctx->nibble = highNbl;\
1898 -: 1286: ctx->nblOffset = (*r)->count -1
1899 #####: 1287: storeTypeOnly(e->data);
1900 call 0 never executed
1901 -: 1288: }
1902 -: 1289: else {
1903 #####: 1290: storeTypeInHighNbl(e->data);
1904 -: 1291: }
1905 #####: 1292: break;
1906 -: 1293: case BOOL:
1907 #####: 1294: if (!ctx->boolOffset) {
1908 branch 0 never executed
1909 branch 1 never executed
1910 -: 1295: // new packed bools
1911 #####: 1296: if (ctx->nibble == lowNbl) {
1912 branch 0 never executed
1913 branch 1 never executed
1914 -: 1297: #define storeNew4bPackedBool(o)\
1915 -: 1298: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
1916 -: 1299: /* set bit 4 when true */\
1917 -: 1300: if (((sBoolt *)(o))->value)\
1918 -: 1301: c |= (1<<4);\
1919 -: 1302: sBytesPush(r, c);\
1920 -: 1303: ctx->boolShift = 5;\
1921 -: 1304: ctx->boolOffset = (*r)->count -1
1922 #####: 1305: storeNew4bPackedBool(e->data);
1923 branch 0 never executed
1924 branch 1 never executed
1925 call 2 never executed
1926 -: 1306: }
1927 -: 1307: else {
1928 -: 1308: // high nibble, next byte is packed bools
1929 #####: 1309: storeTypeInHighNbl(e->data);
1930 -: 1310: #define storeNew8bPackedBool(o)\
1931 -: 1311: u8 c = 0;\
1932 -: 1312: if (((sBoolt *)(o))->value)\
1933 -: 1313: c = 1;\
1934 -: 1314: sBytesPush(r, c);\
1935 -: 1315: ctx->boolShift = 1;\
1936 -: 1316: ctx->boolOffset = (*r)->count -1
1937 #####: 1317: storeNew8bPackedBool(e->data);
1938 branch 0 never executed
1939 branch 1 never executed
1940 call 2 never executed
1941 -: 1318: }
1942 -: 1319: }
1943 -: 1320: else {
1944 -: 1321: // there was a bool before this one, fill bits in nibbles
1945 #####: 1322: if (ctx->nibble == lowNbl) {
1946 branch 0 never executed
1947 branch 1 never executed
1948 #####: 1323: if (ctx->boolShift == 8) {
1949 branch 0 never executed
1950 branch 1 never executed
1951 -: 1324: // previous packed bool is full
1952 -: 1325: // this byte is the new packed bools
1953 #####: 1326: storeNew4bPackedBool(e->data);
1954 branch 0 never executed
1955 branch 1 never executed
1956 call 2 never executed
1957 -: 1327: }
1958 -: 1328: else {
1959 #####: 1329: storeTypeOnly(e->data);
1960 call 0 never executed
1961 -: 1330: #define storeBool(o)\
1962 -: 1331: data = (char *)&((*r)->data) + ctx->boolOffset;\
1963 -: 1332: if (((sBoolt *)(o))->value)\
1964 -: 1333: *data |= 1 << ctx->boolShift;\
1965 -: 1334: ctx->boolShift++
1966 #####: 1335: storeBool(e->data);
1967 branch 0 never executed
1968 branch 1 never executed
1969 -: 1336: }
1970 -: 1337: }
1971 -: 1338: else {
1972 -: 1339: // high nibble
1973 #####: 1340: storeTypeInHighNbl(e->data);
1974 #####: 1341: if (ctx->boolShift == 8) {
1975 branch 0 never executed
1976 branch 1 never executed
1977 -: 1342: // previous packed bool is full
1978 -: 1343: // next byte is the new packed bools
1979 #####: 1344: storeNew8bPackedBool(e->data);
1980 branch 0 never executed
1981 branch 1 never executed
1982 call 2 never executed
1983 -: 1345: }
1984 -: 1346: else {
1985 #####: 1347: storeBool(e->data);
1986 branch 0 never executed
1987 branch 1 never executed
1988 -: 1348: }
1989 -: 1349: }
1990 -: 1350: }
1991 #####: 1351: break;
1992 -: 1352: case DICT:
1993 #####: 1353: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/false);
1994 call 0 never executed
1995 #####: 1354: break;
1996 -: 1355: case DOUBLE:
1997 #####: 1356: if (ctx->nibble == lowNbl) {
1998 branch 0 never executed
1999 branch 1 never executed
2000 #####: 1357: storeTypeOnly(e->data);
2001 call 0 never executed
2002 -: 1358: }
2003 -: 1359: else {
2004 -: 1360: // high nibble
2005 #####: 1361: storeTypeInHighNbl(e->data);
2006 -: 1362: }
2007 #####: 1363: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
2008 call 0 never executed
2009 #####: 1364: break;
2010 -: 1365: case INT: {
2011 -: 1366: // encode int to varint
2012 -: 1367: // v is int64_t to convert to varint
2013 #####: 1368: i64 v = ((sIntt *)(e->data))->value;
2014 #####: 1369: if (ctx->nibble == lowNbl) {
2015 branch 0 never executed
2016 branch 1 never executed
2017 -: 1370: // encode v with arithmetic shifts
2018 #####: 1371: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
2019 call 0 never executed
2020 -: 1372: }
2021 -: 1373: else {
2022 -: 1374: // high nibble
2023 #####: 1375: storeTypeInHighNbl(e->data);
2024 #####: 1376: uintToVarint(r, (v << 1) ^ (v >> 63));
2025 call 0 never executed
2026 -: 1377: }
2027 -: 1378: }
2028 #####: 1379: break;
2029 -: 1380: case STRING:
2030 #####: 1381: if (ctx->nibble == lowNbl) {
2031 branch 0 never executed
2032 branch 1 never executed
2033 #####: 1382: storeTypeOnly(e->data);
2034 call 0 never executed
2035 -: 1383: }
2036 -: 1384: else {
2037 -: 1385: // high nibble
2038 #####: 1386: storeTypeInHighNbl(e->data);
2039 -: 1387: }
2040 #####: 1388: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
2041 call 0 never executed
2042 #####: 1389: break;
2043 -: 1390: case ARRAY:
2044 #####: 1391: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/false);
2045 call 0 never executed
2046 #####: 1392: break;
2047 -: 1393: case BYTES:
2048 #####: 1394: B = (sBytest *)(e->data);
2049 #####: 1395: if (ctx->nibble == lowNbl) {
2050 branch 0 never executed
2051 branch 1 never executed
2052 #####: 1396: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
2053 call 0 never executed
2054 -: 1397: }
2055 -: 1398: else {
2056 -: 1399: // high nibble
2057 #####: 1400: storeTypeInHighNbl(e->data);
2058 #####: 1401: uintToVarint(r, B->count);
2059 call 0 never executed
2060 -: 1402: }
2061 #####: 1403: sBytesPushBuffer(r, &(B->data), B->count);
2062 call 0 never executed
2063 #####: 1404: break;
2064 -: 1405: }
2065 -: 1406: }
2066 -: 1407: }
2067 #####: 1408: ret;
2068 -: 1409:}
2069 -: 1410:
2070 -: 1411:/**
2071 -: 1412: * serialize array
2072 -: 1413: *
2073 -: 1414: * the serialized array is pushed to r.
2074 -: 1415: * All elements are serialized recursively
2075 -: 1416: *
2076 -: 1417: * the data in containers is not serialized
2077 -: 1418: *
2078 -: 1419: * \param
2079 -: 1420: * r small bytes object
2080 -: 1421: * array to serialize
2081 -: 1422: */
2082 function arrayNetSerialLevel2 called 0 returned 0% blocks executed 0%
2083 #####: 1423:internal void arrayNetSerialLevel2(sBytest **r, sArrayt *array, contextt *ctx, bool packed) {
2084 #####: 1424: sBytest *B = NULL;
2085 #####: 1425: char *data = NULL;
2086 -: 1426:
2087 -: 1427: // check if all elements have same type
2088 #####: 1428: bool allElementsHaveSameType = true;
2089 #####: 1429: bool foundFirstType = false;
2090 #####: 1430: char type = 0;
2091 -: 1431:
2092 #####: 1432: {forEachSArray(array, e) {
2093 branch 0 never executed
2094 branch 1 never executed
2095 #####: 1433: if (!e) {
2096 branch 0 never executed
2097 branch 1 never executed
2098 #####: 1434: if (foundFirstType) {
2099 branch 0 never executed
2100 branch 1 never executed
2101 #####: 1435: if (type != S_UNDEFINED) {
2102 branch 0 never executed
2103 branch 1 never executed
2104 #####: 1436: allElementsHaveSameType = false;
2105 #####: 1437: break;
2106 -: 1438: }
2107 -: 1439: }
2108 -: 1440: else {
2109 #####: 1441: type = S_UNDEFINED;
2110 #####: 1442: foundFirstType = true;
2111 -: 1443: }
2112 -: 1444: }
2113 -: 1445: else {
2114 #####: 1446: if (foundFirstType) {
2115 branch 0 never executed
2116 branch 1 never executed
2117 -: 1447: u8 nextType;
2118 #####: 1448: switch(e->type) {
2119 branch 0 never executed
2120 branch 1 never executed
2121 branch 2 never executed
2122 -: 1449: case DICT:
2123 #####: 1450: nextType = isDictUniform((sDictt*)e);
2124 call 0 never executed
2125 #####: 1451: break;
2126 -: 1452: case ARRAY:
2127 #####: 1453: nextType = isArrayUniform((sArrayt*)e);
2128 call 0 never executed
2129 #####: 1454: break;
2130 -: 1455: default:
2131 #####: 1456: nextType = NET_SERIAL_TYPES[(u8)e->type];
2132 -: 1457: }
2133 #####: 1458: if (nextType != type) {
2134 branch 0 never executed
2135 branch 1 never executed
2136 #####: 1459: allElementsHaveSameType = false;
2137 #####: 1460: break;
2138 -: 1461: }
2139 -: 1462: }
2140 -: 1463: else {
2141 #####: 1464: switch(e->type) {
2142 branch 0 never executed
2143 branch 1 never executed
2144 branch 2 never executed
2145 -: 1465: case DICT:
2146 #####: 1466: type = isDictUniform((sDictt*)e);
2147 call 0 never executed
2148 #####: 1467: break;
2149 -: 1468: case ARRAY:
2150 #####: 1469: type = isArrayUniform((sArrayt*)e);
2151 call 0 never executed
2152 #####: 1470: break;
2153 -: 1471: default:
2154 #####: 1472: type = NET_SERIAL_TYPES[(u8)e->type];
2155 -: 1473: }
2156 #####: 1474: foundFirstType = true;
2157 -: 1475: }
2158 -: 1476: }
2159 -: 1477: }}
2160 -: 1478:
2161 #####: 1479: if (allElementsHaveSameType) {
2162 branch 0 never executed
2163 branch 1 never executed
2164 -: 1480: // pack array
2165 #####: 1481: if (packed) {
2166 branch 0 never executed
2167 branch 1 never executed
2168 #####: 1482: uintToNetTypeVarint(r, type, array->count);
2169 call 0 never executed
2170 -: 1483: }
2171 -: 1484: else {
2172 #####: 1485: if (ctx->nibble == lowNbl) {
2173 branch 0 never executed
2174 branch 1 never executed
2175 #####: 1486: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
2176 call 0 never executed
2177 #####: 1487: uintToVarint(r, array->count);
2178 call 0 never executed
2179 -: 1488: }
2180 -: 1489: else {
2181 -: 1490: // high nibble
2182 #####: 1491: ctx->nibble = lowNbl;
2183 #####: 1492: data = (char *)&((*r)->data) + ctx->nblOffset;
2184 #####: 1493: *data |= UNIFORM_ARRAY << 4;
2185 #####: 1494: uintToNetTypeVarint(r, type, array->count);
2186 call 0 never executed
2187 -: 1495: }
2188 -: 1496: }
2189 -: 1497:
2190 #####: 1498: switch(type) {
2191 branch 0 never executed
2192 branch 1 never executed
2193 branch 2 never executed
2194 branch 3 never executed
2195 branch 4 never executed
2196 branch 5 never executed
2197 branch 6 never executed
2198 branch 7 never executed
2199 -: 1499: case S_BOOL:
2200 #####: 1500: {forEachSArray(array, e) {
2201 branch 0 never executed
2202 branch 1 never executed
2203 #####: 1501: if (!ctx->boolOffset) {
2204 branch 0 never executed
2205 branch 1 never executed
2206 -: 1502: // new packed bools
2207 #####: 1503: storeNew8bPackedBool(e);
2208 branch 0 never executed
2209 branch 1 never executed
2210 call 2 never executed
2211 -: 1504: }
2212 -: 1505: else {
2213 -: 1506: // there was a bool before this one, fill bits in nibbles
2214 #####: 1507: if (ctx->boolShift == 8) {
2215 branch 0 never executed
2216 branch 1 never executed
2217 -: 1508: // previous packed bool is full
2218 -: 1509: // next byte is the new packed bools
2219 #####: 1510: storeNew8bPackedBool(e);
2220 branch 0 never executed
2221 branch 1 never executed
2222 call 2 never executed
2223 -: 1511: }
2224 -: 1512: else {
2225 #####: 1513: storeBool(e);
2226 branch 0 never executed
2227 branch 1 never executed
2228 -: 1514: }
2229 -: 1515: }
2230 -: 1516: }}
2231 #####: 1517: break;
2232 -: 1518: case S_DICT:
2233 -: 1519: case UNIFORM_DICT:
2234 #####: 1520: {forEachSArray(array, e) {
2235 branch 0 never executed
2236 branch 1 never executed
2237 #####: 1521: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/true);
2238 call 0 never executed
2239 -: 1522: }}
2240 #####: 1523: break;
2241 -: 1524: case S_DOUBLE:
2242 #####: 1525: {forEachSArray(array, e) {
2243 branch 0 never executed
2244 branch 1 never executed
2245 #####: 1526: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
2246 call 0 never executed
2247 -: 1527: }}
2248 #####: 1528: break;
2249 -: 1529: case S_INT:
2250 #####: 1530: {forEachSArray(array, e) {
2251 branch 0 never executed
2252 branch 1 never executed
2253 #####: 1531: i64 v = ((sIntt *)e)->value;
2254 #####: 1532: uintToVarint(r, (v << 1) ^ (v >> 63));
2255 call 0 never executed
2256 -: 1533: }}
2257 #####: 1534: break;
2258 -: 1535: case S_STRING:
2259 #####: 1536: {forEachSArray(array, e) {
2260 branch 0 never executed
2261 branch 1 never executed
2262 #####: 1537: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
2263 call 0 never executed
2264 -: 1538: }}
2265 #####: 1539: break;
2266 -: 1540: case S_ARRAY:
2267 -: 1541: case UNIFORM_ARRAY:
2268 #####: 1542: {forEachSArray(array, e) {
2269 branch 0 never executed
2270 branch 1 never executed
2271 #####: 1543: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/true);
2272 call 0 never executed
2273 -: 1544: }}
2274 #####: 1545: break;
2275 -: 1546: case S_BYTES:
2276 #####: 1547: {forEachSArray(array, e) {
2277 branch 0 never executed
2278 branch 1 never executed
2279 #####: 1548: B = (sBytest *)e;
2280 #####: 1549: uintToVarint(r, B->count);
2281 call 0 never executed
2282 #####: 1550: sBytesPushBuffer(r, &(B->data), B->count);
2283 call 0 never executed
2284 -: 1551: }}
2285 #####: 1552: break;
2286 -: 1553: }
2287 #####: 1554: ret;
2288 -: 1555: }
2289 -: 1556:
2290 #####: 1557: if (packed) {
2291 branch 0 never executed
2292 branch 1 never executed
2293 #####: 1558: uintToVarint(r, array->count);
2294 call 0 never executed
2295 -: 1559: }
2296 -: 1560: else {
2297 #####: 1561: if (ctx->nibble == lowNbl) {
2298 branch 0 never executed
2299 branch 1 never executed
2300 #####: 1562: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
2301 call 0 never executed
2302 -: 1563: }
2303 -: 1564: else {
2304 -: 1565: // high nibble
2305 #####: 1566: storeTypeInHighNbl(array);
2306 #####: 1567: uintToVarint(r, array->count);
2307 call 0 never executed
2308 -: 1568: }
2309 -: 1569: }
2310 -: 1570:
2311 #####: 1571: forEachSArray(array, e) {
2312 branch 0 never executed
2313 branch 1 never executed
2314 #####: 1572: if (!e) {
2315 branch 0 never executed
2316 branch 1 never executed
2317 -: 1573: // empty slots are represented as undefined elements
2318 #####: 1574: if (ctx->nibble == lowNbl) {
2319 branch 0 never executed
2320 branch 1 never executed
2321 #####: 1575: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
2322 call 0 never executed
2323 #####: 1576: ctx->nibble = highNbl;
2324 #####: 1577: ctx->nblOffset = (*r)->count -1;
2325 -: 1578: }
2326 -: 1579: else {
2327 -: 1580: // high nibble
2328 #####: 1581: ctx->nibble = lowNbl;
2329 #####: 1582: data = (char *)&((*r)->data) + ctx->nblOffset;
2330 #####: 1583: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
2331 -: 1584: }
2332 -: 1585: }
2333 -: 1586: else {
2334 #####: 1587: switch(e->type) {
2335 branch 0 never executed
2336 branch 1 never executed
2337 branch 2 never executed
2338 branch 3 never executed
2339 branch 4 never executed
2340 branch 5 never executed
2341 branch 6 never executed
2342 branch 7 never executed
2343 branch 8 never executed
2344 -: 1588: case UNDEFINED:
2345 -: 1589: case CONTAINER:
2346 #####: 1590: if (ctx->nibble == lowNbl) {
2347 branch 0 never executed
2348 branch 1 never executed
2349 #####: 1591: storeTypeOnly(e);
2350 call 0 never executed
2351 -: 1592: }
2352 -: 1593: else {
2353 -: 1594: // high nibble
2354 #####: 1595: storeTypeInHighNbl(e);
2355 -: 1596: }
2356 #####: 1597: break;
2357 -: 1598: case BOOL:
2358 #####: 1599: if (!ctx->boolOffset) {
2359 branch 0 never executed
2360 branch 1 never executed
2361 -: 1600: // new packed bools
2362 #####: 1601: if (ctx->nibble == lowNbl) {
2363 branch 0 never executed
2364 branch 1 never executed
2365 #####: 1602: storeNew4bPackedBool(e);
2366 branch 0 never executed
2367 branch 1 never executed
2368 call 2 never executed
2369 -: 1603: }
2370 -: 1604: else {
2371 -: 1605: // high nibble, next byte is packed bools
2372 #####: 1606: storeTypeInHighNbl(e);
2373 #####: 1607: storeNew8bPackedBool(e);
2374 branch 0 never executed
2375 branch 1 never executed
2376 call 2 never executed
2377 -: 1608: }
2378 -: 1609: }
2379 -: 1610: else {
2380 -: 1611: // there was a bool before this one, fill bits in nibbles
2381 #####: 1612: if (ctx->nibble == lowNbl) {
2382 branch 0 never executed
2383 branch 1 never executed
2384 #####: 1613: if (ctx->boolShift == 8) {
2385 branch 0 never executed
2386 branch 1 never executed
2387 -: 1614: // previous packed bool is full
2388 -: 1615: // this byte is the new packed bools
2389 #####: 1616: storeNew4bPackedBool(e);
2390 branch 0 never executed
2391 branch 1 never executed
2392 call 2 never executed
2393 -: 1617: }
2394 -: 1618: else {
2395 #####: 1619: storeTypeOnly(e);
2396 call 0 never executed
2397 #####: 1620: storeBool(e);
2398 branch 0 never executed
2399 branch 1 never executed
2400 -: 1621: }
2401 -: 1622: }
2402 -: 1623: else {
2403 -: 1624: // high nibble
2404 #####: 1625: storeTypeInHighNbl(e);
2405 #####: 1626: if (ctx->boolShift == 8) {
2406 branch 0 never executed
2407 branch 1 never executed
2408 -: 1627: // previous packed bool is full
2409 -: 1628: // next byte is the new packed bools
2410 #####: 1629: storeNew8bPackedBool(e);
2411 branch 0 never executed
2412 branch 1 never executed
2413 call 2 never executed
2414 -: 1630: }
2415 -: 1631: else {
2416 #####: 1632: storeBool(e);
2417 branch 0 never executed
2418 branch 1 never executed
2419 -: 1633: }
2420 -: 1634: }
2421 -: 1635: }
2422 #####: 1636: break;
2423 -: 1637: case DICT:
2424 #####: 1638: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/false);
2425 call 0 never executed
2426 #####: 1639: break;
2427 -: 1640: case DOUBLE:
2428 #####: 1641: if (ctx->nibble == lowNbl) {
2429 branch 0 never executed
2430 branch 1 never executed
2431 #####: 1642: storeTypeOnly(e);
2432 call 0 never executed
2433 -: 1643: }
2434 -: 1644: else {
2435 -: 1645: // high nibble
2436 #####: 1646: storeTypeInHighNbl(e);
2437 -: 1647: }
2438 #####: 1648: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
2439 call 0 never executed
2440 #####: 1649: break;
2441 -: 1650: case INT: {
2442 -: 1651: // encode int to varint
2443 -: 1652: // v is int64_t to convert to varint
2444 #####: 1653: i64 v = ((sIntt *)&(e->type))->value;
2445 #####: 1654: if (ctx->nibble == lowNbl) {
2446 branch 0 never executed
2447 branch 1 never executed
2448 -: 1655: // encode v with arithmetic shifts
2449 #####: 1656: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
2450 call 0 never executed
2451 -: 1657: }
2452 -: 1658: else {
2453 -: 1659: // high nibble
2454 #####: 1660: storeTypeInHighNbl(e);
2455 #####: 1661: uintToVarint(r, (v << 1) ^ (v >> 63));
2456 call 0 never executed
2457 -: 1662: }
2458 -: 1663: }
2459 #####: 1664: break;
2460 -: 1665: case STRING:
2461 #####: 1666: if (ctx->nibble == lowNbl) {
2462 branch 0 never executed
2463 branch 1 never executed
2464 #####: 1667: storeTypeOnly(e);
2465 call 0 never executed
2466 -: 1668: }
2467 -: 1669: else {
2468 -: 1670: // high nibble
2469 #####: 1671: storeTypeInHighNbl(e);
2470 -: 1672: }
2471 #####: 1673: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
2472 call 0 never executed
2473 #####: 1674: break;
2474 -: 1675: case ARRAY:
2475 #####: 1676: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/false);
2476 call 0 never executed
2477 #####: 1677: break;
2478 -: 1678: case BYTES:
2479 #####: 1679: B = (sBytest *)e;
2480 #####: 1680: if (ctx->nibble == lowNbl) {
2481 branch 0 never executed
2482 branch 1 never executed
2483 #####: 1681: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
2484 call 0 never executed
2485 -: 1682: }
2486 -: 1683: else {
2487 -: 1684: // high nibble
2488 #####: 1685: storeTypeInHighNbl(e);
2489 #####: 1686: uintToVarint(r, B->count);
2490 call 0 never executed
2491 -: 1687: }
2492 #####: 1688: sBytesPushBuffer(r, &(B->data), B->count);
2493 call 0 never executed
2494 #####: 1689: break;
2495 -: 1690: }
2496 -: 1691: }
2497 -: 1692: }
2498 #####: 1693: ret;
2499 -: 1694:}
2500 -: 1695:
2501 function serialNetSerialLevel2 called 0 returned 0% blocks executed 0%
2502 #####: 1696:internal smallBytest* serialNetSerialLevel2(smallJsont *self) {
2503 -: 1697:
2504 #####: 1698: smallt *o = getsoG(self);
2505 call 0 never executed
2506 -: 1699:
2507 #####: 1700: if (o == NULL)
2508 branch 0 never executed
2509 branch 1 never executed
2510 #####: 1701: ret NULL;
2511 -: 1702:
2512 #####: 1703: sBytest *B = netSerialLevel2(o);
2513 call 0 never executed
2514 -: 1704:
2515 #####: 1705: if (!B) {
2516 branch 0 never executed
2517 branch 1 never executed
2518 #####: 1706: ret NULL;
2519 -: 1707: }
2520 -: 1708:
2521 #####: 1709: createAllocateSmallBytes(r);
2522 call 0 never executed
2523 #####: 1710: r->B = B;
2524 #####: 1711: ret r;
2525 -: 1712:}
2526 -: 1713:
2527 -: 1714:// level 3
2528 -: 1715:// like level 2, elements of identical type in a row are packed
2529 -: 1716:
2530 -: 1717:/**
2531 -: 1718: * serializer top function
2532 -: 1719: */
2533 function netSerial called 86 returned 100% blocks executed 88%
2534 86: 1720:internal sBytest* netSerial(smallt *o) {
2535 86: 1721: sBytest *r = NULL;
2536 86: 1722: sBytest *B = NULL;
2537 86: 1723: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
2538 -: 1724:
2539 86: 1725: switch(o->type) {
2540 branch 0 taken 1%
2541 branch 1 taken 1%
2542 branch 2 taken 47%
2543 branch 3 taken 1%
2544 branch 4 taken 3%
2545 branch 5 taken 1%
2546 branch 6 taken 45%
2547 branch 7 taken 0%
2548 branch 8 taken 0%
2549 -: 1726: case UNDEFINED:
2550 -: 1727: case CONTAINER:
2551 1: 1728: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
2552 call 0 returned 100%
2553 1: 1729: break;
2554 -: 1730: case BOOL: {
2555 1: 1731: u8 c = NET_SERIAL_TYPES[(u8)o->type];
2556 -: 1732: // set bit 4 when true
2557 1: 1733: if (((sBoolt *)&(o->type))->value)
2558 branch 0 taken 100% (fallthrough)
2559 branch 1 taken 0%
2560 1: 1734: c |= (1<<4);
2561 1: 1735: sBytesPush(&r, c);
2562 call 0 returned 100%
2563 -: 1736: }
2564 1: 1737: break;
2565 -: 1738: case DICT:
2566 40: 1739: dictNetSerial(&r, (sDictt *)&(o->type), &ctx, /*packing=*/NOPACKING);
2567 call 0 returned 100%
2568 40: 1740: break;
2569 -: 1741: case DOUBLE:
2570 1: 1742: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
2571 call 0 returned 100%
2572 1: 1743: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
2573 call 0 returned 100%
2574 1: 1744: break;
2575 -: 1745: case INT: {
2576 -: 1746: // encode int to varint
2577 -: 1747: // v is int64_t to convert to varint
2578 3: 1748: i64 v = ((sIntt *)&(o->type))->value;
2579 -: 1749: // encode v with arithmetic shifts
2580 3: 1750: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
2581 call 0 returned 100%
2582 -: 1751: }
2583 3: 1752: break;
2584 -: 1753: case STRING:
2585 1: 1754: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
2586 call 0 returned 100%
2587 1: 1755: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
2588 call 0 returned 100%
2589 1: 1756: break;
2590 -: 1757: case ARRAY:
2591 39: 1758: arrayNetSerial(&r, (sArrayt *)&(o->type), &ctx, /*packing=*/NOPACKING);
2592 call 0 returned 100%
2593 39: 1759: break;
2594 -: 1760: case BYTES:
2595 #####: 1761: B = (sBytest *)&(o->type);
2596 #####: 1762: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
2597 call 0 never executed
2598 #####: 1763: sBytesPushBuffer(&r, &(B->data), B->count);
2599 call 0 never executed
2600 #####: 1764: break;
2601 -: 1765: }
2602 86: 1766: ret r;
2603 -: 1767:}
2604 -: 1768:
2605 -: 1769:/**
2606 -: 1770: * serialize dictionary
2607 -: 1771: *
2608 -: 1772: * the serialized dict is pushed to r.
2609 -: 1773: * All elements are serialized recursively
2610 -: 1774: *
2611 -: 1775: * the data in containers is not serialized
2612 -: 1776: *
2613 -: 1777: * \param
2614 -: 1778: * r small bytes object
2615 -: 1779: * dict dictionary to serialize
2616 -: 1780: */
2617 function dictNetSerial called 83 returned 100% blocks executed 96%
2618 83: 1781:internal void dictNetSerial(sBytest **r, sDictt *dict, contextt *ctx, packingT packing) {
2619 83: 1782: sBytest *B = NULL;
2620 83: 1783: char *data = NULL;
2621 -: 1784:
2622 -: 1785: // compute allocated element count and use that instead of dict->count
2623 -: 1786: // when elements are deleted, some positions are NULL
2624 -: 1787: // and should not be counted
2625 83: 1788: u32 cnt =0;
2626 302: 1789: {forEachSDict(dict, e) {
2627 branch 0 taken 73%
2628 branch 1 taken 27% (fallthrough)
2629 219: 1790: if (e->key) {
2630 branch 0 taken 99% (fallthrough)
2631 branch 1 taken 1%
2632 218: 1791: inc cnt;
2633 -: 1792: }
2634 -: 1793: }}
2635 -: 1794:
2636 -: 1795: // check if all elements have same type
2637 -: 1796: // then set dict type normal or uniform
2638 -: 1797: // array and dict have to be checked recursively to know if they are normal or uniform
2639 83: 1798: bool allElementsHaveSameType = true;
2640 83: 1799: bool foundFirstType = false;
2641 83: 1800: char type = 0;
2642 -: 1801: // get first element type
2643 -: 1802: // compare to other element type
2644 209: 1803: {forEachSDict(dict, e) {
2645 branch 0 taken 78%
2646 branch 1 taken 22% (fallthrough)
2647 164: 1804: if (e->key) {
2648 branch 0 taken 99% (fallthrough)
2649 branch 1 taken 1%
2650 163: 1805: if (foundFirstType) {
2651 branch 0 taken 56% (fallthrough)
2652 branch 1 taken 44%
2653 -: 1806: u8 nextType;
2654 92: 1807: switch(e->data->type) {
2655 branch 0 taken 16%
2656 branch 1 taken 11%
2657 branch 2 taken 73%
2658 -: 1808: case DICT:
2659 15: 1809: nextType = isDictUniform((sDictt*)e->data);
2660 call 0 returned 100%
2661 15: 1810: break;
2662 -: 1811: case ARRAY:
2663 10: 1812: nextType = isArrayUniform((sArrayt*)e->data);
2664 call 0 returned 100%
2665 10: 1813: break;
2666 -: 1814: default:
2667 67: 1815: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
2668 -: 1816: }
2669 92: 1817: if (nextType != type) {
2670 branch 0 taken 41% (fallthrough)
2671 branch 1 taken 59%
2672 38: 1818: allElementsHaveSameType = false;
2673 38: 1819: break;
2674 -: 1820: }
2675 -: 1821: }
2676 -: 1822: else {
2677 71: 1823: switch(e->data->type) {
2678 branch 0 taken 7%
2679 branch 1 taken 4%
2680 branch 2 taken 89%
2681 -: 1824: case DICT:
2682 5: 1825: type = isDictUniform((sDictt*)e->data);
2683 call 0 returned 100%
2684 5: 1826: break;
2685 -: 1827: case ARRAY:
2686 3: 1828: type = isArrayUniform((sArrayt*)e->data);
2687 call 0 returned 100%
2688 3: 1829: break;
2689 -: 1830: default:
2690 63: 1831: type = NET_SERIAL_TYPES[(u8)e->data->type];
2691 -: 1832: }
2692 71: 1833: foundFirstType = true;
2693 -: 1834: }
2694 -: 1835: }
2695 -: 1836: }}
2696 -: 1837:
2697 83: 1838: if (allElementsHaveSameType) {
2698 branch 0 taken 54% (fallthrough)
2699 branch 1 taken 46%
2700 -: 1839: // uniform dict
2701 -: 1840: // encode type and element count
2702 -: 1841:
2703 -: 1842: // in pack dictionary
2704 45: 1843: if (packing == PACK) {
2705 branch 0 taken 40% (fallthrough)
2706 branch 1 taken 60%
2707 -: 1844: // uniform dict can't be packed
2708 -: 1845: // because there is only one type of packed arrays
2709 18: 1846: goto normalDict;
2710 -: 1847: }
2711 27: 1848: elif (packing == UNIFORM) {
2712 branch 0 taken 15% (fallthrough)
2713 branch 1 taken 85%
2714 -: 1849: // when the packing is uniform, there is no need to encode UNIFORM_DICT since all elements have this type
2715 4: 1850: uintToNetTypeVarint(r, type, cnt);
2716 call 0 returned 100%
2717 -: 1851: }
2718 -: 1852: else {
2719 23: 1853: if (ctx->nibble == lowNbl) {
2720 branch 0 taken 91% (fallthrough)
2721 branch 1 taken 9%
2722 21: 1854: sBytesPush(r, (type << 4) + UNIFORM_DICT);
2723 call 0 returned 100%
2724 21: 1855: uintToVarint(r, cnt);
2725 call 0 returned 100%
2726 -: 1856: }
2727 -: 1857: else {
2728 -: 1858: // high nibble
2729 2: 1859: ctx->nibble = lowNbl;
2730 2: 1860: data = (char *)&((*r)->data) + ctx->nblOffset;
2731 2: 1861: *data |= UNIFORM_DICT << 4;
2732 2: 1862: uintToNetTypeVarint(r, type, cnt);
2733 call 0 returned 100%
2734 -: 1863: }
2735 -: 1864: }
2736 -: 1865:
2737 -: 1866: // encode all element keys and values
2738 27: 1867: switch(type) {
2739 branch 0 taken 11%
2740 branch 1 taken 15%
2741 branch 2 taken 7%
2742 branch 3 taken 4%
2743 branch 4 taken 33%
2744 branch 5 taken 19%
2745 branch 6 taken 7%
2746 branch 7 taken 4%
2747 branch 8 taken 0%
2748 -: 1868: case S_UNDEFINED:
2749 10: 1869: {forEachSDict(dict, e) {
2750 branch 0 taken 70%
2751 branch 1 taken 30% (fallthrough)
2752 7: 1870: if (e->key) {
2753 branch 0 taken 86% (fallthrough)
2754 branch 1 taken 14%
2755 6: 1871: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2756 call 0 returned 100%
2757 -: 1872: }
2758 -: 1873: }}
2759 -: 1874:
2760 3: 1875: break;
2761 -: 1876: case S_BOOL:
2762 19: 1877: {forEachSDict(dict, e) {
2763 branch 0 taken 79%
2764 branch 1 taken 21% (fallthrough)
2765 15: 1878: if (e->key) {
2766 branch 0 taken 100% (fallthrough)
2767 branch 1 taken 0%
2768 15: 1879: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2769 call 0 returned 100%
2770 -: 1880:
2771 15: 1881: if (!ctx->boolOffset) {
2772 branch 0 taken 20% (fallthrough)
2773 branch 1 taken 80%
2774 -: 1882: // new packed bools
2775 3: 1883: storeNew8bPackedBool(e->data);
2776 branch 0 taken 100% (fallthrough)
2777 branch 1 taken 0%
2778 call 2 returned 100%
2779 -: 1884: }
2780 -: 1885: else {
2781 -: 1886: // there was a bool before this one, fill bits in nibbles
2782 12: 1887: if (ctx->boolShift == 8) {
2783 branch 0 taken 8% (fallthrough)
2784 branch 1 taken 92%
2785 -: 1888: // previous packed bool is full
2786 -: 1889: // next byte is the new packed bools
2787 1: 1890: storeNew8bPackedBool(e->data);
2788 branch 0 taken 100% (fallthrough)
2789 branch 1 taken 0%
2790 call 2 returned 100%
2791 -: 1891: }
2792 -: 1892: else {
2793 11: 1893: storeBool(e->data);
2794 branch 0 taken 91% (fallthrough)
2795 branch 1 taken 9%
2796 -: 1894: }
2797 -: 1895: }
2798 -: 1896: }
2799 -: 1897: }}
2800 4: 1898: break;
2801 -: 1899: case S_DICT:
2802 -: 1900: case UNIFORM_DICT:
2803 6: 1901: {forEachSDict(dict, e) {
2804 branch 0 taken 67%
2805 branch 1 taken 33% (fallthrough)
2806 4: 1902: if (e->key) {
2807 branch 0 taken 100% (fallthrough)
2808 branch 1 taken 0%
2809 4: 1903: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2810 call 0 returned 100%
2811 4: 1904: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/UNIFORM);
2812 call 0 returned 100%
2813 -: 1905: }
2814 -: 1906: }}
2815 2: 1907: break;
2816 -: 1908: case S_DOUBLE:
2817 4: 1909: {forEachSDict(dict, e) {
2818 branch 0 taken 75%
2819 branch 1 taken 25% (fallthrough)
2820 3: 1910: if (e->key) {
2821 branch 0 taken 100% (fallthrough)
2822 branch 1 taken 0%
2823 3: 1911: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2824 call 0 returned 100%
2825 3: 1912: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
2826 call 0 returned 100%
2827 -: 1913: }
2828 -: 1914: }}
2829 1: 1915: break;
2830 -: 1916: case S_INT:
2831 21: 1917: {forEachSDict(dict, e) {
2832 branch 0 taken 57%
2833 branch 1 taken 43% (fallthrough)
2834 12: 1918: if (e->key) {
2835 branch 0 taken 100% (fallthrough)
2836 branch 1 taken 0%
2837 12: 1919: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2838 call 0 returned 100%
2839 12: 1920: i64 v = ((sIntt *)(e->data))->value;
2840 12: 1921: uintToVarint(r, (v << 1) ^ (v >> 63));
2841 call 0 returned 100%
2842 -: 1922: }
2843 -: 1923: }}
2844 9: 1924: break;
2845 -: 1925: case S_STRING:
2846 16: 1926: {forEachSDict(dict, e) {
2847 branch 0 taken 69%
2848 branch 1 taken 31% (fallthrough)
2849 11: 1927: if (e->key) {
2850 branch 0 taken 100% (fallthrough)
2851 branch 1 taken 0%
2852 11: 1928: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2853 call 0 returned 100%
2854 11: 1929: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
2855 call 0 returned 100%
2856 -: 1930: }
2857 -: 1931: }}
2858 5: 1932: break;
2859 -: 1933: case S_ARRAY:
2860 -: 1934: case UNIFORM_ARRAY:
2861 4: 1935: {forEachSDict(dict, e) {
2862 branch 0 taken 50%
2863 branch 1 taken 50% (fallthrough)
2864 2: 1936: if (e->key) {
2865 branch 0 taken 100% (fallthrough)
2866 branch 1 taken 0%
2867 2: 1937: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2868 call 0 returned 100%
2869 2: 1938: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/UNIFORM);
2870 call 0 returned 100%
2871 -: 1939: }
2872 -: 1940: }}
2873 2: 1941: break;
2874 -: 1942: case S_BYTES:
2875 3: 1943: {forEachSDict(dict, e) {
2876 branch 0 taken 67%
2877 branch 1 taken 33% (fallthrough)
2878 2: 1944: if (e->key) {
2879 branch 0 taken 100% (fallthrough)
2880 branch 1 taken 0%
2881 2: 1945: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2882 call 0 returned 100%
2883 2: 1946: B = (sBytest *)(e->data);
2884 2: 1947: uintToVarint(r, B->count);
2885 call 0 returned 100%
2886 2: 1948: sBytesPushBuffer(r, &(B->data), B->count);
2887 call 0 returned 100%
2888 -: 1949: }
2889 -: 1950: }}
2890 1: 1951: break;
2891 -: 1952: }
2892 27: 1953: ret;
2893 -: 1954: }
2894 -: 1955:
2895 -: 1956: normalDict:
2896 -: 1957: // encode type and element count
2897 56: 1958: if (packing == PACK or packing == UNIFORM) {
2898 branch 0 taken 59% (fallthrough)
2899 branch 1 taken 41%
2900 branch 2 taken 12% (fallthrough)
2901 branch 3 taken 88%
2902 -: 1959: // when the packing is packed or uniform, there is no need to encode DICT type since all elements have this type
2903 27: 1960: uintToVarint(r, cnt);
2904 call 0 returned 100%
2905 -: 1961: }
2906 -: 1962: else {
2907 29: 1963: if (ctx->nibble == lowNbl) {
2908 branch 0 taken 93% (fallthrough)
2909 branch 1 taken 7%
2910 27: 1964: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], cnt);
2911 call 0 returned 100%
2912 -: 1965: }
2913 -: 1966: else {
2914 -: 1967: // high nibble
2915 -: 1968: #define storeTypeInHighNbl(o)\
2916 -: 1969: ctx->nibble = lowNbl;\
2917 -: 1970: data = (char *)&((*r)->data) + ctx->nblOffset;\
2918 -: 1971: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
2919 2: 1972: storeTypeInHighNbl(dict);
2920 2: 1973: uintToVarint(r, cnt);
2921 call 0 returned 100%
2922 -: 1974: }
2923 -: 1975: }
2924 -: 1976:
2925 56: 1977: bool pack = false;
2926 -: 1978: size_t packCount;
2927 219: 1979: enumerateSDict(dict, e, eIdx) {
2928 branch 0 taken 74%
2929 branch 1 taken 26% (fallthrough)
2930 163: 1980: if (e->key) {
2931 branch 0 taken 100% (fallthrough)
2932 branch 1 taken 0%
2933 163: 1981: if (!pack) {
2934 branch 0 taken 77% (fallthrough)
2935 branch 1 taken 23%
2936 -: 1982: // scan dict for packing
2937 125: 1983: if ((cnt - eIdx) > 3) {
2938 branch 0 taken 34% (fallthrough)
2939 branch 1 taken 66%
2940 -: 1984: // at least 4 elements, less than that is not worth it
2941 42: 1985: if ( e->data->type == DICT
2942 branch 0 taken 93% (fallthrough)
2943 branch 1 taken 7%
2944 39: 1986: or e->data->type == DOUBLE
2945 branch 0 taken 95% (fallthrough)
2946 branch 1 taken 5%
2947 37: 1987: or e->data->type == INT
2948 branch 0 taken 95% (fallthrough)
2949 branch 1 taken 5%
2950 35: 1988: or e->data->type == STRING
2951 branch 0 taken 94% (fallthrough)
2952 branch 1 taken 6%
2953 33: 1989: or e->data->type == ARRAY
2954 branch 0 taken 94% (fallthrough)
2955 branch 1 taken 6%
2956 31: 1990: or e->data->type == BYTES) {
2957 branch 0 taken 0% (fallthrough)
2958 branch 1 taken 100%
2959 11: 1991: type = e->data->type;
2960 11: 1992: packCount = 1;
2961 11: 1993: sDictElemt *element = &((dict)->elements) + eIdx +1;
2962 49: 1994: for (size_t i = eIdx+1; i < (dict)->count ; i++, element = &((dict)->elements) + i) {
2963 branch 0 taken 100%
2964 branch 1 taken 0% (fallthrough)
2965 49: 1995: if (element->key) {
2966 branch 0 taken 100% (fallthrough)
2967 branch 1 taken 0%
2968 49: 1996: if (element->data->type != type) {
2969 branch 0 taken 22% (fallthrough)
2970 branch 1 taken 78%
2971 11: 1997: break;
2972 -: 1998: }
2973 38: 1999: packCount++;
2974 -: 2000: } // element->key
2975 -: 2001: } // for
2976 11: 2002: if (packCount > 3) {
2977 branch 0 taken 100% (fallthrough)
2978 branch 1 taken 0%
2979 11: 2003: type = PACKED_NET_SERIAL_TYPES[(u8)type];
2980 11: 2004: pack = true;
2981 -: 2005: }
2982 -: 2006: } // test current element type
2983 -: 2007: } // is dict big enough
2984 -: 2008: } // not already packing
2985 -: 2009:
2986 -: 2010: // encode key
2987 163: 2011: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
2988 call 0 returned 100%
2989 -: 2012:
2990 -: 2013: // encode value
2991 163: 2014: switch(e->data->type) {
2992 branch 0 taken 18%
2993 branch 1 taken 19%
2994 branch 2 taken 12%
2995 branch 3 taken 7%
2996 branch 4 taken 20%
2997 branch 5 taken 13%
2998 branch 6 taken 9%
2999 branch 7 taken 1%
3000 branch 8 taken 0%
3001 -: 2015: case UNDEFINED:
3002 -: 2016: case CONTAINER:
3003 29: 2017: if (ctx->nibble == lowNbl) {
3004 branch 0 taken 93% (fallthrough)
3005 branch 1 taken 7%
3006 -: 2018: #define storeTypeOnly(o)\
3007 -: 2019: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
3008 -: 2020: ctx->nibble = highNbl;\
3009 -: 2021: ctx->nblOffset = (*r)->count -1
3010 27: 2022: storeTypeOnly(e->data);
3011 call 0 returned 100%
3012 -: 2023: }
3013 -: 2024: else {
3014 2: 2025: storeTypeInHighNbl(e->data);
3015 -: 2026: }
3016 29: 2027: break;
3017 -: 2028: case BOOL:
3018 31: 2029: if (!ctx->boolOffset) {
3019 branch 0 taken 16% (fallthrough)
3020 branch 1 taken 84%
3021 -: 2030: // new packed bools
3022 5: 2031: if (ctx->nibble == lowNbl) {
3023 branch 0 taken 60% (fallthrough)
3024 branch 1 taken 40%
3025 -: 2032: #define storeNew4bPackedBool(o)\
3026 -: 2033: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
3027 -: 2034: /* set bit 4 when true */\
3028 -: 2035: if (((sBoolt *)(o))->value)\
3029 -: 2036: c |= (1<<4);\
3030 -: 2037: sBytesPush(r, c);\
3031 -: 2038: ctx->boolShift = 5;\
3032 -: 2039: ctx->boolOffset = (*r)->count -1
3033 3: 2040: storeNew4bPackedBool(e->data);
3034 branch 0 taken 100% (fallthrough)
3035 branch 1 taken 0%
3036 call 2 returned 100%
3037 -: 2041: }
3038 -: 2042: else {
3039 -: 2043: // high nibble, next byte is packed bools
3040 2: 2044: storeTypeInHighNbl(e->data);
3041 -: 2045: #define storeNew8bPackedBool(o)\
3042 -: 2046: u8 c = 0;\
3043 -: 2047: if (((sBoolt *)(o))->value)\
3044 -: 2048: c = 1;\
3045 -: 2049: sBytesPush(r, c);\
3046 -: 2050: ctx->boolShift = 1;\
3047 -: 2051: ctx->boolOffset = (*r)->count -1
3048 2: 2052: storeNew8bPackedBool(e->data);
3049 branch 0 taken 100% (fallthrough)
3050 branch 1 taken 0%
3051 call 2 returned 100%
3052 -: 2053: }
3053 -: 2054: }
3054 -: 2055: else {
3055 -: 2056: // there was a bool before this one, fill bits in nibbles
3056 26: 2057: if (ctx->nibble == lowNbl) {
3057 branch 0 taken 58% (fallthrough)
3058 branch 1 taken 42%
3059 15: 2058: if (ctx->boolShift == 8) {
3060 branch 0 taken 7% (fallthrough)
3061 branch 1 taken 93%
3062 -: 2059: // previous packed bool is full
3063 -: 2060: // this byte is the new packed bools
3064 1: 2061: storeNew4bPackedBool(e->data);
3065 branch 0 taken 100% (fallthrough)
3066 branch 1 taken 0%
3067 call 2 returned 100%
3068 -: 2062: }
3069 -: 2063: else {
3070 14: 2064: storeTypeOnly(e->data);
3071 call 0 returned 100%
3072 -: 2065: #define storeBool(o)\
3073 -: 2066: data = (char *)&((*r)->data) + ctx->boolOffset;\
3074 -: 2067: if (((sBoolt *)(o))->value)\
3075 -: 2068: *data |= 1 << ctx->boolShift;\
3076 -: 2069: ctx->boolShift++
3077 14: 2070: storeBool(e->data);
3078 branch 0 taken 100% (fallthrough)
3079 branch 1 taken 0%
3080 -: 2071: }
3081 -: 2072: }
3082 -: 2073: else {
3083 -: 2074: // high nibble
3084 11: 2075: storeTypeInHighNbl(e->data);
3085 11: 2076: if (ctx->boolShift == 8) {
3086 branch 0 taken 18% (fallthrough)
3087 branch 1 taken 82%
3088 -: 2077: // previous packed bool is full
3089 -: 2078: // next byte is the new packed bools
3090 2: 2079: storeNew8bPackedBool(e->data);
3091 branch 0 taken 100% (fallthrough)
3092 branch 1 taken 0%
3093 call 2 returned 100%
3094 -: 2080: }
3095 -: 2081: else {
3096 9: 2082: storeBool(e->data);
3097 branch 0 taken 100% (fallthrough)
3098 branch 1 taken 0%
3099 -: 2083: }
3100 -: 2084: }
3101 -: 2085: }
3102 31: 2086: break;
3103 -: 2087: case DICT:
3104 20: 2088: if (pack) {
3105 branch 0 taken 75% (fallthrough)
3106 branch 1 taken 25%
3107 15: 2089: if (type) {
3108 branch 0 taken 20% (fallthrough)
3109 branch 1 taken 80%
3110 -: 2090: // this is the first packed element
3111 3: 2091: if (ctx->nibble == lowNbl) {
3112 branch 0 taken 67% (fallthrough)
3113 branch 1 taken 33%
3114 2: 2092: uintToNetTypeVarint(r, type, packCount);
3115 call 0 returned 100%
3116 -: 2093: }
3117 -: 2094: else {
3118 -: 2095: // high nibble
3119 -: 2096: // store type in high nibble
3120 1: 2097: ctx->nibble = lowNbl;
3121 1: 2098: data = (char *)&((*r)->data) + ctx->nblOffset;
3122 1: 2099: *data |= type << 4;
3123 1: 2100: uintToVarint(r, packCount);
3124 call 0 returned 100%
3125 -: 2101: }
3126 3: 2102: type = 0;
3127 -: 2103: } // if type
3128 -: 2104:
3129 15: 2105: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/PACK);
3130 call 0 returned 100%
3131 -: 2106: // stop packing when packCount == 0
3132 15: 2107: packCount--;
3133 15: 2108: if (!packCount) pack = false;
3134 branch 0 taken 20% (fallthrough)
3135 branch 1 taken 80%
3136 -: 2109: } // if pack
3137 -: 2110: else
3138 5: 2111: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/NOPACKING);
3139 call 0 returned 100%
3140 20: 2112: break;
3141 -: 2113: case DOUBLE:
3142 12: 2114: if (pack) {
3143 branch 0 taken 83% (fallthrough)
3144 branch 1 taken 17%
3145 10: 2115: if (type) {
3146 branch 0 taken 20% (fallthrough)
3147 branch 1 taken 80%
3148 -: 2116: // this is the first packed element
3149 2: 2117: if (ctx->nibble == lowNbl) {
3150 branch 0 taken 50% (fallthrough)
3151 branch 1 taken 50%
3152 1: 2118: uintToNetTypeVarint(r, type, packCount);
3153 call 0 returned 100%
3154 -: 2119: }
3155 -: 2120: else {
3156 -: 2121: // high nibble
3157 -: 2122: // store type in high nibble
3158 1: 2123: ctx->nibble = lowNbl;
3159 1: 2124: data = (char *)&((*r)->data) + ctx->nblOffset;
3160 1: 2125: *data |= type << 4;
3161 1: 2126: uintToVarint(r, packCount);
3162 call 0 returned 100%
3163 -: 2127: }
3164 2: 2128: type = 0;
3165 -: 2129: } // if type
3166 -: 2130:
3167 10: 2131: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
3168 call 0 returned 100%
3169 -: 2132: // stop packing when packCount == 0
3170 10: 2133: packCount--;
3171 10: 2134: if (!packCount) pack = false;
3172 branch 0 taken 20% (fallthrough)
3173 branch 1 taken 80%
3174 -: 2135: } // if pack
3175 -: 2136: else {
3176 2: 2137: if (ctx->nibble == lowNbl) {
3177 branch 0 taken 50% (fallthrough)
3178 branch 1 taken 50%
3179 1: 2138: storeTypeOnly(e->data);
3180 call 0 returned 100%
3181 -: 2139: }
3182 -: 2140: else {
3183 -: 2141: // high nibble
3184 1: 2142: storeTypeInHighNbl(e->data);
3185 -: 2143: }
3186 2: 2144: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
3187 call 0 returned 100%
3188 -: 2145: }
3189 12: 2146: break;
3190 -: 2147: case INT:
3191 32: 2148: if (pack) {
3192 branch 0 taken 25% (fallthrough)
3193 branch 1 taken 75%
3194 8: 2149: if (type) {
3195 branch 0 taken 25% (fallthrough)
3196 branch 1 taken 75%
3197 -: 2150: // this is the first packed element
3198 2: 2151: if (ctx->nibble == lowNbl) {
3199 branch 0 taken 50% (fallthrough)
3200 branch 1 taken 50%
3201 1: 2152: uintToNetTypeVarint(r, type, packCount);
3202 call 0 returned 100%
3203 -: 2153: }
3204 -: 2154: else {
3205 -: 2155: // high nibble
3206 -: 2156: // store type in high nibble
3207 1: 2157: ctx->nibble = lowNbl;
3208 1: 2158: data = (char *)&((*r)->data) + ctx->nblOffset;
3209 1: 2159: *data |= type << 4;
3210 1: 2160: uintToVarint(r, packCount);
3211 call 0 returned 100%
3212 -: 2161: }
3213 2: 2162: type = 0;
3214 -: 2163: } // if type
3215 -: 2164:
3216 8: 2165: i64 v = ((sIntt *)(e->data))->value;
3217 8: 2166: uintToVarint(r, (v << 1) ^ (v >> 63));
3218 call 0 returned 100%
3219 -: 2167: // stop packing when packCount == 0
3220 8: 2168: packCount--;
3221 8: 2169: if (!packCount) pack = false;
3222 branch 0 taken 25% (fallthrough)
3223 branch 1 taken 75%
3224 -: 2170: } // if pack
3225 -: 2171: else {
3226 -: 2172: // encode int to varint
3227 -: 2173: // v is int64_t to convert to varint
3228 24: 2174: i64 v = ((sIntt *)(e->data))->value;
3229 24: 2175: if (ctx->nibble == lowNbl) {
3230 branch 0 taken 50% (fallthrough)
3231 branch 1 taken 50%
3232 -: 2176: // encode v with arithmetic shifts
3233 12: 2177: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
3234 call 0 returned 100%
3235 -: 2178: }
3236 -: 2179: else {
3237 -: 2180: // high nibble
3238 12: 2181: storeTypeInHighNbl(e->data);
3239 12: 2182: uintToVarint(r, (v << 1) ^ (v >> 63));
3240 call 0 returned 100%
3241 -: 2183: }
3242 -: 2184: }
3243 32: 2185: break;
3244 -: 2186: case STRING:
3245 22: 2187: if (pack) {
3246 branch 0 taken 36% (fallthrough)
3247 branch 1 taken 64%
3248 8: 2188: if (type) {
3249 branch 0 taken 25% (fallthrough)
3250 branch 1 taken 75%
3251 -: 2189: // this is the first packed element
3252 2: 2190: if (ctx->nibble == lowNbl) {
3253 branch 0 taken 50% (fallthrough)
3254 branch 1 taken 50%
3255 1: 2191: uintToNetTypeVarint(r, type, packCount);
3256 call 0 returned 100%
3257 -: 2192: }
3258 -: 2193: else {
3259 -: 2194: // high nibble
3260 -: 2195: // store type in high nibble
3261 1: 2196: ctx->nibble = lowNbl;
3262 1: 2197: data = (char *)&((*r)->data) + ctx->nblOffset;
3263 1: 2198: *data |= type << 4;
3264 1: 2199: uintToVarint(r, packCount);
3265 call 0 returned 100%
3266 -: 2200: }
3267 2: 2201: type = 0;
3268 -: 2202: } // if type
3269 -: 2203:
3270 8: 2204: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
3271 call 0 returned 100%
3272 -: 2205: // stop packing when packCount == 0
3273 8: 2206: packCount--;
3274 8: 2207: if (!packCount) pack = false;
3275 branch 0 taken 25% (fallthrough)
3276 branch 1 taken 75%
3277 -: 2208: } // if pack
3278 -: 2209: else {
3279 14: 2210: if (ctx->nibble == lowNbl) {
3280 branch 0 taken 93% (fallthrough)
3281 branch 1 taken 7%
3282 13: 2211: storeTypeOnly(e->data);
3283 call 0 returned 100%
3284 -: 2212: }
3285 -: 2213: else {
3286 -: 2214: // high nibble
3287 1: 2215: storeTypeInHighNbl(e->data);
3288 -: 2216: }
3289 14: 2217: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
3290 call 0 returned 100%
3291 -: 2218: }
3292 22: 2219: break;
3293 -: 2220: case ARRAY:
3294 15: 2221: if (pack) {
3295 branch 0 taken 53% (fallthrough)
3296 branch 1 taken 47%
3297 8: 2222: if (type) {
3298 branch 0 taken 25% (fallthrough)
3299 branch 1 taken 75%
3300 -: 2223: // this is the first packed element
3301 2: 2224: if (ctx->nibble == lowNbl) {
3302 branch 0 taken 50% (fallthrough)
3303 branch 1 taken 50%
3304 1: 2225: uintToNetTypeVarint(r, type, packCount);
3305 call 0 returned 100%
3306 -: 2226: }
3307 -: 2227: else {
3308 -: 2228: // high nibble
3309 -: 2229: // store type in high nibble
3310 1: 2230: ctx->nibble = lowNbl;
3311 1: 2231: data = (char *)&((*r)->data) + ctx->nblOffset;
3312 1: 2232: *data |= type << 4;
3313 1: 2233: uintToVarint(r, packCount);
3314 call 0 returned 100%
3315 -: 2234: }
3316 2: 2235: type = 0;
3317 -: 2236: } // if type
3318 -: 2237:
3319 8: 2238: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/PACK);
3320 call 0 returned 100%
3321 -: 2239: // stop packing when packCount == 0
3322 8: 2240: packCount--;
3323 8: 2241: if (!packCount) pack = false;
3324 branch 0 taken 25% (fallthrough)
3325 branch 1 taken 75%
3326 -: 2242: } // if pack
3327 -: 2243: else
3328 7: 2244: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/NOPACKING);
3329 call 0 returned 100%
3330 15: 2245: break;
3331 -: 2246: case BYTES:
3332 2: 2247: if (pack) {
3333 branch 0 taken 0% (fallthrough)
3334 branch 1 taken 100%
3335 #####: 2248: if (type) {
3336 branch 0 never executed
3337 branch 1 never executed
3338 -: 2249: // this is the first packed element
3339 #####: 2250: if (ctx->nibble == lowNbl) {
3340 branch 0 never executed
3341 branch 1 never executed
3342 #####: 2251: uintToNetTypeVarint(r, type, packCount);
3343 call 0 never executed
3344 -: 2252: }
3345 -: 2253: else {
3346 -: 2254: // high nibble
3347 -: 2255: // store type in high nibble
3348 #####: 2256: ctx->nibble = lowNbl;
3349 #####: 2257: data = (char *)&((*r)->data) + ctx->nblOffset;
3350 #####: 2258: *data |= type << 4;
3351 #####: 2259: uintToVarint(r, packCount);
3352 call 0 never executed
3353 -: 2260: }
3354 #####: 2261: type = 0;
3355 -: 2262: } // if type
3356 -: 2263:
3357 #####: 2264: B = (sBytest *)(e->data);
3358 #####: 2265: uintToVarint(r, B->count);
3359 call 0 never executed
3360 #####: 2266: sBytesPushBuffer(r, &(B->data), B->count);
3361 call 0 never executed
3362 -: 2267: // stop packing when packCount == 0
3363 #####: 2268: packCount--;
3364 #####: 2269: if (!packCount) pack = false;
3365 branch 0 never executed
3366 branch 1 never executed
3367 -: 2270: } // if pack
3368 -: 2271: else {
3369 2: 2272: B = (sBytest *)(e->data);
3370 2: 2273: if (ctx->nibble == lowNbl) {
3371 branch 0 taken 50% (fallthrough)
3372 branch 1 taken 50%
3373 1: 2274: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
3374 call 0 returned 100%
3375 -: 2275: }
3376 -: 2276: else {
3377 -: 2277: // high nibble
3378 1: 2278: storeTypeInHighNbl(e->data);
3379 1: 2279: uintToVarint(r, B->count);
3380 call 0 returned 100%
3381 -: 2280: }
3382 2: 2281: sBytesPushBuffer(r, &(B->data), B->count);
3383 call 0 returned 100%
3384 -: 2282: }
3385 2: 2283: break;
3386 -: 2284: }
3387 -: 2285: }
3388 -: 2286: }
3389 56: 2287: ret;
3390 -: 2288:}
3391 -: 2289:
3392 -: 2290:/**
3393 -: 2291: * serialize array
3394 -: 2292: *
3395 -: 2293: * the serialized array is pushed to r.
3396 -: 2294: * All elements are serialized recursively
3397 -: 2295: *
3398 -: 2296: * the data in containers is not serialized
3399 -: 2297: *
3400 -: 2298: * \param
3401 -: 2299: * r small bytes object
3402 -: 2300: * array to serialize
3403 -: 2301: */
3404 function arrayNetSerial called 78 returned 100% blocks executed 91%
3405 78: 2302:internal void arrayNetSerial(sBytest **r, sArrayt *array, contextt *ctx, packingT packing) {
3406 78: 2303: sBytest *B = NULL;
3407 78: 2304: char *data = NULL;
3408 -: 2305:
3409 -: 2306: // check if all elements have same type
3410 -: 2307: // then set array type normal or uniform
3411 -: 2308: // array and dict have to be checked recursively to know if they are normal or uniform
3412 78: 2309: bool allElementsHaveSameType = true;
3413 78: 2310: bool foundFirstType = false;
3414 78: 2311: char type = 0;
3415 -: 2312:
3416 -: 2313: // get first element type
3417 -: 2314: // compare to other element type
3418 -: 2315: // null element are interpreted as undefined
3419 230: 2316: {forEachSArray(array, e) {
3420 branch 0 taken 82%
3421 branch 1 taken 18% (fallthrough)
3422 189: 2317: if (!e) {
3423 branch 0 taken 0% (fallthrough)
3424 branch 1 taken 100%
3425 #####: 2318: if (foundFirstType) {
3426 branch 0 never executed
3427 branch 1 never executed
3428 #####: 2319: if (type != S_UNDEFINED) {
3429 branch 0 never executed
3430 branch 1 never executed
3431 #####: 2320: allElementsHaveSameType = false;
3432 #####: 2321: break;
3433 -: 2322: }
3434 -: 2323: }
3435 -: 2324: else {
3436 #####: 2325: type = S_UNDEFINED;
3437 #####: 2326: foundFirstType = true;
3438 -: 2327: }
3439 -: 2328: }
3440 -: 2329: else {
3441 189: 2330: if (foundFirstType) {
3442 branch 0 taken 61% (fallthrough)
3443 branch 1 taken 39%
3444 -: 2331: u8 nextType;
3445 115: 2332: switch(e->type) {
3446 branch 0 taken 6%
3447 branch 1 taken 10%
3448 branch 2 taken 84%
3449 -: 2333: case DICT:
3450 7: 2334: nextType = isDictUniform((sDictt*)e);
3451 call 0 returned 100%
3452 7: 2335: break;
3453 -: 2336: case ARRAY:
3454 11: 2337: nextType = isArrayUniform((sArrayt*)e);
3455 call 0 returned 100%
3456 11: 2338: break;
3457 -: 2339: default:
3458 97: 2340: nextType = NET_SERIAL_TYPES[(u8)e->type];
3459 -: 2341: }
3460 115: 2342: if (nextType != type) {
3461 branch 0 taken 32% (fallthrough)
3462 branch 1 taken 68%
3463 37: 2343: allElementsHaveSameType = false;
3464 37: 2344: break;
3465 -: 2345: }
3466 -: 2346: }
3467 -: 2347: else {
3468 74: 2348: switch(e->type) {
3469 branch 0 taken 7%
3470 branch 1 taken 8%
3471 branch 2 taken 85%
3472 -: 2349: case DICT:
3473 5: 2350: type = isDictUniform((sDictt*)e);
3474 call 0 returned 100%
3475 5: 2351: break;
3476 -: 2352: case ARRAY:
3477 6: 2353: type = isArrayUniform((sArrayt*)e);
3478 call 0 returned 100%
3479 6: 2354: break;
3480 -: 2355: default:
3481 63: 2356: type = NET_SERIAL_TYPES[(u8)e->type];
3482 -: 2357: }
3483 74: 2358: foundFirstType = true;
3484 -: 2359: }
3485 -: 2360: }
3486 -: 2361: }}
3487 -: 2362:
3488 78: 2363: if (allElementsHaveSameType) {
3489 branch 0 taken 53% (fallthrough)
3490 branch 1 taken 47%
3491 -: 2364: // uniform array
3492 -: 2365: // encode type and element count
3493 -: 2366:
3494 -: 2367: // in pack array
3495 41: 2368: if (packing == PACK) {
3496 branch 0 taken 39% (fallthrough)
3497 branch 1 taken 61%
3498 -: 2369: // uniform array can't be packed
3499 -: 2370: // because there is only one type of packed arrays
3500 16: 2371: goto normalArray;
3501 -: 2372: }
3502 25: 2373: elif (packing == UNIFORM) {
3503 branch 0 taken 8% (fallthrough)
3504 branch 1 taken 92%
3505 -: 2374: // when the packing is uniform, there is no need to encode UNIFORM_ARRAY since all elements have this type
3506 2: 2375: uintToNetTypeVarint(r, type, array->count);
3507 call 0 returned 100%
3508 -: 2376: }
3509 -: 2377: else {
3510 23: 2378: if (ctx->nibble == lowNbl) {
3511 branch 0 taken 78% (fallthrough)
3512 branch 1 taken 22%
3513 18: 2379: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
3514 call 0 returned 100%
3515 18: 2380: uintToVarint(r, array->count);
3516 call 0 returned 100%
3517 -: 2381: }
3518 -: 2382: else {
3519 -: 2383: // high nibble
3520 5: 2384: ctx->nibble = lowNbl;
3521 5: 2385: data = (char *)&((*r)->data) + ctx->nblOffset;
3522 5: 2386: *data |= UNIFORM_ARRAY << 4;
3523 5: 2387: uintToNetTypeVarint(r, type, array->count);
3524 call 0 returned 100%
3525 -: 2388: }
3526 -: 2389: }
3527 -: 2390:
3528 -: 2391: // encode all element values
3529 25: 2392: switch(type) {
3530 branch 0 taken 8%
3531 branch 1 taken 8%
3532 branch 2 taken 4%
3533 branch 3 taken 44%
3534 branch 4 taken 4%
3535 branch 5 taken 16%
3536 branch 6 taken 4%
3537 branch 7 taken 12%
3538 -: 2393: case S_BOOL:
3539 16: 2394: {forEachSArray(array, e) {
3540 branch 0 taken 88%
3541 branch 1 taken 13% (fallthrough)
3542 14: 2395: if (!ctx->boolOffset) {
3543 branch 0 taken 14% (fallthrough)
3544 branch 1 taken 86%
3545 -: 2396: // new packed bools
3546 2: 2397: storeNew8bPackedBool(e);
3547 branch 0 taken 100% (fallthrough)
3548 branch 1 taken 0%
3549 call 2 returned 100%
3550 -: 2398: }
3551 -: 2399: else {
3552 -: 2400: // there was a bool before this one, fill bits in nibbles
3553 12: 2401: if (ctx->boolShift == 8) {
3554 branch 0 taken 8% (fallthrough)
3555 branch 1 taken 92%
3556 -: 2402: // previous packed bool is full
3557 -: 2403: // next byte is the new packed bools
3558 1: 2404: storeNew8bPackedBool(e);
3559 branch 0 taken 0% (fallthrough)
3560 branch 1 taken 100%
3561 call 2 returned 100%
3562 -: 2405: }
3563 -: 2406: else {
3564 11: 2407: storeBool(e);
3565 branch 0 taken 100% (fallthrough)
3566 branch 1 taken 0%
3567 -: 2408: }
3568 -: 2409: }
3569 -: 2410: }}
3570 2: 2411: break;
3571 -: 2412: case S_DICT:
3572 -: 2413: case UNIFORM_DICT:
3573 6: 2414: {forEachSArray(array, e) {
3574 branch 0 taken 67%
3575 branch 1 taken 33% (fallthrough)
3576 4: 2415: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/UNIFORM);
3577 call 0 returned 100%
3578 -: 2416: }}
3579 2: 2417: break;
3580 -: 2418: case S_DOUBLE:
3581 4: 2419: {forEachSArray(array, e) {
3582 branch 0 taken 75%
3583 branch 1 taken 25% (fallthrough)
3584 3: 2420: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
3585 call 0 returned 100%
3586 -: 2421: }}
3587 1: 2422: break;
3588 -: 2423: case S_INT:
3589 49: 2424: {forEachSArray(array, e) {
3590 branch 0 taken 78%
3591 branch 1 taken 22% (fallthrough)
3592 38: 2425: i64 v = ((sIntt *)e)->value;
3593 38: 2426: uintToVarint(r, (v << 1) ^ (v >> 63));
3594 call 0 returned 100%
3595 -: 2427: }}
3596 11: 2428: break;
3597 -: 2429: case S_STRING:
3598 4: 2430: {forEachSArray(array, e) {
3599 branch 0 taken 75%
3600 branch 1 taken 25% (fallthrough)
3601 3: 2431: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
3602 call 0 returned 100%
3603 -: 2432: }}
3604 1: 2433: break;
3605 -: 2434: case S_ARRAY:
3606 -: 2435: case UNIFORM_ARRAY:
3607 10: 2436: {forEachSArray(array, e) {
3608 branch 0 taken 60%
3609 branch 1 taken 40% (fallthrough)
3610 6: 2437: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/UNIFORM);
3611 call 0 returned 100%
3612 -: 2438: }}
3613 4: 2439: break;
3614 -: 2440: case S_BYTES:
3615 3: 2441: {forEachSArray(array, e) {
3616 branch 0 taken 67%
3617 branch 1 taken 33% (fallthrough)
3618 2: 2442: B = (sBytest *)e;
3619 2: 2443: uintToVarint(r, B->count);
3620 call 0 returned 100%
3621 2: 2444: sBytesPushBuffer(r, &(B->data), B->count);
3622 call 0 returned 100%
3623 -: 2445: }}
3624 1: 2446: break;
3625 -: 2447: }
3626 25: 2448: ret;
3627 -: 2449: }
3628 -: 2450:
3629 -: 2451: normalArray:
3630 -: 2452: // encode type and element count
3631 53: 2453: if (packing == PACK or packing == UNIFORM) {
3632 branch 0 taken 70% (fallthrough)
3633 branch 1 taken 30%
3634 branch 2 taken 16% (fallthrough)
3635 branch 3 taken 84%
3636 -: 2454: // when the packing is packed or uniform, there is no need to encode ARRAY type since all elements have this type
3637 22: 2455: uintToVarint(r, array->count);
3638 call 0 returned 100%
3639 -: 2456: }
3640 -: 2457: else {
3641 31: 2458: if (ctx->nibble == lowNbl) {
3642 branch 0 taken 90% (fallthrough)
3643 branch 1 taken 10%
3644 28: 2459: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
3645 call 0 returned 100%
3646 -: 2460: }
3647 -: 2461: else {
3648 -: 2462: // high nibble
3649 3: 2463: storeTypeInHighNbl(array);
3650 3: 2464: uintToVarint(r, array->count);
3651 call 0 returned 100%
3652 -: 2465: }
3653 -: 2466: }
3654 -: 2467:
3655 53: 2468: bool pack = false;
3656 -: 2469: size_t packCount;
3657 218: 2470: enumerateSArray(array, e, eIdx) {
3658 branch 0 taken 76%
3659 branch 1 taken 24% (fallthrough)
3660 165: 2471: if (!e) {
3661 branch 0 taken 0% (fallthrough)
3662 branch 1 taken 100%
3663 -: 2472: // empty slots are represented as undefined elements
3664 #####: 2473: if (ctx->nibble == lowNbl) {
3665 branch 0 never executed
3666 branch 1 never executed
3667 #####: 2474: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
3668 call 0 never executed
3669 #####: 2475: ctx->nibble = highNbl;
3670 #####: 2476: ctx->nblOffset = (*r)->count -1;
3671 -: 2477: }
3672 -: 2478: else {
3673 -: 2479: // high nibble
3674 #####: 2480: ctx->nibble = lowNbl;
3675 #####: 2481: data = (char *)&((*r)->data) + ctx->nblOffset;
3676 #####: 2482: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
3677 -: 2483: }
3678 -: 2484: }
3679 -: 2485: else {
3680 165: 2486: if (!pack) {
3681 branch 0 taken 82% (fallthrough)
3682 branch 1 taken 18%
3683 -: 2487: // scan array for packing
3684 135: 2488: if ((array->count - eIdx) > 3) {
3685 branch 0 taken 30% (fallthrough)
3686 branch 1 taken 70%
3687 -: 2489: // at least 4 elements, less than that is not worth it
3688 41: 2490: if ( e->type == DICT
3689 branch 0 taken 90% (fallthrough)
3690 branch 1 taken 10%
3691 37: 2491: or e->type == DOUBLE
3692 branch 0 taken 95% (fallthrough)
3693 branch 1 taken 5%
3694 35: 2492: or e->type == INT
3695 branch 0 taken 89% (fallthrough)
3696 branch 1 taken 11%
3697 31: 2493: or e->type == STRING
3698 branch 0 taken 94% (fallthrough)
3699 branch 1 taken 6%
3700 29: 2494: or e->type == ARRAY
3701 branch 0 taken 93% (fallthrough)
3702 branch 1 taken 7%
3703 27: 2495: or e->type == BYTES) {
3704 branch 0 taken 0% (fallthrough)
3705 branch 1 taken 100%
3706 14: 2496: type = e->type;
3707 14: 2497: packCount = 1;
3708 14: 2498: smallt *element = ((smallt **) &((array)->data))[eIdx+1];
3709 47: 2499: for (size_t i = eIdx+1; i < (array)->count ; i++, element = ((smallt **) &((array)->data))[i]) {
3710 branch 0 taken 100%
3711 branch 1 taken 0% (fallthrough)
3712 47: 2500: if (!element) {
3713 branch 0 taken 0% (fallthrough)
3714 branch 1 taken 100%
3715 -: 2501: // null element are undefined
3716 #####: 2502: break;
3717 -: 2503: }
3718 -: 2504: else {
3719 47: 2505: if (element->type != type) {
3720 branch 0 taken 30% (fallthrough)
3721 branch 1 taken 70%
3722 14: 2506: break;
3723 -: 2507: }
3724 33: 2508: packCount++;
3725 -: 2509: } // if element
3726 -: 2510: } // for
3727 14: 2511: if (packCount > 3) {
3728 branch 0 taken 71% (fallthrough)
3729 branch 1 taken 29%
3730 10: 2512: type = PACKED_NET_SERIAL_TYPES[(u8)type];
3731 10: 2513: pack = true;
3732 -: 2514: }
3733 -: 2515: } // test current element type
3734 -: 2516: } // is array big enough
3735 -: 2517: } // not already packing
3736 -: 2518:
3737 -: 2519: // encode element value
3738 165: 2520: switch(e->type) {
3739 branch 0 taken 18%
3740 branch 1 taken 22%
3741 branch 2 taken 9%
3742 branch 3 taken 6%
3743 branch 4 taken 22%
3744 branch 5 taken 13%
3745 branch 6 taken 10%
3746 branch 7 taken 1%
3747 branch 8 taken 0%
3748 -: 2521: case UNDEFINED:
3749 -: 2522: case CONTAINER:
3750 29: 2523: if (ctx->nibble == lowNbl) {
3751 branch 0 taken 93% (fallthrough)
3752 branch 1 taken 7%
3753 27: 2524: storeTypeOnly(e);
3754 call 0 returned 100%
3755 -: 2525: }
3756 -: 2526: else {
3757 -: 2527: // high nibble
3758 2: 2528: storeTypeInHighNbl(e);
3759 -: 2529: }
3760 29: 2530: break;
3761 -: 2531: case BOOL:
3762 36: 2532: if (!ctx->boolOffset) {
3763 branch 0 taken 22% (fallthrough)
3764 branch 1 taken 78%
3765 -: 2533: // new packed bools
3766 8: 2534: if (ctx->nibble == lowNbl) {
3767 branch 0 taken 63% (fallthrough)
3768 branch 1 taken 38%
3769 5: 2535: storeNew4bPackedBool(e);
3770 branch 0 taken 80% (fallthrough)
3771 branch 1 taken 20%
3772 call 2 returned 100%
3773 -: 2536: }
3774 -: 2537: else {
3775 -: 2538: // high nibble, next byte is packed bools
3776 3: 2539: storeTypeInHighNbl(e);
3777 3: 2540: storeNew8bPackedBool(e);
3778 branch 0 taken 100% (fallthrough)
3779 branch 1 taken 0%
3780 call 2 returned 100%
3781 -: 2541: }
3782 -: 2542: }
3783 -: 2543: else {
3784 -: 2544: // there was a bool before this one, fill bits in nibbles
3785 28: 2545: if (ctx->nibble == lowNbl) {
3786 branch 0 taken 61% (fallthrough)
3787 branch 1 taken 39%
3788 17: 2546: if (ctx->boolShift == 8) {
3789 branch 0 taken 12% (fallthrough)
3790 branch 1 taken 88%
3791 -: 2547: // previous packed bool is full
3792 -: 2548: // this byte is the new packed bools
3793 2: 2549: storeNew4bPackedBool(e);
3794 branch 0 taken 50% (fallthrough)
3795 branch 1 taken 50%
3796 call 2 returned 100%
3797 -: 2550: }
3798 -: 2551: else {
3799 15: 2552: storeTypeOnly(e);
3800 call 0 returned 100%
3801 15: 2553: storeBool(e);
3802 branch 0 taken 53% (fallthrough)
3803 branch 1 taken 47%
3804 -: 2554: }
3805 -: 2555: }
3806 -: 2556: else {
3807 -: 2557: // high nibble
3808 11: 2558: storeTypeInHighNbl(e);
3809 11: 2559: if (ctx->boolShift == 8) {
3810 branch 0 taken 18% (fallthrough)
3811 branch 1 taken 82%
3812 -: 2560: // previous packed bool is full
3813 -: 2561: // next byte is the new packed bools
3814 2: 2562: storeNew8bPackedBool(e);
3815 branch 0 taken 100% (fallthrough)
3816 branch 1 taken 0%
3817 call 2 returned 100%
3818 -: 2563: }
3819 -: 2564: else {
3820 9: 2565: storeBool(e);
3821 branch 0 taken 78% (fallthrough)
3822 branch 1 taken 22%
3823 -: 2566: }
3824 -: 2567: }
3825 -: 2568: }
3826 36: 2569: break;
3827 -: 2570: case DICT:
3828 15: 2571: if (pack) {
3829 branch 0 taken 53% (fallthrough)
3830 branch 1 taken 47%
3831 8: 2572: if (type) {
3832 branch 0 taken 25% (fallthrough)
3833 branch 1 taken 75%
3834 -: 2573: // this is the first packed element
3835 2: 2574: if (ctx->nibble == lowNbl) {
3836 branch 0 taken 50% (fallthrough)
3837 branch 1 taken 50%
3838 1: 2575: uintToNetTypeVarint(r, type, packCount);
3839 call 0 returned 100%
3840 -: 2576: }
3841 -: 2577: else {
3842 -: 2578: // high nibble
3843 -: 2579: // store type in high nibble
3844 1: 2580: ctx->nibble = lowNbl;
3845 1: 2581: data = (char *)&((*r)->data) + ctx->nblOffset;
3846 1: 2582: *data |= type << 4;
3847 1: 2583: uintToVarint(r, packCount);
3848 call 0 returned 100%
3849 -: 2584: }
3850 2: 2585: type = 0;
3851 -: 2586: } // if type
3852 -: 2587:
3853 8: 2588: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/PACK);
3854 call 0 returned 100%
3855 -: 2589: // stop packing when packCount == 0
3856 8: 2590: packCount--;
3857 8: 2591: if (!packCount) pack = false;
3858 branch 0 taken 25% (fallthrough)
3859 branch 1 taken 75%
3860 -: 2592: } // if pack
3861 -: 2593: else
3862 7: 2594: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/NOPACKING);
3863 call 0 returned 100%
3864 15: 2595: break;
3865 -: 2596: case DOUBLE:
3866 10: 2597: if (pack) {
3867 branch 0 taken 80% (fallthrough)
3868 branch 1 taken 20%
3869 8: 2598: if (type) {
3870 branch 0 taken 25% (fallthrough)
3871 branch 1 taken 75%
3872 -: 2599: // this is the first packed element
3873 2: 2600: if (ctx->nibble == lowNbl) {
3874 branch 0 taken 50% (fallthrough)
3875 branch 1 taken 50%
3876 1: 2601: uintToNetTypeVarint(r, type, packCount);
3877 call 0 returned 100%
3878 -: 2602: }
3879 -: 2603: else {
3880 -: 2604: // high nibble
3881 -: 2605: // store type in high nibble
3882 1: 2606: ctx->nibble = lowNbl;
3883 1: 2607: data = (char *)&((*r)->data) + ctx->nblOffset;
3884 1: 2608: *data |= type << 4;
3885 1: 2609: uintToVarint(r, packCount);
3886 call 0 returned 100%
3887 -: 2610: }
3888 2: 2611: type = 0;
3889 -: 2612: } // if type
3890 -: 2613:
3891 8: 2614: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
3892 call 0 returned 100%
3893 -: 2615: // stop packing when packCount == 0
3894 8: 2616: packCount--;
3895 8: 2617: if (!packCount) pack = false;
3896 branch 0 taken 25% (fallthrough)
3897 branch 1 taken 75%
3898 -: 2618: } // if pack
3899 -: 2619: else {
3900 2: 2620: if (ctx->nibble == lowNbl) {
3901 branch 0 taken 50% (fallthrough)
3902 branch 1 taken 50%
3903 1: 2621: storeTypeOnly(e);
3904 call 0 returned 100%
3905 -: 2622: }
3906 -: 2623: else {
3907 -: 2624: // high nibble
3908 1: 2625: storeTypeInHighNbl(e);
3909 -: 2626: }
3910 2: 2627: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
3911 call 0 returned 100%
3912 -: 2628: }
3913 10: 2629: break;
3914 -: 2630: case INT:
3915 36: 2631: if (pack) {
3916 branch 0 taken 22% (fallthrough)
3917 branch 1 taken 78%
3918 8: 2632: if (type) {
3919 branch 0 taken 25% (fallthrough)
3920 branch 1 taken 75%
3921 -: 2633: // this is the first packed element
3922 2: 2634: if (ctx->nibble == lowNbl) {
3923 branch 0 taken 50% (fallthrough)
3924 branch 1 taken 50%
3925 1: 2635: uintToNetTypeVarint(r, type, packCount);
3926 call 0 returned 100%
3927 -: 2636: }
3928 -: 2637: else {
3929 -: 2638: // high nibble
3930 -: 2639: // store type in high nibble
3931 1: 2640: ctx->nibble = lowNbl;
3932 1: 2641: data = (char *)&((*r)->data) + ctx->nblOffset;
3933 1: 2642: *data |= type << 4;
3934 1: 2643: uintToVarint(r, packCount);
3935 call 0 returned 100%
3936 -: 2644: }
3937 2: 2645: type = 0;
3938 -: 2646: } // if type
3939 -: 2647:
3940 8: 2648: i64 v = ((sIntt *)&(e->type))->value;
3941 8: 2649: uintToVarint(r, (v << 1) ^ (v >> 63));
3942 call 0 returned 100%
3943 -: 2650: // stop packing when packCount == 0
3944 8: 2651: packCount--;
3945 8: 2652: if (!packCount) pack = false;
3946 branch 0 taken 25% (fallthrough)
3947 branch 1 taken 75%
3948 -: 2653: } // if pack
3949 -: 2654: else {
3950 -: 2655: // encode int to varint
3951 -: 2656: // v is int64_t to convert to varint
3952 28: 2657: i64 v = ((sIntt *)&(e->type))->value;
3953 28: 2658: if (ctx->nibble == lowNbl) {
3954 branch 0 taken 86% (fallthrough)
3955 branch 1 taken 14%
3956 -: 2659: // encode v with arithmetic shifts
3957 24: 2660: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
3958 call 0 returned 100%
3959 -: 2661: }
3960 -: 2662: else {
3961 -: 2663: // high nibble
3962 4: 2664: storeTypeInHighNbl(e);
3963 4: 2665: uintToVarint(r, (v << 1) ^ (v >> 63));
3964 call 0 returned 100%
3965 -: 2666: }
3966 -: 2667: }
3967 36: 2668: break;
3968 -: 2669: case STRING:
3969 21: 2670: if (pack) {
3970 branch 0 taken 38% (fallthrough)
3971 branch 1 taken 62%
3972 8: 2671: if (type) {
3973 branch 0 taken 25% (fallthrough)
3974 branch 1 taken 75%
3975 -: 2672: // this is the first packed element
3976 2: 2673: if (ctx->nibble == lowNbl) {
3977 branch 0 taken 50% (fallthrough)
3978 branch 1 taken 50%
3979 1: 2674: uintToNetTypeVarint(r, type, packCount);
3980 call 0 returned 100%
3981 -: 2675: }
3982 -: 2676: else {
3983 -: 2677: // high nibble
3984 -: 2678: // store type in high nibble
3985 1: 2679: ctx->nibble = lowNbl;
3986 1: 2680: data = (char *)&((*r)->data) + ctx->nblOffset;
3987 1: 2681: *data |= type << 4;
3988 1: 2682: uintToVarint(r, packCount);
3989 call 0 returned 100%
3990 -: 2683: }
3991 2: 2684: type = 0;
3992 -: 2685: } // if type
3993 -: 2686:
3994 8: 2687: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
3995 call 0 returned 100%
3996 -: 2688: // stop packing when packCount == 0
3997 8: 2689: packCount--;
3998 8: 2690: if (!packCount) pack = false;
3999 branch 0 taken 25% (fallthrough)
4000 branch 1 taken 75%
4001 -: 2691: } // if pack
4002 -: 2692: else {
4003 13: 2693: if (ctx->nibble == lowNbl) {
4004 branch 0 taken 69% (fallthrough)
4005 branch 1 taken 31%
4006 9: 2694: storeTypeOnly(e);
4007 call 0 returned 100%
4008 -: 2695: }
4009 -: 2696: else {
4010 -: 2697: // high nibble
4011 4: 2698: storeTypeInHighNbl(e);
4012 -: 2699: }
4013 13: 2700: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
4014 call 0 returned 100%
4015 -: 2701: }
4016 21: 2702: break;
4017 -: 2703: case ARRAY:
4018 16: 2704: if (pack) {
4019 branch 0 taken 50% (fallthrough)
4020 branch 1 taken 50%
4021 8: 2705: if (type) {
4022 branch 0 taken 25% (fallthrough)
4023 branch 1 taken 75%
4024 -: 2706: // this is the first packed element
4025 2: 2707: if (ctx->nibble == lowNbl) {
4026 branch 0 taken 50% (fallthrough)
4027 branch 1 taken 50%
4028 1: 2708: uintToNetTypeVarint(r, type, packCount);
4029 call 0 returned 100%
4030 -: 2709: }
4031 -: 2710: else {
4032 -: 2711: // high nibble
4033 -: 2712: // store type in high nibble
4034 1: 2713: ctx->nibble = lowNbl;
4035 1: 2714: data = (char *)&((*r)->data) + ctx->nblOffset;
4036 1: 2715: *data |= type << 4;
4037 1: 2716: uintToVarint(r, packCount);
4038 call 0 returned 100%
4039 -: 2717: }
4040 2: 2718: type = 0;
4041 -: 2719: } // if type
4042 -: 2720:
4043 8: 2721: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/PACK);
4044 call 0 returned 100%
4045 -: 2722: // stop packing when packCount == 0
4046 8: 2723: packCount--;
4047 8: 2724: if (!packCount) pack = false;
4048 branch 0 taken 25% (fallthrough)
4049 branch 1 taken 75%
4050 -: 2725: } // if pack
4051 -: 2726: else
4052 8: 2727: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/NOPACKING);
4053 call 0 returned 100%
4054 16: 2728: break;
4055 -: 2729: case BYTES:
4056 2: 2730: if (pack) {
4057 branch 0 taken 0% (fallthrough)
4058 branch 1 taken 100%
4059 #####: 2731: if (type) {
4060 branch 0 never executed
4061 branch 1 never executed
4062 -: 2732: // this is the first packed element
4063 #####: 2733: if (ctx->nibble == lowNbl) {
4064 branch 0 never executed
4065 branch 1 never executed
4066 #####: 2734: uintToNetTypeVarint(r, type, packCount);
4067 call 0 never executed
4068 -: 2735: }
4069 -: 2736: else {
4070 -: 2737: // high nibble
4071 -: 2738: // store type in high nibble
4072 #####: 2739: ctx->nibble = lowNbl;
4073 #####: 2740: data = (char *)&((*r)->data) + ctx->nblOffset;
4074 #####: 2741: *data |= type << 4;
4075 #####: 2742: uintToVarint(r, packCount);
4076 call 0 never executed
4077 -: 2743: }
4078 #####: 2744: type = 0;
4079 -: 2745: } // if type
4080 -: 2746:
4081 #####: 2747: B = (sBytest *)e;
4082 #####: 2748: uintToVarint(r, B->count);
4083 call 0 never executed
4084 #####: 2749: sBytesPushBuffer(r, &(B->data), B->count);
4085 call 0 never executed
4086 -: 2750: // stop packing when packCount == 0
4087 #####: 2751: packCount--;
4088 #####: 2752: if (!packCount) pack = false;
4089 branch 0 never executed
4090 branch 1 never executed
4091 -: 2753: } // if pack
4092 -: 2754: else {
4093 2: 2755: B = (sBytest *)e;
4094 2: 2756: if (ctx->nibble == lowNbl) {
4095 branch 0 taken 50% (fallthrough)
4096 branch 1 taken 50%
4097 1: 2757: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
4098 call 0 returned 100%
4099 -: 2758: }
4100 -: 2759: else {
4101 -: 2760: // high nibble
4102 1: 2761: storeTypeInHighNbl(e);
4103 1: 2762: uintToVarint(r, B->count);
4104 call 0 returned 100%
4105 -: 2763: }
4106 2: 2764: sBytesPushBuffer(r, &(B->data), B->count);
4107 call 0 returned 100%
4108 -: 2765: }
4109 2: 2766: break;
4110 -: 2767: }
4111 -: 2768: }
4112 -: 2769: }
4113 53: 2770: ret;
4114 -: 2771:}
4115 -: 2772:
4116 function serialNetSerial called 86 returned 100% blocks executed 80%
4117 86: 2773:internal smallBytest* serialNetSerial(smallJsont *self) {
4118 -: 2774:
4119 86: 2775: smallt *o = getsoG(self);
4120 call 0 returned 100%
4121 -: 2776:
4122 86: 2777: if (o == NULL)
4123 branch 0 taken 0% (fallthrough)
4124 branch 1 taken 100%
4125 #####: 2778: ret NULL;
4126 -: 2779:
4127 86: 2780: sBytest *B = netSerial(o);
4128 call 0 returned 100%
4129 -: 2781:
4130 86: 2782: if (!B) {
4131 branch 0 taken 0% (fallthrough)
4132 branch 1 taken 100%
4133 #####: 2783: ret NULL;
4134 -: 2784: }
4135 -: 2785:
4136 86: 2786: createAllocateSmallBytes(r);
4137 call 0 returned 100%
4138 86: 2787: r->B = B;
4139 86: 2788: ret r;
4140 -: 2789:}
4141 -: 2790:
4142 -: 2791:// -------------------------------------
4143 -: 2792:// Deserializers
4144 -: 2793:
4145 -: 2794:// level 0
4146 -: 2795:// like smallJson with ints and length encoded as varints
4147 -: 2796:
4148 -: 2797:/**
4149 -: 2798: * deserializer top function
4150 -: 2799: */
4151 function netDeserialLevel0 called 0 returned 0% blocks executed 0%
4152 #####: 2800:internal smallt* netDeserialLevel0(sBytest *obj) {
4153 #####: 2801: smallt *r = NULL;
4154 #####: 2802: double *D = NULL;
4155 #####: 2803: char *s = NULL;
4156 #####: 2804: sBytest *B = NULL;
4157 -: 2805: uint32_t count;
4158 #####: 2806: char *data = NULL;
4159 -: 2807:
4160 #####: 2808: switch(obj->data & 0xF) {
4161 branch 0 never executed
4162 branch 1 never executed
4163 branch 2 never executed
4164 branch 3 never executed
4165 branch 4 never executed
4166 branch 5 never executed
4167 branch 6 never executed
4168 branch 7 never executed
4169 branch 8 never executed
4170 -: 2809: case S_UNDEFINED:
4171 #####: 2810: r = (smallt *) allocSUndefined();
4172 call 0 never executed
4173 #####: 2811: break;
4174 -: 2812: case S_BOOL:
4175 #####: 2813: r = (smallt *) allocSBool(obj->data & 0x10);
4176 call 0 never executed
4177 #####: 2814: break;
4178 -: 2815: case S_DICT:
4179 #####: 2816: data = (char *)&(obj->data);
4180 #####: 2817: dictNetDeserialLevel0((sDictt **)&r, &data);
4181 call 0 never executed
4182 #####: 2818: break;
4183 -: 2819: case S_DOUBLE:
4184 #####: 2820: data = &(obj->data)+1;
4185 #####: 2821: D = (double *)data;
4186 #####: 2822: r = (smallt *) allocSDouble(*D);
4187 call 0 never executed
4188 #####: 2823: break;
4189 -: 2824: case S_INT:
4190 #####: 2825: data = &(obj->data);
4191 #####: 2826: u64 v = netTypeVarintToUint((u8**)&data);
4192 call 0 never executed
4193 #####: 2827: v = (v >> 1) ^ (~(v & 1) + 1);
4194 #####: 2828: r = (smallt *) allocSInt(v);
4195 call 0 never executed
4196 #####: 2829: break;
4197 -: 2830: case S_STRING:
4198 #####: 2831: s = (char *)&(obj->data)+1;
4199 #####: 2832: r = (smallt *) allocSStringTiny(s);
4200 call 0 never executed
4201 #####: 2833: break;
4202 -: 2834: case S_ARRAY:
4203 #####: 2835: data = (char *)&(obj->data);
4204 #####: 2836: arrayNetDeserialLevel0((sArrayt **)&r, &data);
4205 call 0 never executed
4206 #####: 2837: break;
4207 -: 2838: case S_BYTES:
4208 #####: 2839: B = allocSBytes();
4209 call 0 never executed
4210 #####: 2840: data = &(obj->data);
4211 #####: 2841: count = netTypeVarintToUint((u8**)&data);
4212 call 0 never executed
4213 #####: 2842: sBytesPushBuffer(&B, data, count);
4214 call 0 never executed
4215 #####: 2843: r = (smallt *)B;
4216 #####: 2844: break;
4217 -: 2845: }
4218 -: 2846:
4219 #####: 2847: ret r;
4220 -: 2848:}
4221 -: 2849:
4222 -: 2850:/**
4223 -: 2851: * deserialize dictionary from data
4224 -: 2852: *
4225 -: 2853: * a new dictionary is allocated
4226 -: 2854: *
4227 -: 2855: * \param
4228 -: 2856: * dict dictionary holding the elements
4229 -: 2857: * data serialized dictionary
4230 -: 2858: */
4231 function dictNetDeserialLevel0 called 0 returned 0% blocks executed 0%
4232 #####: 2859:internal void dictNetDeserialLevel0(sDictt **dict, char **data) {
4233 #####: 2860: sUndefinedt *u = NULL;
4234 #####: 2861: sBoolt *bo = NULL;
4235 #####: 2862: double *D = NULL;
4236 #####: 2863: sDoublet *Do = NULL;
4237 #####: 2864: sDictt *d = NULL;
4238 #####: 2865: sIntt *io = NULL;
4239 #####: 2866: char *s = NULL;
4240 #####: 2867: sStringt *so = NULL;
4241 #####: 2868: sArrayt *a = NULL;
4242 #####: 2869: sBytest *B = NULL;
4243 -: 2870: uint32_t count;
4244 -: 2871: uint32_t dictCount;
4245 -: 2872:
4246 #####: 2873: dictCount = netTypeVarintToUint((u8**)data);
4247 call 0 never executed
4248 -: 2874:
4249 #####: 2875: if (!dictCount) {
4250 branch 0 never executed
4251 branch 1 never executed
4252 #####: 2876: *dict = allocSDict();
4253 call 0 never executed
4254 #####: 2877: ret;
4255 -: 2878: }
4256 -: 2879:
4257 #####: 2880: loop(dictCount) {
4258 branch 0 never executed
4259 branch 1 never executed
4260 -: 2881: char type;
4261 -: 2882: char *key;
4262 #####: 2883: key = *data;
4263 #####: 2884: *data += strlen(key)+1;
4264 #####: 2885: type = **data;
4265 -: 2886:
4266 #####: 2887: switch(type & 0xF) {
4267 branch 0 never executed
4268 branch 1 never executed
4269 branch 2 never executed
4270 branch 3 never executed
4271 branch 4 never executed
4272 branch 5 never executed
4273 branch 6 never executed
4274 branch 7 never executed
4275 branch 8 never executed
4276 -: 2888: case S_UNDEFINED:
4277 #####: 2889: (*data)++;
4278 #####: 2890: u = allocSUndefined();
4279 call 0 never executed
4280 #####: 2891: sDictPushTiny(dict, key, (smallt *) u);
4281 call 0 never executed
4282 #####: 2892: break;
4283 -: 2893: case S_BOOL:
4284 #####: 2894: (*data)++;
4285 #####: 2895: bo = allocSBool(type & 0x10);
4286 call 0 never executed
4287 #####: 2896: sDictPushTiny(dict, key, (smallt *) bo);
4288 call 0 never executed
4289 #####: 2897: break;
4290 -: 2898: case S_DICT:
4291 #####: 2899: d = NULL;
4292 #####: 2900: dictNetDeserialLevel0(&d, data);
4293 call 0 never executed
4294 #####: 2901: sDictPushTiny(dict, key, (smallt *) d);
4295 call 0 never executed
4296 #####: 2902: break;
4297 -: 2903: case S_DOUBLE:
4298 #####: 2904: (*data)++;
4299 #####: 2905: D = (double *)(*data);
4300 #####: 2906: *data += sizeof(double);
4301 #####: 2907: Do = allocSDouble(*D);
4302 call 0 never executed
4303 #####: 2908: sDictPushTiny(dict, key, (smallt *) Do);
4304 call 0 never executed
4305 #####: 2909: break;
4306 -: 2910: case S_INT: {
4307 #####: 2911: u64 v = netTypeVarintToUint((u8**)data);
4308 call 0 never executed
4309 #####: 2912: v = (v >> 1) ^ (~(v & 1) + 1);
4310 #####: 2913: io = allocSInt(v);
4311 call 0 never executed
4312 #####: 2914: sDictPushTiny(dict, key, (smallt *) io);
4313 call 0 never executed
4314 -: 2915: }
4315 #####: 2916: break;
4316 -: 2917: case S_STRING:
4317 #####: 2918: (*data)++;
4318 #####: 2919: s = (char *)(*data);
4319 #####: 2920: *data += strlen(s)+1;
4320 #####: 2921: so = allocSStringTiny(s);
4321 call 0 never executed
4322 #####: 2922: sDictPushTiny(dict, key, (smallt *) so);
4323 call 0 never executed
4324 #####: 2923: break;
4325 -: 2924: case S_ARRAY:
4326 #####: 2925: a = NULL;
4327 #####: 2926: arrayNetDeserialLevel0(&a, data);
4328 call 0 never executed
4329 #####: 2927: sDictPushTiny(dict, key, (smallt *) a);
4330 call 0 never executed
4331 #####: 2928: break;
4332 -: 2929: case S_BYTES:
4333 #####: 2930: B = allocSBytes();
4334 call 0 never executed
4335 #####: 2931: count = netTypeVarintToUint((u8**)data);
4336 call 0 never executed
4337 #####: 2932: sBytesPushBuffer(&B, *data, count);
4338 call 0 never executed
4339 #####: 2933: *data += count;
4340 #####: 2934: sDictPushTiny(dict, key, (smallt *) B);
4341 call 0 never executed
4342 #####: 2935: break;
4343 -: 2936: }
4344 -: 2937: }
4345 -: 2938:}
4346 -: 2939:
4347 -: 2940:/**
4348 -: 2941: * deserialize array from data
4349 -: 2942: *
4350 -: 2943: * a new array is allocated
4351 -: 2944: *
4352 -: 2945: * \param
4353 -: 2946: * array holding the elements
4354 -: 2947: * data serialized dictionary
4355 -: 2948: */
4356 function arrayNetDeserialLevel0 called 0 returned 0% blocks executed 0%
4357 #####: 2949:internal void arrayNetDeserialLevel0(sArrayt **array, char **data) {
4358 #####: 2950: sUndefinedt *u = NULL;
4359 #####: 2951: sBoolt *bo = NULL;
4360 #####: 2952: double *D = NULL;
4361 #####: 2953: sDoublet *Do = NULL;
4362 #####: 2954: sDictt *d = NULL;
4363 #####: 2955: sIntt *io = NULL;
4364 #####: 2956: char *s = NULL;
4365 #####: 2957: sStringt *so = NULL;
4366 #####: 2958: sArrayt *a = NULL;
4367 #####: 2959: sBytest *B = NULL;
4368 -: 2960: uint32_t count;
4369 -: 2961: uint32_t arrayCount;
4370 -: 2962:
4371 #####: 2963: arrayCount = netTypeVarintToUint((u8**)data);
4372 call 0 never executed
4373 -: 2964:
4374 #####: 2965: if (!arrayCount) {
4375 branch 0 never executed
4376 branch 1 never executed
4377 #####: 2966: *array = allocSArray();;
4378 call 0 never executed
4379 #####: 2967: ret;
4380 -: 2968: }
4381 -: 2969:
4382 #####: 2970: loop(arrayCount) {
4383 branch 0 never executed
4384 branch 1 never executed
4385 -: 2971: char type;
4386 #####: 2972: type = **data;
4387 -: 2973:
4388 #####: 2974: switch(type & 0xF) {
4389 branch 0 never executed
4390 branch 1 never executed
4391 branch 2 never executed
4392 branch 3 never executed
4393 branch 4 never executed
4394 branch 5 never executed
4395 branch 6 never executed
4396 branch 7 never executed
4397 branch 8 never executed
4398 -: 2975: case S_UNDEFINED:
4399 #####: 2976: (*data)++;
4400 #####: 2977: u = allocSUndefined();
4401 call 0 never executed
4402 #####: 2978: sArrayPushTiny(array, (smallt *) u);
4403 call 0 never executed
4404 #####: 2979: break;
4405 -: 2980: case S_BOOL:
4406 #####: 2981: (*data)++;
4407 #####: 2982: bo = allocSBool(type & 0x10);
4408 call 0 never executed
4409 #####: 2983: sArrayPushTiny(array, (smallt *) bo);
4410 call 0 never executed
4411 #####: 2984: break;
4412 -: 2985: case S_DICT:
4413 #####: 2986: d = NULL;
4414 #####: 2987: dictNetDeserialLevel0(&d, data);
4415 call 0 never executed
4416 #####: 2988: sArrayPushTiny(array, (smallt *) d);
4417 call 0 never executed
4418 #####: 2989: break;
4419 -: 2990: case S_DOUBLE:
4420 #####: 2991: (*data)++;
4421 #####: 2992: D = (double *)(*data);
4422 #####: 2993: *data += sizeof(double);
4423 #####: 2994: Do = allocSDouble(*D);
4424 call 0 never executed
4425 #####: 2995: sArrayPushTiny(array, (smallt *) Do);
4426 call 0 never executed
4427 #####: 2996: break;
4428 -: 2997: case S_INT: {
4429 #####: 2998: u64 v = netTypeVarintToUint((u8**)data);
4430 call 0 never executed
4431 #####: 2999: v = (v >> 1) ^ (~(v & 1) + 1);
4432 #####: 3000: io = allocSInt(v);
4433 call 0 never executed
4434 #####: 3001: sArrayPushTiny(array, (smallt *) io);
4435 call 0 never executed
4436 -: 3002: }
4437 #####: 3003: break;
4438 -: 3004: case S_STRING:
4439 #####: 3005: (*data)++;
4440 #####: 3006: s = (char *)(*data);
4441 #####: 3007: *data += strlen(s)+1;
4442 #####: 3008: so = allocSStringTiny(s);
4443 call 0 never executed
4444 #####: 3009: sArrayPushTiny(array, (smallt *) so);
4445 call 0 never executed
4446 #####: 3010: break;
4447 -: 3011: case S_ARRAY:
4448 #####: 3012: a = NULL;
4449 #####: 3013: arrayNetDeserialLevel0(&a, data);
4450 call 0 never executed
4451 #####: 3014: sArrayPushTiny(array, (smallt *) a);
4452 call 0 never executed
4453 #####: 3015: break;
4454 -: 3016: case S_BYTES:
4455 #####: 3017: B = allocSBytes();
4456 call 0 never executed
4457 #####: 3018: count = netTypeVarintToUint((u8**)data);
4458 call 0 never executed
4459 #####: 3019: sBytesPushBuffer(&B, *data, count);
4460 call 0 never executed
4461 #####: 3020: *data += count;
4462 #####: 3021: sArrayPushTiny(array, (smallt *) B);
4463 call 0 never executed
4464 #####: 3022: break;
4465 -: 3023: }
4466 -: 3024: }
4467 -: 3025:}
4468 -: 3026:
4469 function deserialNetSerialLevel0 called 0 returned 0% blocks executed 0%
4470 #####: 3027:internal smallJsont* deserialNetSerialLevel0(smallJsont *self, smallBytest *data) {
4471 -: 3028:
4472 #####: 3029: if (!data or !data->B or !data->B->count) {
4473 branch 0 never executed
4474 branch 1 never executed
4475 branch 2 never executed
4476 branch 3 never executed
4477 branch 4 never executed
4478 branch 5 never executed
4479 #####: 3030: ret self;
4480 -: 3031: }
4481 -: 3032:
4482 #####: 3033: smallt *o = netDeserialLevel0(data->B);
4483 call 0 never executed
4484 -: 3034:
4485 #####: 3035: if (!o) {
4486 branch 0 never executed
4487 branch 1 never executed
4488 #####: 3036: ret self;
4489 -: 3037: }
4490 -: 3038:
4491 #####: 3039: freeG(self);
4492 call 0 never executed
4493 -: 3040:
4494 #####: 3041: setsoG(self, o);
4495 call 0 never executed
4496 -: 3042:
4497 #####: 3043: ret self;
4498 -: 3044:}
4499 -: 3045:
4500 -: 3046:// level 1
4501 -: 3047:// like level 0 with type encoded in nibbles and bools are packed
4502 -: 3048:
4503 -: 3049:/**
4504 -: 3050: * deserializer top function
4505 -: 3051: */
4506 function netDeserialLevel1 called 0 returned 0% blocks executed 0%
4507 #####: 3052:internal smallt* netDeserialLevel1(sBytest *obj) {
4508 #####: 3053: smallt *r = NULL;
4509 #####: 3054: double *D = NULL;
4510 #####: 3055: char *s = NULL;
4511 #####: 3056: sBytest *B = NULL;
4512 -: 3057: uint32_t count;
4513 #####: 3058: char *data = NULL;
4514 #####: 3059: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
4515 -: 3060:
4516 #####: 3061: switch(obj->data & 0xF) {
4517 branch 0 never executed
4518 branch 1 never executed
4519 branch 2 never executed
4520 branch 3 never executed
4521 branch 4 never executed
4522 branch 5 never executed
4523 branch 6 never executed
4524 branch 7 never executed
4525 branch 8 never executed
4526 -: 3062: case S_UNDEFINED:
4527 #####: 3063: r = (smallt *) allocSUndefined();
4528 call 0 never executed
4529 #####: 3064: break;
4530 -: 3065: case S_BOOL:
4531 #####: 3066: r = (smallt *) allocSBool(obj->data & 0x10);
4532 call 0 never executed
4533 #####: 3067: break;
4534 -: 3068: case S_DICT:
4535 #####: 3069: data = (char *)&(obj->data);
4536 -: 3070: //debug - ctx.dbuf = (u8*) data;
4537 #####: 3071: dictNetDeserialLevel1((sDictt **)&r, (u8**)&data, &ctx);
4538 call 0 never executed
4539 #####: 3072: break;
4540 -: 3073: case S_DOUBLE:
4541 #####: 3074: data = &(obj->data)+1;
4542 #####: 3075: D = (double *)data;
4543 #####: 3076: r = (smallt *) allocSDouble(*D);
4544 call 0 never executed
4545 #####: 3077: break;
4546 -: 3078: case S_INT:
4547 #####: 3079: data = &(obj->data);
4548 #####: 3080: u64 v = netTypeVarintToUint((u8**)&data);
4549 call 0 never executed
4550 #####: 3081: v = (v >> 1) ^ (~(v & 1) + 1);
4551 #####: 3082: r = (smallt *) allocSInt(v);
4552 call 0 never executed
4553 #####: 3083: break;
4554 -: 3084: case S_STRING:
4555 #####: 3085: s = (char *)&(obj->data)+1;
4556 #####: 3086: r = (smallt *) allocSStringTiny(s);
4557 call 0 never executed
4558 #####: 3087: break;
4559 -: 3088: case S_ARRAY:
4560 #####: 3089: data = (char *)&(obj->data);
4561 -: 3090: //debug - ctx.dbuf = (u8*) data;
4562 #####: 3091: arrayNetDeserialLevel1((sArrayt **)&r, (u8**)&data, &ctx);
4563 call 0 never executed
4564 #####: 3092: break;
4565 -: 3093: case S_BYTES:
4566 #####: 3094: B = allocSBytes();
4567 call 0 never executed
4568 #####: 3095: data = &(obj->data);
4569 #####: 3096: count = netTypeVarintToUint((u8**)&data);
4570 call 0 never executed
4571 #####: 3097: sBytesPushBuffer(&B, data, count);
4572 call 0 never executed
4573 #####: 3098: r = (smallt *)B;
4574 #####: 3099: break;
4575 -: 3100: }
4576 -: 3101:
4577 #####: 3102: ret r;
4578 -: 3103:}
4579 -: 3104:
4580 -: 3105:/**
4581 -: 3106: * deserialize dictionary from data
4582 -: 3107: *
4583 -: 3108: * a new dictionary is allocated
4584 -: 3109: *
4585 -: 3110: * \param
4586 -: 3111: * dict dictionary holding the elements
4587 -: 3112: * data serialized dictionary
4588 -: 3113: */
4589 function dictNetDeserialLevel1 called 0 returned 0% blocks executed 0%
4590 #####: 3114:internal void dictNetDeserialLevel1(sDictt **dict, u8 **data, contextt *ctx) {
4591 #####: 3115: sUndefinedt *u = NULL;
4592 #####: 3116: sBoolt *bo = NULL;
4593 #####: 3117: double *D = NULL;
4594 #####: 3118: sDoublet *Do = NULL;
4595 #####: 3119: sDictt *d = NULL;
4596 #####: 3120: sIntt *io = NULL;
4597 #####: 3121: char *s = NULL;
4598 #####: 3122: sStringt *so = NULL;
4599 #####: 3123: sArrayt *a = NULL;
4600 #####: 3124: sBytest *B = NULL;
4601 -: 3125: uint32_t count;
4602 -: 3126: uint32_t dictCount;
4603 -: 3127:
4604 #####: 3128: if (ctx->nibble == lowNbl) {
4605 branch 0 never executed
4606 branch 1 never executed
4607 #####: 3129: dictCount = netTypeVarintToUint(data);
4608 call 0 never executed
4609 -: 3130: }
4610 -: 3131: else {
4611 -: 3132: // high nibble
4612 -: 3133: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
4613 -: 3134: #define readTypeInHighNbl\
4614 -: 3135: ctx->nibble = lowNbl;\
4615 -: 3136: if (ctx->nblAddr == *data)\
4616 -: 3137: /* data points to the type, next byte is count */\
4617 -: 3138: (*data)++
4618 #####: 3139: readTypeInHighNbl;
4619 branch 0 never executed
4620 branch 1 never executed
4621 #####: 3140: dictCount = varintToUint(data);
4622 call 0 never executed
4623 -: 3141: }
4624 -: 3142:
4625 #####: 3143: if (!dictCount) {
4626 branch 0 never executed
4627 branch 1 never executed
4628 #####: 3144: *dict = allocSDict();
4629 call 0 never executed
4630 #####: 3145: ret;
4631 -: 3146: }
4632 -: 3147:
4633 #####: 3148: loop(dictCount) {
4634 branch 0 never executed
4635 branch 1 never executed
4636 #####: 3149: char *key = (char*)*data;
4637 #####: 3150: *data += strlen(key)+1;
4638 -: 3151: char type;
4639 #####: 3152: if (ctx->nibble == lowNbl) {
4640 branch 0 never executed
4641 branch 1 never executed
4642 #####: 3153: type = (**data) & 0xF;
4643 -: 3154: }
4644 -: 3155: else {
4645 -: 3156: // high nibble
4646 #####: 3157: type = (*ctx->nblAddr) >> 4;
4647 -: 3158: }
4648 -: 3159:
4649 #####: 3160: switch(type) {
4650 branch 0 never executed
4651 branch 1 never executed
4652 branch 2 never executed
4653 branch 3 never executed
4654 branch 4 never executed
4655 branch 5 never executed
4656 branch 6 never executed
4657 branch 7 never executed
4658 branch 8 never executed
4659 -: 3161: case S_UNDEFINED:
4660 #####: 3162: if (ctx->nibble == lowNbl) {
4661 branch 0 never executed
4662 branch 1 never executed
4663 -: 3163: #define readTypeOnly\
4664 -: 3164: ctx->nibble = highNbl;\
4665 -: 3165: ctx->nblAddr = *data;\
4666 -: 3166: (*data)++
4667 #####: 3167: readTypeOnly;
4668 -: 3168: }
4669 -: 3169: else {
4670 -: 3170: // high nibble
4671 #####: 3171: readTypeInHighNbl;
4672 branch 0 never executed
4673 branch 1 never executed
4674 -: 3172: }
4675 #####: 3173: u = allocSUndefined();
4676 call 0 never executed
4677 #####: 3174: sDictPushTiny(dict, key, (smallt *) u);
4678 call 0 never executed
4679 #####: 3175: break;
4680 -: 3176: case S_BOOL:
4681 #####: 3177: if (!ctx->boolAddr) {
4682 branch 0 never executed
4683 branch 1 never executed
4684 -: 3178: // new packed bools
4685 #####: 3179: if (ctx->nibble == lowNbl) {
4686 branch 0 never executed
4687 branch 1 never executed
4688 -: 3180: #define read4bPackedBool\
4689 -: 3181: ctx->boolShift = 5;\
4690 -: 3182: ctx->boolAddr = *data;\
4691 -: 3183: (*data)++
4692 #####: 3184: read4bPackedBool;
4693 #####: 3185: bo = allocSBool((*ctx->boolAddr) & 0x10);
4694 call 0 never executed
4695 -: 3186: }
4696 -: 3187: else {
4697 -: 3188: // high nibble
4698 #####: 3189: readTypeInHighNbl;
4699 branch 0 never executed
4700 branch 1 never executed
4701 -: 3190: #define read8bPackedBool\
4702 -: 3191: ctx->boolShift = 1;\
4703 -: 3192: ctx->boolAddr = *data;\
4704 -: 3193: (*data)++
4705 #####: 3194: read8bPackedBool;
4706 #####: 3195: bo = allocSBool((*ctx->boolAddr) & 0x1);
4707 call 0 never executed
4708 -: 3196: }
4709 -: 3197: }
4710 -: 3198: else {
4711 -: 3199: // there was a bool before this one, read bits in nibbles
4712 #####: 3200: if (ctx->nibble == lowNbl) {
4713 branch 0 never executed
4714 branch 1 never executed
4715 #####: 3201: if (ctx->boolShift == 8) {
4716 branch 0 never executed
4717 branch 1 never executed
4718 #####: 3202: read4bPackedBool;
4719 #####: 3203: bo = allocSBool((*ctx->boolAddr) & 0x10);
4720 call 0 never executed
4721 -: 3204: }
4722 -: 3205: else {
4723 #####: 3206: readTypeOnly;
4724 #####: 3207: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
4725 call 0 never executed
4726 -: 3208: }
4727 -: 3209: }
4728 -: 3210: else {
4729 -: 3211: // high nibble
4730 #####: 3212: readTypeInHighNbl;
4731 branch 0 never executed
4732 branch 1 never executed
4733 #####: 3213: if (ctx->boolShift == 8) {
4734 branch 0 never executed
4735 branch 1 never executed
4736 #####: 3214: read8bPackedBool;
4737 #####: 3215: bo = allocSBool((*ctx->boolAddr) & 0x1);
4738 call 0 never executed
4739 -: 3216: }
4740 -: 3217: else {
4741 -: 3218: // high nibble
4742 #####: 3219: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
4743 call 0 never executed
4744 -: 3220: }
4745 -: 3221: }
4746 -: 3222: }
4747 #####: 3223: sDictPushTiny(dict, key, (smallt *) bo);
4748 call 0 never executed
4749 #####: 3224: break;
4750 -: 3225: case S_DICT:
4751 #####: 3226: d = NULL;
4752 #####: 3227: dictNetDeserialLevel1(&d, data, ctx);
4753 call 0 never executed
4754 #####: 3228: sDictPushTiny(dict, key, (smallt *) d);
4755 call 0 never executed
4756 #####: 3229: break;
4757 -: 3230: case S_DOUBLE:
4758 #####: 3231: if (ctx->nibble == lowNbl) {
4759 branch 0 never executed
4760 branch 1 never executed
4761 #####: 3232: readTypeOnly;
4762 -: 3233: }
4763 -: 3234: else {
4764 -: 3235: // high nibble
4765 #####: 3236: readTypeInHighNbl;
4766 branch 0 never executed
4767 branch 1 never executed
4768 -: 3237: }
4769 #####: 3238: D = (double *)(*data);
4770 #####: 3239: *data += sizeof(double);
4771 #####: 3240: Do = allocSDouble(*D);
4772 call 0 never executed
4773 #####: 3241: sDictPushTiny(dict, key, (smallt *) Do);
4774 call 0 never executed
4775 #####: 3242: break;
4776 -: 3243: case S_INT: {
4777 -: 3244: u64 v;
4778 #####: 3245: if (ctx->nibble == lowNbl) {
4779 branch 0 never executed
4780 branch 1 never executed
4781 #####: 3246: v = netTypeVarintToUint((u8**)data);
4782 call 0 never executed
4783 -: 3247: }
4784 -: 3248: else {
4785 -: 3249: // high nibble
4786 #####: 3250: readTypeInHighNbl;
4787 branch 0 never executed
4788 branch 1 never executed
4789 #####: 3251: v = varintToUint(data);
4790 call 0 never executed
4791 -: 3252: }
4792 #####: 3253: v = (v >> 1) ^ (~(v & 1) + 1);
4793 #####: 3254: io = allocSInt(v);
4794 call 0 never executed
4795 #####: 3255: sDictPushTiny(dict, key, (smallt *) io);
4796 call 0 never executed
4797 -: 3256: }
4798 #####: 3257: break;
4799 -: 3258: case S_STRING:
4800 #####: 3259: if (ctx->nibble == lowNbl) {
4801 branch 0 never executed
4802 branch 1 never executed
4803 #####: 3260: readTypeOnly;
4804 -: 3261: }
4805 -: 3262: else {
4806 -: 3263: // high nibble
4807 #####: 3264: readTypeInHighNbl;
4808 branch 0 never executed
4809 branch 1 never executed
4810 -: 3265: }
4811 #####: 3266: s = (char *)(*data);
4812 #####: 3267: *data += strlen(s)+1;
4813 #####: 3268: so = allocSStringTiny(s);
4814 call 0 never executed
4815 #####: 3269: sDictPushTiny(dict, key, (smallt *) so);
4816 call 0 never executed
4817 #####: 3270: break;
4818 -: 3271: case S_ARRAY:
4819 #####: 3272: a = NULL;
4820 #####: 3273: arrayNetDeserialLevel1(&a, data, ctx);
4821 call 0 never executed
4822 #####: 3274: sDictPushTiny(dict, key, (smallt *) a);
4823 call 0 never executed
4824 #####: 3275: break;
4825 -: 3276: case S_BYTES:
4826 #####: 3277: B = allocSBytes();
4827 call 0 never executed
4828 #####: 3278: if (ctx->nibble == lowNbl) {
4829 branch 0 never executed
4830 branch 1 never executed
4831 #####: 3279: count = netTypeVarintToUint((u8**)data);
4832 call 0 never executed
4833 -: 3280: }
4834 -: 3281: else {
4835 -: 3282: // high nibble
4836 #####: 3283: readTypeInHighNbl;
4837 branch 0 never executed
4838 branch 1 never executed
4839 #####: 3284: count = varintToUint((u8**)data);
4840 call 0 never executed
4841 -: 3285: }
4842 #####: 3286: sBytesPushBuffer(&B, *data, count);
4843 call 0 never executed
4844 #####: 3287: *data += count;
4845 #####: 3288: sDictPushTiny(dict, key, (smallt *) B);
4846 call 0 never executed
4847 #####: 3289: break;
4848 -: 3290: }
4849 -: 3291: }
4850 -: 3292:}
4851 -: 3293:
4852 -: 3294:/**
4853 -: 3295: * deserialize array from data
4854 -: 3296: *
4855 -: 3297: * a new array is allocated
4856 -: 3298: *
4857 -: 3299: * \param
4858 -: 3300: * array holding the elements
4859 -: 3301: * data serialized dictionary
4860 -: 3302: */
4861 function arrayNetDeserialLevel1 called 0 returned 0% blocks executed 0%
4862 #####: 3303:internal void arrayNetDeserialLevel1(sArrayt **array, u8 **data, contextt *ctx) {
4863 #####: 3304: sUndefinedt *u = NULL;
4864 #####: 3305: sBoolt *bo = NULL;
4865 #####: 3306: double *D = NULL;
4866 #####: 3307: sDoublet *Do = NULL;
4867 #####: 3308: sDictt *d = NULL;
4868 #####: 3309: sIntt *io = NULL;
4869 #####: 3310: char *s = NULL;
4870 #####: 3311: sStringt *so = NULL;
4871 #####: 3312: sArrayt *a = NULL;
4872 #####: 3313: sBytest *B = NULL;
4873 -: 3314: uint32_t count;
4874 -: 3315: uint32_t arrayCount;
4875 -: 3316:
4876 #####: 3317: if (ctx->nibble == lowNbl) {
4877 branch 0 never executed
4878 branch 1 never executed
4879 #####: 3318: arrayCount = netTypeVarintToUint(data);
4880 call 0 never executed
4881 -: 3319: }
4882 -: 3320: else {
4883 -: 3321: // high nibble
4884 #####: 3322: readTypeInHighNbl;
4885 branch 0 never executed
4886 branch 1 never executed
4887 #####: 3323: arrayCount = varintToUint(data);
4888 call 0 never executed
4889 -: 3324: }
4890 -: 3325:
4891 #####: 3326: if (!arrayCount) {
4892 branch 0 never executed
4893 branch 1 never executed
4894 #####: 3327: *array = allocSArray();;
4895 call 0 never executed
4896 #####: 3328: ret;
4897 -: 3329: }
4898 -: 3330:
4899 #####: 3331: loop(arrayCount) {
4900 branch 0 never executed
4901 branch 1 never executed
4902 -: 3332: char type;
4903 #####: 3333: if (ctx->nibble == lowNbl) {
4904 branch 0 never executed
4905 branch 1 never executed
4906 #####: 3334: type = (**data) & 0xF;
4907 -: 3335: }
4908 -: 3336: else {
4909 -: 3337: // high nibble
4910 #####: 3338: type = (*ctx->nblAddr) >> 4;
4911 -: 3339: }
4912 -: 3340:
4913 #####: 3341: switch(type) {
4914 branch 0 never executed
4915 branch 1 never executed
4916 branch 2 never executed
4917 branch 3 never executed
4918 branch 4 never executed
4919 branch 5 never executed
4920 branch 6 never executed
4921 branch 7 never executed
4922 branch 8 never executed
4923 -: 3342: case S_UNDEFINED:
4924 #####: 3343: if (ctx->nibble == lowNbl) {
4925 branch 0 never executed
4926 branch 1 never executed
4927 #####: 3344: readTypeOnly;
4928 -: 3345: }
4929 -: 3346: else {
4930 -: 3347: // high nibble
4931 #####: 3348: readTypeInHighNbl;
4932 branch 0 never executed
4933 branch 1 never executed
4934 -: 3349: }
4935 #####: 3350: u = allocSUndefined();
4936 call 0 never executed
4937 #####: 3351: sArrayPushTiny(array, (smallt *) u);
4938 call 0 never executed
4939 #####: 3352: break;
4940 -: 3353: case S_BOOL:
4941 #####: 3354: if (!ctx->boolAddr) {
4942 branch 0 never executed
4943 branch 1 never executed
4944 -: 3355: // new packed bools
4945 #####: 3356: if (ctx->nibble == lowNbl) {
4946 branch 0 never executed
4947 branch 1 never executed
4948 #####: 3357: read4bPackedBool;
4949 #####: 3358: bo = allocSBool((*ctx->boolAddr) & 0x10);
4950 call 0 never executed
4951 -: 3359: }
4952 -: 3360: else {
4953 -: 3361: // high nibble
4954 #####: 3362: readTypeInHighNbl;
4955 branch 0 never executed
4956 branch 1 never executed
4957 #####: 3363: read8bPackedBool;
4958 #####: 3364: bo = allocSBool((*ctx->boolAddr) & 0x1);
4959 call 0 never executed
4960 -: 3365: }
4961 -: 3366: }
4962 -: 3367: else {
4963 -: 3368: // there was a bool before this one, read bits in nibbles
4964 #####: 3369: if (ctx->nibble == lowNbl) {
4965 branch 0 never executed
4966 branch 1 never executed
4967 #####: 3370: if (ctx->boolShift == 8) {
4968 branch 0 never executed
4969 branch 1 never executed
4970 #####: 3371: read4bPackedBool;
4971 #####: 3372: bo = allocSBool((*ctx->boolAddr) & 0x10);
4972 call 0 never executed
4973 -: 3373: }
4974 -: 3374: else {
4975 #####: 3375: readTypeOnly;
4976 #####: 3376: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
4977 call 0 never executed
4978 -: 3377: }
4979 -: 3378: }
4980 -: 3379: else {
4981 -: 3380: // high nibble
4982 #####: 3381: readTypeInHighNbl;
4983 branch 0 never executed
4984 branch 1 never executed
4985 #####: 3382: if (ctx->boolShift == 8) {
4986 branch 0 never executed
4987 branch 1 never executed
4988 #####: 3383: read8bPackedBool;
4989 #####: 3384: bo = allocSBool((*ctx->boolAddr) & 0x1);
4990 call 0 never executed
4991 -: 3385: }
4992 -: 3386: else {
4993 #####: 3387: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
4994 call 0 never executed
4995 -: 3388: }
4996 -: 3389: }
4997 -: 3390: }
4998 #####: 3391: sArrayPushTiny(array, (smallt *) bo);
4999 call 0 never executed
5000 #####: 3392: break;
5001 -: 3393: case S_DICT:
5002 #####: 3394: d = NULL;
5003 #####: 3395: dictNetDeserialLevel1(&d, data, ctx);
5004 call 0 never executed
5005 #####: 3396: sArrayPushTiny(array, (smallt *) d);
5006 call 0 never executed
5007 #####: 3397: break;
5008 -: 3398: case S_DOUBLE:
5009 #####: 3399: if (ctx->nibble == lowNbl) {
5010 branch 0 never executed
5011 branch 1 never executed
5012 #####: 3400: readTypeOnly;
5013 -: 3401: }
5014 -: 3402: else {
5015 -: 3403: // high nibble
5016 #####: 3404: readTypeInHighNbl;
5017 branch 0 never executed
5018 branch 1 never executed
5019 -: 3405: }
5020 #####: 3406: D = (double *)(*data);
5021 #####: 3407: *data += sizeof(double);
5022 #####: 3408: Do = allocSDouble(*D);
5023 call 0 never executed
5024 #####: 3409: sArrayPushTiny(array, (smallt *) Do);
5025 call 0 never executed
5026 #####: 3410: break;
5027 -: 3411: case S_INT: {
5028 -: 3412: u64 v;
5029 #####: 3413: if (ctx->nibble == lowNbl) {
5030 branch 0 never executed
5031 branch 1 never executed
5032 #####: 3414: v = netTypeVarintToUint((u8**)data);
5033 call 0 never executed
5034 -: 3415: }
5035 -: 3416: else {
5036 -: 3417: // high nibble
5037 #####: 3418: readTypeInHighNbl;
5038 branch 0 never executed
5039 branch 1 never executed
5040 #####: 3419: v = varintToUint(data);
5041 call 0 never executed
5042 -: 3420: }
5043 #####: 3421: v = (v >> 1) ^ (~(v & 1) + 1);
5044 #####: 3422: io = allocSInt(v);
5045 call 0 never executed
5046 #####: 3423: sArrayPushTiny(array, (smallt *) io);
5047 call 0 never executed
5048 -: 3424: }
5049 #####: 3425: break;
5050 -: 3426: case S_STRING:
5051 #####: 3427: if (ctx->nibble == lowNbl) {
5052 branch 0 never executed
5053 branch 1 never executed
5054 #####: 3428: readTypeOnly;
5055 -: 3429: }
5056 -: 3430: else {
5057 -: 3431: // high nibble
5058 #####: 3432: readTypeInHighNbl;
5059 branch 0 never executed
5060 branch 1 never executed
5061 -: 3433: }
5062 #####: 3434: s = (char *)(*data);
5063 #####: 3435: *data += strlen(s)+1;
5064 #####: 3436: so = allocSStringTiny(s);
5065 call 0 never executed
5066 #####: 3437: sArrayPushTiny(array, (smallt *) so);
5067 call 0 never executed
5068 #####: 3438: break;
5069 -: 3439: case S_ARRAY:
5070 #####: 3440: a = NULL;
5071 #####: 3441: arrayNetDeserialLevel1(&a, data, ctx);
5072 call 0 never executed
5073 #####: 3442: sArrayPushTiny(array, (smallt *) a);
5074 call 0 never executed
5075 #####: 3443: break;
5076 -: 3444: case S_BYTES:
5077 #####: 3445: B = allocSBytes();
5078 call 0 never executed
5079 #####: 3446: if (ctx->nibble == lowNbl) {
5080 branch 0 never executed
5081 branch 1 never executed
5082 #####: 3447: count = netTypeVarintToUint((u8**)data);
5083 call 0 never executed
5084 -: 3448: }
5085 -: 3449: else {
5086 -: 3450: // high nibble
5087 #####: 3451: readTypeInHighNbl;
5088 branch 0 never executed
5089 branch 1 never executed
5090 #####: 3452: count = varintToUint((u8**)data);
5091 call 0 never executed
5092 -: 3453: }
5093 #####: 3454: sBytesPushBuffer(&B, *data, count);
5094 call 0 never executed
5095 #####: 3455: *data += count;
5096 #####: 3456: sArrayPushTiny(array, (smallt *) B);
5097 call 0 never executed
5098 #####: 3457: break;
5099 -: 3458: }
5100 -: 3459: }
5101 -: 3460:}
5102 -: 3461:
5103 function deserialNetSerialLevel1 called 0 returned 0% blocks executed 0%
5104 #####: 3462:internal smallJsont* deserialNetSerialLevel1(smallJsont *self, smallBytest *data) {
5105 -: 3463:
5106 #####: 3464: if (!data or !data->B or !data->B->count) {
5107 branch 0 never executed
5108 branch 1 never executed
5109 branch 2 never executed
5110 branch 3 never executed
5111 branch 4 never executed
5112 branch 5 never executed
5113 #####: 3465: ret self;
5114 -: 3466: }
5115 -: 3467:
5116 #####: 3468: smallt *o = netDeserialLevel1(data->B);
5117 call 0 never executed
5118 -: 3469:
5119 #####: 3470: if (!o) {
5120 branch 0 never executed
5121 branch 1 never executed
5122 #####: 3471: ret self;
5123 -: 3472: }
5124 -: 3473:
5125 #####: 3474: freeG(self);
5126 call 0 never executed
5127 -: 3475:
5128 #####: 3476: setsoG(self, o);
5129 call 0 never executed
5130 -: 3477:
5131 #####: 3478: ret self;
5132 -: 3479:}
5133 -: 3480:
5134 -: 3481:// level 2
5135 -: 3482:// like level 1, arrays are set to uniform when all elements are same type
5136 -: 3483:
5137 -: 3484:/**
5138 -: 3485: * deserializer top function
5139 -: 3486: */
5140 function netDeserialLevel2 called 0 returned 0% blocks executed 0%
5141 #####: 3487:internal smallt* netDeserialLevel2(sBytest *obj) {
5142 #####: 3488: smallt *r = NULL;
5143 #####: 3489: double *D = NULL;
5144 #####: 3490: char *s = NULL;
5145 #####: 3491: sBytest *B = NULL;
5146 -: 3492: uint32_t count;
5147 #####: 3493: char *data = NULL;
5148 #####: 3494: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
5149 -: 3495:
5150 #####: 3496: switch(obj->data & 0xF) {
5151 branch 0 never executed
5152 branch 1 never executed
5153 branch 2 never executed
5154 branch 3 never executed
5155 branch 4 never executed
5156 branch 5 never executed
5157 branch 6 never executed
5158 branch 7 never executed
5159 branch 8 never executed
5160 branch 9 never executed
5161 branch 10 never executed
5162 -: 3497: case S_UNDEFINED:
5163 #####: 3498: r = (smallt *) allocSUndefined();
5164 call 0 never executed
5165 #####: 3499: break;
5166 -: 3500: case S_BOOL:
5167 #####: 3501: r = (smallt *) allocSBool(obj->data & 0x10);
5168 call 0 never executed
5169 #####: 3502: break;
5170 -: 3503: case S_DICT:
5171 #####: 3504: data = (char *)&(obj->data);
5172 -: 3505: //debug - ctx.dbuf = (u8*) data;
5173 #####: 3506: dictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
5174 call 0 never executed
5175 #####: 3507: break;
5176 -: 3508: case S_DOUBLE:
5177 #####: 3509: data = &(obj->data)+1;
5178 #####: 3510: D = (double *)data;
5179 #####: 3511: r = (smallt *) allocSDouble(*D);
5180 call 0 never executed
5181 #####: 3512: break;
5182 -: 3513: case S_INT:
5183 #####: 3514: data = &(obj->data);
5184 #####: 3515: u64 v = netTypeVarintToUint((u8**)&data);
5185 call 0 never executed
5186 #####: 3516: v = (v >> 1) ^ (~(v & 1) + 1);
5187 #####: 3517: r = (smallt *) allocSInt(v);
5188 call 0 never executed
5189 #####: 3518: break;
5190 -: 3519: case S_STRING:
5191 #####: 3520: s = (char *)&(obj->data)+1;
5192 #####: 3521: r = (smallt *) allocSStringTiny(s);
5193 call 0 never executed
5194 #####: 3522: break;
5195 -: 3523: case S_ARRAY:
5196 #####: 3524: data = (char *)&(obj->data);
5197 -: 3525: //debug - ctx.dbuf = (u8*) data;
5198 #####: 3526: arrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
5199 call 0 never executed
5200 #####: 3527: break;
5201 -: 3528: case S_BYTES:
5202 #####: 3529: B = allocSBytes();
5203 call 0 never executed
5204 #####: 3530: data = &(obj->data);
5205 #####: 3531: count = netTypeVarintToUint((u8**)&data);
5206 call 0 never executed
5207 #####: 3532: sBytesPushBuffer(&B, data, count);
5208 call 0 never executed
5209 #####: 3533: r = (smallt *)B;
5210 #####: 3534: break;
5211 -: 3535: case UNIFORM_DICT:
5212 #####: 3536: data = (char *)&(obj->data);
5213 -: 3537: //debug - ctx.dbuf = (u8*) data;
5214 #####: 3538: uniformDictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
5215 call 0 never executed
5216 #####: 3539: break;
5217 -: 3540: case UNIFORM_ARRAY:
5218 #####: 3541: data = (char *)&(obj->data);
5219 -: 3542: //debug - ctx.dbuf = (u8*) data;
5220 #####: 3543: uniformArrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
5221 call 0 never executed
5222 #####: 3544: break;
5223 -: 3545: }
5224 -: 3546:
5225 #####: 3547: ret r;
5226 -: 3548:}
5227 -: 3549:
5228 -: 3550:/**
5229 -: 3551: * deserialize dictionary from data
5230 -: 3552: *
5231 -: 3553: * a new dictionary is allocated
5232 -: 3554: *
5233 -: 3555: * \param
5234 -: 3556: * dict dictionary holding the elements
5235 -: 3557: * data serialized dictionary
5236 -: 3558: */
5237 function dictNetDeserialLevel2 called 0 returned 0% blocks executed 0%
5238 #####: 3559:internal void dictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
5239 #####: 3560: sUndefinedt *u = NULL;
5240 #####: 3561: sBoolt *bo = NULL;
5241 #####: 3562: double *D = NULL;
5242 #####: 3563: sDoublet *Do = NULL;
5243 #####: 3564: sDictt *d = NULL;
5244 #####: 3565: sIntt *io = NULL;
5245 #####: 3566: char *s = NULL;
5246 #####: 3567: sStringt *so = NULL;
5247 #####: 3568: sArrayt *a = NULL;
5248 #####: 3569: sBytest *B = NULL;
5249 -: 3570: uint32_t count;
5250 -: 3571: uint32_t dictCount;
5251 -: 3572:
5252 #####: 3573: if (packed) {
5253 branch 0 never executed
5254 branch 1 never executed
5255 #####: 3574: dictCount = varintToUint(data);
5256 call 0 never executed
5257 -: 3575: }
5258 -: 3576: else {
5259 #####: 3577: if (ctx->nibble == lowNbl) {
5260 branch 0 never executed
5261 branch 1 never executed
5262 #####: 3578: dictCount = netTypeVarintToUint(data);
5263 call 0 never executed
5264 -: 3579: }
5265 -: 3580: else {
5266 -: 3581: // high nibble
5267 -: 3582: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
5268 -: 3583: #define readTypeInHighNbl\
5269 -: 3584: ctx->nibble = lowNbl;\
5270 -: 3585: if (ctx->nblAddr == *data)\
5271 -: 3586: /* data points to the type, next byte is count */\
5272 -: 3587: (*data)++
5273 #####: 3588: readTypeInHighNbl;
5274 branch 0 never executed
5275 branch 1 never executed
5276 #####: 3589: dictCount = varintToUint(data);
5277 call 0 never executed
5278 -: 3590: }
5279 -: 3591: }
5280 -: 3592:
5281 #####: 3593: if (!dictCount) {
5282 branch 0 never executed
5283 branch 1 never executed
5284 #####: 3594: *dict = allocSDict();
5285 call 0 never executed
5286 #####: 3595: ret;
5287 -: 3596: }
5288 -: 3597:
5289 #####: 3598: loop(dictCount) {
5290 branch 0 never executed
5291 branch 1 never executed
5292 #####: 3599: char *key = (char*)*data;
5293 #####: 3600: *data += strlen(key)+1;
5294 -: 3601: char type;
5295 #####: 3602: if (ctx->nibble == lowNbl) {
5296 branch 0 never executed
5297 branch 1 never executed
5298 #####: 3603: type = (**data) & 0xF;
5299 -: 3604: }
5300 -: 3605: else {
5301 -: 3606: // high nibble
5302 #####: 3607: type = (*ctx->nblAddr) >> 4;
5303 -: 3608: }
5304 -: 3609:
5305 #####: 3610: switch(type) {
5306 branch 0 never executed
5307 branch 1 never executed
5308 branch 2 never executed
5309 branch 3 never executed
5310 branch 4 never executed
5311 branch 5 never executed
5312 branch 6 never executed
5313 branch 7 never executed
5314 branch 8 never executed
5315 branch 9 never executed
5316 branch 10 never executed
5317 -: 3611: case S_UNDEFINED:
5318 #####: 3612: if (ctx->nibble == lowNbl) {
5319 branch 0 never executed
5320 branch 1 never executed
5321 -: 3613: #define readTypeOnly\
5322 -: 3614: ctx->nibble = highNbl;\
5323 -: 3615: ctx->nblAddr = *data;\
5324 -: 3616: (*data)++
5325 #####: 3617: readTypeOnly;
5326 -: 3618: }
5327 -: 3619: else {
5328 -: 3620: // high nibble
5329 #####: 3621: readTypeInHighNbl;
5330 branch 0 never executed
5331 branch 1 never executed
5332 -: 3622: }
5333 #####: 3623: u = allocSUndefined();
5334 call 0 never executed
5335 #####: 3624: sDictPushTiny(dict, key, (smallt *) u);
5336 call 0 never executed
5337 #####: 3625: break;
5338 -: 3626: case S_BOOL:
5339 #####: 3627: if (!ctx->boolAddr) {
5340 branch 0 never executed
5341 branch 1 never executed
5342 -: 3628: // new packed bools
5343 #####: 3629: if (ctx->nibble == lowNbl) {
5344 branch 0 never executed
5345 branch 1 never executed
5346 -: 3630: #define read4bPackedBool\
5347 -: 3631: ctx->boolShift = 5;\
5348 -: 3632: ctx->boolAddr = *data;\
5349 -: 3633: (*data)++
5350 #####: 3634: read4bPackedBool;
5351 #####: 3635: bo = allocSBool((*ctx->boolAddr) & 0x10);
5352 call 0 never executed
5353 -: 3636: }
5354 -: 3637: else {
5355 -: 3638: // high nibble
5356 #####: 3639: readTypeInHighNbl;
5357 branch 0 never executed
5358 branch 1 never executed
5359 -: 3640: #define read8bPackedBool\
5360 -: 3641: ctx->boolShift = 1;\
5361 -: 3642: ctx->boolAddr = *data;\
5362 -: 3643: (*data)++
5363 #####: 3644: read8bPackedBool;
5364 #####: 3645: bo = allocSBool((*ctx->boolAddr) & 0x1);
5365 call 0 never executed
5366 -: 3646: }
5367 -: 3647: }
5368 -: 3648: else {
5369 -: 3649: // there was a bool before this one, read bits in nibbles
5370 #####: 3650: if (ctx->nibble == lowNbl) {
5371 branch 0 never executed
5372 branch 1 never executed
5373 #####: 3651: if (ctx->boolShift == 8) {
5374 branch 0 never executed
5375 branch 1 never executed
5376 #####: 3652: read4bPackedBool;
5377 #####: 3653: bo = allocSBool((*ctx->boolAddr) & 0x10);
5378 call 0 never executed
5379 -: 3654: }
5380 -: 3655: else {
5381 #####: 3656: readTypeOnly;
5382 #####: 3657: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
5383 call 0 never executed
5384 -: 3658: }
5385 -: 3659: }
5386 -: 3660: else {
5387 -: 3661: // high nibble
5388 #####: 3662: readTypeInHighNbl;
5389 branch 0 never executed
5390 branch 1 never executed
5391 #####: 3663: if (ctx->boolShift == 8) {
5392 branch 0 never executed
5393 branch 1 never executed
5394 #####: 3664: read8bPackedBool;
5395 #####: 3665: bo = allocSBool((*ctx->boolAddr) & 0x1);
5396 call 0 never executed
5397 -: 3666: }
5398 -: 3667: else {
5399 -: 3668: // high nibble
5400 #####: 3669: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
5401 call 0 never executed
5402 -: 3670: }
5403 -: 3671: }
5404 -: 3672: }
5405 #####: 3673: sDictPushTiny(dict, key, (smallt *) bo);
5406 call 0 never executed
5407 #####: 3674: break;
5408 -: 3675: case S_DICT:
5409 #####: 3676: d = NULL;
5410 #####: 3677: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
5411 call 0 never executed
5412 #####: 3678: sDictPushTiny(dict, key, (smallt *) d);
5413 call 0 never executed
5414 #####: 3679: break;
5415 -: 3680: case S_DOUBLE:
5416 #####: 3681: if (ctx->nibble == lowNbl) {
5417 branch 0 never executed
5418 branch 1 never executed
5419 #####: 3682: readTypeOnly;
5420 -: 3683: }
5421 -: 3684: else {
5422 -: 3685: // high nibble
5423 #####: 3686: readTypeInHighNbl;
5424 branch 0 never executed
5425 branch 1 never executed
5426 -: 3687: }
5427 #####: 3688: D = (double *)(*data);
5428 #####: 3689: *data += sizeof(double);
5429 #####: 3690: Do = allocSDouble(*D);
5430 call 0 never executed
5431 #####: 3691: sDictPushTiny(dict, key, (smallt *) Do);
5432 call 0 never executed
5433 #####: 3692: break;
5434 -: 3693: case S_INT: {
5435 -: 3694: u64 v;
5436 #####: 3695: if (ctx->nibble == lowNbl) {
5437 branch 0 never executed
5438 branch 1 never executed
5439 #####: 3696: v = netTypeVarintToUint((u8**)data);
5440 call 0 never executed
5441 -: 3697: }
5442 -: 3698: else {
5443 -: 3699: // high nibble
5444 #####: 3700: readTypeInHighNbl;
5445 branch 0 never executed
5446 branch 1 never executed
5447 #####: 3701: v = varintToUint(data);
5448 call 0 never executed
5449 -: 3702: }
5450 #####: 3703: v = (v >> 1) ^ (~(v & 1) + 1);
5451 #####: 3704: io = allocSInt(v);
5452 call 0 never executed
5453 #####: 3705: sDictPushTiny(dict, key, (smallt *) io);
5454 call 0 never executed
5455 -: 3706: }
5456 #####: 3707: break;
5457 -: 3708: case S_STRING:
5458 #####: 3709: if (ctx->nibble == lowNbl) {
5459 branch 0 never executed
5460 branch 1 never executed
5461 #####: 3710: readTypeOnly;
5462 -: 3711: }
5463 -: 3712: else {
5464 -: 3713: // high nibble
5465 #####: 3714: readTypeInHighNbl;
5466 branch 0 never executed
5467 branch 1 never executed
5468 -: 3715: }
5469 #####: 3716: s = (char *)(*data);
5470 #####: 3717: *data += strlen(s)+1;
5471 #####: 3718: so = allocSStringTiny(s);
5472 call 0 never executed
5473 #####: 3719: sDictPushTiny(dict, key, (smallt *) so);
5474 call 0 never executed
5475 #####: 3720: break;
5476 -: 3721: case S_ARRAY:
5477 #####: 3722: a = NULL;
5478 #####: 3723: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
5479 call 0 never executed
5480 #####: 3724: sDictPushTiny(dict, key, (smallt *) a);
5481 call 0 never executed
5482 #####: 3725: break;
5483 -: 3726: case S_BYTES:
5484 #####: 3727: B = allocSBytes();
5485 call 0 never executed
5486 #####: 3728: if (ctx->nibble == lowNbl) {
5487 branch 0 never executed
5488 branch 1 never executed
5489 #####: 3729: count = netTypeVarintToUint((u8**)data);
5490 call 0 never executed
5491 -: 3730: }
5492 -: 3731: else {
5493 -: 3732: // high nibble
5494 #####: 3733: readTypeInHighNbl;
5495 branch 0 never executed
5496 branch 1 never executed
5497 #####: 3734: count = varintToUint((u8**)data);
5498 call 0 never executed
5499 -: 3735: }
5500 #####: 3736: sBytesPushBuffer(&B, *data, count);
5501 call 0 never executed
5502 #####: 3737: *data += count;
5503 #####: 3738: sDictPushTiny(dict, key, (smallt *) B);
5504 call 0 never executed
5505 #####: 3739: break;
5506 -: 3740: case UNIFORM_DICT:
5507 #####: 3741: d = NULL;
5508 #####: 3742: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
5509 call 0 never executed
5510 #####: 3743: sDictPushTiny(dict, key, (smallt *) d);
5511 call 0 never executed
5512 #####: 3744: break;
5513 -: 3745: case UNIFORM_ARRAY:
5514 #####: 3746: a = NULL;
5515 #####: 3747: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
5516 call 0 never executed
5517 #####: 3748: sDictPushTiny(dict, key, (smallt *) a);
5518 call 0 never executed
5519 #####: 3749: break;
5520 -: 3750: }
5521 -: 3751: }
5522 -: 3752:}
5523 -: 3753:
5524 -: 3754:/**
5525 -: 3755: * deserialize dictionary from data
5526 -: 3756: *
5527 -: 3757: * a new dictionary is allocated
5528 -: 3758: *
5529 -: 3759: * \param
5530 -: 3760: * dict dictionary holding the elements
5531 -: 3761: * data serialized dictionary
5532 -: 3762: */
5533 function uniformDictNetDeserialLevel2 called 0 returned 0% blocks executed 0%
5534 #####: 3763:internal void uniformDictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
5535 #####: 3764: sUndefinedt *u = NULL;
5536 #####: 3765: sBoolt *bo = NULL;
5537 #####: 3766: double *D = NULL;
5538 #####: 3767: sDoublet *Do = NULL;
5539 #####: 3768: sDictt *d = NULL;
5540 #####: 3769: sIntt *io = NULL;
5541 #####: 3770: char *s = NULL;
5542 #####: 3771: sStringt *so = NULL;
5543 #####: 3772: sArrayt *a = NULL;
5544 #####: 3773: sBytest *B = NULL;
5545 -: 3774: uint32_t count;
5546 -: 3775: uint32_t dictCount;
5547 -: 3776: u8 type;
5548 -: 3777:
5549 #####: 3778: if (packed) {
5550 branch 0 never executed
5551 branch 1 never executed
5552 #####: 3779: type = (**data) & 0xF;
5553 #####: 3780: dictCount = netTypeVarintToUint(data);
5554 call 0 never executed
5555 -: 3781: }
5556 -: 3782: else {
5557 #####: 3783: if (ctx->nibble == lowNbl) {
5558 branch 0 never executed
5559 branch 1 never executed
5560 #####: 3784: type = (**data) >> 4;
5561 #####: 3785: (*data)++;
5562 #####: 3786: dictCount = varintToUint(data);
5563 call 0 never executed
5564 -: 3787: }
5565 -: 3788: else {
5566 #####: 3789: readTypeInHighNbl;
5567 branch 0 never executed
5568 branch 1 never executed
5569 #####: 3790: type = (**data) & 0xF;
5570 #####: 3791: dictCount = netTypeVarintToUint(data);
5571 call 0 never executed
5572 -: 3792: }
5573 -: 3793: }
5574 -: 3794:
5575 #####: 3795: if (!dictCount) {
5576 branch 0 never executed
5577 branch 1 never executed
5578 #####: 3796: *dict = allocSDict();
5579 call 0 never executed
5580 #####: 3797: ret;
5581 -: 3798: }
5582 -: 3799:
5583 -: 3800:
5584 #####: 3801: switch(type) {
5585 branch 0 never executed
5586 branch 1 never executed
5587 branch 2 never executed
5588 branch 3 never executed
5589 branch 4 never executed
5590 branch 5 never executed
5591 branch 6 never executed
5592 branch 7 never executed
5593 branch 8 never executed
5594 branch 9 never executed
5595 branch 10 never executed
5596 -: 3802: case S_UNDEFINED:
5597 #####: 3803: loop(dictCount) {
5598 branch 0 never executed
5599 branch 1 never executed
5600 #####: 3804: char *key = (char*)*data;
5601 #####: 3805: *data += strlen(key)+1;
5602 #####: 3806: u = allocSUndefined();
5603 call 0 never executed
5604 #####: 3807: sDictPushTiny(dict, key, (smallt *) u);
5605 call 0 never executed
5606 -: 3808: }
5607 #####: 3809: break;
5608 -: 3810: case S_BOOL:
5609 #####: 3811: loop(dictCount) {
5610 branch 0 never executed
5611 branch 1 never executed
5612 #####: 3812: char *key = (char*)*data;
5613 #####: 3813: *data += strlen(key)+1;
5614 #####: 3814: if (!ctx->boolAddr) {
5615 branch 0 never executed
5616 branch 1 never executed
5617 #####: 3815: read8bPackedBool;
5618 #####: 3816: ctx->boolShift = 0;
5619 -: 3817: }
5620 #####: 3818: if (ctx->boolShift == 8) {
5621 branch 0 never executed
5622 branch 1 never executed
5623 #####: 3819: readTypeInHighNbl;
5624 branch 0 never executed
5625 branch 1 never executed
5626 #####: 3820: read8bPackedBool;
5627 #####: 3821: bo = allocSBool((*ctx->boolAddr) & 0x1);
5628 call 0 never executed
5629 -: 3822: }
5630 -: 3823: else {
5631 -: 3824: // high nibble
5632 #####: 3825: readTypeInHighNbl;
5633 branch 0 never executed
5634 branch 1 never executed
5635 #####: 3826: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
5636 call 0 never executed
5637 -: 3827: }
5638 #####: 3828: sDictPushTiny(dict, key, (smallt *) bo);
5639 call 0 never executed
5640 -: 3829: }
5641 #####: 3830: break;
5642 -: 3831: case S_DICT:
5643 #####: 3832: loop(dictCount) {
5644 branch 0 never executed
5645 branch 1 never executed
5646 #####: 3833: char *key = (char*)*data;
5647 #####: 3834: *data += strlen(key)+1;
5648 #####: 3835: d = NULL;
5649 #####: 3836: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
5650 call 0 never executed
5651 #####: 3837: sDictPushTiny(dict, key, (smallt *) d);
5652 call 0 never executed
5653 -: 3838: }
5654 #####: 3839: break;
5655 -: 3840: case S_DOUBLE:
5656 #####: 3841: loop(dictCount) {
5657 branch 0 never executed
5658 branch 1 never executed
5659 #####: 3842: char *key = (char*)*data;
5660 #####: 3843: *data += strlen(key)+1;
5661 #####: 3844: D = (double *)(*data);
5662 #####: 3845: *data += sizeof(double);
5663 #####: 3846: Do = allocSDouble(*D);
5664 call 0 never executed
5665 #####: 3847: sDictPushTiny(dict, key, (smallt *) Do);
5666 call 0 never executed
5667 -: 3848: }
5668 #####: 3849: break;
5669 -: 3850: case S_INT:
5670 #####: 3851: loop(dictCount) {
5671 branch 0 never executed
5672 branch 1 never executed
5673 #####: 3852: char *key = (char*)*data;
5674 #####: 3853: *data += strlen(key)+1;
5675 #####: 3854: u64 v = varintToUint(data);
5676 call 0 never executed
5677 #####: 3855: v = (v >> 1) ^ (~(v & 1) + 1);
5678 #####: 3856: io = allocSInt(v);
5679 call 0 never executed
5680 #####: 3857: sDictPushTiny(dict, key, (smallt *) io);
5681 call 0 never executed
5682 -: 3858: }
5683 #####: 3859: break;
5684 -: 3860: case S_STRING:
5685 #####: 3861: loop(dictCount) {
5686 branch 0 never executed
5687 branch 1 never executed
5688 #####: 3862: char *key = (char*)*data;
5689 #####: 3863: *data += strlen(key)+1;
5690 #####: 3864: s = (char *)(*data);
5691 #####: 3865: *data += strlen(s)+1;
5692 #####: 3866: so = allocSStringTiny(s);
5693 call 0 never executed
5694 #####: 3867: sDictPushTiny(dict, key, (smallt *) so);
5695 call 0 never executed
5696 -: 3868: }
5697 #####: 3869: break;
5698 -: 3870: case S_ARRAY:
5699 #####: 3871: loop(dictCount) {
5700 branch 0 never executed
5701 branch 1 never executed
5702 #####: 3872: char *key = (char*)*data;
5703 #####: 3873: *data += strlen(key)+1;
5704 #####: 3874: a = NULL;
5705 #####: 3875: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
5706 call 0 never executed
5707 #####: 3876: sDictPushTiny(dict, key, (smallt *) a);
5708 call 0 never executed
5709 -: 3877: }
5710 #####: 3878: break;
5711 -: 3879: case S_BYTES:
5712 #####: 3880: loop(dictCount) {
5713 branch 0 never executed
5714 branch 1 never executed
5715 #####: 3881: char *key = (char*)*data;
5716 #####: 3882: *data += strlen(key)+1;
5717 #####: 3883: B = allocSBytes();
5718 call 0 never executed
5719 #####: 3884: count = varintToUint((u8**)data);
5720 call 0 never executed
5721 #####: 3885: sBytesPushBuffer(&B, *data, count);
5722 call 0 never executed
5723 #####: 3886: *data += count;
5724 #####: 3887: sDictPushTiny(dict, key, (smallt *) B);
5725 call 0 never executed
5726 -: 3888: }
5727 #####: 3889: break;
5728 -: 3890: case UNIFORM_DICT:
5729 #####: 3891: loop(dictCount) {
5730 branch 0 never executed
5731 branch 1 never executed
5732 #####: 3892: char *key = (char*)*data;
5733 #####: 3893: *data += strlen(key)+1;
5734 #####: 3894: d = NULL;
5735 #####: 3895: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
5736 call 0 never executed
5737 #####: 3896: sDictPushTiny(dict, key, (smallt *) d);
5738 call 0 never executed
5739 -: 3897: }
5740 #####: 3898: break;
5741 -: 3899: case UNIFORM_ARRAY:
5742 #####: 3900: loop(dictCount) {
5743 branch 0 never executed
5744 branch 1 never executed
5745 #####: 3901: char *key = (char*)*data;
5746 #####: 3902: *data += strlen(key)+1;
5747 #####: 3903: a = NULL;
5748 #####: 3904: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
5749 call 0 never executed
5750 #####: 3905: sDictPushTiny(dict, key, (smallt *) a);
5751 call 0 never executed
5752 -: 3906: }
5753 #####: 3907: break;
5754 -: 3908: }
5755 -: 3909:}
5756 -: 3910:
5757 -: 3911:/**
5758 -: 3912: * deserialize array from data
5759 -: 3913: *
5760 -: 3914: * a new array is allocated
5761 -: 3915: *
5762 -: 3916: * \param
5763 -: 3917: * array holding the elements
5764 -: 3918: * data serialized dictionary
5765 -: 3919: */
5766 function arrayNetDeserialLevel2 called 0 returned 0% blocks executed 0%
5767 #####: 3920:internal void arrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
5768 #####: 3921: sUndefinedt *u = NULL;
5769 #####: 3922: sBoolt *bo = NULL;
5770 #####: 3923: double *D = NULL;
5771 #####: 3924: sDoublet *Do = NULL;
5772 #####: 3925: sDictt *d = NULL;
5773 #####: 3926: sIntt *io = NULL;
5774 #####: 3927: char *s = NULL;
5775 #####: 3928: sStringt *so = NULL;
5776 #####: 3929: sArrayt *a = NULL;
5777 #####: 3930: sBytest *B = NULL;
5778 -: 3931: uint32_t count;
5779 -: 3932: uint32_t arrayCount;
5780 -: 3933:
5781 #####: 3934: if (packed) {
5782 branch 0 never executed
5783 branch 1 never executed
5784 #####: 3935: arrayCount = varintToUint(data);
5785 call 0 never executed
5786 -: 3936: }
5787 -: 3937: else {
5788 #####: 3938: if (ctx->nibble == lowNbl) {
5789 branch 0 never executed
5790 branch 1 never executed
5791 #####: 3939: arrayCount = netTypeVarintToUint(data);
5792 call 0 never executed
5793 -: 3940: }
5794 -: 3941: else {
5795 -: 3942: // high nibble
5796 #####: 3943: readTypeInHighNbl;
5797 branch 0 never executed
5798 branch 1 never executed
5799 #####: 3944: arrayCount = varintToUint(data);
5800 call 0 never executed
5801 -: 3945: }
5802 -: 3946: }
5803 -: 3947:
5804 #####: 3948: if (!arrayCount) {
5805 branch 0 never executed
5806 branch 1 never executed
5807 #####: 3949: *array = allocSArray();;
5808 call 0 never executed
5809 #####: 3950: ret;
5810 -: 3951: }
5811 -: 3952:
5812 #####: 3953: loop(arrayCount) {
5813 branch 0 never executed
5814 branch 1 never executed
5815 -: 3954: char type;
5816 #####: 3955: if (ctx->nibble == lowNbl) {
5817 branch 0 never executed
5818 branch 1 never executed
5819 #####: 3956: type = (**data) & 0xF;
5820 -: 3957: }
5821 -: 3958: else {
5822 -: 3959: // high nibble
5823 #####: 3960: type = (*ctx->nblAddr) >> 4;
5824 -: 3961: }
5825 -: 3962:
5826 #####: 3963: switch(type) {
5827 branch 0 never executed
5828 branch 1 never executed
5829 branch 2 never executed
5830 branch 3 never executed
5831 branch 4 never executed
5832 branch 5 never executed
5833 branch 6 never executed
5834 branch 7 never executed
5835 branch 8 never executed
5836 branch 9 never executed
5837 branch 10 never executed
5838 -: 3964: case S_UNDEFINED:
5839 #####: 3965: if (ctx->nibble == lowNbl) {
5840 branch 0 never executed
5841 branch 1 never executed
5842 #####: 3966: readTypeOnly;
5843 -: 3967: }
5844 -: 3968: else {
5845 -: 3969: // high nibble
5846 #####: 3970: readTypeInHighNbl;
5847 branch 0 never executed
5848 branch 1 never executed
5849 -: 3971: }
5850 #####: 3972: u = allocSUndefined();
5851 call 0 never executed
5852 #####: 3973: sArrayPushTiny(array, (smallt *) u);
5853 call 0 never executed
5854 #####: 3974: break;
5855 -: 3975: case S_BOOL:
5856 #####: 3976: if (!ctx->boolAddr) {
5857 branch 0 never executed
5858 branch 1 never executed
5859 -: 3977: // new packed bools
5860 #####: 3978: if (ctx->nibble == lowNbl) {
5861 branch 0 never executed
5862 branch 1 never executed
5863 #####: 3979: read4bPackedBool;
5864 #####: 3980: bo = allocSBool((*ctx->boolAddr) & 0x10);
5865 call 0 never executed
5866 -: 3981: }
5867 -: 3982: else {
5868 -: 3983: // high nibble
5869 #####: 3984: readTypeInHighNbl;
5870 branch 0 never executed
5871 branch 1 never executed
5872 #####: 3985: read8bPackedBool;
5873 #####: 3986: bo = allocSBool((*ctx->boolAddr) & 0x1);
5874 call 0 never executed
5875 -: 3987: }
5876 -: 3988: }
5877 -: 3989: else {
5878 -: 3990: // there was a bool before this one, read bits in nibbles
5879 #####: 3991: if (ctx->nibble == lowNbl) {
5880 branch 0 never executed
5881 branch 1 never executed
5882 #####: 3992: if (ctx->boolShift == 8) {
5883 branch 0 never executed
5884 branch 1 never executed
5885 #####: 3993: read4bPackedBool;
5886 #####: 3994: bo = allocSBool((*ctx->boolAddr) & 0x10);
5887 call 0 never executed
5888 -: 3995: }
5889 -: 3996: else {
5890 #####: 3997: readTypeOnly;
5891 #####: 3998: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
5892 call 0 never executed
5893 -: 3999: }
5894 -: 4000: }
5895 -: 4001: else {
5896 -: 4002: // high nibble
5897 #####: 4003: readTypeInHighNbl;
5898 branch 0 never executed
5899 branch 1 never executed
5900 #####: 4004: if (ctx->boolShift == 8) {
5901 branch 0 never executed
5902 branch 1 never executed
5903 #####: 4005: read8bPackedBool;
5904 #####: 4006: bo = allocSBool((*ctx->boolAddr) & 0x1);
5905 call 0 never executed
5906 -: 4007: }
5907 -: 4008: else {
5908 #####: 4009: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
5909 call 0 never executed
5910 -: 4010: }
5911 -: 4011: }
5912 -: 4012: }
5913 #####: 4013: sArrayPushTiny(array, (smallt *) bo);
5914 call 0 never executed
5915 #####: 4014: break;
5916 -: 4015: case S_DICT:
5917 #####: 4016: d = NULL;
5918 #####: 4017: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
5919 call 0 never executed
5920 #####: 4018: sArrayPushTiny(array, (smallt *) d);
5921 call 0 never executed
5922 #####: 4019: break;
5923 -: 4020: case S_DOUBLE:
5924 #####: 4021: if (ctx->nibble == lowNbl) {
5925 branch 0 never executed
5926 branch 1 never executed
5927 #####: 4022: readTypeOnly;
5928 -: 4023: }
5929 -: 4024: else {
5930 -: 4025: // high nibble
5931 #####: 4026: readTypeInHighNbl;
5932 branch 0 never executed
5933 branch 1 never executed
5934 -: 4027: }
5935 #####: 4028: D = (double *)(*data);
5936 #####: 4029: *data += sizeof(double);
5937 #####: 4030: Do = allocSDouble(*D);
5938 call 0 never executed
5939 #####: 4031: sArrayPushTiny(array, (smallt *) Do);
5940 call 0 never executed
5941 #####: 4032: break;
5942 -: 4033: case S_INT: {
5943 -: 4034: u64 v;
5944 #####: 4035: if (ctx->nibble == lowNbl) {
5945 branch 0 never executed
5946 branch 1 never executed
5947 #####: 4036: v = netTypeVarintToUint((u8**)data);
5948 call 0 never executed
5949 -: 4037: }
5950 -: 4038: else {
5951 -: 4039: // high nibble
5952 #####: 4040: readTypeInHighNbl;
5953 branch 0 never executed
5954 branch 1 never executed
5955 #####: 4041: v = varintToUint(data);
5956 call 0 never executed
5957 -: 4042: }
5958 #####: 4043: v = (v >> 1) ^ (~(v & 1) + 1);
5959 #####: 4044: io = allocSInt(v);
5960 call 0 never executed
5961 #####: 4045: sArrayPushTiny(array, (smallt *) io);
5962 call 0 never executed
5963 -: 4046: }
5964 #####: 4047: break;
5965 -: 4048: case S_STRING:
5966 #####: 4049: if (ctx->nibble == lowNbl) {
5967 branch 0 never executed
5968 branch 1 never executed
5969 #####: 4050: readTypeOnly;
5970 -: 4051: }
5971 -: 4052: else {
5972 -: 4053: // high nibble
5973 #####: 4054: readTypeInHighNbl;
5974 branch 0 never executed
5975 branch 1 never executed
5976 -: 4055: }
5977 #####: 4056: s = (char *)(*data);
5978 #####: 4057: *data += strlen(s)+1;
5979 #####: 4058: so = allocSStringTiny(s);
5980 call 0 never executed
5981 #####: 4059: sArrayPushTiny(array, (smallt *) so);
5982 call 0 never executed
5983 #####: 4060: break;
5984 -: 4061: case S_ARRAY:
5985 #####: 4062: a = NULL;
5986 #####: 4063: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
5987 call 0 never executed
5988 #####: 4064: sArrayPushTiny(array, (smallt *) a);
5989 call 0 never executed
5990 #####: 4065: break;
5991 -: 4066: case S_BYTES:
5992 #####: 4067: B = allocSBytes();
5993 call 0 never executed
5994 #####: 4068: if (ctx->nibble == lowNbl) {
5995 branch 0 never executed
5996 branch 1 never executed
5997 #####: 4069: count = netTypeVarintToUint((u8**)data);
5998 call 0 never executed
5999 -: 4070: }
6000 -: 4071: else {
6001 -: 4072: // high nibble
6002 #####: 4073: readTypeInHighNbl;
6003 branch 0 never executed
6004 branch 1 never executed
6005 #####: 4074: count = varintToUint((u8**)data);
6006 call 0 never executed
6007 -: 4075: }
6008 #####: 4076: sBytesPushBuffer(&B, *data, count);
6009 call 0 never executed
6010 #####: 4077: *data += count;
6011 #####: 4078: sArrayPushTiny(array, (smallt *) B);
6012 call 0 never executed
6013 #####: 4079: break;
6014 -: 4080: case UNIFORM_DICT:
6015 #####: 4081: d = NULL;
6016 #####: 4082: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
6017 call 0 never executed
6018 #####: 4083: sArrayPushTiny(array, (smallt *) d);
6019 call 0 never executed
6020 #####: 4084: break;
6021 -: 4085: case UNIFORM_ARRAY:
6022 #####: 4086: a = NULL;
6023 #####: 4087: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
6024 call 0 never executed
6025 #####: 4088: sArrayPushTiny(array, (smallt *) a);
6026 call 0 never executed
6027 #####: 4089: break;
6028 -: 4090: }
6029 -: 4091: }
6030 -: 4092:}
6031 -: 4093:
6032 function uniformArrayNetDeserialLevel2 called 0 returned 0% blocks executed 0%
6033 #####: 4094:internal void uniformArrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
6034 #####: 4095: sUndefinedt *u = NULL;
6035 #####: 4096: sBoolt *bo = NULL;
6036 #####: 4097: double *D = NULL;
6037 #####: 4098: sDoublet *Do = NULL;
6038 #####: 4099: sDictt *d = NULL;
6039 #####: 4100: sIntt *io = NULL;
6040 #####: 4101: char *s = NULL;
6041 #####: 4102: sStringt *so = NULL;
6042 #####: 4103: sArrayt *a = NULL;
6043 #####: 4104: sBytest *B = NULL;
6044 -: 4105: uint32_t count;
6045 -: 4106: uint32_t arrayCount;
6046 -: 4107: u8 type;
6047 -: 4108:
6048 #####: 4109: if (packed) {
6049 branch 0 never executed
6050 branch 1 never executed
6051 #####: 4110: type = (**data) & 0xF;
6052 #####: 4111: arrayCount = netTypeVarintToUint(data);
6053 call 0 never executed
6054 -: 4112: }
6055 -: 4113: else {
6056 #####: 4114: if (ctx->nibble == lowNbl) {
6057 branch 0 never executed
6058 branch 1 never executed
6059 #####: 4115: type = (**data) >> 4;
6060 #####: 4116: (*data)++;
6061 #####: 4117: arrayCount = varintToUint(data);
6062 call 0 never executed
6063 -: 4118: }
6064 -: 4119: else {
6065 #####: 4120: readTypeInHighNbl;
6066 branch 0 never executed
6067 branch 1 never executed
6068 #####: 4121: type = (**data) & 0xF;
6069 #####: 4122: arrayCount = netTypeVarintToUint(data);
6070 call 0 never executed
6071 -: 4123: }
6072 -: 4124: }
6073 -: 4125:
6074 #####: 4126: if (!arrayCount) {
6075 branch 0 never executed
6076 branch 1 never executed
6077 #####: 4127: *array = allocSArray();;
6078 call 0 never executed
6079 #####: 4128: ret;
6080 -: 4129: }
6081 -: 4130:
6082 #####: 4131: switch(type) {
6083 branch 0 never executed
6084 branch 1 never executed
6085 branch 2 never executed
6086 branch 3 never executed
6087 branch 4 never executed
6088 branch 5 never executed
6089 branch 6 never executed
6090 branch 7 never executed
6091 branch 8 never executed
6092 branch 9 never executed
6093 branch 10 never executed
6094 -: 4132: case S_UNDEFINED:
6095 #####: 4133: loop(arrayCount) {
6096 branch 0 never executed
6097 branch 1 never executed
6098 #####: 4134: u = allocSUndefined();
6099 call 0 never executed
6100 #####: 4135: sArrayPushTiny(array, (smallt *) u);
6101 call 0 never executed
6102 -: 4136: }
6103 #####: 4137: break;
6104 -: 4138: case S_BOOL:
6105 #####: 4139: loop(arrayCount) {
6106 branch 0 never executed
6107 branch 1 never executed
6108 #####: 4140: if (!ctx->boolAddr) {
6109 branch 0 never executed
6110 branch 1 never executed
6111 #####: 4141: read8bPackedBool;
6112 #####: 4142: ctx->boolShift = 0;
6113 -: 4143: }
6114 #####: 4144: if (ctx->boolShift == 8) {
6115 branch 0 never executed
6116 branch 1 never executed
6117 #####: 4145: read8bPackedBool;
6118 #####: 4146: bo = allocSBool((*ctx->boolAddr) & 0x1);
6119 call 0 never executed
6120 -: 4147: }
6121 -: 4148: else {
6122 #####: 4149: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
6123 call 0 never executed
6124 -: 4150: }
6125 #####: 4151: sArrayPushTiny(array, (smallt *) bo);
6126 call 0 never executed
6127 -: 4152: }
6128 #####: 4153: break;
6129 -: 4154: case S_DICT:
6130 #####: 4155: loop(arrayCount) {
6131 branch 0 never executed
6132 branch 1 never executed
6133 #####: 4156: d = NULL;
6134 #####: 4157: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
6135 call 0 never executed
6136 #####: 4158: sArrayPushTiny(array, (smallt *) d);
6137 call 0 never executed
6138 -: 4159: }
6139 #####: 4160: break;
6140 -: 4161: case S_DOUBLE:
6141 #####: 4162: loop(arrayCount) {
6142 branch 0 never executed
6143 branch 1 never executed
6144 #####: 4163: D = (double *)(*data);
6145 #####: 4164: *data += sizeof(double);
6146 #####: 4165: Do = allocSDouble(*D);
6147 call 0 never executed
6148 #####: 4166: sArrayPushTiny(array, (smallt *) Do);
6149 call 0 never executed
6150 -: 4167: }
6151 #####: 4168: break;
6152 -: 4169: case S_INT:
6153 #####: 4170: loop(arrayCount) {
6154 branch 0 never executed
6155 branch 1 never executed
6156 #####: 4171: u64 v = varintToUint(data);
6157 call 0 never executed
6158 #####: 4172: v = (v >> 1) ^ (~(v & 1) + 1);
6159 #####: 4173: io = allocSInt(v);
6160 call 0 never executed
6161 #####: 4174: sArrayPushTiny(array, (smallt *) io);
6162 call 0 never executed
6163 -: 4175: }
6164 #####: 4176: break;
6165 -: 4177: case S_STRING:
6166 #####: 4178: loop(arrayCount) {
6167 branch 0 never executed
6168 branch 1 never executed
6169 #####: 4179: s = (char *)(*data);
6170 #####: 4180: *data += strlen(s)+1;
6171 #####: 4181: so = allocSStringTiny(s);
6172 call 0 never executed
6173 #####: 4182: sArrayPushTiny(array, (smallt *) so);
6174 call 0 never executed
6175 -: 4183: }
6176 #####: 4184: break;
6177 -: 4185: case S_ARRAY:
6178 #####: 4186: loop(arrayCount) {
6179 branch 0 never executed
6180 branch 1 never executed
6181 #####: 4187: a = NULL;
6182 #####: 4188: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
6183 call 0 never executed
6184 #####: 4189: sArrayPushTiny(array, (smallt *) a);
6185 call 0 never executed
6186 -: 4190: }
6187 #####: 4191: break;
6188 -: 4192: case S_BYTES:
6189 #####: 4193: loop(arrayCount) {
6190 branch 0 never executed
6191 branch 1 never executed
6192 #####: 4194: B = allocSBytes();
6193 call 0 never executed
6194 #####: 4195: count = varintToUint((u8**)data);
6195 call 0 never executed
6196 #####: 4196: sBytesPushBuffer(&B, *data, count);
6197 call 0 never executed
6198 #####: 4197: *data += count;
6199 #####: 4198: sArrayPushTiny(array, (smallt *) B);
6200 call 0 never executed
6201 -: 4199: }
6202 #####: 4200: break;
6203 -: 4201: case UNIFORM_DICT:
6204 #####: 4202: loop(arrayCount) {
6205 branch 0 never executed
6206 branch 1 never executed
6207 #####: 4203: d = NULL;
6208 #####: 4204: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
6209 call 0 never executed
6210 #####: 4205: sArrayPushTiny(array, (smallt *) d);
6211 call 0 never executed
6212 -: 4206: }
6213 #####: 4207: break;
6214 -: 4208: case UNIFORM_ARRAY:
6215 #####: 4209: loop(arrayCount) {
6216 branch 0 never executed
6217 branch 1 never executed
6218 #####: 4210: a = NULL;
6219 #####: 4211: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
6220 call 0 never executed
6221 #####: 4212: sArrayPushTiny(array, (smallt *) a);
6222 call 0 never executed
6223 -: 4213: }
6224 #####: 4214: break;
6225 -: 4215: }
6226 -: 4216:}
6227 -: 4217:
6228 function deserialNetSerialLevel2 called 0 returned 0% blocks executed 0%
6229 #####: 4218:internal smallJsont* deserialNetSerialLevel2(smallJsont *self, smallBytest *data) {
6230 -: 4219:
6231 #####: 4220: if (!data or !data->B or !data->B->count) {
6232 branch 0 never executed
6233 branch 1 never executed
6234 branch 2 never executed
6235 branch 3 never executed
6236 branch 4 never executed
6237 branch 5 never executed
6238 #####: 4221: ret self;
6239 -: 4222: }
6240 -: 4223:
6241 #####: 4224: smallt *o = netDeserialLevel2(data->B);
6242 call 0 never executed
6243 -: 4225:
6244 #####: 4226: if (!o) {
6245 branch 0 never executed
6246 branch 1 never executed
6247 #####: 4227: ret self;
6248 -: 4228: }
6249 -: 4229:
6250 #####: 4230: freeG(self);
6251 call 0 never executed
6252 -: 4231:
6253 #####: 4232: setsoG(self, o);
6254 call 0 never executed
6255 -: 4233:
6256 #####: 4234: ret self;
6257 -: 4235:}
6258 -: 4236:
6259 -: 4237:// level 3
6260 -: 4238:// like level 2, elements of identical type in a row are packed
6261 -: 4239:
6262 -: 4240:/**
6263 -: 4241: * deserializer top function
6264 -: 4242: */
6265 function netDeserial called 86 returned 100% blocks executed 85%
6266 86: 4243:internal smallt* netDeserial(sBytest *obj) {
6267 86: 4244: smallt *r = NULL;
6268 86: 4245: double *D = NULL;
6269 86: 4246: char *s = NULL;
6270 86: 4247: sBytest *B = NULL;
6271 -: 4248: uint32_t count;
6272 86: 4249: char *data = NULL;
6273 86: 4250: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
6274 -: 4251:
6275 86: 4252: switch(obj->data & 0xF) {
6276 branch 0 taken 1%
6277 branch 1 taken 1%
6278 branch 2 taken 30%
6279 branch 3 taken 1%
6280 branch 4 taken 3%
6281 branch 5 taken 1%
6282 branch 6 taken 30%
6283 branch 7 taken 0%
6284 branch 8 taken 16%
6285 branch 9 taken 15%
6286 branch 10 taken 0%
6287 -: 4253: case S_UNDEFINED:
6288 1: 4254: r = (smallt *) allocSUndefined();
6289 call 0 returned 100%
6290 1: 4255: break;
6291 -: 4256: case S_BOOL:
6292 1: 4257: r = (smallt *) allocSBool(obj->data & 0x10);
6293 call 0 returned 100%
6294 1: 4258: break;
6295 -: 4259: case S_DICT:
6296 26: 4260: data = (char *)&(obj->data);
6297 -: 4261: //debug - ctx.dbuf = (u8*) data;
6298 26: 4262: dictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
6299 call 0 returned 100%
6300 26: 4263: break;
6301 -: 4264: case S_DOUBLE:
6302 1: 4265: data = &(obj->data)+1;
6303 1: 4266: D = (double *)data;
6304 1: 4267: r = (smallt *) allocSDouble(*D);
6305 call 0 returned 100%
6306 1: 4268: break;
6307 -: 4269: case S_INT:
6308 3: 4270: data = &(obj->data);
6309 3: 4271: u64 v = netTypeVarintToUint((u8**)&data);
6310 call 0 returned 100%
6311 3: 4272: v = (v >> 1) ^ (~(v & 1) + 1);
6312 3: 4273: r = (smallt *) allocSInt(v);
6313 call 0 returned 100%
6314 3: 4274: break;
6315 -: 4275: case S_STRING:
6316 1: 4276: s = (char *)&(obj->data)+1;
6317 1: 4277: r = (smallt *) allocSStringTiny(s);
6318 call 0 returned 100%
6319 1: 4278: break;
6320 -: 4279: case S_ARRAY:
6321 26: 4280: data = (char *)&(obj->data);
6322 -: 4281: //debug - ctx.dbuf = (u8*) data;
6323 26: 4282: arrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
6324 call 0 returned 100%
6325 26: 4283: break;
6326 -: 4284: case S_BYTES:
6327 #####: 4285: B = allocSBytes();
6328 call 0 never executed
6329 #####: 4286: data = &(obj->data);
6330 #####: 4287: count = netTypeVarintToUint((u8**)&data);
6331 call 0 never executed
6332 #####: 4288: sBytesPushBuffer(&B, data, count);
6333 call 0 never executed
6334 #####: 4289: r = (smallt *)B;
6335 #####: 4290: break;
6336 -: 4291: case UNIFORM_DICT:
6337 14: 4292: data = (char *)&(obj->data);
6338 -: 4293: //debug - ctx.dbuf = (u8*) data;
6339 14: 4294: uniformDictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
6340 call 0 returned 100%
6341 14: 4295: break;
6342 -: 4296: case UNIFORM_ARRAY:
6343 13: 4297: data = (char *)&(obj->data);
6344 -: 4298: //debug - ctx.dbuf = (u8*) data;
6345 13: 4299: uniformArrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
6346 call 0 returned 100%
6347 13: 4300: break;
6348 -: 4301: }
6349 -: 4302:
6350 86: 4303: ret r;
6351 -: 4304:}
6352 -: 4305:
6353 -: 4306:/**
6354 -: 4307: * deserialize dictionary from data
6355 -: 4308: *
6356 -: 4309: * a new dictionary is allocated
6357 -: 4310: *
6358 -: 4311: * \param
6359 -: 4312: * dict dictionary holding the elements
6360 -: 4313: * data serialized dictionary
6361 -: 4314: */
6362 function dictNetDeserial called 56 returned 100% blocks executed 84%
6363 56: 4315:internal void dictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
6364 56: 4316: sUndefinedt *u = NULL;
6365 56: 4317: sBoolt *bo = NULL;
6366 56: 4318: double *D = NULL;
6367 56: 4319: sDoublet *Do = NULL;
6368 56: 4320: sDictt *d = NULL;
6369 56: 4321: sIntt *io = NULL;
6370 56: 4322: char *s = NULL;
6371 56: 4323: sStringt *so = NULL;
6372 56: 4324: sArrayt *a = NULL;
6373 56: 4325: sBytest *B = NULL;
6374 -: 4326: uint32_t count;
6375 -: 4327: uint32_t dictCount;
6376 -: 4328:
6377 56: 4329: if (packed) {
6378 branch 0 taken 48% (fallthrough)
6379 branch 1 taken 52%
6380 27: 4330: dictCount = varintToUint(data);
6381 call 0 returned 100%
6382 -: 4331: }
6383 -: 4332: else {
6384 29: 4333: if (ctx->nibble == lowNbl) {
6385 branch 0 taken 93% (fallthrough)
6386 branch 1 taken 7%
6387 27: 4334: dictCount = netTypeVarintToUint(data);
6388 call 0 returned 100%
6389 -: 4335: }
6390 -: 4336: else {
6391 -: 4337: // high nibble
6392 -: 4338: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
6393 -: 4339: #define readTypeInHighNbl\
6394 -: 4340: ctx->nibble = lowNbl;\
6395 -: 4341: if (ctx->nblAddr == *data)\
6396 -: 4342: /* data points to the type, next byte is count */\
6397 -: 4343: (*data)++
6398 2: 4344: readTypeInHighNbl;
6399 branch 0 taken 0% (fallthrough)
6400 branch 1 taken 100%
6401 2: 4345: dictCount = varintToUint(data);
6402 call 0 returned 100%
6403 -: 4346: }
6404 -: 4347: }
6405 -: 4348:
6406 56: 4349: if (!dictCount) {
6407 branch 0 taken 18% (fallthrough)
6408 branch 1 taken 82%
6409 10: 4350: *dict = allocSDict();
6410 call 0 returned 100%
6411 66: 4351: ret;
6412 -: 4352: }
6413 -: 4353:
6414 46: 4354: bool inPack = false;
6415 -: 4355: u8 packedType;
6416 -: 4356: size_t packCount;
6417 209: 4357: loop(dictCount) {
6418 branch 0 taken 78%
6419 branch 1 taken 22% (fallthrough)
6420 163: 4358: char *key = (char*)*data;
6421 163: 4359: *data += strlen(key)+1;
6422 -: 4360: char type;
6423 163: 4361: if (inPack) {
6424 branch 0 taken 23% (fallthrough)
6425 branch 1 taken 77%
6426 38: 4362: type = packedType;
6427 -: 4363: }
6428 -: 4364: else {
6429 125: 4365: if (ctx->nibble == lowNbl) {
6430 branch 0 taken 66% (fallthrough)
6431 branch 1 taken 34%
6432 83: 4366: type = (**data) & 0xF;
6433 -: 4367: }
6434 -: 4368: else {
6435 -: 4369: // high nibble
6436 42: 4370: type = (*ctx->nblAddr) >> 4;
6437 -: 4371: }
6438 -: 4372: }
6439 -: 4373:
6440 163: 4374: switch(type) {
6441 branch 0 taken 18%
6442 branch 1 taken 19%
6443 branch 2 taken 1%
6444 branch 3 taken 1%
6445 branch 4 taken 15%
6446 branch 5 taken 9%
6447 branch 6 taken 2%
6448 branch 7 taken 1%
6449 branch 8 taken 9%
6450 branch 9 taken 6%
6451 branch 10 taken 5%
6452 branch 11 taken 5%
6453 branch 12 taken 5%
6454 branch 13 taken 0%
6455 branch 14 taken 2%
6456 branch 15 taken 2%
6457 branch 16 taken 0%
6458 -: 4375: case S_UNDEFINED:
6459 29: 4376: if (ctx->nibble == lowNbl) {
6460 branch 0 taken 93% (fallthrough)
6461 branch 1 taken 7%
6462 -: 4377: #define readTypeOnly\
6463 -: 4378: ctx->nibble = highNbl;\
6464 -: 4379: ctx->nblAddr = *data;\
6465 -: 4380: (*data)++
6466 27: 4381: readTypeOnly;
6467 -: 4382: }
6468 -: 4383: else {
6469 -: 4384: // high nibble
6470 2: 4385: readTypeInHighNbl;
6471 branch 0 taken 0% (fallthrough)
6472 branch 1 taken 100%
6473 -: 4386: }
6474 29: 4387: u = allocSUndefined();
6475 call 0 returned 100%
6476 29: 4388: sDictPushTiny(dict, key, (smallt *) u);
6477 call 0 returned 100%
6478 29: 4389: break;
6479 -: 4390: case S_BOOL:
6480 31: 4391: if (!ctx->boolAddr) {
6481 branch 0 taken 16% (fallthrough)
6482 branch 1 taken 84%
6483 -: 4392: // new packed bools
6484 5: 4393: if (ctx->nibble == lowNbl) {
6485 branch 0 taken 60% (fallthrough)
6486 branch 1 taken 40%
6487 -: 4394: #define read4bPackedBool\
6488 -: 4395: ctx->boolShift = 5;\
6489 -: 4396: ctx->boolAddr = *data;\
6490 -: 4397: (*data)++
6491 3: 4398: read4bPackedBool;
6492 3: 4399: bo = allocSBool((*ctx->boolAddr) & 0x10);
6493 call 0 returned 100%
6494 -: 4400: }
6495 -: 4401: else {
6496 -: 4402: // high nibble
6497 2: 4403: readTypeInHighNbl;
6498 branch 0 taken 0% (fallthrough)
6499 branch 1 taken 100%
6500 -: 4404: #define read8bPackedBool\
6501 -: 4405: ctx->boolShift = 1;\
6502 -: 4406: ctx->boolAddr = *data;\
6503 -: 4407: (*data)++
6504 2: 4408: read8bPackedBool;
6505 2: 4409: bo = allocSBool((*ctx->boolAddr) & 0x1);
6506 call 0 returned 100%
6507 -: 4410: }
6508 -: 4411: }
6509 -: 4412: else {
6510 -: 4413: // there was a bool before this one, read bits in nibbles
6511 26: 4414: if (ctx->nibble == lowNbl) {
6512 branch 0 taken 58% (fallthrough)
6513 branch 1 taken 42%
6514 15: 4415: if (ctx->boolShift == 8) {
6515 branch 0 taken 7% (fallthrough)
6516 branch 1 taken 93%
6517 1: 4416: read4bPackedBool;
6518 1: 4417: bo = allocSBool((*ctx->boolAddr) & 0x10);
6519 call 0 returned 100%
6520 -: 4418: }
6521 -: 4419: else {
6522 14: 4420: readTypeOnly;
6523 14: 4421: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
6524 call 0 returned 100%
6525 -: 4422: }
6526 -: 4423: }
6527 -: 4424: else {
6528 -: 4425: // high nibble
6529 11: 4426: readTypeInHighNbl;
6530 branch 0 taken 0% (fallthrough)
6531 branch 1 taken 100%
6532 11: 4427: if (ctx->boolShift == 8) {
6533 branch 0 taken 18% (fallthrough)
6534 branch 1 taken 82%
6535 2: 4428: read8bPackedBool;
6536 2: 4429: bo = allocSBool((*ctx->boolAddr) & 0x1);
6537 call 0 returned 100%
6538 -: 4430: }
6539 -: 4431: else {
6540 -: 4432: // high nibble
6541 9: 4433: readTypeInHighNbl;
6542 branch 0 taken 0% (fallthrough)
6543 branch 1 taken 100%
6544 9: 4434: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
6545 call 0 returned 100%
6546 -: 4435: }
6547 -: 4436: }
6548 -: 4437: }
6549 31: 4438: sDictPushTiny(dict, key, (smallt *) bo);
6550 call 0 returned 100%
6551 31: 4439: break;
6552 -: 4440: case S_DICT:
6553 1: 4441: d = NULL;
6554 1: 4442: dictNetDeserial(&d, data, ctx, /*packed=*/false);
6555 call 0 returned 100%
6556 1: 4443: sDictPushTiny(dict, key, (smallt *) d);
6557 call 0 returned 100%
6558 1: 4444: break;
6559 -: 4445: case S_DOUBLE:
6560 2: 4446: if (ctx->nibble == lowNbl) {
6561 branch 0 taken 50% (fallthrough)
6562 branch 1 taken 50%
6563 1: 4447: readTypeOnly;
6564 -: 4448: }
6565 -: 4449: else {
6566 -: 4450: // high nibble
6567 1: 4451: readTypeInHighNbl;
6568 branch 0 taken 0% (fallthrough)
6569 branch 1 taken 100%
6570 -: 4452: }
6571 2: 4453: D = (double *)(*data);
6572 2: 4454: *data += sizeof(double);
6573 2: 4455: Do = allocSDouble(*D);
6574 call 0 returned 100%
6575 2: 4456: sDictPushTiny(dict, key, (smallt *) Do);
6576 call 0 returned 100%
6577 2: 4457: break;
6578 -: 4458: case S_INT: {
6579 -: 4459: u64 v;
6580 24: 4460: if (ctx->nibble == lowNbl) {
6581 branch 0 taken 50% (fallthrough)
6582 branch 1 taken 50%
6583 12: 4461: v = netTypeVarintToUint((u8**)data);
6584 call 0 returned 100%
6585 -: 4462: }
6586 -: 4463: else {
6587 -: 4464: // high nibble
6588 12: 4465: readTypeInHighNbl;
6589 branch 0 taken 0% (fallthrough)
6590 branch 1 taken 100%
6591 12: 4466: v = varintToUint(data);
6592 call 0 returned 100%
6593 -: 4467: }
6594 24: 4468: v = (v >> 1) ^ (~(v & 1) + 1);
6595 24: 4469: io = allocSInt(v);
6596 call 0 returned 100%
6597 24: 4470: sDictPushTiny(dict, key, (smallt *) io);
6598 call 0 returned 100%
6599 -: 4471: }
6600 24: 4472: break;
6601 -: 4473: case S_STRING:
6602 14: 4474: if (ctx->nibble == lowNbl) {
6603 branch 0 taken 93% (fallthrough)
6604 branch 1 taken 7%
6605 13: 4475: readTypeOnly;
6606 -: 4476: }
6607 -: 4477: else {
6608 -: 4478: // high nibble
6609 1: 4479: readTypeInHighNbl;
6610 branch 0 taken 0% (fallthrough)
6611 branch 1 taken 100%
6612 -: 4480: }
6613 14: 4481: s = (char *)(*data);
6614 14: 4482: *data += strlen(s)+1;
6615 14: 4483: so = allocSStringTiny(s);
6616 call 0 returned 100%
6617 14: 4484: sDictPushTiny(dict, key, (smallt *) so);
6618 call 0 returned 100%
6619 14: 4485: break;
6620 -: 4486: case S_ARRAY:
6621 3: 4487: a = NULL;
6622 3: 4488: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
6623 call 0 returned 100%
6624 3: 4489: sDictPushTiny(dict, key, (smallt *) a);
6625 call 0 returned 100%
6626 3: 4490: break;
6627 -: 4491: case S_BYTES:
6628 2: 4492: B = allocSBytes();
6629 call 0 returned 100%
6630 2: 4493: if (ctx->nibble == lowNbl) {
6631 branch 0 taken 50% (fallthrough)
6632 branch 1 taken 50%
6633 1: 4494: count = netTypeVarintToUint((u8**)data);
6634 call 0 returned 100%
6635 -: 4495: }
6636 -: 4496: else {
6637 -: 4497: // high nibble
6638 1: 4498: readTypeInHighNbl;
6639 branch 0 taken 0% (fallthrough)
6640 branch 1 taken 100%
6641 1: 4499: count = varintToUint((u8**)data);
6642 call 0 returned 100%
6643 -: 4500: }
6644 2: 4501: sBytesPushBuffer(&B, *data, count);
6645 call 0 returned 100%
6646 2: 4502: *data += count;
6647 2: 4503: sDictPushTiny(dict, key, (smallt *) B);
6648 call 0 returned 100%
6649 2: 4504: break;
6650 -: 4505: case PK_DICT:
6651 15: 4506: if (!inPack) {
6652 branch 0 taken 20% (fallthrough)
6653 branch 1 taken 80%
6654 3: 4507: inPack = true;
6655 3: 4508: if (ctx->nibble == lowNbl) {
6656 branch 0 taken 67% (fallthrough)
6657 branch 1 taken 33%
6658 2: 4509: packCount = netTypeVarintToUint((u8**)data);
6659 call 0 returned 100%
6660 -: 4510: }
6661 -: 4511: else {
6662 -: 4512: // high nibble
6663 1: 4513: readTypeInHighNbl;
6664 branch 0 taken 0% (fallthrough)
6665 branch 1 taken 100%
6666 1: 4514: packCount = varintToUint((u8**)data);
6667 call 0 returned 100%
6668 -: 4515: }
6669 3: 4516: packedType = PK_DICT;
6670 -: 4517: }
6671 -: 4518:
6672 15: 4519: d = NULL;
6673 15: 4520: dictNetDeserial(&d, data, ctx, /*packed=*/true);
6674 call 0 returned 100%
6675 15: 4521: sDictPushTiny(dict, key, (smallt *) d);
6676 call 0 returned 100%
6677 -: 4522: // stop unpacking when packCount == 0
6678 15: 4523: packCount--;
6679 15: 4524: if (!packCount) inPack = false;
6680 branch 0 taken 20% (fallthrough)
6681 branch 1 taken 80%
6682 15: 4525: break;
6683 -: 4526: case PK_DOUBLE:
6684 10: 4527: if (!inPack) {
6685 branch 0 taken 20% (fallthrough)
6686 branch 1 taken 80%
6687 2: 4528: inPack = true;
6688 2: 4529: if (ctx->nibble == lowNbl) {
6689 branch 0 taken 50% (fallthrough)
6690 branch 1 taken 50%
6691 1: 4530: packCount = netTypeVarintToUint((u8**)data);
6692 call 0 returned 100%
6693 -: 4531: }
6694 -: 4532: else {
6695 -: 4533: // high nibble
6696 1: 4534: readTypeInHighNbl;
6697 branch 0 taken 0% (fallthrough)
6698 branch 1 taken 100%
6699 1: 4535: packCount = varintToUint((u8**)data);
6700 call 0 returned 100%
6701 -: 4536: }
6702 2: 4537: packedType = PK_DOUBLE;
6703 -: 4538: }
6704 -: 4539:
6705 10: 4540: D = (double *)(*data);
6706 10: 4541: *data += sizeof(double);
6707 10: 4542: Do = allocSDouble(*D);
6708 call 0 returned 100%
6709 10: 4543: sDictPushTiny(dict, key, (smallt *) Do);
6710 call 0 returned 100%
6711 -: 4544: // stop unpacking when packCount == 0
6712 10: 4545: packCount--;
6713 10: 4546: if (!packCount) inPack = false;
6714 branch 0 taken 20% (fallthrough)
6715 branch 1 taken 80%
6716 10: 4547: break;
6717 -: 4548: case PK_INT:
6718 8: 4549: if (!inPack) {
6719 branch 0 taken 25% (fallthrough)
6720 branch 1 taken 75%
6721 2: 4550: inPack = true;
6722 2: 4551: if (ctx->nibble == lowNbl) {
6723 branch 0 taken 50% (fallthrough)
6724 branch 1 taken 50%
6725 1: 4552: packCount = netTypeVarintToUint((u8**)data);
6726 call 0 returned 100%
6727 -: 4553: }
6728 -: 4554: else {
6729 -: 4555: // high nibble
6730 1: 4556: readTypeInHighNbl;
6731 branch 0 taken 0% (fallthrough)
6732 branch 1 taken 100%
6733 1: 4557: packCount = varintToUint((u8**)data);
6734 call 0 returned 100%
6735 -: 4558: }
6736 2: 4559: packedType = PK_INT;
6737 -: 4560: }
6738 -: 4561:
6739 8: 4562: u64 v = varintToUint(data);
6740 call 0 returned 100%
6741 8: 4563: v = (v >> 1) ^ (~(v & 1) + 1);
6742 8: 4564: io = allocSInt(v);
6743 call 0 returned 100%
6744 8: 4565: sDictPushTiny(dict, key, (smallt *) io);
6745 call 0 returned 100%
6746 -: 4566: // stop unpacking when packCount == 0
6747 8: 4567: packCount--;
6748 8: 4568: if (!packCount) inPack = false;
6749 branch 0 taken 25% (fallthrough)
6750 branch 1 taken 75%
6751 8: 4569: break;
6752 -: 4570: case PK_STRING:
6753 8: 4571: if (!inPack) {
6754 branch 0 taken 25% (fallthrough)
6755 branch 1 taken 75%
6756 2: 4572: inPack = true;
6757 2: 4573: if (ctx->nibble == lowNbl) {
6758 branch 0 taken 50% (fallthrough)
6759 branch 1 taken 50%
6760 1: 4574: packCount = netTypeVarintToUint((u8**)data);
6761 call 0 returned 100%
6762 -: 4575: }
6763 -: 4576: else {
6764 -: 4577: // high nibble
6765 1: 4578: readTypeInHighNbl;
6766 branch 0 taken 0% (fallthrough)
6767 branch 1 taken 100%
6768 1: 4579: packCount = varintToUint((u8**)data);
6769 call 0 returned 100%
6770 -: 4580: }
6771 2: 4581: packedType = PK_STRING;
6772 -: 4582: }
6773 -: 4583:
6774 8: 4584: s = (char *)(*data);
6775 8: 4585: *data += strlen(s)+1;
6776 8: 4586: so = allocSStringTiny(s);
6777 call 0 returned 100%
6778 8: 4587: sDictPushTiny(dict, key, (smallt *) so);
6779 call 0 returned 100%
6780 -: 4588: // stop unpacking when packCount == 0
6781 8: 4589: packCount--;
6782 8: 4590: if (!packCount) inPack = false;
6783 branch 0 taken 25% (fallthrough)
6784 branch 1 taken 75%
6785 8: 4591: break;
6786 -: 4592: case PK_ARRAY:
6787 8: 4593: if (!inPack) {
6788 branch 0 taken 25% (fallthrough)
6789 branch 1 taken 75%
6790 2: 4594: inPack = true;
6791 2: 4595: if (ctx->nibble == lowNbl) {
6792 branch 0 taken 50% (fallthrough)
6793 branch 1 taken 50%
6794 1: 4596: packCount = netTypeVarintToUint((u8**)data);
6795 call 0 returned 100%
6796 -: 4597: }
6797 -: 4598: else {
6798 -: 4599: // high nibble
6799 1: 4600: readTypeInHighNbl;
6800 branch 0 taken 0% (fallthrough)
6801 branch 1 taken 100%
6802 1: 4601: packCount = varintToUint((u8**)data);
6803 call 0 returned 100%
6804 -: 4602: }
6805 2: 4603: packedType = PK_ARRAY;
6806 -: 4604: }
6807 -: 4605:
6808 8: 4606: a = NULL;
6809 8: 4607: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
6810 call 0 returned 100%
6811 8: 4608: sDictPushTiny(dict, key, (smallt *) a);
6812 call 0 returned 100%
6813 -: 4609: // stop unpacking when packCount == 0
6814 8: 4610: packCount--;
6815 8: 4611: if (!packCount) inPack = false;
6816 branch 0 taken 25% (fallthrough)
6817 branch 1 taken 75%
6818 8: 4612: break;
6819 -: 4613: case PK_BYTES:
6820 #####: 4614: if (!inPack) {
6821 branch 0 never executed
6822 branch 1 never executed
6823 #####: 4615: inPack = true;
6824 #####: 4616: if (ctx->nibble == lowNbl) {
6825 branch 0 never executed
6826 branch 1 never executed
6827 #####: 4617: packCount = netTypeVarintToUint((u8**)data);
6828 call 0 never executed
6829 -: 4618: }
6830 -: 4619: else {
6831 -: 4620: // high nibble
6832 #####: 4621: readTypeInHighNbl;
6833 branch 0 never executed
6834 branch 1 never executed
6835 #####: 4622: packCount = varintToUint((u8**)data);
6836 call 0 never executed
6837 -: 4623: }
6838 #####: 4624: packedType = PK_BYTES;
6839 -: 4625: }
6840 -: 4626:
6841 #####: 4627: B = allocSBytes();
6842 call 0 never executed
6843 #####: 4628: count = varintToUint((u8**)data);
6844 call 0 never executed
6845 #####: 4629: sBytesPushBuffer(&B, *data, count);
6846 call 0 never executed
6847 #####: 4630: *data += count;
6848 #####: 4631: sDictPushTiny(dict, key, (smallt *) B);
6849 call 0 never executed
6850 -: 4632: // stop unpacking when packCount == 0
6851 #####: 4633: packCount--;
6852 #####: 4634: if (!packCount) inPack = false;
6853 branch 0 never executed
6854 branch 1 never executed
6855 #####: 4635: break;
6856 -: 4636: case UNIFORM_DICT:
6857 4: 4637: d = NULL;
6858 4: 4638: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
6859 call 0 returned 100%
6860 4: 4639: sDictPushTiny(dict, key, (smallt *) d);
6861 call 0 returned 100%
6862 4: 4640: break;
6863 -: 4641: case UNIFORM_ARRAY:
6864 4: 4642: a = NULL;
6865 4: 4643: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
6866 call 0 returned 100%
6867 4: 4644: sDictPushTiny(dict, key, (smallt *) a);
6868 call 0 returned 100%
6869 4: 4645: break;
6870 -: 4646: }
6871 -: 4647: }
6872 -: 4648:}
6873 -: 4649:
6874 -: 4650:/**
6875 -: 4651: * deserialize dictionary from data
6876 -: 4652: *
6877 -: 4653: * a new dictionary is allocated
6878 -: 4654: *
6879 -: 4655: * \param
6880 -: 4656: * dict dictionary holding the elements
6881 -: 4657: * data serialized dictionary
6882 -: 4658: */
6883 function uniformDictNetDeserial called 27 returned 100% blocks executed 97%
6884 27: 4659:internal void uniformDictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
6885 27: 4660: sUndefinedt *u = NULL;
6886 27: 4661: sBoolt *bo = NULL;
6887 27: 4662: double *D = NULL;
6888 27: 4663: sDoublet *Do = NULL;
6889 27: 4664: sDictt *d = NULL;
6890 27: 4665: sIntt *io = NULL;
6891 27: 4666: char *s = NULL;
6892 27: 4667: sStringt *so = NULL;
6893 27: 4668: sArrayt *a = NULL;
6894 27: 4669: sBytest *B = NULL;
6895 -: 4670: uint32_t count;
6896 -: 4671: uint32_t dictCount;
6897 -: 4672: u8 type;
6898 -: 4673:
6899 27: 4674: if (packed) {
6900 branch 0 taken 15% (fallthrough)
6901 branch 1 taken 85%
6902 4: 4675: type = (**data) & 0xF;
6903 4: 4676: dictCount = netTypeVarintToUint(data);
6904 call 0 returned 100%
6905 -: 4677: }
6906 -: 4678: else {
6907 23: 4679: if (ctx->nibble == lowNbl) {
6908 branch 0 taken 91% (fallthrough)
6909 branch 1 taken 9%
6910 21: 4680: type = (**data) >> 4;
6911 21: 4681: (*data)++;
6912 21: 4682: dictCount = varintToUint(data);
6913 call 0 returned 100%
6914 -: 4683: }
6915 -: 4684: else {
6916 2: 4685: readTypeInHighNbl;
6917 branch 0 taken 0% (fallthrough)
6918 branch 1 taken 100%
6919 2: 4686: type = (**data) & 0xF;
6920 2: 4687: dictCount = netTypeVarintToUint(data);
6921 call 0 returned 100%
6922 -: 4688: }
6923 -: 4689: }
6924 -: 4690:
6925 27: 4691: if (!dictCount) {
6926 branch 0 taken 7% (fallthrough)
6927 branch 1 taken 93%
6928 2: 4692: *dict = allocSDict();
6929 call 0 returned 100%
6930 29: 4693: ret;
6931 -: 4694: }
6932 -: 4695:
6933 -: 4696:
6934 25: 4697: switch(type) {
6935 branch 0 taken 4%
6936 branch 1 taken 16%
6937 branch 2 taken 4%
6938 branch 3 taken 4%
6939 branch 4 taken 36%
6940 branch 5 taken 20%
6941 branch 6 taken 4%
6942 branch 7 taken 4%
6943 branch 8 taken 4%
6944 branch 9 taken 4%
6945 branch 10 taken 0%
6946 -: 4698: case S_UNDEFINED:
6947 7: 4699: loop(dictCount) {
6948 branch 0 taken 86%
6949 branch 1 taken 14% (fallthrough)
6950 6: 4700: char *key = (char*)*data;
6951 6: 4701: *data += strlen(key)+1;
6952 6: 4702: u = allocSUndefined();
6953 call 0 returned 100%
6954 6: 4703: sDictPushTiny(dict, key, (smallt *) u);
6955 call 0 returned 100%
6956 -: 4704: }
6957 1: 4705: break;
6958 -: 4706: case S_BOOL:
6959 19: 4707: loop(dictCount) {
6960 branch 0 taken 79%
6961 branch 1 taken 21% (fallthrough)
6962 15: 4708: char *key = (char*)*data;
6963 15: 4709: *data += strlen(key)+1;
6964 15: 4710: if (!ctx->boolAddr) {
6965 branch 0 taken 20% (fallthrough)
6966 branch 1 taken 80%
6967 3: 4711: read8bPackedBool;
6968 3: 4712: ctx->boolShift = 0;
6969 -: 4713: }
6970 15: 4714: if (ctx->boolShift == 8) {
6971 branch 0 taken 7% (fallthrough)
6972 branch 1 taken 93%
6973 1: 4715: readTypeInHighNbl;
6974 branch 0 taken 0% (fallthrough)
6975 branch 1 taken 100%
6976 1: 4716: read8bPackedBool;
6977 1: 4717: bo = allocSBool((*ctx->boolAddr) & 0x1);
6978 call 0 returned 100%
6979 -: 4718: }
6980 -: 4719: else {
6981 -: 4720: // high nibble
6982 14: 4721: readTypeInHighNbl;
6983 branch 0 taken 0% (fallthrough)
6984 branch 1 taken 100%
6985 14: 4722: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
6986 call 0 returned 100%
6987 -: 4723: }
6988 15: 4724: sDictPushTiny(dict, key, (smallt *) bo);
6989 call 0 returned 100%
6990 -: 4725: }
6991 4: 4726: break;
6992 -: 4727: case S_DICT:
6993 3: 4728: loop(dictCount) {
6994 branch 0 taken 67%
6995 branch 1 taken 33% (fallthrough)
6996 2: 4729: char *key = (char*)*data;
6997 2: 4730: *data += strlen(key)+1;
6998 2: 4731: d = NULL;
6999 2: 4732: dictNetDeserial(&d, data, ctx, /*packed=*/true);
7000 call 0 returned 100%
7001 2: 4733: sDictPushTiny(dict, key, (smallt *) d);
7002 call 0 returned 100%
7003 -: 4734: }
7004 1: 4735: break;
7005 -: 4736: case S_DOUBLE:
7006 4: 4737: loop(dictCount) {
7007 branch 0 taken 75%
7008 branch 1 taken 25% (fallthrough)
7009 3: 4738: char *key = (char*)*data;
7010 3: 4739: *data += strlen(key)+1;
7011 3: 4740: D = (double *)(*data);
7012 3: 4741: *data += sizeof(double);
7013 3: 4742: Do = allocSDouble(*D);
7014 call 0 returned 100%
7015 3: 4743: sDictPushTiny(dict, key, (smallt *) Do);
7016 call 0 returned 100%
7017 -: 4744: }
7018 1: 4745: break;
7019 -: 4746: case S_INT:
7020 21: 4747: loop(dictCount) {
7021 branch 0 taken 57%
7022 branch 1 taken 43% (fallthrough)
7023 12: 4748: char *key = (char*)*data;
7024 12: 4749: *data += strlen(key)+1;
7025 12: 4750: u64 v = varintToUint(data);
7026 call 0 returned 100%
7027 12: 4751: v = (v >> 1) ^ (~(v & 1) + 1);
7028 12: 4752: io = allocSInt(v);
7029 call 0 returned 100%
7030 12: 4753: sDictPushTiny(dict, key, (smallt *) io);
7031 call 0 returned 100%
7032 -: 4754: }
7033 9: 4755: break;
7034 -: 4756: case S_STRING:
7035 16: 4757: loop(dictCount) {
7036 branch 0 taken 69%
7037 branch 1 taken 31% (fallthrough)
7038 11: 4758: char *key = (char*)*data;
7039 11: 4759: *data += strlen(key)+1;
7040 11: 4760: s = (char *)(*data);
7041 11: 4761: *data += strlen(s)+1;
7042 11: 4762: so = allocSStringTiny(s);
7043 call 0 returned 100%
7044 11: 4763: sDictPushTiny(dict, key, (smallt *) so);
7045 call 0 returned 100%
7046 -: 4764: }
7047 5: 4765: break;
7048 -: 4766: case S_ARRAY:
7049 2: 4767: loop(dictCount) {
7050 branch 0 taken 50%
7051 branch 1 taken 50% (fallthrough)
7052 1: 4768: char *key = (char*)*data;
7053 1: 4769: *data += strlen(key)+1;
7054 1: 4770: a = NULL;
7055 1: 4771: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
7056 call 0 returned 100%
7057 1: 4772: sDictPushTiny(dict, key, (smallt *) a);
7058 call 0 returned 100%
7059 -: 4773: }
7060 1: 4774: break;
7061 -: 4775: case S_BYTES:
7062 3: 4776: loop(dictCount) {
7063 branch 0 taken 67%
7064 branch 1 taken 33% (fallthrough)
7065 2: 4777: char *key = (char*)*data;
7066 2: 4778: *data += strlen(key)+1;
7067 2: 4779: B = allocSBytes();
7068 call 0 returned 100%
7069 2: 4780: count = varintToUint((u8**)data);
7070 call 0 returned 100%
7071 2: 4781: sBytesPushBuffer(&B, *data, count);
7072 call 0 returned 100%
7073 2: 4782: *data += count;
7074 2: 4783: sDictPushTiny(dict, key, (smallt *) B);
7075 call 0 returned 100%
7076 -: 4784: }
7077 1: 4785: break;
7078 -: 4786: case UNIFORM_DICT:
7079 3: 4787: loop(dictCount) {
7080 branch 0 taken 67%
7081 branch 1 taken 33% (fallthrough)
7082 2: 4788: char *key = (char*)*data;
7083 2: 4789: *data += strlen(key)+1;
7084 2: 4790: d = NULL;
7085 2: 4791: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
7086 call 0 returned 100%
7087 2: 4792: sDictPushTiny(dict, key, (smallt *) d);
7088 call 0 returned 100%
7089 -: 4793: }
7090 1: 4794: break;
7091 -: 4795: case UNIFORM_ARRAY:
7092 2: 4796: loop(dictCount) {
7093 branch 0 taken 50%
7094 branch 1 taken 50% (fallthrough)
7095 1: 4797: char *key = (char*)*data;
7096 1: 4798: *data += strlen(key)+1;
7097 1: 4799: a = NULL;
7098 1: 4800: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
7099 call 0 returned 100%
7100 1: 4801: sDictPushTiny(dict, key, (smallt *) a);
7101 call 0 returned 100%
7102 -: 4802: }
7103 1: 4803: break;
7104 -: 4804: }
7105 -: 4805:}
7106 -: 4806:
7107 -: 4807:/**
7108 -: 4808: * deserialize array from data
7109 -: 4809: *
7110 -: 4810: * a new array is allocated
7111 -: 4811: *
7112 -: 4812: * \param
7113 -: 4813: * array holding the elements
7114 -: 4814: * data serialized dictionary
7115 -: 4815: */
7116 function arrayNetDeserial called 53 returned 100% blocks executed 84%
7117 53: 4816:internal void arrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
7118 53: 4817: sUndefinedt *u = NULL;
7119 53: 4818: sBoolt *bo = NULL;
7120 53: 4819: double *D = NULL;
7121 53: 4820: sDoublet *Do = NULL;
7122 53: 4821: sDictt *d = NULL;
7123 53: 4822: sIntt *io = NULL;
7124 53: 4823: char *s = NULL;
7125 53: 4824: sStringt *so = NULL;
7126 53: 4825: sArrayt *a = NULL;
7127 53: 4826: sBytest *B = NULL;
7128 -: 4827: uint32_t count;
7129 -: 4828: uint32_t arrayCount;
7130 -: 4829:
7131 53: 4830: if (packed) {
7132 branch 0 taken 42% (fallthrough)
7133 branch 1 taken 58%
7134 22: 4831: arrayCount = varintToUint(data);
7135 call 0 returned 100%
7136 -: 4832: }
7137 -: 4833: else {
7138 31: 4834: if (ctx->nibble == lowNbl) {
7139 branch 0 taken 90% (fallthrough)
7140 branch 1 taken 10%
7141 28: 4835: arrayCount = netTypeVarintToUint(data);
7142 call 0 returned 100%
7143 -: 4836: }
7144 -: 4837: else {
7145 -: 4838: // high nibble
7146 3: 4839: readTypeInHighNbl;
7147 branch 0 taken 0% (fallthrough)
7148 branch 1 taken 100%
7149 3: 4840: arrayCount = varintToUint(data);
7150 call 0 returned 100%
7151 -: 4841: }
7152 -: 4842: }
7153 -: 4843:
7154 53: 4844: if (!arrayCount) {
7155 branch 0 taken 4% (fallthrough)
7156 branch 1 taken 96%
7157 2: 4845: *array = allocSArray();;
7158 call 0 returned 100%
7159 55: 4846: ret;
7160 -: 4847: }
7161 -: 4848:
7162 51: 4849: bool inPack = false;
7163 -: 4850: u8 packedType;
7164 -: 4851: size_t packCount;
7165 216: 4852: loop(arrayCount) {
7166 branch 0 taken 76%
7167 branch 1 taken 24% (fallthrough)
7168 -: 4853: char type;
7169 165: 4854: if (inPack) {
7170 branch 0 taken 18% (fallthrough)
7171 branch 1 taken 82%
7172 30: 4855: type = packedType;
7173 -: 4856: }
7174 -: 4857: else {
7175 135: 4858: if (ctx->nibble == lowNbl) {
7176 branch 0 taken 73% (fallthrough)
7177 branch 1 taken 27%
7178 99: 4859: type = (**data) & 0xF;
7179 -: 4860: }
7180 -: 4861: else {
7181 -: 4862: // high nibble
7182 36: 4863: type = (*ctx->nblAddr) >> 4;
7183 -: 4864: }
7184 -: 4865: }
7185 -: 4866:
7186 165: 4867: switch(type) {
7187 branch 0 taken 18%
7188 branch 1 taken 22%
7189 branch 2 taken 1%
7190 branch 3 taken 1%
7191 branch 4 taken 17%
7192 branch 5 taken 8%
7193 branch 6 taken 1%
7194 branch 7 taken 1%
7195 branch 8 taken 5%
7196 branch 9 taken 5%
7197 branch 10 taken 5%
7198 branch 11 taken 5%
7199 branch 12 taken 5%
7200 branch 13 taken 0%
7201 branch 14 taken 3%
7202 branch 15 taken 4%
7203 branch 16 taken 0%
7204 -: 4868: case S_UNDEFINED:
7205 29: 4869: if (ctx->nibble == lowNbl) {
7206 branch 0 taken 93% (fallthrough)
7207 branch 1 taken 7%
7208 27: 4870: readTypeOnly;
7209 -: 4871: }
7210 -: 4872: else {
7211 -: 4873: // high nibble
7212 2: 4874: readTypeInHighNbl;
7213 branch 0 taken 0% (fallthrough)
7214 branch 1 taken 100%
7215 -: 4875: }
7216 29: 4876: u = allocSUndefined();
7217 call 0 returned 100%
7218 29: 4877: sArrayPushTiny(array, (smallt *) u);
7219 call 0 returned 100%
7220 29: 4878: break;
7221 -: 4879: case S_BOOL:
7222 36: 4880: if (!ctx->boolAddr) {
7223 branch 0 taken 22% (fallthrough)
7224 branch 1 taken 78%
7225 -: 4881: // new packed bools
7226 8: 4882: if (ctx->nibble == lowNbl) {
7227 branch 0 taken 63% (fallthrough)
7228 branch 1 taken 38%
7229 5: 4883: read4bPackedBool;
7230 5: 4884: bo = allocSBool((*ctx->boolAddr) & 0x10);
7231 call 0 returned 100%
7232 -: 4885: }
7233 -: 4886: else {
7234 -: 4887: // high nibble
7235 3: 4888: readTypeInHighNbl;
7236 branch 0 taken 0% (fallthrough)
7237 branch 1 taken 100%
7238 3: 4889: read8bPackedBool;
7239 3: 4890: bo = allocSBool((*ctx->boolAddr) & 0x1);
7240 call 0 returned 100%
7241 -: 4891: }
7242 -: 4892: }
7243 -: 4893: else {
7244 -: 4894: // there was a bool before this one, read bits in nibbles
7245 28: 4895: if (ctx->nibble == lowNbl) {
7246 branch 0 taken 61% (fallthrough)
7247 branch 1 taken 39%
7248 17: 4896: if (ctx->boolShift == 8) {
7249 branch 0 taken 12% (fallthrough)
7250 branch 1 taken 88%
7251 2: 4897: read4bPackedBool;
7252 2: 4898: bo = allocSBool((*ctx->boolAddr) & 0x10);
7253 call 0 returned 100%
7254 -: 4899: }
7255 -: 4900: else {
7256 15: 4901: readTypeOnly;
7257 15: 4902: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
7258 call 0 returned 100%
7259 -: 4903: }
7260 -: 4904: }
7261 -: 4905: else {
7262 -: 4906: // high nibble
7263 11: 4907: readTypeInHighNbl;
7264 branch 0 taken 0% (fallthrough)
7265 branch 1 taken 100%
7266 11: 4908: if (ctx->boolShift == 8) {
7267 branch 0 taken 18% (fallthrough)
7268 branch 1 taken 82%
7269 2: 4909: read8bPackedBool;
7270 2: 4910: bo = allocSBool((*ctx->boolAddr) & 0x1);
7271 call 0 returned 100%
7272 -: 4911: }
7273 -: 4912: else {
7274 9: 4913: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
7275 call 0 returned 100%
7276 -: 4914: }
7277 -: 4915: }
7278 -: 4916: }
7279 36: 4917: sArrayPushTiny(array, (smallt *) bo);
7280 call 0 returned 100%
7281 36: 4918: break;
7282 -: 4919: case S_DICT:
7283 2: 4920: d = NULL;
7284 2: 4921: dictNetDeserial(&d, data, ctx, /*packed=*/false);
7285 call 0 returned 100%
7286 2: 4922: sArrayPushTiny(array, (smallt *) d);
7287 call 0 returned 100%
7288 2: 4923: break;
7289 -: 4924: case S_DOUBLE:
7290 2: 4925: if (ctx->nibble == lowNbl) {
7291 branch 0 taken 50% (fallthrough)
7292 branch 1 taken 50%
7293 1: 4926: readTypeOnly;
7294 -: 4927: }
7295 -: 4928: else {
7296 -: 4929: // high nibble
7297 1: 4930: readTypeInHighNbl;
7298 branch 0 taken 0% (fallthrough)
7299 branch 1 taken 100%
7300 -: 4931: }
7301 2: 4932: D = (double *)(*data);
7302 2: 4933: *data += sizeof(double);
7303 2: 4934: Do = allocSDouble(*D);
7304 call 0 returned 100%
7305 2: 4935: sArrayPushTiny(array, (smallt *) Do);
7306 call 0 returned 100%
7307 2: 4936: break;
7308 -: 4937: case S_INT: {
7309 -: 4938: u64 v;
7310 28: 4939: if (ctx->nibble == lowNbl) {
7311 branch 0 taken 86% (fallthrough)
7312 branch 1 taken 14%
7313 24: 4940: v = netTypeVarintToUint((u8**)data);
7314 call 0 returned 100%
7315 -: 4941: }
7316 -: 4942: else {
7317 -: 4943: // high nibble
7318 4: 4944: readTypeInHighNbl;
7319 branch 0 taken 0% (fallthrough)
7320 branch 1 taken 100%
7321 4: 4945: v = varintToUint(data);
7322 call 0 returned 100%
7323 -: 4946: }
7324 28: 4947: v = (v >> 1) ^ (~(v & 1) + 1);
7325 28: 4948: io = allocSInt(v);
7326 call 0 returned 100%
7327 28: 4949: sArrayPushTiny(array, (smallt *) io);
7328 call 0 returned 100%
7329 -: 4950: }
7330 28: 4951: break;
7331 -: 4952: case S_STRING:
7332 13: 4953: if (ctx->nibble == lowNbl) {
7333 branch 0 taken 69% (fallthrough)
7334 branch 1 taken 31%
7335 9: 4954: readTypeOnly;
7336 -: 4955: }
7337 -: 4956: else {
7338 -: 4957: // high nibble
7339 4: 4958: readTypeInHighNbl;
7340 branch 0 taken 0% (fallthrough)
7341 branch 1 taken 100%
7342 -: 4959: }
7343 13: 4960: s = (char *)(*data);
7344 13: 4961: *data += strlen(s)+1;
7345 13: 4962: so = allocSStringTiny(s);
7346 call 0 returned 100%
7347 13: 4963: sArrayPushTiny(array, (smallt *) so);
7348 call 0 returned 100%
7349 13: 4964: break;
7350 -: 4965: case S_ARRAY:
7351 2: 4966: a = NULL;
7352 2: 4967: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
7353 call 0 returned 100%
7354 2: 4968: sArrayPushTiny(array, (smallt *) a);
7355 call 0 returned 100%
7356 2: 4969: break;
7357 -: 4970: case S_BYTES:
7358 2: 4971: B = allocSBytes();
7359 call 0 returned 100%
7360 2: 4972: if (ctx->nibble == lowNbl) {
7361 branch 0 taken 50% (fallthrough)
7362 branch 1 taken 50%
7363 1: 4973: count = netTypeVarintToUint((u8**)data);
7364 call 0 returned 100%
7365 -: 4974: }
7366 -: 4975: else {
7367 -: 4976: // high nibble
7368 1: 4977: readTypeInHighNbl;
7369 branch 0 taken 0% (fallthrough)
7370 branch 1 taken 100%
7371 1: 4978: count = varintToUint((u8**)data);
7372 call 0 returned 100%
7373 -: 4979: }
7374 2: 4980: sBytesPushBuffer(&B, *data, count);
7375 call 0 returned 100%
7376 2: 4981: *data += count;
7377 2: 4982: sArrayPushTiny(array, (smallt *) B);
7378 call 0 returned 100%
7379 2: 4983: break;
7380 -: 4984: case PK_DICT:
7381 8: 4985: if (!inPack) {
7382 branch 0 taken 25% (fallthrough)
7383 branch 1 taken 75%
7384 2: 4986: inPack = true;
7385 2: 4987: if (ctx->nibble == lowNbl) {
7386 branch 0 taken 50% (fallthrough)
7387 branch 1 taken 50%
7388 1: 4988: packCount = netTypeVarintToUint((u8**)data);
7389 call 0 returned 100%
7390 -: 4989: }
7391 -: 4990: else {
7392 -: 4991: // high nibble
7393 1: 4992: readTypeInHighNbl;
7394 branch 0 taken 0% (fallthrough)
7395 branch 1 taken 100%
7396 1: 4993: packCount = varintToUint((u8**)data);
7397 call 0 returned 100%
7398 -: 4994: }
7399 2: 4995: packedType = PK_DICT;
7400 -: 4996: }
7401 -: 4997:
7402 8: 4998: d = NULL;
7403 8: 4999: dictNetDeserial(&d, data, ctx, /*packed=*/true);
7404 call 0 returned 100%
7405 8: 5000: sArrayPushTiny(array, (smallt *) d);
7406 call 0 returned 100%
7407 -: 5001: // stop unpacking when packCount == 0
7408 8: 5002: packCount--;
7409 8: 5003: if (!packCount) inPack = false;
7410 branch 0 taken 25% (fallthrough)
7411 branch 1 taken 75%
7412 8: 5004: break;
7413 -: 5005: case PK_DOUBLE:
7414 8: 5006: if (!inPack) {
7415 branch 0 taken 25% (fallthrough)
7416 branch 1 taken 75%
7417 2: 5007: inPack = true;
7418 2: 5008: if (ctx->nibble == lowNbl) {
7419 branch 0 taken 50% (fallthrough)
7420 branch 1 taken 50%
7421 1: 5009: packCount = netTypeVarintToUint((u8**)data);
7422 call 0 returned 100%
7423 -: 5010: }
7424 -: 5011: else {
7425 -: 5012: // high nibble
7426 1: 5013: readTypeInHighNbl;
7427 branch 0 taken 0% (fallthrough)
7428 branch 1 taken 100%
7429 1: 5014: packCount = varintToUint((u8**)data);
7430 call 0 returned 100%
7431 -: 5015: }
7432 2: 5016: packedType = PK_DOUBLE;
7433 -: 5017: }
7434 -: 5018:
7435 8: 5019: D = (double *)(*data);
7436 8: 5020: *data += sizeof(double);
7437 8: 5021: Do = allocSDouble(*D);
7438 call 0 returned 100%
7439 8: 5022: sArrayPushTiny(array, (smallt *) Do);
7440 call 0 returned 100%
7441 -: 5023: // stop unpacking when packCount == 0
7442 8: 5024: packCount--;
7443 8: 5025: if (!packCount) inPack = false;
7444 branch 0 taken 25% (fallthrough)
7445 branch 1 taken 75%
7446 8: 5026: break;
7447 -: 5027: case PK_INT:
7448 8: 5028: if (!inPack) {
7449 branch 0 taken 25% (fallthrough)
7450 branch 1 taken 75%
7451 2: 5029: inPack = true;
7452 2: 5030: if (ctx->nibble == lowNbl) {
7453 branch 0 taken 50% (fallthrough)
7454 branch 1 taken 50%
7455 1: 5031: packCount = netTypeVarintToUint((u8**)data);
7456 call 0 returned 100%
7457 -: 5032: }
7458 -: 5033: else {
7459 -: 5034: // high nibble
7460 1: 5035: readTypeInHighNbl;
7461 branch 0 taken 0% (fallthrough)
7462 branch 1 taken 100%
7463 1: 5036: packCount = varintToUint((u8**)data);
7464 call 0 returned 100%
7465 -: 5037: }
7466 2: 5038: packedType = PK_INT;
7467 -: 5039: }
7468 -: 5040:
7469 8: 5041: u64 v = varintToUint(data);
7470 call 0 returned 100%
7471 8: 5042: v = (v >> 1) ^ (~(v & 1) + 1);
7472 8: 5043: io = allocSInt(v);
7473 call 0 returned 100%
7474 8: 5044: sArrayPushTiny(array, (smallt *) io);
7475 call 0 returned 100%
7476 -: 5045: // stop unpacking when packCount == 0
7477 8: 5046: packCount--;
7478 8: 5047: if (!packCount) inPack = false;
7479 branch 0 taken 25% (fallthrough)
7480 branch 1 taken 75%
7481 8: 5048: break;
7482 -: 5049: case PK_STRING:
7483 8: 5050: if (!inPack) {
7484 branch 0 taken 25% (fallthrough)
7485 branch 1 taken 75%
7486 2: 5051: inPack = true;
7487 2: 5052: if (ctx->nibble == lowNbl) {
7488 branch 0 taken 50% (fallthrough)
7489 branch 1 taken 50%
7490 1: 5053: packCount = netTypeVarintToUint((u8**)data);
7491 call 0 returned 100%
7492 -: 5054: }
7493 -: 5055: else {
7494 -: 5056: // high nibble
7495 1: 5057: readTypeInHighNbl;
7496 branch 0 taken 0% (fallthrough)
7497 branch 1 taken 100%
7498 1: 5058: packCount = varintToUint((u8**)data);
7499 call 0 returned 100%
7500 -: 5059: }
7501 2: 5060: packedType = PK_STRING;
7502 -: 5061: }
7503 -: 5062:
7504 8: 5063: s = (char *)(*data);
7505 8: 5064: *data += strlen(s)+1;
7506 8: 5065: so = allocSStringTiny(s);
7507 call 0 returned 100%
7508 8: 5066: sArrayPushTiny(array, (smallt *) so);
7509 call 0 returned 100%
7510 -: 5067: // stop unpacking when packCount == 0
7511 8: 5068: packCount--;
7512 8: 5069: if (!packCount) inPack = false;
7513 branch 0 taken 25% (fallthrough)
7514 branch 1 taken 75%
7515 8: 5070: break;
7516 -: 5071: case PK_ARRAY:
7517 8: 5072: if (!inPack) {
7518 branch 0 taken 25% (fallthrough)
7519 branch 1 taken 75%
7520 2: 5073: inPack = true;
7521 2: 5074: if (ctx->nibble == lowNbl) {
7522 branch 0 taken 50% (fallthrough)
7523 branch 1 taken 50%
7524 1: 5075: packCount = netTypeVarintToUint((u8**)data);
7525 call 0 returned 100%
7526 -: 5076: }
7527 -: 5077: else {
7528 -: 5078: // high nibble
7529 1: 5079: readTypeInHighNbl;
7530 branch 0 taken 0% (fallthrough)
7531 branch 1 taken 100%
7532 1: 5080: packCount = varintToUint((u8**)data);
7533 call 0 returned 100%
7534 -: 5081: }
7535 2: 5082: packedType = PK_ARRAY;
7536 -: 5083: }
7537 -: 5084:
7538 8: 5085: a = NULL;
7539 8: 5086: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
7540 call 0 returned 100%
7541 8: 5087: sArrayPushTiny(array, (smallt *) a);
7542 call 0 returned 100%
7543 -: 5088: // stop unpacking when packCount == 0
7544 8: 5089: packCount--;
7545 8: 5090: if (!packCount) inPack = false;
7546 branch 0 taken 25% (fallthrough)
7547 branch 1 taken 75%
7548 8: 5091: break;
7549 -: 5092: case PK_BYTES:
7550 #####: 5093: if (!inPack) {
7551 branch 0 never executed
7552 branch 1 never executed
7553 #####: 5094: inPack = true;
7554 #####: 5095: if (ctx->nibble == lowNbl) {
7555 branch 0 never executed
7556 branch 1 never executed
7557 #####: 5096: packCount = netTypeVarintToUint((u8**)data);
7558 call 0 never executed
7559 -: 5097: }
7560 -: 5098: else {
7561 -: 5099: // high nibble
7562 #####: 5100: readTypeInHighNbl;
7563 branch 0 never executed
7564 branch 1 never executed
7565 #####: 5101: packCount = varintToUint((u8**)data);
7566 call 0 never executed
7567 -: 5102: }
7568 #####: 5103: packedType = PK_BYTES;
7569 -: 5104: }
7570 -: 5105:
7571 #####: 5106: B = allocSBytes();
7572 call 0 never executed
7573 #####: 5107: count = varintToUint((u8**)data);
7574 call 0 never executed
7575 #####: 5108: sBytesPushBuffer(&B, *data, count);
7576 call 0 never executed
7577 #####: 5109: *data += count;
7578 #####: 5110: sArrayPushTiny(array, (smallt *) B);
7579 call 0 never executed
7580 -: 5111: // stop unpacking when packCount == 0
7581 #####: 5112: packCount--;
7582 #####: 5113: if (!packCount) inPack = false;
7583 branch 0 never executed
7584 branch 1 never executed
7585 #####: 5114: break;
7586 -: 5115: case UNIFORM_DICT:
7587 5: 5116: d = NULL;
7588 5: 5117: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
7589 call 0 returned 100%
7590 5: 5118: sArrayPushTiny(array, (smallt *) d);
7591 call 0 returned 100%
7592 5: 5119: break;
7593 -: 5120: case UNIFORM_ARRAY:
7594 6: 5121: a = NULL;
7595 6: 5122: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
7596 call 0 returned 100%
7597 6: 5123: sArrayPushTiny(array, (smallt *) a);
7598 call 0 returned 100%
7599 6: 5124: break;
7600 -: 5125: }
7601 -: 5126: }
7602 -: 5127:}
7603 -: 5128:
7604 function uniformArrayNetDeserial called 25 returned 100% blocks executed 99%
7605 25: 5129:internal void uniformArrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
7606 25: 5130: sUndefinedt *u = NULL;
7607 25: 5131: sBoolt *bo = NULL;
7608 25: 5132: double *D = NULL;
7609 25: 5133: sDoublet *Do = NULL;
7610 25: 5134: sDictt *d = NULL;
7611 25: 5135: sIntt *io = NULL;
7612 25: 5136: char *s = NULL;
7613 25: 5137: sStringt *so = NULL;
7614 25: 5138: sArrayt *a = NULL;
7615 25: 5139: sBytest *B = NULL;
7616 -: 5140: uint32_t count;
7617 -: 5141: uint32_t arrayCount;
7618 -: 5142: u8 type;
7619 -: 5143:
7620 25: 5144: if (packed) {
7621 branch 0 taken 8% (fallthrough)
7622 branch 1 taken 92%
7623 2: 5145: type = (**data) & 0xF;
7624 2: 5146: arrayCount = netTypeVarintToUint(data);
7625 call 0 returned 100%
7626 -: 5147: }
7627 -: 5148: else {
7628 23: 5149: if (ctx->nibble == lowNbl) {
7629 branch 0 taken 78% (fallthrough)
7630 branch 1 taken 22%
7631 18: 5150: type = (**data) >> 4;
7632 18: 5151: (*data)++;
7633 18: 5152: arrayCount = varintToUint(data);
7634 call 0 returned 100%
7635 -: 5153: }
7636 -: 5154: else {
7637 5: 5155: readTypeInHighNbl;
7638 branch 0 taken 0% (fallthrough)
7639 branch 1 taken 100%
7640 5: 5156: type = (**data) & 0xF;
7641 5: 5157: arrayCount = netTypeVarintToUint(data);
7642 call 0 returned 100%
7643 -: 5158: }
7644 -: 5159: }
7645 -: 5160:
7646 25: 5161: if (!arrayCount) {
7647 branch 0 taken 8% (fallthrough)
7648 branch 1 taken 92%
7649 2: 5162: *array = allocSArray();;
7650 call 0 returned 100%
7651 27: 5163: ret;
7652 -: 5164: }
7653 -: 5165:
7654 23: 5166: switch(type) {
7655 branch 0 taken 4%
7656 branch 1 taken 9%
7657 branch 2 taken 4%
7658 branch 3 taken 4%
7659 branch 4 taken 48%
7660 branch 5 taken 4%
7661 branch 6 taken 13%
7662 branch 7 taken 4%
7663 branch 8 taken 4%
7664 branch 9 taken 4%
7665 branch 10 taken 0%
7666 -: 5167: case S_UNDEFINED:
7667 7: 5168: loop(arrayCount) {
7668 branch 0 taken 86%
7669 branch 1 taken 14% (fallthrough)
7670 6: 5169: u = allocSUndefined();
7671 call 0 returned 100%
7672 6: 5170: sArrayPushTiny(array, (smallt *) u);
7673 call 0 returned 100%
7674 -: 5171: }
7675 1: 5172: break;
7676 -: 5173: case S_BOOL:
7677 16: 5174: loop(arrayCount) {
7678 branch 0 taken 88%
7679 branch 1 taken 13% (fallthrough)
7680 14: 5175: if (!ctx->boolAddr) {
7681 branch 0 taken 14% (fallthrough)
7682 branch 1 taken 86%
7683 2: 5176: read8bPackedBool;
7684 2: 5177: ctx->boolShift = 0;
7685 -: 5178: }
7686 14: 5179: if (ctx->boolShift == 8) {
7687 branch 0 taken 7% (fallthrough)
7688 branch 1 taken 93%
7689 1: 5180: read8bPackedBool;
7690 1: 5181: bo = allocSBool((*ctx->boolAddr) & 0x1);
7691 call 0 returned 100%
7692 -: 5182: }
7693 -: 5183: else {
7694 13: 5184: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
7695 call 0 returned 100%
7696 -: 5185: }
7697 14: 5186: sArrayPushTiny(array, (smallt *) bo);
7698 call 0 returned 100%
7699 -: 5187: }
7700 2: 5188: break;
7701 -: 5189: case S_DICT:
7702 3: 5190: loop(arrayCount) {
7703 branch 0 taken 67%
7704 branch 1 taken 33% (fallthrough)
7705 2: 5191: d = NULL;
7706 2: 5192: dictNetDeserial(&d, data, ctx, /*packed=*/true);
7707 call 0 returned 100%
7708 2: 5193: sArrayPushTiny(array, (smallt *) d);
7709 call 0 returned 100%
7710 -: 5194: }
7711 1: 5195: break;
7712 -: 5196: case S_DOUBLE:
7713 4: 5197: loop(arrayCount) {
7714 branch 0 taken 75%
7715 branch 1 taken 25% (fallthrough)
7716 3: 5198: D = (double *)(*data);
7717 3: 5199: *data += sizeof(double);
7718 3: 5200: Do = allocSDouble(*D);
7719 call 0 returned 100%
7720 3: 5201: sArrayPushTiny(array, (smallt *) Do);
7721 call 0 returned 100%
7722 -: 5202: }
7723 1: 5203: break;
7724 -: 5204: case S_INT:
7725 49: 5205: loop(arrayCount) {
7726 branch 0 taken 78%
7727 branch 1 taken 22% (fallthrough)
7728 38: 5206: u64 v = varintToUint(data);
7729 call 0 returned 100%
7730 38: 5207: v = (v >> 1) ^ (~(v & 1) + 1);
7731 38: 5208: io = allocSInt(v);
7732 call 0 returned 100%
7733 38: 5209: sArrayPushTiny(array, (smallt *) io);
7734 call 0 returned 100%
7735 -: 5210: }
7736 11: 5211: break;
7737 -: 5212: case S_STRING:
7738 4: 5213: loop(arrayCount) {
7739 branch 0 taken 75%
7740 branch 1 taken 25% (fallthrough)
7741 3: 5214: s = (char *)(*data);
7742 3: 5215: *data += strlen(s)+1;
7743 3: 5216: so = allocSStringTiny(s);
7744 call 0 returned 100%
7745 3: 5217: sArrayPushTiny(array, (smallt *) so);
7746 call 0 returned 100%
7747 -: 5218: }
7748 1: 5219: break;
7749 -: 5220: case S_ARRAY:
7750 8: 5221: loop(arrayCount) {
7751 branch 0 taken 63%
7752 branch 1 taken 38% (fallthrough)
7753 5: 5222: a = NULL;
7754 5: 5223: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
7755 call 0 returned 100%
7756 5: 5224: sArrayPushTiny(array, (smallt *) a);
7757 call 0 returned 100%
7758 -: 5225: }
7759 3: 5226: break;
7760 -: 5227: case S_BYTES:
7761 3: 5228: loop(arrayCount) {
7762 branch 0 taken 67%
7763 branch 1 taken 33% (fallthrough)
7764 2: 5229: B = allocSBytes();
7765 call 0 returned 100%
7766 2: 5230: count = varintToUint((u8**)data);
7767 call 0 returned 100%
7768 2: 5231: sBytesPushBuffer(&B, *data, count);
7769 call 0 returned 100%
7770 2: 5232: *data += count;
7771 2: 5233: sArrayPushTiny(array, (smallt *) B);
7772 call 0 returned 100%
7773 -: 5234: }
7774 1: 5235: break;
7775 -: 5236: case UNIFORM_DICT:
7776 3: 5237: loop(arrayCount) {
7777 branch 0 taken 67%
7778 branch 1 taken 33% (fallthrough)
7779 2: 5238: d = NULL;
7780 2: 5239: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
7781 call 0 returned 100%
7782 2: 5240: sArrayPushTiny(array, (smallt *) d);
7783 call 0 returned 100%
7784 -: 5241: }
7785 1: 5242: break;
7786 -: 5243: case UNIFORM_ARRAY:
7787 2: 5244: loop(arrayCount) {
7788 branch 0 taken 50%
7789 branch 1 taken 50% (fallthrough)
7790 1: 5245: a = NULL;
7791 1: 5246: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
7792 call 0 returned 100%
7793 1: 5247: sArrayPushTiny(array, (smallt *) a);
7794 call 0 returned 100%
7795 -: 5248: }
7796 1: 5249: break;
7797 -: 5250: }
7798 -: 5251:}
7799 -: 5252:
7800 function deserialNetSerial called 87 returned 100% blocks executed 91%
7801 87: 5253:internal smallJsont* deserialNetSerial(smallJsont *self, smallBytest *data) {
7802 -: 5254:
7803 87: 5255: if (!data or !data->B or !data->B->count) {
7804 branch 0 taken 100% (fallthrough)
7805 branch 1 taken 0%
7806 branch 2 taken 100% (fallthrough)
7807 branch 3 taken 0%
7808 branch 4 taken 1% (fallthrough)
7809 branch 5 taken 99%
7810 1: 5256: ret self;
7811 -: 5257: }
7812 -: 5258:
7813 86: 5259: smallt *o = netDeserial(data->B);
7814 call 0 returned 100%
7815 -: 5260:
7816 86: 5261: if (!o) {
7817 branch 0 taken 0% (fallthrough)
7818 branch 1 taken 100%
7819 #####: 5262: ret self;
7820 -: 5263: }
7821 -: 5264:
7822 86: 5265: freeG(self);
7823 call 0 returned 100%
7824 -: 5266:
7825 86: 5267: setsoG(self, o);
7826 call 0 returned 100%
7827 -: 5268:
7828 86: 5269: ret self;
7829 -: 5270:}
7830 -: 5271:
7831 -: 5272:// vim: set expandtab ts=2 sw=2:
7832 -: 5273:
7833 function checkLibsheepyVersionNetSerial called 0 returned 0% blocks executed 0%
7834 #####: 5274:bool checkLibsheepyVersionNetSerial(const char *currentLibsheepyVersion) {
7835 #####: 5275: return eqG(currentLibsheepyVersion, LIBSHEEPY_VERSION);
7836 call 0 never executed
7837 -: 5276:}
7838 -: 5277: