commit 73a72747443a0da6a7547bac9579fd9c3c1a6b77
parent 4218bf0f6d62f672f52067ec6d8594c111fb7c99
Author: Remy Noulin <loader2x@gmail.com>
Date: Sun, 28 Oct 2018 20:58:46 -0400
fix bug in the code packing the elements in arrays and dicts
memcheckNetSerial.c | 14 +
netSerial.c | 4 +-
netSerial.c.gcov | 10900 +++++++++++++++++++++++++-------------------------
package.yml | 2 +-
testNetSerial.c | 14 +
testNetSerial.sh | 4 +-
6 files changed, 5520 insertions(+), 5418 deletions(-)
Diffstat:
6 files changed, 5520 insertions(+), 5418 deletions(-)
diff --git a/memcheckNetSerial.c b/memcheckNetSerial.c
@@ -1519,6 +1519,20 @@ void variousT(void) {
terminateG(B);
freeManyG(&n, &ds);
+ parseG(&n, "[[{a:1}, null, {a:1}, {a:1}]]");
+ logVarG(&n);
+ B = serialG(&n);
+ logI("len %u", lenG(B));
+ logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
+ s = sToString((smallt *) B->B);
+ ck_assert_str_eq(s, "[111,1,4,78,1,97,0,2,-32,20,97,0,2,78,1,97,0,2]");
+ free(s);
+ deserialG(&ds, B);
+ s = toStringG(&ds);
+ ck_assert_str_eq(s, "[[{\"a\":1},null,{\"a\":1},{\"a\":1}]]");
+ free(s);
+ terminateG(B);
+ freeManyG(&n, &ds);
}
diff --git a/netSerial.c b/netSerial.c
@@ -1978,7 +1978,7 @@ internal void dictNetSerial(sBytest **r, sDictt *dict, contextt *ctx, packingT p
or e->data->type == BYTES) {
type = e->data->type;
packCount = 1;
- sDictElemt *element = &((dict)->elements) + eIdx;
+ sDictElemt *element = &((dict)->elements) + eIdx +1;
for (size_t i = eIdx+1; i < (dict)->count ; i++, element = &((dict)->elements) + i) {
if (element->key) {
if (element->data->type != type) {
@@ -2483,7 +2483,7 @@ internal void arrayNetSerial(sBytest **r, sArrayt *array, contextt *ctx, packing
or e->type == BYTES) {
type = e->type;
packCount = 1;
- smallt *element = ((smallt **) &((array)->data))[eIdx];
+ smallt *element = ((smallt **) &((array)->data))[eIdx+1];
for (size_t i = eIdx+1; i < (array)->count ; i++, element = ((smallt **) &((array)->data))[i]) {
if (!element) {
// null element are undefined
diff --git a/netSerial.c.gcov b/netSerial.c.gcov
@@ -1,4 +1,4 @@
- -: 0:Source:/home/remy/git/sw/sheepyPackagesGitHub/netSerial/netSerial.c
+ -: 0:Source:/home/rlp/git/sw/sheepyPackagesGitHub/netSerial/netSerial.c
-: 0:Graph:netSerial.gcno
-: 0:Data:netSerial.gcda
-: 0:Runs:7
@@ -363,111 +363,129 @@ function helpNetSerial called 0 returned 0% blocks executed 0%
#####: 242: ret "TODO helpNetSerial \n" helpTextSmallJson;
-: 243:}
-: 244:
-function uintToNetTypeVarint called 105 returned 100% blocks executed 100%
- 105: 245:internal void uintToNetTypeVarint(sBytest **buf, u8 type, u64 value) {
- 105: 246: u64 c = value;
- -: 247: /* encode b0..2 */
- 105: 248: u8 b = type + ((c & 0x7) << 4);
- 105: 249: if (c & 0xFFFFFFFFFFFFFFF8) {
-branch 0 taken 10% (fallthrough)
-branch 1 taken 90%
- 10: 250: b |= 0x80;
- 10: 251: sBytesPush(buf, b);
-call 0 returned 100%
- 10: 252: c >>=3;
- -: 253: /* encode b3..9 ...*/
- 31: 254: while(c) {
+ -: 245:/**
+ -: 246: * encode type in lower nibble, uint value in high nibble and next bytes as varuint
+ -: 247: */
+function uintToNetTypeVarint called 106 returned 100% blocks executed 100%
+ 106: 248:internal void uintToNetTypeVarint(sBytest **buf, u8 type, u64 value) {
+ 106: 249: u64 c = value;
+ -: 250: /* encode b0..2 */
+ 106: 251: u8 b = type + ((c & 0x7) << 4);
+ 106: 252: if (c & 0xFFFFFFFFFFFFFFF8) {
+branch 0 taken 9% (fallthrough)
+branch 1 taken 91%
+ 10: 253: b |= 0x80;
+ 10: 254: sBytesPush(buf, b);
+call 0 returned 100%
+ 10: 255: c >>=3;
+ -: 256: /* encode b3..9 ...*/
+ 31: 257: while(c) {
branch 0 taken 52%
branch 1 taken 48%
- 11: 255: b = c & 0x7F;
- 11: 256: if (c & 0xFFFFFFFFFFFFFF80)
+ 11: 258: b = c & 0x7F;
+ 11: 259: if (c & 0xFFFFFFFFFFFFFF80)
branch 0 taken 9% (fallthrough)
branch 1 taken 91%
- 1: 257: b |= 0x80;
- 11: 258: sBytesPush(buf, b);
-call 0 returned 100%
- 11: 259: c >>=7;
- -: 260: }
- -: 261: }
- -: 262: else
- 95: 263: sBytesPush(buf, b);
-call 0 returned 100%
- 105: 264:}
- -: 265:
-function uintToVarint called 173 returned 100% blocks executed 90%
- 173: 266:internal void uintToVarint(sBytest **buf, u64 value) {
- 173: 267: u64 c = value;
- 173: 268: u8 b = c & 0x7F;
- 173: 269: if (c & 0xFFFFFFFFFFFFFF80) {
+ 1: 260: b |= 0x80;
+ 11: 261: sBytesPush(buf, b);
+call 0 returned 100%
+ 11: 262: c >>=7;
+ -: 263: }
+ -: 264: }
+ -: 265: else
+ 96: 266: sBytesPush(buf, b);
+call 0 returned 100%
+ 106: 267:}
+ -: 268:
+ -: 269:/**
+ -: 270: * encode uint as varuint
+ -: 271: */
+function uintToVarint called 180 returned 100% blocks executed 90%
+ 180: 272:internal void uintToVarint(sBytest **buf, u64 value) {
+ 180: 273: u64 c = value;
+ 180: 274: u8 b = c & 0x7F;
+ 180: 275: if (c & 0xFFFFFFFFFFFFFF80) {
branch 0 taken 2% (fallthrough)
branch 1 taken 98%
- 3: 270: b |= 0x80;
- 3: 271: sBytesPush(buf, b);
+ 3: 276: b |= 0x80;
+ 3: 277: sBytesPush(buf, b);
call 0 returned 100%
- 3: 272: c >>=7;
- -: 273: /* encode b7..14 ...*/
- 9: 274: while(c) {
+ 3: 278: c >>=7;
+ -: 279: /* encode b7..14 ...*/
+ 9: 280: while(c) {
branch 0 taken 50%
branch 1 taken 50%
- 3: 275: b = c & 0x7F;
- 3: 276: if (c & 0xFFFFFFFFFFFFFF80)
+ 3: 281: b = c & 0x7F;
+ 3: 282: if (c & 0xFFFFFFFFFFFFFF80)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 277: b |= 0x80;
- 3: 278: sBytesPush(buf, b);
-call 0 returned 100%
- 3: 279: c >>=7;
- -: 280: }
- -: 281: }
- -: 282: else
- 170: 283: sBytesPush(buf, b);
-call 0 returned 100%
- 173: 284:}
- -: 285:
-function netTypeVarintToUint called 105 returned 100% blocks executed 100%
- 105: 286:internal u64 netTypeVarintToUint(u8 **buf) {
- 105: 287: u64 r = 0;
- -: 288:
- 105: 289: r = (**buf >> 4) & 0x7;
- -: 290:
- 105: 291: u8 c = 0;
- 221: 292: while (**buf & 0x80) {
+ #####: 283: b |= 0x80;
+ 3: 284: sBytesPush(buf, b);
+call 0 returned 100%
+ 3: 285: c >>=7;
+ -: 286: }
+ -: 287: }
+ -: 288: else
+ 177: 289: sBytesPush(buf, b);
+call 0 returned 100%
+ 180: 290:}
+ -: 291:
+ -: 292:/**
+ -: 293: * decode type and varuint to uint
+ -: 294: */
+function netTypeVarintToUint called 106 returned 100% blocks executed 100%
+ 106: 295:internal u64 netTypeVarintToUint(u8 **buf) {
+ 106: 296: u64 r = 0;
+ -: 297:
+ 106: 298: r = (**buf >> 4) & 0x7;
+ -: 299:
+ 106: 300: u8 c = 0;
+ 223: 301: while (**buf & 0x80) {
branch 0 taken 9%
branch 1 taken 91% (fallthrough)
- 11: 293: (*buf)++;
- 11: 294: r |= (**buf & 0x7F) << (7*c+3);
- 11: 295: c++;
- -: 296: }
- 105: 297: (*buf)++;
- 105: 298: ret r;
- -: 299:}
- -: 300:
-function varintToUint called 173 returned 100% blocks executed 100%
- 173: 301:internal u64 varintToUint(u8 **buf) {
- 173: 302: u64 r = 0;
- -: 303:
- 173: 304: r = (**buf) & 0x7F;
- 173: 305: u8 c = 1;
- 349: 306: while (**buf & 0x80) {
+ 11: 302: (*buf)++;
+ 11: 303: r |= (**buf & 0x7F) << (7*c+3);
+ 11: 304: c++;
+ -: 305: }
+ 106: 306: (*buf)++;
+ 106: 307: ret r;
+ -: 308:}
+ -: 309:
+ -: 310:/**
+ -: 311: * decode varuint to uint
+ -: 312: */
+function varintToUint called 180 returned 100% blocks executed 100%
+ 180: 313:internal u64 varintToUint(u8 **buf) {
+ 180: 314: u64 r = 0;
+ -: 315:
+ 180: 316: r = (**buf) & 0x7F;
+ 180: 317: u8 c = 1;
+ 363: 318: while (**buf & 0x80) {
branch 0 taken 2%
branch 1 taken 98% (fallthrough)
- 3: 307: (*buf)++;
- 3: 308: r |= (**buf & 0x7F) << (7*c);
- 3: 309: c++;
- -: 310: }
- 173: 311: (*buf)++;
- 173: 312: ret r;
- -: 313:}
- -: 314:
- -: 315:// -------------------------------------
- -: 316:// Serializers
- -: 317:
+ 3: 319: (*buf)++;
+ 3: 320: r |= (**buf & 0x7F) << (7*c);
+ 3: 321: c++;
+ -: 322: }
+ 180: 323: (*buf)++;
+ 180: 324: ret r;
+ -: 325:}
+ -: 326:
+ -: 327:// -------------------------------------
+ -: 328:// Serializers
+ -: 329:
+ -: 330:// level 0
+ -: 331:// like smallJson with ints and length encoded as varints
+ -: 332:
+ -: 333:/**
+ -: 334: * serializer top function
+ -: 335: */
function netSerialLevel0 called 0 returned 0% blocks executed 0%
- #####: 318:internal sBytest* netSerialLevel0(smallt *o) {
- #####: 319: sBytest *r = NULL;
- #####: 320: sBytest *B = NULL;
- -: 321:
- #####: 322: switch(o->type) {
+ #####: 336:internal sBytest* netSerialLevel0(smallt *o) {
+ #####: 337: sBytest *r = NULL;
+ #####: 338: sBytest *B = NULL;
+ -: 339:
+ #####: 340: switch(o->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -478,95 +496,95 @@ branch 6 never executed
branch 7 never executed
branch 8 never executed
branch 9 never executed
- -: 323: case UNDEFINED:
- #####: 324: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+ -: 341: case UNDEFINED:
+ #####: 342: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 325: break;
- -: 326: case BOOL: {
- #####: 327: u8 c = NET_SERIAL_TYPES[(u8)o->type];
- -: 328: // set bit 4 when true
- #####: 329: if (((sBoolt *)&(o->type))->value)
+ #####: 343: break;
+ -: 344: case BOOL: {
+ #####: 345: u8 c = NET_SERIAL_TYPES[(u8)o->type];
+ -: 346: // set bit 4 when true
+ #####: 347: if (((sBoolt *)&(o->type))->value)
branch 0 never executed
branch 1 never executed
- #####: 330: c |= (1<<4);
- #####: 331: sBytesPush(&r, c);
-call 0 never executed
- -: 332: }
- #####: 333: break;
- -: 334: case CONTAINER:
- -: 335: // undefined
- #####: 336: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 never executed
- #####: 337: break;
- -: 338: case DICT:
- #####: 339: dictNetSerialLevel0(&r, (sDictt *)&(o->type));
-call 0 never executed
- #####: 340: break;
- -: 341: case DOUBLE:
- #####: 342: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 never executed
- #####: 343: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
-call 0 never executed
- #####: 344: break;
- -: 345: case INT: {
- -: 346: // encode int to varint
- -: 347: // v is int64_t to convert to varint
- #####: 348: i64 v = ((sIntt *)&(o->type))->value;
- -: 349: // encode v with arithmetic shifts
- #####: 350: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
+ #####: 348: c |= (1<<4);
+ #####: 349: sBytesPush(&r, c);
call 0 never executed
- -: 351: }
- #####: 352: break;
- -: 353: case STRING:
+ -: 350: }
+ #####: 351: break;
+ -: 352: case CONTAINER:
+ -: 353: // undefined
#####: 354: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 355: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
-call 0 never executed
- #####: 356: break;
- -: 357: case ARRAY:
- #####: 358: arrayNetSerialLevel0(&r, (sArrayt *)&(o->type));
-call 0 never executed
- #####: 359: break;
- -: 360: case BYTES:
- #####: 361: B = (sBytest *)&(o->type);
- #####: 362: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
-call 0 never executed
- #####: 363: sBytesPushBuffer(&r, &(B->data), B->count);
-call 0 never executed
- #####: 364: break;
- -: 365: }
- #####: 366: ret r;
- -: 367:}
- -: 368:
- -: 369:/**
- -: 370: * serialize dictionary
- -: 371: *
- -: 372: * the serialized dict is pushed to r.
- -: 373: * All elements are serialized recursively
- -: 374: *
- -: 375: * the data in containers is not serialized
- -: 376: *
- -: 377: * \param
- -: 378: * r small bytes object
- -: 379: * dict dictionary to serialize
- -: 380: */
+ #####: 355: break;
+ -: 356: case DICT:
+ #####: 357: dictNetSerialLevel0(&r, (sDictt *)&(o->type));
+call 0 never executed
+ #####: 358: break;
+ -: 359: case DOUBLE:
+ #####: 360: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 never executed
+ #####: 361: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
+call 0 never executed
+ #####: 362: break;
+ -: 363: case INT: {
+ -: 364: // encode int to varint
+ -: 365: // v is int64_t to convert to varint
+ #####: 366: i64 v = ((sIntt *)&(o->type))->value;
+ -: 367: // encode v with arithmetic shifts
+ #####: 368: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 369: }
+ #####: 370: break;
+ -: 371: case STRING:
+ #####: 372: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 never executed
+ #####: 373: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
+call 0 never executed
+ #####: 374: break;
+ -: 375: case ARRAY:
+ #####: 376: arrayNetSerialLevel0(&r, (sArrayt *)&(o->type));
+call 0 never executed
+ #####: 377: break;
+ -: 378: case BYTES:
+ #####: 379: B = (sBytest *)&(o->type);
+ #####: 380: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
+call 0 never executed
+ #####: 381: sBytesPushBuffer(&r, &(B->data), B->count);
+call 0 never executed
+ #####: 382: break;
+ -: 383: }
+ #####: 384: ret r;
+ -: 385:}
+ -: 386:
+ -: 387:/**
+ -: 388: * serialize dictionary
+ -: 389: *
+ -: 390: * the serialized dict is pushed to r.
+ -: 391: * All elements are serialized recursively
+ -: 392: *
+ -: 393: * the data in containers is not serialized
+ -: 394: *
+ -: 395: * \param
+ -: 396: * r small bytes object
+ -: 397: * dict dictionary to serialize
+ -: 398: */
function dictNetSerialLevel0 called 0 returned 0% blocks executed 0%
- #####: 381:internal void dictNetSerialLevel0(sBytest **r, sDictt *dict) {
- #####: 382: sBytest *B = NULL;
- -: 383:
- #####: 384: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
+ #####: 399:internal void dictNetSerialLevel0(sBytest **r, sDictt *dict) {
+ #####: 400: sBytest *B = NULL;
+ -: 401:
+ #####: 402: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
call 0 never executed
- -: 385:
- #####: 386: forEachSDict(dict, e) {
+ -: 403:
+ #####: 404: forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 387: if (e->key) {
+ #####: 405: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 388: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 406: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- -: 389:
- #####: 390: switch(e->data->type) {
+ -: 407:
+ #####: 408: switch(e->data->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -577,99 +595,99 @@ branch 6 never executed
branch 7 never executed
branch 8 never executed
branch 9 never executed
- -: 391: case UNDEFINED:
- #####: 392: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
+ -: 409: case UNDEFINED:
+ #####: 410: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
call 0 never executed
- #####: 393: break;
- -: 394: case BOOL: {
- #####: 395: u8 c = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 396: // set bit 4 when true
- #####: 397: if (((sBoolt *)(e->data))->value)
+ #####: 411: break;
+ -: 412: case BOOL: {
+ #####: 413: u8 c = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 414: // set bit 4 when true
+ #####: 415: if (((sBoolt *)(e->data))->value)
branch 0 never executed
branch 1 never executed
- #####: 398: c |= (1<<4);
- #####: 399: sBytesPush(r, c);
-call 0 never executed
- -: 400: }
- #####: 401: break;
- -: 402: case CONTAINER:
- -: 403: // undefined
- #####: 404: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
-call 0 never executed
- #####: 405: break;
- -: 406: case DICT:
- #####: 407: dictNetSerialLevel0(r, (sDictt *)(e->data));
-call 0 never executed
- #####: 408: break;
- -: 409: case DOUBLE:
- #####: 410: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
+ #####: 416: c |= (1<<4);
+ #####: 417: sBytesPush(r, c);
call 0 never executed
- #####: 411: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 never executed
- #####: 412: break;
- -: 413: case INT: {
- -: 414: // encode int to varint
- -: 415: // v is int64_t to convert to varint
- #####: 416: i64 v = ((sIntt *)(e->data))->value;
- -: 417: // encode v with arithmetic shifts
- #####: 418: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 419: }
- #####: 420: break;
- -: 421: case STRING:
+ -: 418: }
+ #####: 419: break;
+ -: 420: case CONTAINER:
+ -: 421: // undefined
#####: 422: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
call 0 never executed
- #####: 423: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
-call 0 never executed
- #####: 424: break;
- -: 425: case ARRAY:
- #####: 426: arrayNetSerialLevel0(r, (sArrayt *)(e->data));
-call 0 never executed
- #####: 427: break;
- -: 428: case BYTES:
- #####: 429: B = (sBytest *)(e->data);
- #####: 430: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
-call 0 never executed
- #####: 431: sBytesPushBuffer(r, &(B->data), B->count);
-call 0 never executed
- #####: 432: break;
- -: 433: }
- -: 434: }
- -: 435: }
- #####: 436: ret;
- -: 437:}
- -: 438:
- -: 439:/**
- -: 440: * serialize array
- -: 441: *
- -: 442: * the serialized array is pushed to r.
- -: 443: * All elements are serialized recursively
- -: 444: *
- -: 445: * the data in containers is not serialized
- -: 446: *
- -: 447: * \param
- -: 448: * r small bytes object
- -: 449: * array to serialize
- -: 450: */
+ #####: 423: break;
+ -: 424: case DICT:
+ #####: 425: dictNetSerialLevel0(r, (sDictt *)(e->data));
+call 0 never executed
+ #####: 426: break;
+ -: 427: case DOUBLE:
+ #####: 428: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
+call 0 never executed
+ #####: 429: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 never executed
+ #####: 430: break;
+ -: 431: case INT: {
+ -: 432: // encode int to varint
+ -: 433: // v is int64_t to convert to varint
+ #####: 434: i64 v = ((sIntt *)(e->data))->value;
+ -: 435: // encode v with arithmetic shifts
+ #####: 436: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 437: }
+ #####: 438: break;
+ -: 439: case STRING:
+ #####: 440: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->data->type]);
+call 0 never executed
+ #####: 441: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+call 0 never executed
+ #####: 442: break;
+ -: 443: case ARRAY:
+ #####: 444: arrayNetSerialLevel0(r, (sArrayt *)(e->data));
+call 0 never executed
+ #####: 445: break;
+ -: 446: case BYTES:
+ #####: 447: B = (sBytest *)(e->data);
+ #####: 448: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
+call 0 never executed
+ #####: 449: sBytesPushBuffer(r, &(B->data), B->count);
+call 0 never executed
+ #####: 450: break;
+ -: 451: }
+ -: 452: }
+ -: 453: }
+ #####: 454: ret;
+ -: 455:}
+ -: 456:
+ -: 457:/**
+ -: 458: * serialize array
+ -: 459: *
+ -: 460: * the serialized array is pushed to r.
+ -: 461: * All elements are serialized recursively
+ -: 462: *
+ -: 463: * the data in containers is not serialized
+ -: 464: *
+ -: 465: * \param
+ -: 466: * r small bytes object
+ -: 467: * array to serialize
+ -: 468: */
function arrayNetSerialLevel0 called 0 returned 0% blocks executed 0%
- #####: 451:internal void arrayNetSerialLevel0(sBytest **r, sArrayt *array) {
- #####: 452: sBytest *B = NULL;
- -: 453:
- #####: 454: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
+ #####: 469:internal void arrayNetSerialLevel0(sBytest **r, sArrayt *array) {
+ #####: 470: sBytest *B = NULL;
+ -: 471:
+ #####: 472: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
call 0 never executed
- -: 455:
- #####: 456: forEachSArray(array, e) {
+ -: 473:
+ #####: 474: forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 457: if (!e) {
+ #####: 475: if (!e) {
branch 0 never executed
branch 1 never executed
- -: 458: // empty slots are represented as undefined elements
- #####: 459: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
+ -: 476: // empty slots are represented as undefined elements
+ #####: 477: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
call 0 never executed
- -: 460: }
- -: 461: else {
- #####: 462: switch(e->type) {
+ -: 478: }
+ -: 479: else {
+ #####: 480: switch(e->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -680,103 +698,107 @@ branch 6 never executed
branch 7 never executed
branch 8 never executed
branch 9 never executed
- -: 463: case UNDEFINED:
- #####: 464: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
+ -: 481: case UNDEFINED:
+ #####: 482: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
call 0 never executed
- #####: 465: break;
- -: 466: case BOOL: {
- #####: 467: u8 c = NET_SERIAL_TYPES[(u8)e->type];
- -: 468: // set bit 4 when true
- #####: 469: if (((sBoolt *)&(e->type))->value)
+ #####: 483: break;
+ -: 484: case BOOL: {
+ #####: 485: u8 c = NET_SERIAL_TYPES[(u8)e->type];
+ -: 486: // set bit 4 when true
+ #####: 487: if (((sBoolt *)&(e->type))->value)
branch 0 never executed
branch 1 never executed
- #####: 470: c |= (1<<4);
- #####: 471: sBytesPush(r, c);
+ #####: 488: c |= (1<<4);
+ #####: 489: sBytesPush(r, c);
call 0 never executed
- -: 472: }
- #####: 473: break;
- -: 474: case CONTAINER:
- -: 475: // undefined
- #####: 476: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
+ -: 490: }
+ #####: 491: break;
+ -: 492: case CONTAINER:
+ -: 493: // undefined
+ #####: 494: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
call 0 never executed
- #####: 477: break;
- -: 478: case DICT:
- #####: 479: dictNetSerialLevel0(r, (sDictt *)e);
+ #####: 495: break;
+ -: 496: case DICT:
+ #####: 497: dictNetSerialLevel0(r, (sDictt *)e);
call 0 never executed
- #####: 480: break;
- -: 481: case DOUBLE:
- #####: 482: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
+ #####: 498: break;
+ -: 499: case DOUBLE:
+ #####: 500: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
call 0 never executed
- #####: 483: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+ #####: 501: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
call 0 never executed
- #####: 484: break;
- -: 485: case INT: {
- -: 486: // encode int to varint
- -: 487: // v is int64_t to convert to varint
- #####: 488: i64 v = ((sIntt *)&(e->type))->value;
- -: 489: // encode v with arithmetic shifts
- #####: 490: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
+ #####: 502: break;
+ -: 503: case INT: {
+ -: 504: // encode int to varint
+ -: 505: // v is int64_t to convert to varint
+ #####: 506: i64 v = ((sIntt *)&(e->type))->value;
+ -: 507: // encode v with arithmetic shifts
+ #####: 508: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
call 0 never executed
- -: 491: }
- #####: 492: break;
- -: 493: case STRING:
- #####: 494: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
+ -: 509: }
+ #####: 510: break;
+ -: 511: case STRING:
+ #####: 512: sBytesPush(r, NET_SERIAL_TYPES[(u8)e->type]);
call 0 never executed
- #####: 495: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+ #####: 513: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
call 0 never executed
- #####: 496: break;
- -: 497: case ARRAY:
- #####: 498: arrayNetSerialLevel0(r, (sArrayt *)e);
+ #####: 514: break;
+ -: 515: case ARRAY:
+ #####: 516: arrayNetSerialLevel0(r, (sArrayt *)e);
call 0 never executed
- #####: 499: break;
- -: 500: case BYTES:
- #####: 501: B = (sBytest *)e;
- #####: 502: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
+ #####: 517: break;
+ -: 518: case BYTES:
+ #####: 519: B = (sBytest *)e;
+ #####: 520: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
call 0 never executed
- #####: 503: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 521: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- #####: 504: break;
- -: 505: }
- -: 506: }
- -: 507: }
- #####: 508: ret;
- -: 509:}
- -: 510:
+ #####: 522: break;
+ -: 523: }
+ -: 524: }
+ -: 525: }
+ #####: 526: ret;
+ -: 527:}
+ -: 528:
function serialNetSerialLevel0 called 0 returned 0% blocks executed 0%
- #####: 511:internal smallBytest* serialNetSerialLevel0(smallJsont *self) {
- -: 512:
- #####: 513: smallt *o = getsoG(self);
-call 0 never executed
- -: 514:
- #####: 515: if (o == NULL)
-branch 0 never executed
-branch 1 never executed
- #####: 516: ret NULL;
- -: 517:
- #####: 518: sBytest *B = netSerialLevel0(o);
+ #####: 529:internal smallBytest* serialNetSerialLevel0(smallJsont *self) {
+ -: 530:
+ #####: 531: smallt *o = getsoG(self);
call 0 never executed
- -: 519:
- #####: 520: if (!B) {
+ -: 532:
+ #####: 533: if (o == NULL)
branch 0 never executed
branch 1 never executed
- #####: 521: ret NULL;
- -: 522: }
- -: 523:
- #####: 524: createAllocateSmallBytes(r);
-call 0 never executed
- #####: 525: r->B = B;
- #####: 526: ret r;
- -: 527:}
- -: 528:
- -: 529:// level 1
- -: 530:
-function netSerialLevel1 called 0 returned 0% blocks executed 0%
- #####: 531:internal sBytest* netSerialLevel1(smallt *o) {
- #####: 532: sBytest *r = NULL;
- #####: 533: sBytest *B = NULL;
- #####: 534: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
+ #####: 534: ret NULL;
-: 535:
- #####: 536: switch(o->type) {
+ #####: 536: sBytest *B = netSerialLevel0(o);
+call 0 never executed
+ -: 537:
+ #####: 538: if (!B) {
+branch 0 never executed
+branch 1 never executed
+ #####: 539: ret NULL;
+ -: 540: }
+ -: 541:
+ #####: 542: createAllocateSmallBytes(r);
+call 0 never executed
+ #####: 543: r->B = B;
+ #####: 544: ret r;
+ -: 545:}
+ -: 546:
+ -: 547:// level 1
+ -: 548:// like level 0 with type encoded in nibbles and bools are packed
+ -: 549:
+ -: 550:/**
+ -: 551: * serializer top function
+ -: 552: */
+function netSerialLevel1 called 0 returned 0% blocks executed 0%
+ #####: 553:internal sBytest* netSerialLevel1(smallt *o) {
+ #####: 554: sBytest *r = NULL;
+ #####: 555: sBytest *B = NULL;
+ #####: 556: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
+ -: 557:
+ #####: 558: switch(o->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -786,106 +808,106 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 537: case UNDEFINED:
- -: 538: case CONTAINER:
- #####: 539: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+ -: 559: case UNDEFINED:
+ -: 560: case CONTAINER:
+ #####: 561: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 540: break;
- -: 541: case BOOL: {
- #####: 542: u8 c = NET_SERIAL_TYPES[(u8)o->type];
- -: 543: // set bit 4 when true
- #####: 544: if (((sBoolt *)&(o->type))->value)
+ #####: 562: break;
+ -: 563: case BOOL: {
+ #####: 564: u8 c = NET_SERIAL_TYPES[(u8)o->type];
+ -: 565: // set bit 4 when true
+ #####: 566: if (((sBoolt *)&(o->type))->value)
branch 0 never executed
branch 1 never executed
- #####: 545: c |= (1<<4);
- #####: 546: sBytesPush(&r, c);
+ #####: 567: c |= (1<<4);
+ #####: 568: sBytesPush(&r, c);
call 0 never executed
- -: 547: }
- #####: 548: break;
- -: 549: case DICT:
- #####: 550: dictNetSerialLevel1(&r, (sDictt *)&(o->type), &ctx);
+ -: 569: }
+ #####: 570: break;
+ -: 571: case DICT:
+ #####: 572: dictNetSerialLevel1(&r, (sDictt *)&(o->type), &ctx);
call 0 never executed
- #####: 551: break;
- -: 552: case DOUBLE:
- #####: 553: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+ #####: 573: break;
+ -: 574: case DOUBLE:
+ #####: 575: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 554: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
+ #####: 576: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
call 0 never executed
- #####: 555: break;
- -: 556: case INT: {
- -: 557: // encode int to varint
- -: 558: // v is int64_t to convert to varint
- #####: 559: i64 v = ((sIntt *)&(o->type))->value;
- -: 560: // encode v with arithmetic shifts
- #####: 561: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
+ #####: 577: break;
+ -: 578: case INT: {
+ -: 579: // encode int to varint
+ -: 580: // v is int64_t to convert to varint
+ #####: 581: i64 v = ((sIntt *)&(o->type))->value;
+ -: 582: // encode v with arithmetic shifts
+ #####: 583: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
call 0 never executed
- -: 562: }
- #####: 563: break;
- -: 564: case STRING:
- #####: 565: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+ -: 584: }
+ #####: 585: break;
+ -: 586: case STRING:
+ #####: 587: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 566: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
+ #####: 588: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
call 0 never executed
- #####: 567: break;
- -: 568: case ARRAY:
- #####: 569: arrayNetSerialLevel1(&r, (sArrayt *)&(o->type), &ctx);
+ #####: 589: break;
+ -: 590: case ARRAY:
+ #####: 591: arrayNetSerialLevel1(&r, (sArrayt *)&(o->type), &ctx);
call 0 never executed
- #####: 570: break;
- -: 571: case BYTES:
- #####: 572: B = (sBytest *)&(o->type);
- #####: 573: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
-call 0 never executed
- #####: 574: sBytesPushBuffer(&r, &(B->data), B->count);
-call 0 never executed
- #####: 575: break;
- -: 576: }
- #####: 577: ret r;
- -: 578:}
- -: 579:
- -: 580:/**
- -: 581: * serialize dictionary
- -: 582: *
- -: 583: * the serialized dict is pushed to r.
- -: 584: * All elements are serialized recursively
- -: 585: *
- -: 586: * the data in containers is not serialized
- -: 587: *
- -: 588: * \param
- -: 589: * r small bytes object
- -: 590: * dict dictionary to serialize
- -: 591: */
+ #####: 592: break;
+ -: 593: case BYTES:
+ #####: 594: B = (sBytest *)&(o->type);
+ #####: 595: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
+call 0 never executed
+ #####: 596: sBytesPushBuffer(&r, &(B->data), B->count);
+call 0 never executed
+ #####: 597: break;
+ -: 598: }
+ #####: 599: ret r;
+ -: 600:}
+ -: 601:
+ -: 602:/**
+ -: 603: * serialize dictionary
+ -: 604: *
+ -: 605: * the serialized dict is pushed to r.
+ -: 606: * All elements are serialized recursively
+ -: 607: *
+ -: 608: * the data in containers is not serialized
+ -: 609: *
+ -: 610: * \param
+ -: 611: * r small bytes object
+ -: 612: * dict dictionary to serialize
+ -: 613: */
function dictNetSerialLevel1 called 0 returned 0% blocks executed 0%
- #####: 592:internal void dictNetSerialLevel1(sBytest **r, sDictt *dict, contextt *ctx) {
- #####: 593: sBytest *B = NULL;
- #####: 594: char *data = NULL;
- -: 595:
- #####: 596: if (ctx->nibble == lowNbl) {
+ #####: 614:internal void dictNetSerialLevel1(sBytest **r, sDictt *dict, contextt *ctx) {
+ #####: 615: sBytest *B = NULL;
+ #####: 616: char *data = NULL;
+ -: 617:
+ #####: 618: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 597: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
+ #####: 619: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
call 0 never executed
- -: 598: }
- -: 599: else {
- -: 600: // high nibble
- -: 601: #define storeTypeInHighNbl(o)\
- -: 602: ctx->nibble = lowNbl;\
- -: 603: data = (char *)&((*r)->data) + ctx->nblOffset;\
- -: 604: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
- #####: 605: storeTypeInHighNbl(dict);
- #####: 606: uintToVarint(r, dict->count);
+ -: 620: }
+ -: 621: else {
+ -: 622: // high nibble
+ -: 623: #define storeTypeInHighNbl(o)\
+ -: 624: ctx->nibble = lowNbl;\
+ -: 625: data = (char *)&((*r)->data) + ctx->nblOffset;\
+ -: 626: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
+ #####: 627: storeTypeInHighNbl(dict);
+ #####: 628: uintToVarint(r, dict->count);
call 0 never executed
- -: 607: }
- -: 608:
- #####: 609: forEachSDict(dict, e) {
+ -: 629: }
+ -: 630:
+ #####: 631: forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 610: if (e->key) {
+ #####: 632: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 611: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 633: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- -: 612:
- #####: 613: switch(e->data->type) {
+ -: 634:
+ #####: 635: switch(e->data->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -895,240 +917,240 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 614: case UNDEFINED:
- -: 615: case CONTAINER:
- #####: 616: if (ctx->nibble == lowNbl) {
+ -: 636: case UNDEFINED:
+ -: 637: case CONTAINER:
+ #####: 638: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 617: #define storeTypeOnly(o)\
- -: 618: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
- -: 619: ctx->nibble = highNbl;\
- -: 620: ctx->nblOffset = (*r)->count -1
- #####: 621: storeTypeOnly(e->data);
+ -: 639: #define storeTypeOnly(o)\
+ -: 640: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
+ -: 641: ctx->nibble = highNbl;\
+ -: 642: ctx->nblOffset = (*r)->count -1
+ #####: 643: storeTypeOnly(e->data);
call 0 never executed
- -: 622: }
- -: 623: else {
- #####: 624: storeTypeInHighNbl(e->data);
- -: 625: }
- #####: 626: break;
- -: 627: case BOOL:
- #####: 628: if (!ctx->boolOffset) {
+ -: 644: }
+ -: 645: else {
+ #####: 646: storeTypeInHighNbl(e->data);
+ -: 647: }
+ #####: 648: break;
+ -: 649: case BOOL:
+ #####: 650: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 629: // new packed bools
- #####: 630: if (ctx->nibble == lowNbl) {
+ -: 651: // new packed bools
+ #####: 652: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 631: #define storeNew4bPackedBool(o)\
- -: 632: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
- -: 633: /* set bit 4 when true */\
- -: 634: if (((sBoolt *)(o))->value)\
- -: 635: c |= (1<<4);\
- -: 636: sBytesPush(r, c);\
- -: 637: ctx->boolShift = 5;\
- -: 638: ctx->boolOffset = (*r)->count -1
- #####: 639: storeNew4bPackedBool(e->data);
+ -: 653: #define storeNew4bPackedBool(o)\
+ -: 654: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
+ -: 655: /* set bit 4 when true */\
+ -: 656: if (((sBoolt *)(o))->value)\
+ -: 657: c |= (1<<4);\
+ -: 658: sBytesPush(r, c);\
+ -: 659: ctx->boolShift = 5;\
+ -: 660: ctx->boolOffset = (*r)->count -1
+ #####: 661: storeNew4bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 640: }
- -: 641: else {
- -: 642: // high nibble, next byte is packed bools
- #####: 643: storeTypeInHighNbl(e->data);
- -: 644: #define storeNew8bPackedBool(o)\
- -: 645: u8 c = 0;\
- -: 646: if (((sBoolt *)(o))->value)\
- -: 647: c = 1;\
- -: 648: sBytesPush(r, c);\
- -: 649: ctx->boolShift = 1;\
- -: 650: ctx->boolOffset = (*r)->count -1
- #####: 651: storeNew8bPackedBool(e->data);
+ -: 662: }
+ -: 663: else {
+ -: 664: // high nibble, next byte is packed bools
+ #####: 665: storeTypeInHighNbl(e->data);
+ -: 666: #define storeNew8bPackedBool(o)\
+ -: 667: u8 c = 0;\
+ -: 668: if (((sBoolt *)(o))->value)\
+ -: 669: c = 1;\
+ -: 670: sBytesPush(r, c);\
+ -: 671: ctx->boolShift = 1;\
+ -: 672: ctx->boolOffset = (*r)->count -1
+ #####: 673: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 652: }
- -: 653: }
- -: 654: else {
- -: 655: // there was a bool before this one, fill bits in nibbles
- #####: 656: if (ctx->nibble == lowNbl) {
+ -: 674: }
+ -: 675: }
+ -: 676: else {
+ -: 677: // there was a bool before this one, fill bits in nibbles
+ #####: 678: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 657: if (ctx->boolShift == 8) {
+ #####: 679: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 658: // previous packed bool is full
- -: 659: // this byte is the new packed bools
- #####: 660: storeNew4bPackedBool(e->data);
+ -: 680: // previous packed bool is full
+ -: 681: // this byte is the new packed bools
+ #####: 682: storeNew4bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 661: }
- -: 662: else {
- #####: 663: storeTypeOnly(e->data);
+ -: 683: }
+ -: 684: else {
+ #####: 685: storeTypeOnly(e->data);
call 0 never executed
- -: 664: #define storeBool(o)\
- -: 665: data = (char *)&((*r)->data) + ctx->boolOffset;\
- -: 666: if (((sBoolt *)(o))->value)\
- -: 667: *data |= 1 << ctx->boolShift;\
- -: 668: ctx->boolShift++
- #####: 669: storeBool(e->data);
+ -: 686: #define storeBool(o)\
+ -: 687: data = (char *)&((*r)->data) + ctx->boolOffset;\
+ -: 688: if (((sBoolt *)(o))->value)\
+ -: 689: *data |= 1 << ctx->boolShift;\
+ -: 690: ctx->boolShift++
+ #####: 691: storeBool(e->data);
branch 0 never executed
branch 1 never executed
- -: 670: }
- -: 671: }
- -: 672: else {
- -: 673: // high nibble
- #####: 674: storeTypeInHighNbl(e->data);
- #####: 675: if (ctx->boolShift == 8) {
+ -: 692: }
+ -: 693: }
+ -: 694: else {
+ -: 695: // high nibble
+ #####: 696: storeTypeInHighNbl(e->data);
+ #####: 697: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 676: // previous packed bool is full
- -: 677: // next byte is the new packed bools
- #####: 678: storeNew8bPackedBool(e->data);
+ -: 698: // previous packed bool is full
+ -: 699: // next byte is the new packed bools
+ #####: 700: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 679: }
- -: 680: else {
- #####: 681: storeBool(e->data);
-branch 0 never executed
-branch 1 never executed
- -: 682: }
- -: 683: }
- -: 684: }
- #####: 685: break;
- -: 686: case DICT:
- #####: 687: dictNetSerialLevel1(r, (sDictt *)(e->data), ctx);
-call 0 never executed
- #####: 688: break;
- -: 689: case DOUBLE:
- #####: 690: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 691: storeTypeOnly(e->data);
-call 0 never executed
- -: 692: }
- -: 693: else {
- -: 694: // high nibble
- #####: 695: storeTypeInHighNbl(e->data);
- -: 696: }
- #####: 697: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 never executed
- #####: 698: break;
- -: 699: case INT: {
- -: 700: // encode int to varint
- -: 701: // v is int64_t to convert to varint
- #####: 702: i64 v = ((sIntt *)(e->data))->value;
- #####: 703: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- -: 704: // encode v with arithmetic shifts
- #####: 705: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 706: }
- -: 707: else {
- -: 708: // high nibble
- #####: 709: storeTypeInHighNbl(e->data);
- #####: 710: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 711: }
- -: 712: }
- #####: 713: break;
- -: 714: case STRING:
- #####: 715: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 716: storeTypeOnly(e->data);
-call 0 never executed
- -: 717: }
- -: 718: else {
- -: 719: // high nibble
- #####: 720: storeTypeInHighNbl(e->data);
- -: 721: }
- #####: 722: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
-call 0 never executed
- #####: 723: break;
- -: 724: case ARRAY:
- #####: 725: arrayNetSerialLevel1(r, (sArrayt *)(e->data), ctx);
-call 0 never executed
- #####: 726: break;
- -: 727: case BYTES:
- #####: 728: B = (sBytest *)(e->data);
- #####: 729: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 730: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
-call 0 never executed
- -: 731: }
- -: 732: else {
- -: 733: // high nibble
- #####: 734: storeTypeInHighNbl(e->data);
- #####: 735: uintToVarint(r, B->count);
-call 0 never executed
- -: 736: }
- #####: 737: sBytesPushBuffer(r, &(B->data), B->count);
-call 0 never executed
- #####: 738: break;
- -: 739: }
- -: 740: }
- -: 741: }
- #####: 742: ret;
- -: 743:}
- -: 744:
- -: 745:/**
- -: 746: * serialize array
- -: 747: *
- -: 748: * the serialized array is pushed to r.
- -: 749: * All elements are serialized recursively
- -: 750: *
- -: 751: * the data in containers is not serialized
- -: 752: *
- -: 753: * \param
- -: 754: * r small bytes object
- -: 755: * array to serialize
- -: 756: */
-function arrayNetSerialLevel1 called 0 returned 0% blocks executed 0%
- #####: 757:internal void arrayNetSerialLevel1(sBytest **r, sArrayt *array, contextt *ctx) {
- #####: 758: sBytest *B = NULL;
- #####: 759: char *data = NULL;
- -: 760:
- #####: 761: if (ctx->nibble == lowNbl) {
+ -: 701: }
+ -: 702: else {
+ #####: 703: storeBool(e->data);
branch 0 never executed
branch 1 never executed
- #####: 762: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
+ -: 704: }
+ -: 705: }
+ -: 706: }
+ #####: 707: break;
+ -: 708: case DICT:
+ #####: 709: dictNetSerialLevel1(r, (sDictt *)(e->data), ctx);
call 0 never executed
+ #####: 710: break;
+ -: 711: case DOUBLE:
+ #####: 712: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 713: storeTypeOnly(e->data);
+call 0 never executed
+ -: 714: }
+ -: 715: else {
+ -: 716: // high nibble
+ #####: 717: storeTypeInHighNbl(e->data);
+ -: 718: }
+ #####: 719: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 never executed
+ #####: 720: break;
+ -: 721: case INT: {
+ -: 722: // encode int to varint
+ -: 723: // v is int64_t to convert to varint
+ #####: 724: i64 v = ((sIntt *)(e->data))->value;
+ #####: 725: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ -: 726: // encode v with arithmetic shifts
+ #####: 727: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 728: }
+ -: 729: else {
+ -: 730: // high nibble
+ #####: 731: storeTypeInHighNbl(e->data);
+ #####: 732: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 733: }
+ -: 734: }
+ #####: 735: break;
+ -: 736: case STRING:
+ #####: 737: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 738: storeTypeOnly(e->data);
+call 0 never executed
+ -: 739: }
+ -: 740: else {
+ -: 741: // high nibble
+ #####: 742: storeTypeInHighNbl(e->data);
+ -: 743: }
+ #####: 744: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+call 0 never executed
+ #####: 745: break;
+ -: 746: case ARRAY:
+ #####: 747: arrayNetSerialLevel1(r, (sArrayt *)(e->data), ctx);
+call 0 never executed
+ #####: 748: break;
+ -: 749: case BYTES:
+ #####: 750: B = (sBytest *)(e->data);
+ #####: 751: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 752: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
+call 0 never executed
+ -: 753: }
+ -: 754: else {
+ -: 755: // high nibble
+ #####: 756: storeTypeInHighNbl(e->data);
+ #####: 757: uintToVarint(r, B->count);
+call 0 never executed
+ -: 758: }
+ #####: 759: sBytesPushBuffer(r, &(B->data), B->count);
+call 0 never executed
+ #####: 760: break;
+ -: 761: }
+ -: 762: }
-: 763: }
- -: 764: else {
- -: 765: // high nibble
- #####: 766: storeTypeInHighNbl(array);
- #####: 767: uintToVarint(r, array->count);
+ #####: 764: ret;
+ -: 765:}
+ -: 766:
+ -: 767:/**
+ -: 768: * serialize array
+ -: 769: *
+ -: 770: * the serialized array is pushed to r.
+ -: 771: * All elements are serialized recursively
+ -: 772: *
+ -: 773: * the data in containers is not serialized
+ -: 774: *
+ -: 775: * \param
+ -: 776: * r small bytes object
+ -: 777: * array to serialize
+ -: 778: */
+function arrayNetSerialLevel1 called 0 returned 0% blocks executed 0%
+ #####: 779:internal void arrayNetSerialLevel1(sBytest **r, sArrayt *array, contextt *ctx) {
+ #####: 780: sBytest *B = NULL;
+ #####: 781: char *data = NULL;
+ -: 782:
+ #####: 783: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 784: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
+call 0 never executed
+ -: 785: }
+ -: 786: else {
+ -: 787: // high nibble
+ #####: 788: storeTypeInHighNbl(array);
+ #####: 789: uintToVarint(r, array->count);
call 0 never executed
- -: 768: }
- -: 769:
- #####: 770: forEachSArray(array, e) {
+ -: 790: }
+ -: 791:
+ #####: 792: forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 771: if (!e) {
+ #####: 793: if (!e) {
branch 0 never executed
branch 1 never executed
- -: 772: // empty slots are represented as undefined elements
- #####: 773: if (ctx->nibble == lowNbl) {
+ -: 794: // empty slots are represented as undefined elements
+ #####: 795: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 774: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
+ #####: 796: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
call 0 never executed
- #####: 775: ctx->nibble = highNbl;
- #####: 776: ctx->nblOffset = (*r)->count -1;
- -: 777: }
- -: 778: else {
- -: 779: // high nibble
- #####: 780: ctx->nibble = lowNbl;
- #####: 781: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 782: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
- -: 783: }
- -: 784: }
- -: 785: else {
- #####: 786: switch(e->type) {
+ #####: 797: ctx->nibble = highNbl;
+ #####: 798: ctx->nblOffset = (*r)->count -1;
+ -: 799: }
+ -: 800: else {
+ -: 801: // high nibble
+ #####: 802: ctx->nibble = lowNbl;
+ #####: 803: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 804: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
+ -: 805: }
+ -: 806: }
+ -: 807: else {
+ #####: 808: switch(e->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -1138,198 +1160,202 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 787: case UNDEFINED:
- -: 788: case CONTAINER:
- #####: 789: if (ctx->nibble == lowNbl) {
+ -: 809: case UNDEFINED:
+ -: 810: case CONTAINER:
+ #####: 811: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 790: storeTypeOnly(e);
+ #####: 812: storeTypeOnly(e);
call 0 never executed
- -: 791: }
- -: 792: else {
- -: 793: // high nibble
- #####: 794: storeTypeInHighNbl(e);
- -: 795: }
- #####: 796: break;
- -: 797: case BOOL:
- #####: 798: if (!ctx->boolOffset) {
+ -: 813: }
+ -: 814: else {
+ -: 815: // high nibble
+ #####: 816: storeTypeInHighNbl(e);
+ -: 817: }
+ #####: 818: break;
+ -: 819: case BOOL:
+ #####: 820: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 799: // new packed bools
- #####: 800: if (ctx->nibble == lowNbl) {
+ -: 821: // new packed bools
+ #####: 822: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 801: storeNew4bPackedBool(e);
+ #####: 823: storeNew4bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 802: }
- -: 803: else {
- -: 804: // high nibble, next byte is packed bools
- #####: 805: storeTypeInHighNbl(e);
- #####: 806: storeNew8bPackedBool(e);
+ -: 824: }
+ -: 825: else {
+ -: 826: // high nibble, next byte is packed bools
+ #####: 827: storeTypeInHighNbl(e);
+ #####: 828: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 807: }
- -: 808: }
- -: 809: else {
- -: 810: // there was a bool before this one, fill bits in nibbles
- #####: 811: if (ctx->nibble == lowNbl) {
+ -: 829: }
+ -: 830: }
+ -: 831: else {
+ -: 832: // there was a bool before this one, fill bits in nibbles
+ #####: 833: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 812: if (ctx->boolShift == 8) {
+ #####: 834: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 813: // previous packed bool is full
- -: 814: // this byte is the new packed bools
- #####: 815: storeNew4bPackedBool(e);
+ -: 835: // previous packed bool is full
+ -: 836: // this byte is the new packed bools
+ #####: 837: storeNew4bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 816: }
- -: 817: else {
- #####: 818: storeTypeOnly(e);
+ -: 838: }
+ -: 839: else {
+ #####: 840: storeTypeOnly(e);
call 0 never executed
- #####: 819: storeBool(e);
+ #####: 841: storeBool(e);
branch 0 never executed
branch 1 never executed
- -: 820: }
- -: 821: }
- -: 822: else {
- -: 823: // high nibble
- #####: 824: storeTypeInHighNbl(e);
- #####: 825: if (ctx->boolShift == 8) {
+ -: 842: }
+ -: 843: }
+ -: 844: else {
+ -: 845: // high nibble
+ #####: 846: storeTypeInHighNbl(e);
+ #####: 847: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 826: // previous packed bool is full
- -: 827: // next byte is the new packed bools
- #####: 828: storeNew8bPackedBool(e);
+ -: 848: // previous packed bool is full
+ -: 849: // next byte is the new packed bools
+ #####: 850: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 829: }
- -: 830: else {
- #####: 831: storeBool(e);
+ -: 851: }
+ -: 852: else {
+ #####: 853: storeBool(e);
branch 0 never executed
branch 1 never executed
- -: 832: }
- -: 833: }
- -: 834: }
- #####: 835: break;
- -: 836: case DICT:
- #####: 837: dictNetSerialLevel1(r, (sDictt *)e, ctx);
+ -: 854: }
+ -: 855: }
+ -: 856: }
+ #####: 857: break;
+ -: 858: case DICT:
+ #####: 859: dictNetSerialLevel1(r, (sDictt *)e, ctx);
call 0 never executed
- #####: 838: break;
- -: 839: case DOUBLE:
- #####: 840: if (ctx->nibble == lowNbl) {
+ #####: 860: break;
+ -: 861: case DOUBLE:
+ #####: 862: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 841: storeTypeOnly(e);
+ #####: 863: storeTypeOnly(e);
call 0 never executed
- -: 842: }
- -: 843: else {
- -: 844: // high nibble
- #####: 845: storeTypeInHighNbl(e);
- -: 846: }
- #####: 847: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+ -: 864: }
+ -: 865: else {
+ -: 866: // high nibble
+ #####: 867: storeTypeInHighNbl(e);
+ -: 868: }
+ #####: 869: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
call 0 never executed
- #####: 848: break;
- -: 849: case INT: {
- -: 850: // encode int to varint
- -: 851: // v is int64_t to convert to varint
- #####: 852: i64 v = ((sIntt *)&(e->type))->value;
- #####: 853: if (ctx->nibble == lowNbl) {
+ #####: 870: break;
+ -: 871: case INT: {
+ -: 872: // encode int to varint
+ -: 873: // v is int64_t to convert to varint
+ #####: 874: i64 v = ((sIntt *)&(e->type))->value;
+ #####: 875: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 854: // encode v with arithmetic shifts
- #####: 855: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
+ -: 876: // encode v with arithmetic shifts
+ #####: 877: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
call 0 never executed
- -: 856: }
- -: 857: else {
- -: 858: // high nibble
- #####: 859: storeTypeInHighNbl(e);
- #####: 860: uintToVarint(r, (v << 1) ^ (v >> 63));
+ -: 878: }
+ -: 879: else {
+ -: 880: // high nibble
+ #####: 881: storeTypeInHighNbl(e);
+ #####: 882: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 never executed
- -: 861: }
- -: 862: }
- #####: 863: break;
- -: 864: case STRING:
- #####: 865: if (ctx->nibble == lowNbl) {
+ -: 883: }
+ -: 884: }
+ #####: 885: break;
+ -: 886: case STRING:
+ #####: 887: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 866: storeTypeOnly(e);
+ #####: 888: storeTypeOnly(e);
call 0 never executed
- -: 867: }
- -: 868: else {
- -: 869: // high nibble
- #####: 870: storeTypeInHighNbl(e);
- -: 871: }
- #####: 872: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+ -: 889: }
+ -: 890: else {
+ -: 891: // high nibble
+ #####: 892: storeTypeInHighNbl(e);
+ -: 893: }
+ #####: 894: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
call 0 never executed
- #####: 873: break;
- -: 874: case ARRAY:
- #####: 875: arrayNetSerialLevel1(r, (sArrayt *)e, ctx);
+ #####: 895: break;
+ -: 896: case ARRAY:
+ #####: 897: arrayNetSerialLevel1(r, (sArrayt *)e, ctx);
call 0 never executed
- #####: 876: break;
- -: 877: case BYTES:
- #####: 878: B = (sBytest *)e;
- #####: 879: if (ctx->nibble == lowNbl) {
+ #####: 898: break;
+ -: 899: case BYTES:
+ #####: 900: B = (sBytest *)e;
+ #####: 901: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 880: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
+ #####: 902: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
call 0 never executed
- -: 881: }
- -: 882: else {
- -: 883: // high nibble
- #####: 884: storeTypeInHighNbl(e);
- #####: 885: uintToVarint(r, B->count);
+ -: 903: }
+ -: 904: else {
+ -: 905: // high nibble
+ #####: 906: storeTypeInHighNbl(e);
+ #####: 907: uintToVarint(r, B->count);
call 0 never executed
- -: 886: }
- #####: 887: sBytesPushBuffer(r, &(B->data), B->count);
+ -: 908: }
+ #####: 909: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- #####: 888: break;
- -: 889: }
- -: 890: }
- -: 891: }
- #####: 892: ret;
- -: 893:}
- -: 894:
+ #####: 910: break;
+ -: 911: }
+ -: 912: }
+ -: 913: }
+ #####: 914: ret;
+ -: 915:}
+ -: 916:
function serialNetSerialLevel1 called 0 returned 0% blocks executed 0%
- #####: 895:internal smallBytest* serialNetSerialLevel1(smallJsont *self) {
- -: 896:
- #####: 897: smallt *o = getsoG(self);
+ #####: 917:internal smallBytest* serialNetSerialLevel1(smallJsont *self) {
+ -: 918:
+ #####: 919: smallt *o = getsoG(self);
call 0 never executed
- -: 898:
- #####: 899: if (o == NULL)
+ -: 920:
+ #####: 921: if (o == NULL)
branch 0 never executed
branch 1 never executed
- #####: 900: ret NULL;
- -: 901:
- #####: 902: sBytest *B = netSerialLevel1(o);
+ #####: 922: ret NULL;
+ -: 923:
+ #####: 924: sBytest *B = netSerialLevel1(o);
call 0 never executed
- -: 903:
- #####: 904: if (!B) {
+ -: 925:
+ #####: 926: if (!B) {
branch 0 never executed
branch 1 never executed
- #####: 905: ret NULL;
- -: 906: }
- -: 907:
- #####: 908: createAllocateSmallBytes(r);
+ #####: 927: ret NULL;
+ -: 928: }
+ -: 929:
+ #####: 930: createAllocateSmallBytes(r);
call 0 never executed
- #####: 909: r->B = B;
- #####: 910: ret r;
- -: 911:}
- -: 912:
- -: 913:// level 2
- -: 914:
+ #####: 931: r->B = B;
+ #####: 932: ret r;
+ -: 933:}
+ -: 934:
+ -: 935:// level 2
+ -: 936:// like level 1, arrays are set to uniform when all elements are same type
+ -: 937:
+ -: 938:/**
+ -: 939: * serializer top function
+ -: 940: */
function netSerialLevel2 called 0 returned 0% blocks executed 0%
- #####: 915:internal sBytest* netSerialLevel2(smallt *o) {
- #####: 916: sBytest *r = NULL;
- #####: 917: sBytest *B = NULL;
- #####: 918: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
- -: 919:
- #####: 920: switch(o->type) {
+ #####: 941:internal sBytest* netSerialLevel2(smallt *o) {
+ #####: 942: sBytest *r = NULL;
+ #####: 943: sBytest *B = NULL;
+ #####: 944: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
+ -: 945:
+ #####: 946: switch(o->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -1339,314 +1365,314 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 921: case UNDEFINED:
- -: 922: case CONTAINER:
- #####: 923: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 never executed
- #####: 924: break;
- -: 925: case BOOL: {
- #####: 926: u8 c = NET_SERIAL_TYPES[(u8)o->type];
- -: 927: // set bit 4 when true
- #####: 928: if (((sBoolt *)&(o->type))->value)
-branch 0 never executed
-branch 1 never executed
- #####: 929: c |= (1<<4);
- #####: 930: sBytesPush(&r, c);
-call 0 never executed
- -: 931: }
- #####: 932: break;
- -: 933: case DICT:
- #####: 934: dictNetSerialLevel2(&r, (sDictt *)&(o->type), &ctx, /*packed=*/false);
-call 0 never executed
- #####: 935: break;
- -: 936: case DOUBLE:
- #####: 937: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 never executed
- #####: 938: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
-call 0 never executed
- #####: 939: break;
- -: 940: case INT: {
- -: 941: // encode int to varint
- -: 942: // v is int64_t to convert to varint
- #####: 943: i64 v = ((sIntt *)&(o->type))->value;
- -: 944: // encode v with arithmetic shifts
- #####: 945: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 946: }
- #####: 947: break;
- -: 948: case STRING:
+ -: 947: case UNDEFINED:
+ -: 948: case CONTAINER:
#####: 949: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
call 0 never executed
- #####: 950: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
-call 0 never executed
- #####: 951: break;
- -: 952: case ARRAY:
- #####: 953: arrayNetSerialLevel2(&r, (sArrayt *)&(o->type), &ctx, /*packed=*/false);
-call 0 never executed
- #####: 954: break;
- -: 955: case BYTES:
- #####: 956: B = (sBytest *)&(o->type);
- #####: 957: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
-call 0 never executed
- #####: 958: sBytesPushBuffer(&r, &(B->data), B->count);
-call 0 never executed
- #####: 959: break;
- -: 960: }
- #####: 961: ret r;
- -: 962:}
- -: 963:
-function isDictUniform called 31 returned 100% blocks executed 69%
- 31: 964:internal u8 isDictUniform(sDictt *dict) {
- 31: 965: bool allElementsHaveSameType = true;
- 31: 966: bool foundFirstType = false;
- 31: 967: u8 type = 0;
- 62: 968: forEachSDict(dict, e) {
-branch 0 taken 68%
-branch 1 taken 32% (fallthrough)
- 42: 969: if (e->key) {
+ #####: 950: break;
+ -: 951: case BOOL: {
+ #####: 952: u8 c = NET_SERIAL_TYPES[(u8)o->type];
+ -: 953: // set bit 4 when true
+ #####: 954: if (((sBoolt *)&(o->type))->value)
+branch 0 never executed
+branch 1 never executed
+ #####: 955: c |= (1<<4);
+ #####: 956: sBytesPush(&r, c);
+call 0 never executed
+ -: 957: }
+ #####: 958: break;
+ -: 959: case DICT:
+ #####: 960: dictNetSerialLevel2(&r, (sDictt *)&(o->type), &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 961: break;
+ -: 962: case DOUBLE:
+ #####: 963: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 never executed
+ #####: 964: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
+call 0 never executed
+ #####: 965: break;
+ -: 966: case INT: {
+ -: 967: // encode int to varint
+ -: 968: // v is int64_t to convert to varint
+ #####: 969: i64 v = ((sIntt *)&(o->type))->value;
+ -: 970: // encode v with arithmetic shifts
+ #####: 971: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 972: }
+ #####: 973: break;
+ -: 974: case STRING:
+ #####: 975: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 never executed
+ #####: 976: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
+call 0 never executed
+ #####: 977: break;
+ -: 978: case ARRAY:
+ #####: 979: arrayNetSerialLevel2(&r, (sArrayt *)&(o->type), &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 980: break;
+ -: 981: case BYTES:
+ #####: 982: B = (sBytest *)&(o->type);
+ #####: 983: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
+call 0 never executed
+ #####: 984: sBytesPushBuffer(&r, &(B->data), B->count);
+call 0 never executed
+ #####: 985: break;
+ -: 986: }
+ #####: 987: ret r;
+ -: 988:}
+ -: 989:
+function isDictUniform called 33 returned 100% blocks executed 69%
+ 33: 990:internal u8 isDictUniform(sDictt *dict) {
+ 33: 991: bool allElementsHaveSameType = true;
+ 33: 992: bool foundFirstType = false;
+ 33: 993: u8 type = 0;
+ 66: 994: forEachSDict(dict, e) {
+branch 0 taken 67%
+branch 1 taken 33% (fallthrough)
+ 44: 995: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 42: 970: if (foundFirstType) {
-branch 0 taken 40% (fallthrough)
-branch 1 taken 60%
- -: 971: u8 nextType;
- 17: 972: switch(e->data->type) {
+ 44: 996: if (foundFirstType) {
+branch 0 taken 39% (fallthrough)
+branch 1 taken 61%
+ -: 997: u8 nextType;
+ 17: 998: switch(e->data->type) {
branch 0 taken 0%
branch 1 taken 0%
branch 2 taken 100%
- -: 973: case DICT:
- #####: 974: nextType = isDictUniform((sDictt*)e->data);
-call 0 never executed
- #####: 975: break;
- -: 976: case ARRAY:
- #####: 977: nextType = isArrayUniform((sArrayt*)e->data);
-call 0 never executed
- #####: 978: break;
- -: 979: default:
- 17: 980: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 981: }
- 17: 982: if (nextType != type) {
+ -: 999: case DICT:
+ #####: 1000: nextType = isDictUniform((sDictt*)e->data);
+call 0 never executed
+ #####: 1001: break;
+ -: 1002: case ARRAY:
+ #####: 1003: nextType = isArrayUniform((sArrayt*)e->data);
+call 0 never executed
+ #####: 1004: break;
+ -: 1005: default:
+ 17: 1006: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1007: }
+ 17: 1008: if (nextType != type) {
branch 0 taken 65% (fallthrough)
branch 1 taken 35%
- 11: 983: allElementsHaveSameType = false;
- 11: 984: break;
- -: 985: }
- -: 986: }
- -: 987: else {
- 25: 988: switch(e->data->type) {
+ 11: 1009: allElementsHaveSameType = false;
+ 11: 1010: break;
+ -: 1011: }
+ -: 1012: }
+ -: 1013: else {
+ 27: 1014: switch(e->data->type) {
branch 0 taken 0%
branch 1 taken 0%
branch 2 taken 100%
- -: 989: case DICT:
- #####: 990: type = isDictUniform((sDictt*)e->data);
-call 0 never executed
- #####: 991: break;
- -: 992: case ARRAY:
- #####: 993: type = isArrayUniform((sArrayt*)e->data);
-call 0 never executed
- #####: 994: break;
- -: 995: default:
- 25: 996: type = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 997: }
- 25: 998: foundFirstType = true;
- -: 999: }
- -: 1000: }
- -: 1001: }
- 31: 1002: if (allElementsHaveSameType)
-branch 0 taken 65% (fallthrough)
-branch 1 taken 35%
- 20: 1003: type = UNIFORM_DICT;
- -: 1004: else
- 11: 1005: type = S_DICT;
- 31: 1006: ret type;
- -: 1007:}
- -: 1008:
-function isArrayUniform called 27 returned 100% blocks executed 58%
- 27: 1009:internal u8 isArrayUniform(sArrayt *array) {
- 27: 1010: bool allElementsHaveSameType = true;
- 27: 1011: bool foundFirstType = false;
- 27: 1012: char type = 0;
- 77: 1013: forEachSArray(array, e) {
+ -: 1015: case DICT:
+ #####: 1016: type = isDictUniform((sDictt*)e->data);
+call 0 never executed
+ #####: 1017: break;
+ -: 1018: case ARRAY:
+ #####: 1019: type = isArrayUniform((sArrayt*)e->data);
+call 0 never executed
+ #####: 1020: break;
+ -: 1021: default:
+ 27: 1022: type = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1023: }
+ 27: 1024: foundFirstType = true;
+ -: 1025: }
+ -: 1026: }
+ -: 1027: }
+ 33: 1028: if (allElementsHaveSameType)
+branch 0 taken 67% (fallthrough)
+branch 1 taken 33%
+ 22: 1029: type = UNIFORM_DICT;
+ -: 1030: else
+ 11: 1031: type = S_DICT;
+ 33: 1032: ret type;
+ -: 1033:}
+ -: 1034:
+function isArrayUniform called 28 returned 100% blocks executed 65%
+ 28: 1035:internal u8 isArrayUniform(sArrayt *array) {
+ 28: 1036: bool allElementsHaveSameType = true;
+ 28: 1037: bool foundFirstType = false;
+ 28: 1038: char type = 0;
+ 79: 1039: forEachSArray(array, e) {
branch 0 taken 73%
branch 1 taken 27% (fallthrough)
- 56: 1014: if (!e) {
+ 58: 1040: if (!e) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 1015: if (foundFirstType) {
+ #####: 1041: if (foundFirstType) {
branch 0 never executed
branch 1 never executed
- #####: 1016: if (type != S_UNDEFINED) {
+ #####: 1042: if (type != S_UNDEFINED) {
branch 0 never executed
branch 1 never executed
- #####: 1017: allElementsHaveSameType = false;
- #####: 1018: break;
- -: 1019: }
- -: 1020: }
- -: 1021: else {
- #####: 1022: type = S_UNDEFINED;
- #####: 1023: foundFirstType = true;
- -: 1024: }
- -: 1025: }
- -: 1026: else {
- 56: 1027: if (foundFirstType) {
+ #####: 1043: allElementsHaveSameType = false;
+ #####: 1044: break;
+ -: 1045: }
+ -: 1046: }
+ -: 1047: else {
+ #####: 1048: type = S_UNDEFINED;
+ #####: 1049: foundFirstType = true;
+ -: 1050: }
+ -: 1051: }
+ -: 1052: else {
+ 58: 1053: if (foundFirstType) {
branch 0 taken 57% (fallthrough)
branch 1 taken 43%
- -: 1028: u8 nextType;
- 32: 1029: switch(e->type) {
+ -: 1054: u8 nextType;
+ 33: 1055: switch(e->type) {
branch 0 taken 0%
branch 1 taken 0%
branch 2 taken 100%
- -: 1030: case DICT:
- #####: 1031: nextType = isDictUniform((sDictt*)e);
-call 0 never executed
- #####: 1032: break;
- -: 1033: case ARRAY:
- #####: 1034: nextType = isArrayUniform((sArrayt*)e);
-call 0 never executed
- #####: 1035: break;
- -: 1036: default:
- 32: 1037: nextType = NET_SERIAL_TYPES[(u8)e->type];
- -: 1038: }
- 32: 1039: if (nextType != type) {
-branch 0 taken 19% (fallthrough)
-branch 1 taken 81%
- 6: 1040: allElementsHaveSameType = false;
- 6: 1041: break;
- -: 1042: }
- -: 1043: }
- -: 1044: else {
- 24: 1045: switch(e->type) {
-branch 0 taken 0%
+ -: 1056: case DICT:
+ #####: 1057: nextType = isDictUniform((sDictt*)e);
+call 0 never executed
+ #####: 1058: break;
+ -: 1059: case ARRAY:
+ #####: 1060: nextType = isArrayUniform((sArrayt*)e);
+call 0 never executed
+ #####: 1061: break;
+ -: 1062: default:
+ 33: 1063: nextType = NET_SERIAL_TYPES[(u8)e->type];
+ -: 1064: }
+ 33: 1065: if (nextType != type) {
+branch 0 taken 21% (fallthrough)
+branch 1 taken 79%
+ 7: 1066: allElementsHaveSameType = false;
+ 7: 1067: break;
+ -: 1068: }
+ -: 1069: }
+ -: 1070: else {
+ 25: 1071: switch(e->type) {
+branch 0 taken 4%
branch 1 taken 0%
-branch 2 taken 100%
- -: 1046: case DICT:
- #####: 1047: type = isDictUniform((sDictt*)e);
-call 0 never executed
- #####: 1048: break;
- -: 1049: case ARRAY:
- #####: 1050: type = isArrayUniform((sArrayt*)e);
-call 0 never executed
- #####: 1051: break;
- -: 1052: default:
- 24: 1053: type = NET_SERIAL_TYPES[(u8)e->type];
- -: 1054: }
- 24: 1055: foundFirstType = true;
- -: 1056: }
- -: 1057: }
- -: 1058: }
- 27: 1059: if (allElementsHaveSameType)
-branch 0 taken 78% (fallthrough)
-branch 1 taken 22%
- 21: 1060: type = UNIFORM_ARRAY;
- -: 1061: else
- 6: 1062: type = S_ARRAY;
- 27: 1063: ret type;
- -: 1064:}
- -: 1065:
- -: 1066:/**
- -: 1067: * serialize dictionary
- -: 1068: *
- -: 1069: * the serialized dict is pushed to r.
- -: 1070: * All elements are serialized recursively
- -: 1071: *
- -: 1072: * the data in containers is not serialized
- -: 1073: *
- -: 1074: * \param
- -: 1075: * r small bytes object
- -: 1076: * dict dictionary to serialize
- -: 1077: */
+branch 2 taken 96%
+ -: 1072: case DICT:
+ 1: 1073: type = isDictUniform((sDictt*)e);
+call 0 returned 100%
+ 1: 1074: break;
+ -: 1075: case ARRAY:
+ #####: 1076: type = isArrayUniform((sArrayt*)e);
+call 0 never executed
+ #####: 1077: break;
+ -: 1078: default:
+ 24: 1079: type = NET_SERIAL_TYPES[(u8)e->type];
+ -: 1080: }
+ 25: 1081: foundFirstType = true;
+ -: 1082: }
+ -: 1083: }
+ -: 1084: }
+ 28: 1085: if (allElementsHaveSameType)
+branch 0 taken 75% (fallthrough)
+branch 1 taken 25%
+ 21: 1086: type = UNIFORM_ARRAY;
+ -: 1087: else
+ 7: 1088: type = S_ARRAY;
+ 28: 1089: ret type;
+ -: 1090:}
+ -: 1091:
+ -: 1092:/**
+ -: 1093: * serialize dictionary
+ -: 1094: *
+ -: 1095: * the serialized dict is pushed to r.
+ -: 1096: * All elements are serialized recursively
+ -: 1097: *
+ -: 1098: * the data in containers is not serialized
+ -: 1099: *
+ -: 1100: * \param
+ -: 1101: * r small bytes object
+ -: 1102: * dict dictionary to serialize
+ -: 1103: */
function dictNetSerialLevel2 called 0 returned 0% blocks executed 0%
- #####: 1078:internal void dictNetSerialLevel2(sBytest **r, sDictt *dict, contextt *ctx, bool packed) {
- #####: 1079: sBytest *B = NULL;
- #####: 1080: char *data = NULL;
- -: 1081:
- -: 1082: // check if all elements have same type
- #####: 1083: bool allElementsHaveSameType = true;
- #####: 1084: bool foundFirstType = false;
- #####: 1085: char type = 0;
- #####: 1086: {forEachSDict(dict, e) {
+ #####: 1104:internal void dictNetSerialLevel2(sBytest **r, sDictt *dict, contextt *ctx, bool packed) {
+ #####: 1105: sBytest *B = NULL;
+ #####: 1106: char *data = NULL;
+ -: 1107:
+ -: 1108: // check if all elements have same type
+ #####: 1109: bool allElementsHaveSameType = true;
+ #####: 1110: bool foundFirstType = false;
+ #####: 1111: char type = 0;
+ #####: 1112: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1087: if (e->key) {
+ #####: 1113: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1088: if (foundFirstType) {
+ #####: 1114: if (foundFirstType) {
branch 0 never executed
branch 1 never executed
- -: 1089: u8 nextType;
- #####: 1090: switch(e->data->type) {
+ -: 1115: u8 nextType;
+ #####: 1116: switch(e->data->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
- -: 1091: case DICT:
- #####: 1092: nextType = isDictUniform((sDictt*)e->data);
+ -: 1117: case DICT:
+ #####: 1118: nextType = isDictUniform((sDictt*)e->data);
call 0 never executed
- #####: 1093: break;
- -: 1094: case ARRAY:
- #####: 1095: nextType = isArrayUniform((sArrayt*)e->data);
+ #####: 1119: break;
+ -: 1120: case ARRAY:
+ #####: 1121: nextType = isArrayUniform((sArrayt*)e->data);
call 0 never executed
- #####: 1096: break;
- -: 1097: default:
- #####: 1098: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 1099: }
- #####: 1100: if (nextType != type) {
+ #####: 1122: break;
+ -: 1123: default:
+ #####: 1124: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1125: }
+ #####: 1126: if (nextType != type) {
branch 0 never executed
branch 1 never executed
- #####: 1101: allElementsHaveSameType = false;
- #####: 1102: break;
- -: 1103: }
- -: 1104: }
- -: 1105: else {
- #####: 1106: switch(e->data->type) {
+ #####: 1127: allElementsHaveSameType = false;
+ #####: 1128: break;
+ -: 1129: }
+ -: 1130: }
+ -: 1131: else {
+ #####: 1132: switch(e->data->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
- -: 1107: case DICT:
- #####: 1108: type = isDictUniform((sDictt*)e->data);
+ -: 1133: case DICT:
+ #####: 1134: type = isDictUniform((sDictt*)e->data);
call 0 never executed
- #####: 1109: break;
- -: 1110: case ARRAY:
- #####: 1111: type = isArrayUniform((sArrayt*)e->data);
+ #####: 1135: break;
+ -: 1136: case ARRAY:
+ #####: 1137: type = isArrayUniform((sArrayt*)e->data);
call 0 never executed
- #####: 1112: break;
- -: 1113: default:
- #####: 1114: type = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 1115: }
- #####: 1116: foundFirstType = true;
- -: 1117: }
- -: 1118: }
- -: 1119: }}
- -: 1120:
- #####: 1121: if (allElementsHaveSameType) {
+ #####: 1138: break;
+ -: 1139: default:
+ #####: 1140: type = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1141: }
+ #####: 1142: foundFirstType = true;
+ -: 1143: }
+ -: 1144: }
+ -: 1145: }}
+ -: 1146:
+ #####: 1147: if (allElementsHaveSameType) {
branch 0 never executed
branch 1 never executed
- -: 1122: // pack dictionary
- #####: 1123: if (packed) {
+ -: 1148: // pack dictionary
+ #####: 1149: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 1124: uintToNetTypeVarint(r, type, dict->count);
+ #####: 1150: uintToNetTypeVarint(r, type, dict->count);
call 0 never executed
- -: 1125: }
- -: 1126: else {
- #####: 1127: if (ctx->nibble == lowNbl) {
+ -: 1151: }
+ -: 1152: else {
+ #####: 1153: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1128: sBytesPush(r, (type << 4) + UNIFORM_DICT);
+ #####: 1154: sBytesPush(r, (type << 4) + UNIFORM_DICT);
call 0 never executed
- #####: 1129: uintToVarint(r, dict->count);
+ #####: 1155: uintToVarint(r, dict->count);
call 0 never executed
- -: 1130: }
- -: 1131: else {
- -: 1132: // high nibble
- #####: 1133: ctx->nibble = lowNbl;
- #####: 1134: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 1135: *data |= UNIFORM_DICT << 4;
- #####: 1136: uintToNetTypeVarint(r, type, dict->count);
+ -: 1156: }
+ -: 1157: else {
+ -: 1158: // high nibble
+ #####: 1159: ctx->nibble = lowNbl;
+ #####: 1160: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 1161: *data |= UNIFORM_DICT << 4;
+ #####: 1162: uintToNetTypeVarint(r, type, dict->count);
call 0 never executed
- -: 1137: }
- -: 1138: }
- -: 1139:
- #####: 1140: switch(type) {
+ -: 1163: }
+ -: 1164: }
+ -: 1165:
+ #####: 1166: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -1656,188 +1682,188 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 1141: case S_UNDEFINED:
- #####: 1142: {forEachSDict(dict, e) {
+ -: 1167: case S_UNDEFINED:
+ #####: 1168: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1143: if (e->key) {
+ #####: 1169: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1144: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1170: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- -: 1145: }
- -: 1146: }}
- -: 1147:
- #####: 1148: break;
- -: 1149: case S_BOOL:
- #####: 1150: {forEachSDict(dict, e) {
+ -: 1171: }
+ -: 1172: }}
+ -: 1173:
+ #####: 1174: break;
+ -: 1175: case S_BOOL:
+ #####: 1176: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1151: if (e->key) {
+ #####: 1177: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1152: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1178: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- -: 1153:
- #####: 1154: if (!ctx->boolOffset) {
+ -: 1179:
+ #####: 1180: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 1155: // new packed bools
- #####: 1156: storeNew8bPackedBool(e->data);
+ -: 1181: // new packed bools
+ #####: 1182: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1157: }
- -: 1158: else {
- -: 1159: // there was a bool before this one, fill bits in nibbles
- #####: 1160: if (ctx->boolShift == 8) {
+ -: 1183: }
+ -: 1184: else {
+ -: 1185: // there was a bool before this one, fill bits in nibbles
+ #####: 1186: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1161: // previous packed bool is full
- -: 1162: // next byte is the new packed bools
- #####: 1163: storeNew8bPackedBool(e->data);
+ -: 1187: // previous packed bool is full
+ -: 1188: // next byte is the new packed bools
+ #####: 1189: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1164: }
- -: 1165: else {
- #####: 1166: storeBool(e->data);
+ -: 1190: }
+ -: 1191: else {
+ #####: 1192: storeBool(e->data);
branch 0 never executed
branch 1 never executed
- -: 1167: }
- -: 1168: }
- -: 1169: }
- -: 1170: }}
- #####: 1171: break;
- -: 1172: case S_DICT:
- -: 1173: case UNIFORM_DICT:
- #####: 1174: {forEachSDict(dict, e) {
+ -: 1193: }
+ -: 1194: }
+ -: 1195: }
+ -: 1196: }}
+ #####: 1197: break;
+ -: 1198: case S_DICT:
+ -: 1199: case UNIFORM_DICT:
+ #####: 1200: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1175: if (e->key) {
+ #####: 1201: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1176: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1202: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1177: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/true);
+ #####: 1203: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/true);
call 0 never executed
- -: 1178: }
- -: 1179: }}
- #####: 1180: break;
- -: 1181: case S_DOUBLE:
- #####: 1182: {forEachSDict(dict, e) {
+ -: 1204: }
+ -: 1205: }}
+ #####: 1206: break;
+ -: 1207: case S_DOUBLE:
+ #####: 1208: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1183: if (e->key) {
+ #####: 1209: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1184: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1210: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1185: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+ #####: 1211: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
call 0 never executed
- -: 1186: }
- -: 1187: }}
- #####: 1188: break;
- -: 1189: case S_INT:
- #####: 1190: {forEachSDict(dict, e) {
+ -: 1212: }
+ -: 1213: }}
+ #####: 1214: break;
+ -: 1215: case S_INT:
+ #####: 1216: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1191: if (e->key) {
+ #####: 1217: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1192: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1218: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1193: i64 v = ((sIntt *)(e->data))->value;
- #####: 1194: uintToVarint(r, (v << 1) ^ (v >> 63));
+ #####: 1219: i64 v = ((sIntt *)(e->data))->value;
+ #####: 1220: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 never executed
- -: 1195: }
- -: 1196: }}
- #####: 1197: break;
- -: 1198: case S_STRING:
- #####: 1199: {forEachSDict(dict, e) {
+ -: 1221: }
+ -: 1222: }}
+ #####: 1223: break;
+ -: 1224: case S_STRING:
+ #####: 1225: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1200: if (e->key) {
+ #####: 1226: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1201: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1227: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1202: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+ #####: 1228: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
call 0 never executed
- -: 1203: }
- -: 1204: }}
- #####: 1205: break;
- -: 1206: case S_ARRAY:
- -: 1207: case UNIFORM_ARRAY:
- #####: 1208: {forEachSDict(dict, e) {
+ -: 1229: }
+ -: 1230: }}
+ #####: 1231: break;
+ -: 1232: case S_ARRAY:
+ -: 1233: case UNIFORM_ARRAY:
+ #####: 1234: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1209: if (e->key) {
+ #####: 1235: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1210: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1236: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1211: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/true);
+ #####: 1237: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/true);
call 0 never executed
- -: 1212: }
- -: 1213: }}
- #####: 1214: break;
- -: 1215: case S_BYTES:
- #####: 1216: {forEachSDict(dict, e) {
+ -: 1238: }
+ -: 1239: }}
+ #####: 1240: break;
+ -: 1241: case S_BYTES:
+ #####: 1242: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1217: if (e->key) {
+ #####: 1243: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1218: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1244: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1219: B = (sBytest *)(e->data);
- #####: 1220: uintToVarint(r, B->count);
+ #####: 1245: B = (sBytest *)(e->data);
+ #####: 1246: uintToVarint(r, B->count);
call 0 never executed
- #####: 1221: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 1247: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 1222: }
- -: 1223: }}
- #####: 1224: break;
- -: 1225: }
- #####: 1226: ret;
- -: 1227: }
- -: 1228:
- #####: 1229: if (packed) {
+ -: 1248: }
+ -: 1249: }}
+ #####: 1250: break;
+ -: 1251: }
+ #####: 1252: ret;
+ -: 1253: }
+ -: 1254:
+ #####: 1255: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 1230: uintToVarint(r, dict->count);
+ #####: 1256: uintToVarint(r, dict->count);
call 0 never executed
- -: 1231: }
- -: 1232: else {
- #####: 1233: if (ctx->nibble == lowNbl) {
+ -: 1257: }
+ -: 1258: else {
+ #####: 1259: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1234: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
+ #####: 1260: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
call 0 never executed
- -: 1235: }
- -: 1236: else {
- -: 1237: // high nibble
- -: 1238:#define storeTypeInHighNbl(o)\
- -: 1239: ctx->nibble = lowNbl;\
- -: 1240: data = (char *)&((*r)->data) + ctx->nblOffset;\
- -: 1241: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
- #####: 1242: storeTypeInHighNbl(dict);
- #####: 1243: uintToVarint(r, dict->count);
+ -: 1261: }
+ -: 1262: else {
+ -: 1263: // high nibble
+ -: 1264:#define storeTypeInHighNbl(o)\
+ -: 1265: ctx->nibble = lowNbl;\
+ -: 1266: data = (char *)&((*r)->data) + ctx->nblOffset;\
+ -: 1267: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
+ #####: 1268: storeTypeInHighNbl(dict);
+ #####: 1269: uintToVarint(r, dict->count);
call 0 never executed
- -: 1244: }
- -: 1245: }
- -: 1246:
- #####: 1247: forEachSDict(dict, e) {
+ -: 1270: }
+ -: 1271: }
+ -: 1272:
+ #####: 1273: forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1248: if (e->key) {
+ #####: 1274: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1249: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1275: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- -: 1250:
- #####: 1251: switch(e->data->type) {
+ -: 1276:
+ #####: 1277: switch(e->data->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -1847,307 +1873,307 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 1252: case UNDEFINED:
- -: 1253: case CONTAINER:
- #####: 1254: if (ctx->nibble == lowNbl) {
+ -: 1278: case UNDEFINED:
+ -: 1279: case CONTAINER:
+ #####: 1280: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 1255: #define storeTypeOnly(o)\
- -: 1256: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
- -: 1257: ctx->nibble = highNbl;\
- -: 1258: ctx->nblOffset = (*r)->count -1
- #####: 1259: storeTypeOnly(e->data);
+ -: 1281: #define storeTypeOnly(o)\
+ -: 1282: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
+ -: 1283: ctx->nibble = highNbl;\
+ -: 1284: ctx->nblOffset = (*r)->count -1
+ #####: 1285: storeTypeOnly(e->data);
call 0 never executed
- -: 1260: }
- -: 1261: else {
- #####: 1262: storeTypeInHighNbl(e->data);
- -: 1263: }
- #####: 1264: break;
- -: 1265: case BOOL:
- #####: 1266: if (!ctx->boolOffset) {
+ -: 1286: }
+ -: 1287: else {
+ #####: 1288: storeTypeInHighNbl(e->data);
+ -: 1289: }
+ #####: 1290: break;
+ -: 1291: case BOOL:
+ #####: 1292: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 1267: // new packed bools
- #####: 1268: if (ctx->nibble == lowNbl) {
+ -: 1293: // new packed bools
+ #####: 1294: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 1269: #define storeNew4bPackedBool(o)\
- -: 1270: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
- -: 1271: /* set bit 4 when true */\
- -: 1272: if (((sBoolt *)(o))->value)\
- -: 1273: c |= (1<<4);\
- -: 1274: sBytesPush(r, c);\
- -: 1275: ctx->boolShift = 5;\
- -: 1276: ctx->boolOffset = (*r)->count -1
- #####: 1277: storeNew4bPackedBool(e->data);
+ -: 1295: #define storeNew4bPackedBool(o)\
+ -: 1296: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
+ -: 1297: /* set bit 4 when true */\
+ -: 1298: if (((sBoolt *)(o))->value)\
+ -: 1299: c |= (1<<4);\
+ -: 1300: sBytesPush(r, c);\
+ -: 1301: ctx->boolShift = 5;\
+ -: 1302: ctx->boolOffset = (*r)->count -1
+ #####: 1303: storeNew4bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1278: }
- -: 1279: else {
- -: 1280: // high nibble, next byte is packed bools
- #####: 1281: storeTypeInHighNbl(e->data);
- -: 1282: #define storeNew8bPackedBool(o)\
- -: 1283: u8 c = 0;\
- -: 1284: if (((sBoolt *)(o))->value)\
- -: 1285: c = 1;\
- -: 1286: sBytesPush(r, c);\
- -: 1287: ctx->boolShift = 1;\
- -: 1288: ctx->boolOffset = (*r)->count -1
- #####: 1289: storeNew8bPackedBool(e->data);
+ -: 1304: }
+ -: 1305: else {
+ -: 1306: // high nibble, next byte is packed bools
+ #####: 1307: storeTypeInHighNbl(e->data);
+ -: 1308: #define storeNew8bPackedBool(o)\
+ -: 1309: u8 c = 0;\
+ -: 1310: if (((sBoolt *)(o))->value)\
+ -: 1311: c = 1;\
+ -: 1312: sBytesPush(r, c);\
+ -: 1313: ctx->boolShift = 1;\
+ -: 1314: ctx->boolOffset = (*r)->count -1
+ #####: 1315: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1290: }
- -: 1291: }
- -: 1292: else {
- -: 1293: // there was a bool before this one, fill bits in nibbles
- #####: 1294: if (ctx->nibble == lowNbl) {
+ -: 1316: }
+ -: 1317: }
+ -: 1318: else {
+ -: 1319: // there was a bool before this one, fill bits in nibbles
+ #####: 1320: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1295: if (ctx->boolShift == 8) {
+ #####: 1321: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1296: // previous packed bool is full
- -: 1297: // this byte is the new packed bools
- #####: 1298: storeNew4bPackedBool(e->data);
+ -: 1322: // previous packed bool is full
+ -: 1323: // this byte is the new packed bools
+ #####: 1324: storeNew4bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1299: }
- -: 1300: else {
- #####: 1301: storeTypeOnly(e->data);
+ -: 1325: }
+ -: 1326: else {
+ #####: 1327: storeTypeOnly(e->data);
call 0 never executed
- -: 1302: #define storeBool(o)\
- -: 1303: data = (char *)&((*r)->data) + ctx->boolOffset;\
- -: 1304: if (((sBoolt *)(o))->value)\
- -: 1305: *data |= 1 << ctx->boolShift;\
- -: 1306: ctx->boolShift++
- #####: 1307: storeBool(e->data);
+ -: 1328: #define storeBool(o)\
+ -: 1329: data = (char *)&((*r)->data) + ctx->boolOffset;\
+ -: 1330: if (((sBoolt *)(o))->value)\
+ -: 1331: *data |= 1 << ctx->boolShift;\
+ -: 1332: ctx->boolShift++
+ #####: 1333: storeBool(e->data);
branch 0 never executed
branch 1 never executed
- -: 1308: }
- -: 1309: }
- -: 1310: else {
- -: 1311: // high nibble
- #####: 1312: storeTypeInHighNbl(e->data);
- #####: 1313: if (ctx->boolShift == 8) {
+ -: 1334: }
+ -: 1335: }
+ -: 1336: else {
+ -: 1337: // high nibble
+ #####: 1338: storeTypeInHighNbl(e->data);
+ #####: 1339: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1314: // previous packed bool is full
- -: 1315: // next byte is the new packed bools
- #####: 1316: storeNew8bPackedBool(e->data);
+ -: 1340: // previous packed bool is full
+ -: 1341: // next byte is the new packed bools
+ #####: 1342: storeNew8bPackedBool(e->data);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1317: }
- -: 1318: else {
- #####: 1319: storeBool(e->data);
-branch 0 never executed
-branch 1 never executed
- -: 1320: }
- -: 1321: }
- -: 1322: }
- #####: 1323: break;
- -: 1324: case DICT:
- #####: 1325: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/false);
-call 0 never executed
- #####: 1326: break;
- -: 1327: case DOUBLE:
- #####: 1328: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 1329: storeTypeOnly(e->data);
-call 0 never executed
- -: 1330: }
- -: 1331: else {
- -: 1332: // high nibble
- #####: 1333: storeTypeInHighNbl(e->data);
- -: 1334: }
- #####: 1335: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 never executed
- #####: 1336: break;
- -: 1337: case INT: {
- -: 1338: // encode int to varint
- -: 1339: // v is int64_t to convert to varint
- #####: 1340: i64 v = ((sIntt *)(e->data))->value;
- #####: 1341: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- -: 1342: // encode v with arithmetic shifts
- #####: 1343: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 1344: }
- -: 1345: else {
- -: 1346: // high nibble
- #####: 1347: storeTypeInHighNbl(e->data);
- #####: 1348: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 never executed
- -: 1349: }
- -: 1350: }
- #####: 1351: break;
- -: 1352: case STRING:
- #####: 1353: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 1354: storeTypeOnly(e->data);
-call 0 never executed
- -: 1355: }
- -: 1356: else {
- -: 1357: // high nibble
- #####: 1358: storeTypeInHighNbl(e->data);
- -: 1359: }
- #####: 1360: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
-call 0 never executed
- #####: 1361: break;
- -: 1362: case ARRAY:
- #####: 1363: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/false);
-call 0 never executed
- #####: 1364: break;
- -: 1365: case BYTES:
- #####: 1366: B = (sBytest *)(e->data);
- #####: 1367: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 1368: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
-call 0 never executed
- -: 1369: }
- -: 1370: else {
- -: 1371: // high nibble
- #####: 1372: storeTypeInHighNbl(e->data);
- #####: 1373: uintToVarint(r, B->count);
-call 0 never executed
- -: 1374: }
- #####: 1375: sBytesPushBuffer(r, &(B->data), B->count);
-call 0 never executed
- #####: 1376: break;
- -: 1377: }
- -: 1378: }
- -: 1379: }
- #####: 1380: ret;
- -: 1381:}
- -: 1382:
- -: 1383:/**
- -: 1384: * serialize array
- -: 1385: *
- -: 1386: * the serialized array is pushed to r.
- -: 1387: * All elements are serialized recursively
- -: 1388: *
- -: 1389: * the data in containers is not serialized
- -: 1390: *
- -: 1391: * \param
- -: 1392: * r small bytes object
- -: 1393: * array to serialize
- -: 1394: */
+ -: 1343: }
+ -: 1344: else {
+ #####: 1345: storeBool(e->data);
+branch 0 never executed
+branch 1 never executed
+ -: 1346: }
+ -: 1347: }
+ -: 1348: }
+ #####: 1349: break;
+ -: 1350: case DICT:
+ #####: 1351: dictNetSerialLevel2(r, (sDictt *)(e->data), ctx, /*packed=*/false);
+call 0 never executed
+ #####: 1352: break;
+ -: 1353: case DOUBLE:
+ #####: 1354: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 1355: storeTypeOnly(e->data);
+call 0 never executed
+ -: 1356: }
+ -: 1357: else {
+ -: 1358: // high nibble
+ #####: 1359: storeTypeInHighNbl(e->data);
+ -: 1360: }
+ #####: 1361: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 never executed
+ #####: 1362: break;
+ -: 1363: case INT: {
+ -: 1364: // encode int to varint
+ -: 1365: // v is int64_t to convert to varint
+ #####: 1366: i64 v = ((sIntt *)(e->data))->value;
+ #####: 1367: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ -: 1368: // encode v with arithmetic shifts
+ #####: 1369: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 1370: }
+ -: 1371: else {
+ -: 1372: // high nibble
+ #####: 1373: storeTypeInHighNbl(e->data);
+ #####: 1374: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 never executed
+ -: 1375: }
+ -: 1376: }
+ #####: 1377: break;
+ -: 1378: case STRING:
+ #####: 1379: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 1380: storeTypeOnly(e->data);
+call 0 never executed
+ -: 1381: }
+ -: 1382: else {
+ -: 1383: // high nibble
+ #####: 1384: storeTypeInHighNbl(e->data);
+ -: 1385: }
+ #####: 1386: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+call 0 never executed
+ #####: 1387: break;
+ -: 1388: case ARRAY:
+ #####: 1389: arrayNetSerialLevel2(r, (sArrayt *)(e->data), ctx, /*packed=*/false);
+call 0 never executed
+ #####: 1390: break;
+ -: 1391: case BYTES:
+ #####: 1392: B = (sBytest *)(e->data);
+ #####: 1393: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 1394: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
+call 0 never executed
+ -: 1395: }
+ -: 1396: else {
+ -: 1397: // high nibble
+ #####: 1398: storeTypeInHighNbl(e->data);
+ #####: 1399: uintToVarint(r, B->count);
+call 0 never executed
+ -: 1400: }
+ #####: 1401: sBytesPushBuffer(r, &(B->data), B->count);
+call 0 never executed
+ #####: 1402: break;
+ -: 1403: }
+ -: 1404: }
+ -: 1405: }
+ #####: 1406: ret;
+ -: 1407:}
+ -: 1408:
+ -: 1409:/**
+ -: 1410: * serialize array
+ -: 1411: *
+ -: 1412: * the serialized array is pushed to r.
+ -: 1413: * All elements are serialized recursively
+ -: 1414: *
+ -: 1415: * the data in containers is not serialized
+ -: 1416: *
+ -: 1417: * \param
+ -: 1418: * r small bytes object
+ -: 1419: * array to serialize
+ -: 1420: */
function arrayNetSerialLevel2 called 0 returned 0% blocks executed 0%
- #####: 1395:internal void arrayNetSerialLevel2(sBytest **r, sArrayt *array, contextt *ctx, bool packed) {
- #####: 1396: sBytest *B = NULL;
- #####: 1397: char *data = NULL;
- -: 1398:
- -: 1399: // check if all elements have same type
- #####: 1400: bool allElementsHaveSameType = true;
- #####: 1401: bool foundFirstType = false;
- #####: 1402: char type = 0;
- -: 1403:
- #####: 1404: {forEachSArray(array, e) {
+ #####: 1421:internal void arrayNetSerialLevel2(sBytest **r, sArrayt *array, contextt *ctx, bool packed) {
+ #####: 1422: sBytest *B = NULL;
+ #####: 1423: char *data = NULL;
+ -: 1424:
+ -: 1425: // check if all elements have same type
+ #####: 1426: bool allElementsHaveSameType = true;
+ #####: 1427: bool foundFirstType = false;
+ #####: 1428: char type = 0;
+ -: 1429:
+ #####: 1430: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1405: if (!e) {
+ #####: 1431: if (!e) {
branch 0 never executed
branch 1 never executed
- #####: 1406: if (foundFirstType) {
+ #####: 1432: if (foundFirstType) {
branch 0 never executed
branch 1 never executed
- #####: 1407: if (type != S_UNDEFINED) {
+ #####: 1433: if (type != S_UNDEFINED) {
branch 0 never executed
branch 1 never executed
- #####: 1408: allElementsHaveSameType = false;
- #####: 1409: break;
- -: 1410: }
- -: 1411: }
- -: 1412: else {
- #####: 1413: type = S_UNDEFINED;
- #####: 1414: foundFirstType = true;
- -: 1415: }
- -: 1416: }
- -: 1417: else {
- #####: 1418: if (foundFirstType) {
+ #####: 1434: allElementsHaveSameType = false;
+ #####: 1435: break;
+ -: 1436: }
+ -: 1437: }
+ -: 1438: else {
+ #####: 1439: type = S_UNDEFINED;
+ #####: 1440: foundFirstType = true;
+ -: 1441: }
+ -: 1442: }
+ -: 1443: else {
+ #####: 1444: if (foundFirstType) {
branch 0 never executed
branch 1 never executed
- -: 1419: u8 nextType;
- #####: 1420: switch(e->type) {
+ -: 1445: u8 nextType;
+ #####: 1446: switch(e->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
- -: 1421: case DICT:
- #####: 1422: nextType = isDictUniform((sDictt*)e);
+ -: 1447: case DICT:
+ #####: 1448: nextType = isDictUniform((sDictt*)e);
call 0 never executed
- #####: 1423: break;
- -: 1424: case ARRAY:
- #####: 1425: nextType = isArrayUniform((sArrayt*)e);
+ #####: 1449: break;
+ -: 1450: case ARRAY:
+ #####: 1451: nextType = isArrayUniform((sArrayt*)e);
call 0 never executed
- #####: 1426: break;
- -: 1427: default:
- #####: 1428: nextType = NET_SERIAL_TYPES[(u8)e->type];
- -: 1429: }
- #####: 1430: if (nextType != type) {
+ #####: 1452: break;
+ -: 1453: default:
+ #####: 1454: nextType = NET_SERIAL_TYPES[(u8)e->type];
+ -: 1455: }
+ #####: 1456: if (nextType != type) {
branch 0 never executed
branch 1 never executed
- #####: 1431: allElementsHaveSameType = false;
- #####: 1432: break;
- -: 1433: }
- -: 1434: }
- -: 1435: else {
- #####: 1436: switch(e->type) {
+ #####: 1457: allElementsHaveSameType = false;
+ #####: 1458: break;
+ -: 1459: }
+ -: 1460: }
+ -: 1461: else {
+ #####: 1462: switch(e->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
- -: 1437: case DICT:
- #####: 1438: type = isDictUniform((sDictt*)e);
+ -: 1463: case DICT:
+ #####: 1464: type = isDictUniform((sDictt*)e);
call 0 never executed
- #####: 1439: break;
- -: 1440: case ARRAY:
- #####: 1441: type = isArrayUniform((sArrayt*)e);
+ #####: 1465: break;
+ -: 1466: case ARRAY:
+ #####: 1467: type = isArrayUniform((sArrayt*)e);
call 0 never executed
- #####: 1442: break;
- -: 1443: default:
- #####: 1444: type = NET_SERIAL_TYPES[(u8)e->type];
- -: 1445: }
- #####: 1446: foundFirstType = true;
- -: 1447: }
- -: 1448: }
- -: 1449: }}
- -: 1450:
- #####: 1451: if (allElementsHaveSameType) {
+ #####: 1468: break;
+ -: 1469: default:
+ #####: 1470: type = NET_SERIAL_TYPES[(u8)e->type];
+ -: 1471: }
+ #####: 1472: foundFirstType = true;
+ -: 1473: }
+ -: 1474: }
+ -: 1475: }}
+ -: 1476:
+ #####: 1477: if (allElementsHaveSameType) {
branch 0 never executed
branch 1 never executed
- -: 1452: // pack array
- #####: 1453: if (packed) {
+ -: 1478: // pack array
+ #####: 1479: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 1454: uintToNetTypeVarint(r, type, array->count);
+ #####: 1480: uintToNetTypeVarint(r, type, array->count);
call 0 never executed
- -: 1455: }
- -: 1456: else {
- #####: 1457: if (ctx->nibble == lowNbl) {
+ -: 1481: }
+ -: 1482: else {
+ #####: 1483: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1458: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
+ #####: 1484: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
call 0 never executed
- #####: 1459: uintToVarint(r, array->count);
+ #####: 1485: uintToVarint(r, array->count);
call 0 never executed
- -: 1460: }
- -: 1461: else {
- -: 1462: // high nibble
- #####: 1463: ctx->nibble = lowNbl;
- #####: 1464: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 1465: *data |= UNIFORM_ARRAY << 4;
- #####: 1466: uintToNetTypeVarint(r, type, array->count);
+ -: 1486: }
+ -: 1487: else {
+ -: 1488: // high nibble
+ #####: 1489: ctx->nibble = lowNbl;
+ #####: 1490: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 1491: *data |= UNIFORM_ARRAY << 4;
+ #####: 1492: uintToNetTypeVarint(r, type, array->count);
call 0 never executed
- -: 1467: }
- -: 1468: }
- -: 1469:
- #####: 1470: switch(type) {
+ -: 1493: }
+ -: 1494: }
+ -: 1495:
+ #####: 1496: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -2156,142 +2182,142 @@ branch 4 never executed
branch 5 never executed
branch 6 never executed
branch 7 never executed
- -: 1471: case S_BOOL:
- #####: 1472: {forEachSArray(array, e) {
+ -: 1497: case S_BOOL:
+ #####: 1498: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1473: if (!ctx->boolOffset) {
+ #####: 1499: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 1474: // new packed bools
- #####: 1475: storeNew8bPackedBool(e);
+ -: 1500: // new packed bools
+ #####: 1501: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1476: }
- -: 1477: else {
- -: 1478: // there was a bool before this one, fill bits in nibbles
- #####: 1479: if (ctx->boolShift == 8) {
+ -: 1502: }
+ -: 1503: else {
+ -: 1504: // there was a bool before this one, fill bits in nibbles
+ #####: 1505: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1480: // previous packed bool is full
- -: 1481: // next byte is the new packed bools
- #####: 1482: storeNew8bPackedBool(e);
+ -: 1506: // previous packed bool is full
+ -: 1507: // next byte is the new packed bools
+ #####: 1508: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1483: }
- -: 1484: else {
- #####: 1485: storeBool(e);
+ -: 1509: }
+ -: 1510: else {
+ #####: 1511: storeBool(e);
branch 0 never executed
branch 1 never executed
- -: 1486: }
- -: 1487: }
- -: 1488: }}
- #####: 1489: break;
- -: 1490: case S_DICT:
- -: 1491: case UNIFORM_DICT:
- #####: 1492: {forEachSArray(array, e) {
+ -: 1512: }
+ -: 1513: }
+ -: 1514: }}
+ #####: 1515: break;
+ -: 1516: case S_DICT:
+ -: 1517: case UNIFORM_DICT:
+ #####: 1518: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1493: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/true);
+ #####: 1519: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/true);
call 0 never executed
- -: 1494: }}
- #####: 1495: break;
- -: 1496: case S_DOUBLE:
- #####: 1497: {forEachSArray(array, e) {
+ -: 1520: }}
+ #####: 1521: break;
+ -: 1522: case S_DOUBLE:
+ #####: 1523: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1498: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+ #####: 1524: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
call 0 never executed
- -: 1499: }}
- #####: 1500: break;
- -: 1501: case S_INT:
- #####: 1502: {forEachSArray(array, e) {
+ -: 1525: }}
+ #####: 1526: break;
+ -: 1527: case S_INT:
+ #####: 1528: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1503: i64 v = ((sIntt *)e)->value;
- #####: 1504: uintToVarint(r, (v << 1) ^ (v >> 63));
+ #####: 1529: i64 v = ((sIntt *)e)->value;
+ #####: 1530: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 never executed
- -: 1505: }}
- #####: 1506: break;
- -: 1507: case S_STRING:
- #####: 1508: {forEachSArray(array, e) {
+ -: 1531: }}
+ #####: 1532: break;
+ -: 1533: case S_STRING:
+ #####: 1534: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1509: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+ #####: 1535: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
call 0 never executed
- -: 1510: }}
- #####: 1511: break;
- -: 1512: case S_ARRAY:
- -: 1513: case UNIFORM_ARRAY:
- #####: 1514: {forEachSArray(array, e) {
+ -: 1536: }}
+ #####: 1537: break;
+ -: 1538: case S_ARRAY:
+ -: 1539: case UNIFORM_ARRAY:
+ #####: 1540: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1515: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/true);
+ #####: 1541: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/true);
call 0 never executed
- -: 1516: }}
- #####: 1517: break;
- -: 1518: case S_BYTES:
- #####: 1519: {forEachSArray(array, e) {
+ -: 1542: }}
+ #####: 1543: break;
+ -: 1544: case S_BYTES:
+ #####: 1545: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1520: B = (sBytest *)e;
- #####: 1521: uintToVarint(r, B->count);
+ #####: 1546: B = (sBytest *)e;
+ #####: 1547: uintToVarint(r, B->count);
call 0 never executed
- #####: 1522: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 1548: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 1523: }}
- #####: 1524: break;
- -: 1525: }
- #####: 1526: ret;
- -: 1527: }
- -: 1528:
- #####: 1529: if (packed) {
+ -: 1549: }}
+ #####: 1550: break;
+ -: 1551: }
+ #####: 1552: ret;
+ -: 1553: }
+ -: 1554:
+ #####: 1555: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 1530: uintToVarint(r, array->count);
+ #####: 1556: uintToVarint(r, array->count);
call 0 never executed
- -: 1531: }
- -: 1532: else {
- #####: 1533: if (ctx->nibble == lowNbl) {
+ -: 1557: }
+ -: 1558: else {
+ #####: 1559: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1534: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
+ #####: 1560: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
call 0 never executed
- -: 1535: }
- -: 1536: else {
- -: 1537: // high nibble
- #####: 1538: storeTypeInHighNbl(array);
- #####: 1539: uintToVarint(r, array->count);
+ -: 1561: }
+ -: 1562: else {
+ -: 1563: // high nibble
+ #####: 1564: storeTypeInHighNbl(array);
+ #####: 1565: uintToVarint(r, array->count);
call 0 never executed
- -: 1540: }
- -: 1541: }
- -: 1542:
- #####: 1543: forEachSArray(array, e) {
+ -: 1566: }
+ -: 1567: }
+ -: 1568:
+ #####: 1569: forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 1544: if (!e) {
+ #####: 1570: if (!e) {
branch 0 never executed
branch 1 never executed
- -: 1545: // empty slots are represented as undefined elements
- #####: 1546: if (ctx->nibble == lowNbl) {
+ -: 1571: // empty slots are represented as undefined elements
+ #####: 1572: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1547: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
+ #####: 1573: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
call 0 never executed
- #####: 1548: ctx->nibble = highNbl;
- #####: 1549: ctx->nblOffset = (*r)->count -1;
- -: 1550: }
- -: 1551: else {
- -: 1552: // high nibble
- #####: 1553: ctx->nibble = lowNbl;
- #####: 1554: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 1555: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
- -: 1556: }
- -: 1557: }
- -: 1558: else {
- #####: 1559: switch(e->type) {
+ #####: 1574: ctx->nibble = highNbl;
+ #####: 1575: ctx->nblOffset = (*r)->count -1;
+ -: 1576: }
+ -: 1577: else {
+ -: 1578: // high nibble
+ #####: 1579: ctx->nibble = lowNbl;
+ #####: 1580: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 1581: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
+ -: 1582: }
+ -: 1583: }
+ -: 1584: else {
+ #####: 1585: switch(e->type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -2301,623 +2327,640 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 1560: case UNDEFINED:
- -: 1561: case CONTAINER:
- #####: 1562: if (ctx->nibble == lowNbl) {
+ -: 1586: case UNDEFINED:
+ -: 1587: case CONTAINER:
+ #####: 1588: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1563: storeTypeOnly(e);
+ #####: 1589: storeTypeOnly(e);
call 0 never executed
- -: 1564: }
- -: 1565: else {
- -: 1566: // high nibble
- #####: 1567: storeTypeInHighNbl(e);
- -: 1568: }
- #####: 1569: break;
- -: 1570: case BOOL:
- #####: 1571: if (!ctx->boolOffset) {
+ -: 1590: }
+ -: 1591: else {
+ -: 1592: // high nibble
+ #####: 1593: storeTypeInHighNbl(e);
+ -: 1594: }
+ #####: 1595: break;
+ -: 1596: case BOOL:
+ #####: 1597: if (!ctx->boolOffset) {
branch 0 never executed
branch 1 never executed
- -: 1572: // new packed bools
- #####: 1573: if (ctx->nibble == lowNbl) {
+ -: 1598: // new packed bools
+ #####: 1599: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1574: storeNew4bPackedBool(e);
+ #####: 1600: storeNew4bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1575: }
- -: 1576: else {
- -: 1577: // high nibble, next byte is packed bools
- #####: 1578: storeTypeInHighNbl(e);
- #####: 1579: storeNew8bPackedBool(e);
+ -: 1601: }
+ -: 1602: else {
+ -: 1603: // high nibble, next byte is packed bools
+ #####: 1604: storeTypeInHighNbl(e);
+ #####: 1605: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1580: }
- -: 1581: }
- -: 1582: else {
- -: 1583: // there was a bool before this one, fill bits in nibbles
- #####: 1584: if (ctx->nibble == lowNbl) {
+ -: 1606: }
+ -: 1607: }
+ -: 1608: else {
+ -: 1609: // there was a bool before this one, fill bits in nibbles
+ #####: 1610: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1585: if (ctx->boolShift == 8) {
+ #####: 1611: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1586: // previous packed bool is full
- -: 1587: // this byte is the new packed bools
- #####: 1588: storeNew4bPackedBool(e);
+ -: 1612: // previous packed bool is full
+ -: 1613: // this byte is the new packed bools
+ #####: 1614: storeNew4bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1589: }
- -: 1590: else {
- #####: 1591: storeTypeOnly(e);
+ -: 1615: }
+ -: 1616: else {
+ #####: 1617: storeTypeOnly(e);
call 0 never executed
- #####: 1592: storeBool(e);
+ #####: 1618: storeBool(e);
branch 0 never executed
branch 1 never executed
- -: 1593: }
- -: 1594: }
- -: 1595: else {
- -: 1596: // high nibble
- #####: 1597: storeTypeInHighNbl(e);
- #####: 1598: if (ctx->boolShift == 8) {
+ -: 1619: }
+ -: 1620: }
+ -: 1621: else {
+ -: 1622: // high nibble
+ #####: 1623: storeTypeInHighNbl(e);
+ #####: 1624: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- -: 1599: // previous packed bool is full
- -: 1600: // next byte is the new packed bools
- #####: 1601: storeNew8bPackedBool(e);
+ -: 1625: // previous packed bool is full
+ -: 1626: // next byte is the new packed bools
+ #####: 1627: storeNew8bPackedBool(e);
branch 0 never executed
branch 1 never executed
call 2 never executed
- -: 1602: }
- -: 1603: else {
- #####: 1604: storeBool(e);
+ -: 1628: }
+ -: 1629: else {
+ #####: 1630: storeBool(e);
branch 0 never executed
branch 1 never executed
- -: 1605: }
- -: 1606: }
- -: 1607: }
- #####: 1608: break;
- -: 1609: case DICT:
- #####: 1610: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/false);
+ -: 1631: }
+ -: 1632: }
+ -: 1633: }
+ #####: 1634: break;
+ -: 1635: case DICT:
+ #####: 1636: dictNetSerialLevel2(r, (sDictt *)e, ctx, /*packed=*/false);
call 0 never executed
- #####: 1611: break;
- -: 1612: case DOUBLE:
- #####: 1613: if (ctx->nibble == lowNbl) {
+ #####: 1637: break;
+ -: 1638: case DOUBLE:
+ #####: 1639: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1614: storeTypeOnly(e);
+ #####: 1640: storeTypeOnly(e);
call 0 never executed
- -: 1615: }
- -: 1616: else {
- -: 1617: // high nibble
- #####: 1618: storeTypeInHighNbl(e);
- -: 1619: }
- #####: 1620: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+ -: 1641: }
+ -: 1642: else {
+ -: 1643: // high nibble
+ #####: 1644: storeTypeInHighNbl(e);
+ -: 1645: }
+ #####: 1646: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
call 0 never executed
- #####: 1621: break;
- -: 1622: case INT: {
- -: 1623: // encode int to varint
- -: 1624: // v is int64_t to convert to varint
- #####: 1625: i64 v = ((sIntt *)&(e->type))->value;
- #####: 1626: if (ctx->nibble == lowNbl) {
+ #####: 1647: break;
+ -: 1648: case INT: {
+ -: 1649: // encode int to varint
+ -: 1650: // v is int64_t to convert to varint
+ #####: 1651: i64 v = ((sIntt *)&(e->type))->value;
+ #####: 1652: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 1627: // encode v with arithmetic shifts
- #####: 1628: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
+ -: 1653: // encode v with arithmetic shifts
+ #####: 1654: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
call 0 never executed
- -: 1629: }
- -: 1630: else {
- -: 1631: // high nibble
- #####: 1632: storeTypeInHighNbl(e);
- #####: 1633: uintToVarint(r, (v << 1) ^ (v >> 63));
+ -: 1655: }
+ -: 1656: else {
+ -: 1657: // high nibble
+ #####: 1658: storeTypeInHighNbl(e);
+ #####: 1659: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 never executed
- -: 1634: }
- -: 1635: }
- #####: 1636: break;
- -: 1637: case STRING:
- #####: 1638: if (ctx->nibble == lowNbl) {
+ -: 1660: }
+ -: 1661: }
+ #####: 1662: break;
+ -: 1663: case STRING:
+ #####: 1664: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1639: storeTypeOnly(e);
+ #####: 1665: storeTypeOnly(e);
call 0 never executed
- -: 1640: }
- -: 1641: else {
- -: 1642: // high nibble
- #####: 1643: storeTypeInHighNbl(e);
- -: 1644: }
- #####: 1645: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+ -: 1666: }
+ -: 1667: else {
+ -: 1668: // high nibble
+ #####: 1669: storeTypeInHighNbl(e);
+ -: 1670: }
+ #####: 1671: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
call 0 never executed
- #####: 1646: break;
- -: 1647: case ARRAY:
- #####: 1648: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/false);
+ #####: 1672: break;
+ -: 1673: case ARRAY:
+ #####: 1674: arrayNetSerialLevel2(r, (sArrayt *)e, ctx, /*packed=*/false);
call 0 never executed
- #####: 1649: break;
- -: 1650: case BYTES:
- #####: 1651: B = (sBytest *)e;
- #####: 1652: if (ctx->nibble == lowNbl) {
+ #####: 1675: break;
+ -: 1676: case BYTES:
+ #####: 1677: B = (sBytest *)e;
+ #####: 1678: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 1653: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
+ #####: 1679: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
call 0 never executed
- -: 1654: }
- -: 1655: else {
- -: 1656: // high nibble
- #####: 1657: storeTypeInHighNbl(e);
- #####: 1658: uintToVarint(r, B->count);
+ -: 1680: }
+ -: 1681: else {
+ -: 1682: // high nibble
+ #####: 1683: storeTypeInHighNbl(e);
+ #####: 1684: uintToVarint(r, B->count);
call 0 never executed
- -: 1659: }
- #####: 1660: sBytesPushBuffer(r, &(B->data), B->count);
+ -: 1685: }
+ #####: 1686: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- #####: 1661: break;
- -: 1662: }
- -: 1663: }
- -: 1664: }
- #####: 1665: ret;
- -: 1666:}
- -: 1667:
+ #####: 1687: break;
+ -: 1688: }
+ -: 1689: }
+ -: 1690: }
+ #####: 1691: ret;
+ -: 1692:}
+ -: 1693:
function serialNetSerialLevel2 called 0 returned 0% blocks executed 0%
- #####: 1668:internal smallBytest* serialNetSerialLevel2(smallJsont *self) {
- -: 1669:
- #####: 1670: smallt *o = getsoG(self);
-call 0 never executed
- -: 1671:
- #####: 1672: if (o == NULL)
-branch 0 never executed
-branch 1 never executed
- #####: 1673: ret NULL;
- -: 1674:
- #####: 1675: sBytest *B = netSerialLevel2(o);
-call 0 never executed
- -: 1676:
- #####: 1677: if (!B) {
-branch 0 never executed
-branch 1 never executed
- #####: 1678: ret NULL;
- -: 1679: }
- -: 1680:
- #####: 1681: createAllocateSmallBytes(r);
-call 0 never executed
- #####: 1682: r->B = B;
- #####: 1683: ret r;
- -: 1684:}
- -: 1685:
- -: 1686:// level 3
- -: 1687:
-function netSerial called 76 returned 100% blocks executed 88%
- 76: 1688:internal sBytest* netSerial(smallt *o) {
- 76: 1689: sBytest *r = NULL;
- 76: 1690: sBytest *B = NULL;
- 76: 1691: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
- -: 1692:
- 76: 1693: switch(o->type) {
+ #####: 1694:internal smallBytest* serialNetSerialLevel2(smallJsont *self) {
+ -: 1695:
+ #####: 1696: smallt *o = getsoG(self);
+call 0 never executed
+ -: 1697:
+ #####: 1698: if (o == NULL)
+branch 0 never executed
+branch 1 never executed
+ #####: 1699: ret NULL;
+ -: 1700:
+ #####: 1701: sBytest *B = netSerialLevel2(o);
+call 0 never executed
+ -: 1702:
+ #####: 1703: if (!B) {
+branch 0 never executed
+branch 1 never executed
+ #####: 1704: ret NULL;
+ -: 1705: }
+ -: 1706:
+ #####: 1707: createAllocateSmallBytes(r);
+call 0 never executed
+ #####: 1708: r->B = B;
+ #####: 1709: ret r;
+ -: 1710:}
+ -: 1711:
+ -: 1712:// level 3
+ -: 1713:// like level 2, elements of identical type in a row are packed
+ -: 1714:
+ -: 1715:/**
+ -: 1716: * serializer top function
+ -: 1717: */
+function netSerial called 77 returned 100% blocks executed 88%
+ 77: 1718:internal sBytest* netSerial(smallt *o) {
+ 77: 1719: sBytest *r = NULL;
+ 77: 1720: sBytest *B = NULL;
+ 77: 1721: contextt ctx = {.nibble=lowNbl, .nblOffset=0, .boolShift = 0, .boolOffset=0};
+ -: 1722:
+ 77: 1723: switch(o->type) {
branch 0 taken 1%
branch 1 taken 1%
branch 2 taken 47%
branch 3 taken 1%
branch 4 taken 1%
branch 5 taken 1%
-branch 6 taken 46%
+branch 6 taken 47%
branch 7 taken 0%
branch 8 taken 0%
- -: 1694: case UNDEFINED:
- -: 1695: case CONTAINER:
- 1: 1696: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 returned 100%
- 1: 1697: break;
- -: 1698: case BOOL: {
- 1: 1699: u8 c = NET_SERIAL_TYPES[(u8)o->type];
- -: 1700: // set bit 4 when true
- 1: 1701: if (((sBoolt *)&(o->type))->value)
+ -: 1724: case UNDEFINED:
+ -: 1725: case CONTAINER:
+ 1: 1726: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 returned 100%
+ 1: 1727: break;
+ -: 1728: case BOOL: {
+ 1: 1729: u8 c = NET_SERIAL_TYPES[(u8)o->type];
+ -: 1730: // set bit 4 when true
+ 1: 1731: if (((sBoolt *)&(o->type))->value)
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 1: 1702: c |= (1<<4);
- 1: 1703: sBytesPush(&r, c);
-call 0 returned 100%
- -: 1704: }
- 1: 1705: break;
- -: 1706: case DICT:
- 36: 1707: dictNetSerial(&r, (sDictt *)&(o->type), &ctx, /*packing=*/NOPACKING);
-call 0 returned 100%
- 36: 1708: break;
- -: 1709: case DOUBLE:
- 1: 1710: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 returned 100%
- 1: 1711: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
-call 0 returned 100%
- 1: 1712: break;
- -: 1713: case INT: {
- -: 1714: // encode int to varint
- -: 1715: // v is int64_t to convert to varint
- 1: 1716: i64 v = ((sIntt *)&(o->type))->value;
- -: 1717: // encode v with arithmetic shifts
- 1: 1718: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 1719: }
- 1: 1720: break;
- -: 1721: case STRING:
- 1: 1722: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
-call 0 returned 100%
- 1: 1723: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
-call 0 returned 100%
- 1: 1724: break;
- -: 1725: case ARRAY:
- 35: 1726: arrayNetSerial(&r, (sArrayt *)&(o->type), &ctx, /*packing=*/NOPACKING);
-call 0 returned 100%
- 35: 1727: break;
- -: 1728: case BYTES:
- #####: 1729: B = (sBytest *)&(o->type);
- #####: 1730: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
-call 0 never executed
- #####: 1731: sBytesPushBuffer(&r, &(B->data), B->count);
-call 0 never executed
- #####: 1732: break;
- -: 1733: }
- 76: 1734: ret r;
- -: 1735:}
- -: 1736:
- -: 1737:/**
- -: 1738: * serialize dictionary
- -: 1739: *
- -: 1740: * the serialized dict is pushed to r.
- -: 1741: * All elements are serialized recursively
- -: 1742: *
- -: 1743: * the data in containers is not serialized
- -: 1744: *
- -: 1745: * \param
- -: 1746: * r small bytes object
- -: 1747: * dict dictionary to serialize
- -: 1748: */
-function dictNetSerial called 76 returned 100% blocks executed 91%
- 76: 1749:internal void dictNetSerial(sBytest **r, sDictt *dict, contextt *ctx, packingT packing) {
- 76: 1750: sBytest *B = NULL;
- 76: 1751: char *data = NULL;
- -: 1752:
- -: 1753: // check if all elements have same type
- 76: 1754: bool allElementsHaveSameType = true;
- 76: 1755: bool foundFirstType = false;
- 76: 1756: char type = 0;
- 194: 1757: {forEachSDict(dict, e) {
+ 1: 1732: c |= (1<<4);
+ 1: 1733: sBytesPush(&r, c);
+call 0 returned 100%
+ -: 1734: }
+ 1: 1735: break;
+ -: 1736: case DICT:
+ 36: 1737: dictNetSerial(&r, (sDictt *)&(o->type), &ctx, /*packing=*/NOPACKING);
+call 0 returned 100%
+ 36: 1738: break;
+ -: 1739: case DOUBLE:
+ 1: 1740: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 returned 100%
+ 1: 1741: sBytesPushBuffer(&r, &((sDoublet *)&(o->type))->value, sizeof(double));
+call 0 returned 100%
+ 1: 1742: break;
+ -: 1743: case INT: {
+ -: 1744: // encode int to varint
+ -: 1745: // v is int64_t to convert to varint
+ 1: 1746: i64 v = ((sIntt *)&(o->type))->value;
+ -: 1747: // encode v with arithmetic shifts
+ 1: 1748: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 1749: }
+ 1: 1750: break;
+ -: 1751: case STRING:
+ 1: 1752: sBytesPush(&r, NET_SERIAL_TYPES[(u8)o->type]);
+call 0 returned 100%
+ 1: 1753: sBytesPushBuffer(&r, &((sStringt *)&(o->type))->data, sizeof(sStringt) + strlen(&(((sStringt *)&(o->type))->data)) -1);
+call 0 returned 100%
+ 1: 1754: break;
+ -: 1755: case ARRAY:
+ 36: 1756: arrayNetSerial(&r, (sArrayt *)&(o->type), &ctx, /*packing=*/NOPACKING);
+call 0 returned 100%
+ 36: 1757: break;
+ -: 1758: case BYTES:
+ #####: 1759: B = (sBytest *)&(o->type);
+ #####: 1760: uintToNetTypeVarint(&r, NET_SERIAL_TYPES[(u8)o->type], B->count);
+call 0 never executed
+ #####: 1761: sBytesPushBuffer(&r, &(B->data), B->count);
+call 0 never executed
+ #####: 1762: break;
+ -: 1763: }
+ 77: 1764: ret r;
+ -: 1765:}
+ -: 1766:
+ -: 1767:/**
+ -: 1768: * serialize dictionary
+ -: 1769: *
+ -: 1770: * the serialized dict is pushed to r.
+ -: 1771: * All elements are serialized recursively
+ -: 1772: *
+ -: 1773: * the data in containers is not serialized
+ -: 1774: *
+ -: 1775: * \param
+ -: 1776: * r small bytes object
+ -: 1777: * dict dictionary to serialize
+ -: 1778: */
+function dictNetSerial called 79 returned 100% blocks executed 91%
+ 79: 1779:internal void dictNetSerial(sBytest **r, sDictt *dict, contextt *ctx, packingT packing) {
+ 79: 1780: sBytest *B = NULL;
+ 79: 1781: char *data = NULL;
+ -: 1782:
+ -: 1783: // check if all elements have same type
+ -: 1784: // then set dict type normal or uniform
+ -: 1785: // array and dict have to be checked recursively to know if they are normal or uniform
+ 79: 1786: bool allElementsHaveSameType = true;
+ 79: 1787: bool foundFirstType = false;
+ 79: 1788: char type = 0;
+ -: 1789: // get first element type
+ -: 1790: // compare to other element type
+ 200: 1791: {forEachSDict(dict, e) {
branch 0 taken 79%
-branch 1 taken 21% (fallthrough)
- 154: 1758: if (e->key) {
+branch 1 taken 22% (fallthrough)
+ 157: 1792: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 154: 1759: if (foundFirstType) {
-branch 0 taken 58% (fallthrough)
-branch 1 taken 42%
- -: 1760: u8 nextType;
- 89: 1761: switch(e->data->type) {
+ 157: 1793: if (foundFirstType) {
+branch 0 taken 57% (fallthrough)
+branch 1 taken 43%
+ -: 1794: u8 nextType;
+ 89: 1795: switch(e->data->type) {
branch 0 taken 17%
branch 1 taken 9%
branch 2 taken 74%
- -: 1762: case DICT:
- 15: 1763: nextType = isDictUniform((sDictt*)e->data);
-call 0 returned 100%
- 15: 1764: break;
- -: 1765: case ARRAY:
- 8: 1766: nextType = isArrayUniform((sArrayt*)e->data);
-call 0 returned 100%
- 8: 1767: break;
- -: 1768: default:
- 66: 1769: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 1770: }
- 89: 1771: if (nextType != type) {
+ -: 1796: case DICT:
+ 15: 1797: nextType = isDictUniform((sDictt*)e->data);
+call 0 returned 100%
+ 15: 1798: break;
+ -: 1799: case ARRAY:
+ 8: 1800: nextType = isArrayUniform((sArrayt*)e->data);
+call 0 returned 100%
+ 8: 1801: break;
+ -: 1802: default:
+ 66: 1803: nextType = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1804: }
+ 89: 1805: if (nextType != type) {
branch 0 taken 40% (fallthrough)
branch 1 taken 60%
- 36: 1772: allElementsHaveSameType = false;
- 36: 1773: break;
- -: 1774: }
- -: 1775: }
- -: 1776: else {
- 65: 1777: switch(e->data->type) {
-branch 0 taken 8%
-branch 1 taken 5%
+ 36: 1806: allElementsHaveSameType = false;
+ 36: 1807: break;
+ -: 1808: }
+ -: 1809: }
+ -: 1810: else {
+ 68: 1811: switch(e->data->type) {
+branch 0 taken 7%
+branch 1 taken 4%
branch 2 taken 88%
- -: 1778: case DICT:
- 5: 1779: type = isDictUniform((sDictt*)e->data);
-call 0 returned 100%
- 5: 1780: break;
- -: 1781: case ARRAY:
- 3: 1782: type = isArrayUniform((sArrayt*)e->data);
-call 0 returned 100%
- 3: 1783: break;
- -: 1784: default:
- 57: 1785: type = NET_SERIAL_TYPES[(u8)e->data->type];
- -: 1786: }
- 65: 1787: foundFirstType = true;
- -: 1788: }
- -: 1789: }
- -: 1790: }}
- -: 1791:
- 76: 1792: if (allElementsHaveSameType) {
-branch 0 taken 53% (fallthrough)
-branch 1 taken 47%
- -: 1793: // pack dictionary
- 40: 1794: if (packing == PACKED) {
-branch 0 taken 45% (fallthrough)
-branch 1 taken 55%
- -: 1795: // uniform dict can't be packed
- -: 1796: // because there is only one type of packed arrays
- 18: 1797: goto normalDict;
- -: 1798: }
- 22: 1799: elif (packing == UNIFORM) {
-branch 0 taken 18% (fallthrough)
-branch 1 taken 82%
- 4: 1800: uintToNetTypeVarint(r, type, dict->count);
+ -: 1812: case DICT:
+ 5: 1813: type = isDictUniform((sDictt*)e->data);
+call 0 returned 100%
+ 5: 1814: break;
+ -: 1815: case ARRAY:
+ 3: 1816: type = isArrayUniform((sArrayt*)e->data);
+call 0 returned 100%
+ 3: 1817: break;
+ -: 1818: default:
+ 60: 1819: type = NET_SERIAL_TYPES[(u8)e->data->type];
+ -: 1820: }
+ 68: 1821: foundFirstType = true;
+ -: 1822: }
+ -: 1823: }
+ -: 1824: }}
+ -: 1825:
+ 79: 1826: if (allElementsHaveSameType) {
+branch 0 taken 54% (fallthrough)
+branch 1 taken 46%
+ -: 1827: // uniform dict
+ -: 1828: // encode type and element count
+ -: 1829:
+ -: 1830: // in pack dictionary
+ 43: 1831: if (packing == PACKED) {
+branch 0 taken 42% (fallthrough)
+branch 1 taken 58%
+ -: 1832: // uniform dict can't be packed
+ -: 1833: // because there is only one type of packed arrays
+ 18: 1834: goto normalDict;
+ -: 1835: }
+ 25: 1836: elif (packing == UNIFORM) {
+branch 0 taken 16% (fallthrough)
+branch 1 taken 84%
+ -: 1837: // when the packing is uniform, there is no need to encode UNIFORM_DICT since all elements have this type
+ 4: 1838: uintToNetTypeVarint(r, type, dict->count);
call 0 returned 100%
- -: 1801: }
- -: 1802: else {
- 18: 1803: if (ctx->nibble == lowNbl) {
-branch 0 taken 94% (fallthrough)
-branch 1 taken 6%
- 17: 1804: sBytesPush(r, (type << 4) + UNIFORM_DICT);
-call 0 returned 100%
- 17: 1805: uintToVarint(r, dict->count);
-call 0 returned 100%
- -: 1806: }
- -: 1807: else {
- -: 1808: // high nibble
- 1: 1809: ctx->nibble = lowNbl;
- 1: 1810: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 1811: *data |= UNIFORM_DICT << 4;
- 1: 1812: uintToNetTypeVarint(r, type, dict->count);
-call 0 returned 100%
- -: 1813: }
- -: 1814: }
- -: 1815:
- 22: 1816: switch(type) {
-branch 0 taken 9%
-branch 1 taken 18%
-branch 2 taken 9%
-branch 3 taken 5%
-branch 4 taken 27%
-branch 5 taken 23%
-branch 6 taken 9%
+ -: 1839: }
+ -: 1840: else {
+ 21: 1841: if (ctx->nibble == lowNbl) {
+branch 0 taken 90% (fallthrough)
+branch 1 taken 10%
+ 19: 1842: sBytesPush(r, (type << 4) + UNIFORM_DICT);
+call 0 returned 100%
+ 19: 1843: uintToVarint(r, dict->count);
+call 0 returned 100%
+ -: 1844: }
+ -: 1845: else {
+ -: 1846: // high nibble
+ 2: 1847: ctx->nibble = lowNbl;
+ 2: 1848: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 2: 1849: *data |= UNIFORM_DICT << 4;
+ 2: 1850: uintToNetTypeVarint(r, type, dict->count);
+call 0 returned 100%
+ -: 1851: }
+ -: 1852: }
+ -: 1853:
+ -: 1854: // encode all element keys and values
+ 25: 1855: switch(type) {
+branch 0 taken 8%
+branch 1 taken 16%
+branch 2 taken 8%
+branch 3 taken 4%
+branch 4 taken 36%
+branch 5 taken 20%
+branch 6 taken 8%
branch 7 taken 0%
branch 8 taken 0%
- -: 1817: case S_UNDEFINED:
- 8: 1818: {forEachSDict(dict, e) {
+ -: 1856: case S_UNDEFINED:
+ 8: 1857: {forEachSDict(dict, e) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 6: 1819: if (e->key) {
+ 6: 1858: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 6: 1820: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
-call 0 returned 100%
- -: 1821: }
- -: 1822: }}
- -: 1823:
- 2: 1824: break;
- -: 1825: case S_BOOL:
- 19: 1826: {forEachSDict(dict, e) {
+ 6: 1859: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+call 0 returned 100%
+ -: 1860: }
+ -: 1861: }}
+ -: 1862:
+ 2: 1863: break;
+ -: 1864: case S_BOOL:
+ 19: 1865: {forEachSDict(dict, e) {
branch 0 taken 79%
branch 1 taken 21% (fallthrough)
- 15: 1827: if (e->key) {
+ 15: 1866: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 15: 1828: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ 15: 1867: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 returned 100%
- -: 1829:
- 15: 1830: if (!ctx->boolOffset) {
+ -: 1868:
+ 15: 1869: if (!ctx->boolOffset) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- -: 1831: // new packed bools
- 3: 1832: storeNew8bPackedBool(e->data);
+ -: 1870: // new packed bools
+ 3: 1871: storeNew8bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 1833: }
- -: 1834: else {
- -: 1835: // there was a bool before this one, fill bits in nibbles
- 12: 1836: if (ctx->boolShift == 8) {
+ -: 1872: }
+ -: 1873: else {
+ -: 1874: // there was a bool before this one, fill bits in nibbles
+ 12: 1875: if (ctx->boolShift == 8) {
branch 0 taken 8% (fallthrough)
branch 1 taken 92%
- -: 1837: // previous packed bool is full
- -: 1838: // next byte is the new packed bools
- 1: 1839: storeNew8bPackedBool(e->data);
+ -: 1876: // previous packed bool is full
+ -: 1877: // next byte is the new packed bools
+ 1: 1878: storeNew8bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 1840: }
- -: 1841: else {
- 11: 1842: storeBool(e->data);
+ -: 1879: }
+ -: 1880: else {
+ 11: 1881: storeBool(e->data);
branch 0 taken 91% (fallthrough)
branch 1 taken 9%
- -: 1843: }
- -: 1844: }
- -: 1845: }
- -: 1846: }}
- 4: 1847: break;
- -: 1848: case S_DICT:
- -: 1849: case UNIFORM_DICT:
- 6: 1850: {forEachSDict(dict, e) {
+ -: 1882: }
+ -: 1883: }
+ -: 1884: }
+ -: 1885: }}
+ 4: 1886: break;
+ -: 1887: case S_DICT:
+ -: 1888: case UNIFORM_DICT:
+ 6: 1889: {forEachSDict(dict, e) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 4: 1851: if (e->key) {
+ 4: 1890: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 4: 1852: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ 4: 1891: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 returned 100%
- 4: 1853: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/UNIFORM);
+ 4: 1892: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/UNIFORM);
call 0 returned 100%
- -: 1854: }
- -: 1855: }}
- 2: 1856: break;
- -: 1857: case S_DOUBLE:
- 4: 1858: {forEachSDict(dict, e) {
+ -: 1893: }
+ -: 1894: }}
+ 2: 1895: break;
+ -: 1896: case S_DOUBLE:
+ 4: 1897: {forEachSDict(dict, e) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 1859: if (e->key) {
+ 3: 1898: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 3: 1860: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
-call 0 returned 100%
- 3: 1861: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 returned 100%
- -: 1862: }
- -: 1863: }}
- 1: 1864: break;
- -: 1865: case S_INT:
- 15: 1866: {forEachSDict(dict, e) {
-branch 0 taken 60%
-branch 1 taken 40% (fallthrough)
- 9: 1867: if (e->key) {
+ 3: 1899: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+call 0 returned 100%
+ 3: 1900: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 returned 100%
+ -: 1901: }
+ -: 1902: }}
+ 1: 1903: break;
+ -: 1904: case S_INT:
+ 21: 1905: {forEachSDict(dict, e) {
+branch 0 taken 57%
+branch 1 taken 43% (fallthrough)
+ 12: 1906: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 9: 1868: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ 12: 1907: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 returned 100%
- 9: 1869: i64 v = ((sIntt *)(e->data))->value;
- 9: 1870: uintToVarint(r, (v << 1) ^ (v >> 63));
+ 12: 1908: i64 v = ((sIntt *)(e->data))->value;
+ 12: 1909: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 returned 100%
- -: 1871: }
- -: 1872: }}
- 6: 1873: break;
- -: 1874: case S_STRING:
- 16: 1875: {forEachSDict(dict, e) {
+ -: 1910: }
+ -: 1911: }}
+ 9: 1912: break;
+ -: 1913: case S_STRING:
+ 16: 1914: {forEachSDict(dict, e) {
branch 0 taken 69%
branch 1 taken 31% (fallthrough)
- 11: 1876: if (e->key) {
+ 11: 1915: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 11: 1877: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ 11: 1916: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 returned 100%
- 11: 1878: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+ 11: 1917: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
call 0 returned 100%
- -: 1879: }
- -: 1880: }}
- 5: 1881: break;
- -: 1882: case S_ARRAY:
- -: 1883: case UNIFORM_ARRAY:
- 4: 1884: {forEachSDict(dict, e) {
+ -: 1918: }
+ -: 1919: }}
+ 5: 1920: break;
+ -: 1921: case S_ARRAY:
+ -: 1922: case UNIFORM_ARRAY:
+ 4: 1923: {forEachSDict(dict, e) {
branch 0 taken 50%
branch 1 taken 50% (fallthrough)
- 2: 1885: if (e->key) {
+ 2: 1924: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 2: 1886: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ 2: 1925: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 returned 100%
- 2: 1887: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/UNIFORM);
+ 2: 1926: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/UNIFORM);
call 0 returned 100%
- -: 1888: }
- -: 1889: }}
- 2: 1890: break;
- -: 1891: case S_BYTES:
- #####: 1892: {forEachSDict(dict, e) {
+ -: 1927: }
+ -: 1928: }}
+ 2: 1929: break;
+ -: 1930: case S_BYTES:
+ #####: 1931: {forEachSDict(dict, e) {
branch 0 never executed
branch 1 never executed
- #####: 1893: if (e->key) {
+ #####: 1932: if (e->key) {
branch 0 never executed
branch 1 never executed
- #####: 1894: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+ #####: 1933: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
call 0 never executed
- #####: 1895: B = (sBytest *)(e->data);
- #####: 1896: uintToVarint(r, B->count);
+ #####: 1934: B = (sBytest *)(e->data);
+ #####: 1935: uintToVarint(r, B->count);
call 0 never executed
- #####: 1897: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 1936: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 1898: }
- -: 1899: }}
- #####: 1900: break;
- -: 1901: }
- 22: 1902: ret;
- -: 1903: }
- -: 1904:
- -: 1905: normalDict:
- 54: 1906: if (packing == PACKED or packing == UNIFORM) {
+ -: 1937: }
+ -: 1938: }}
+ #####: 1939: break;
+ -: 1940: }
+ 25: 1941: ret;
+ -: 1942: }
+ -: 1943:
+ -: 1944: normalDict:
+ -: 1945: // encode type and element count
+ 54: 1946: if (packing == PACKED or packing == UNIFORM) {
branch 0 taken 57% (fallthrough)
branch 1 taken 43%
branch 2 taken 13% (fallthrough)
branch 3 taken 87%
- 27: 1907: uintToVarint(r, dict->count);
+ -: 1947: // when the packing is packed or uniform, there is no need to encode DICT type since all elements have this type
+ 27: 1948: uintToVarint(r, dict->count);
call 0 returned 100%
- -: 1908: }
- -: 1909: else {
- 27: 1910: if (ctx->nibble == lowNbl) {
+ -: 1949: }
+ -: 1950: else {
+ 27: 1951: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 25: 1911: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
-call 0 returned 100%
- -: 1912: }
- -: 1913: else {
- -: 1914: // high nibble
- -: 1915: #define storeTypeInHighNbl(o)\
- -: 1916: ctx->nibble = lowNbl;\
- -: 1917: data = (char *)&((*r)->data) + ctx->nblOffset;\
- -: 1918: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
- 2: 1919: storeTypeInHighNbl(dict);
- 2: 1920: uintToVarint(r, dict->count);
-call 0 returned 100%
- -: 1921: }
- -: 1922: }
- -: 1923:
- 54: 1924: bool pack = false;
- -: 1925: size_t packCount;
- 210: 1926: enumerateSDict(dict, e, eIdx) {
+ 25: 1952: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)dict->type], dict->count);
+call 0 returned 100%
+ -: 1953: }
+ -: 1954: else {
+ -: 1955: // high nibble
+ -: 1956: #define storeTypeInHighNbl(o)\
+ -: 1957: ctx->nibble = lowNbl;\
+ -: 1958: data = (char *)&((*r)->data) + ctx->nblOffset;\
+ -: 1959: *data |= NET_SERIAL_TYPES[(u8)o->type] << 4
+ 2: 1960: storeTypeInHighNbl(dict);
+ 2: 1961: uintToVarint(r, dict->count);
+call 0 returned 100%
+ -: 1962: }
+ -: 1963: }
+ -: 1964:
+ 54: 1965: bool pack = false;
+ -: 1966: size_t packCount;
+ 210: 1967: enumerateSDict(dict, e, eIdx) {
branch 0 taken 74%
branch 1 taken 26% (fallthrough)
- 156: 1927: if (e->key) {
+ 156: 1968: if (e->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 156: 1928: if (!pack) {
+ 156: 1969: if (!pack) {
branch 0 taken 76% (fallthrough)
branch 1 taken 24%
- -: 1929: // scan dict for packing
- 118: 1930: if ((dict->count - eIdx) > 3) {
+ -: 1970: // scan dict for packing
+ 118: 1971: if ((dict->count - eIdx) > 3) {
branch 0 taken 35% (fallthrough)
branch 1 taken 65%
- -: 1931: // at least 4 elements, less than that is not worth it
- 41: 1932: if ( e->data->type == DICT
+ -: 1972: // at least 4 elements, less than that is not worth it
+ 41: 1973: if ( e->data->type == DICT
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 38: 1933: or e->data->type == DOUBLE
+ 38: 1974: or e->data->type == DOUBLE
branch 0 taken 95% (fallthrough)
branch 1 taken 5%
- 36: 1934: or e->data->type == INT
+ 36: 1975: or e->data->type == INT
branch 0 taken 94% (fallthrough)
branch 1 taken 6%
- 34: 1935: or e->data->type == STRING
+ 34: 1976: or e->data->type == STRING
branch 0 taken 94% (fallthrough)
branch 1 taken 6%
- 32: 1936: or e->data->type == ARRAY
+ 32: 1977: or e->data->type == ARRAY
branch 0 taken 94% (fallthrough)
branch 1 taken 6%
- 30: 1937: or e->data->type == BYTES) {
+ 30: 1978: or e->data->type == BYTES) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 11: 1938: type = e->data->type;
- 11: 1939: packCount = 1;
- 11: 1940: sDictElemt *element = &((dict)->elements) + eIdx;
- 49: 1941: for (size_t i = eIdx+1; i < (dict)->count ; i++, element = &((dict)->elements) + i) {
+ 11: 1979: type = e->data->type;
+ 11: 1980: packCount = 1;
+ 11: 1981: sDictElemt *element = &((dict)->elements) + eIdx +1;
+ 49: 1982: for (size_t i = eIdx+1; i < (dict)->count ; i++, element = &((dict)->elements) + i) {
branch 0 taken 100%
branch 1 taken 0% (fallthrough)
- 49: 1942: if (element->key) {
+ 49: 1983: if (element->key) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 49: 1943: if (element->data->type != type) {
+ 49: 1984: if (element->data->type != type) {
branch 0 taken 22% (fallthrough)
branch 1 taken 78%
- 11: 1944: break;
- -: 1945: }
- 38: 1946: packCount++;
- -: 1947: } // element->key
- -: 1948: } // for
- 11: 1949: if (packCount > 3) {
+ 11: 1985: break;
+ -: 1986: }
+ 38: 1987: packCount++;
+ -: 1988: } // element->key
+ -: 1989: } // for
+ 11: 1990: if (packCount > 3) {
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- 11: 1950: type = PACKED_NET_SERIAL_TYPES[(u8)type];
- 11: 1951: pack = true;
- -: 1952: }
- -: 1953: } // test current element type
- -: 1954: } // is dict big enough
- -: 1955: } // not already packing
- -: 1956:
- 156: 1957: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
-call 0 returned 100%
- -: 1958:
- 156: 1959: switch(e->data->type) {
+ 11: 1991: type = PACKED_NET_SERIAL_TYPES[(u8)type];
+ 11: 1992: pack = true;
+ -: 1993: }
+ -: 1994: } // test current element type
+ -: 1995: } // is dict big enough
+ -: 1996: } // not already packing
+ -: 1997:
+ -: 1998: // encode key
+ 156: 1999: sBytesPushBuffer(r, e->key, strlen(e->key) + 1);
+call 0 returned 100%
+ -: 2000:
+ -: 2001: // encode value
+ 156: 2002: switch(e->data->type) {
branch 0 taken 17%
branch 1 taken 20%
branch 2 taken 13%
@@ -2927,1147 +2970,1166 @@ branch 5 taken 14%
branch 6 taken 8%
branch 7 taken 0%
branch 8 taken 0%
- -: 1960: case UNDEFINED:
- -: 1961: case CONTAINER:
- 26: 1962: if (ctx->nibble == lowNbl) {
+ -: 2003: case UNDEFINED:
+ -: 2004: case CONTAINER:
+ 26: 2005: if (ctx->nibble == lowNbl) {
branch 0 taken 92% (fallthrough)
branch 1 taken 8%
- -: 1963: #define storeTypeOnly(o)\
- -: 1964: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
- -: 1965: ctx->nibble = highNbl;\
- -: 1966: ctx->nblOffset = (*r)->count -1
- 24: 1967: storeTypeOnly(e->data);
-call 0 returned 100%
- -: 1968: }
- -: 1969: else {
- 2: 1970: storeTypeInHighNbl(e->data);
- -: 1971: }
- 26: 1972: break;
- -: 1973: case BOOL:
- 31: 1974: if (!ctx->boolOffset) {
+ -: 2006: #define storeTypeOnly(o)\
+ -: 2007: sBytesPush(r, NET_SERIAL_TYPES[(u8)o->type]);\
+ -: 2008: ctx->nibble = highNbl;\
+ -: 2009: ctx->nblOffset = (*r)->count -1
+ 24: 2010: storeTypeOnly(e->data);
+call 0 returned 100%
+ -: 2011: }
+ -: 2012: else {
+ 2: 2013: storeTypeInHighNbl(e->data);
+ -: 2014: }
+ 26: 2015: break;
+ -: 2016: case BOOL:
+ 31: 2017: if (!ctx->boolOffset) {
branch 0 taken 16% (fallthrough)
branch 1 taken 84%
- -: 1975: // new packed bools
- 5: 1976: if (ctx->nibble == lowNbl) {
+ -: 2018: // new packed bools
+ 5: 2019: if (ctx->nibble == lowNbl) {
branch 0 taken 60% (fallthrough)
branch 1 taken 40%
- -: 1977: #define storeNew4bPackedBool(o)\
- -: 1978: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
- -: 1979: /* set bit 4 when true */\
- -: 1980: if (((sBoolt *)(o))->value)\
- -: 1981: c |= (1<<4);\
- -: 1982: sBytesPush(r, c);\
- -: 1983: ctx->boolShift = 5;\
- -: 1984: ctx->boolOffset = (*r)->count -1
- 3: 1985: storeNew4bPackedBool(e->data);
+ -: 2020: #define storeNew4bPackedBool(o)\
+ -: 2021: u8 c = NET_SERIAL_TYPES[(u8)o->type];\
+ -: 2022: /* set bit 4 when true */\
+ -: 2023: if (((sBoolt *)(o))->value)\
+ -: 2024: c |= (1<<4);\
+ -: 2025: sBytesPush(r, c);\
+ -: 2026: ctx->boolShift = 5;\
+ -: 2027: ctx->boolOffset = (*r)->count -1
+ 3: 2028: storeNew4bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 1986: }
- -: 1987: else {
- -: 1988: // high nibble, next byte is packed bools
- 2: 1989: storeTypeInHighNbl(e->data);
- -: 1990: #define storeNew8bPackedBool(o)\
- -: 1991: u8 c = 0;\
- -: 1992: if (((sBoolt *)(o))->value)\
- -: 1993: c = 1;\
- -: 1994: sBytesPush(r, c);\
- -: 1995: ctx->boolShift = 1;\
- -: 1996: ctx->boolOffset = (*r)->count -1
- 2: 1997: storeNew8bPackedBool(e->data);
+ -: 2029: }
+ -: 2030: else {
+ -: 2031: // high nibble, next byte is packed bools
+ 2: 2032: storeTypeInHighNbl(e->data);
+ -: 2033: #define storeNew8bPackedBool(o)\
+ -: 2034: u8 c = 0;\
+ -: 2035: if (((sBoolt *)(o))->value)\
+ -: 2036: c = 1;\
+ -: 2037: sBytesPush(r, c);\
+ -: 2038: ctx->boolShift = 1;\
+ -: 2039: ctx->boolOffset = (*r)->count -1
+ 2: 2040: storeNew8bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 1998: }
- -: 1999: }
- -: 2000: else {
- -: 2001: // there was a bool before this one, fill bits in nibbles
- 26: 2002: if (ctx->nibble == lowNbl) {
+ -: 2041: }
+ -: 2042: }
+ -: 2043: else {
+ -: 2044: // there was a bool before this one, fill bits in nibbles
+ 26: 2045: if (ctx->nibble == lowNbl) {
branch 0 taken 58% (fallthrough)
branch 1 taken 42%
- 15: 2003: if (ctx->boolShift == 8) {
+ 15: 2046: if (ctx->boolShift == 8) {
branch 0 taken 7% (fallthrough)
branch 1 taken 93%
- -: 2004: // previous packed bool is full
- -: 2005: // this byte is the new packed bools
- 1: 2006: storeNew4bPackedBool(e->data);
+ -: 2047: // previous packed bool is full
+ -: 2048: // this byte is the new packed bools
+ 1: 2049: storeNew4bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 2007: }
- -: 2008: else {
- 14: 2009: storeTypeOnly(e->data);
-call 0 returned 100%
- -: 2010: #define storeBool(o)\
- -: 2011: data = (char *)&((*r)->data) + ctx->boolOffset;\
- -: 2012: if (((sBoolt *)(o))->value)\
- -: 2013: *data |= 1 << ctx->boolShift;\
- -: 2014: ctx->boolShift++
- 14: 2015: storeBool(e->data);
+ -: 2050: }
+ -: 2051: else {
+ 14: 2052: storeTypeOnly(e->data);
+call 0 returned 100%
+ -: 2053: #define storeBool(o)\
+ -: 2054: data = (char *)&((*r)->data) + ctx->boolOffset;\
+ -: 2055: if (((sBoolt *)(o))->value)\
+ -: 2056: *data |= 1 << ctx->boolShift;\
+ -: 2057: ctx->boolShift++
+ 14: 2058: storeBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- -: 2016: }
- -: 2017: }
- -: 2018: else {
- -: 2019: // high nibble
- 11: 2020: storeTypeInHighNbl(e->data);
- 11: 2021: if (ctx->boolShift == 8) {
+ -: 2059: }
+ -: 2060: }
+ -: 2061: else {
+ -: 2062: // high nibble
+ 11: 2063: storeTypeInHighNbl(e->data);
+ 11: 2064: if (ctx->boolShift == 8) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- -: 2022: // previous packed bool is full
- -: 2023: // next byte is the new packed bools
- 2: 2024: storeNew8bPackedBool(e->data);
+ -: 2065: // previous packed bool is full
+ -: 2066: // next byte is the new packed bools
+ 2: 2067: storeNew8bPackedBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 2025: }
- -: 2026: else {
- 9: 2027: storeBool(e->data);
+ -: 2068: }
+ -: 2069: else {
+ 9: 2070: storeBool(e->data);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- -: 2028: }
- -: 2029: }
- -: 2030: }
- 31: 2031: break;
- -: 2032: case DICT:
- 20: 2033: if (pack) {
+ -: 2071: }
+ -: 2072: }
+ -: 2073: }
+ 31: 2074: break;
+ -: 2075: case DICT:
+ 20: 2076: if (pack) {
branch 0 taken 75% (fallthrough)
branch 1 taken 25%
- 15: 2034: if (type) {
+ 15: 2077: if (type) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- -: 2035: // this is the first packed element
- 3: 2036: if (ctx->nibble == lowNbl) {
+ -: 2078: // this is the first packed element
+ 3: 2079: if (ctx->nibble == lowNbl) {
branch 0 taken 67% (fallthrough)
branch 1 taken 33%
- 2: 2037: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2038: }
- -: 2039: else {
- -: 2040: // high nibble
- -: 2041: // store type in high nibble
- 1: 2042: ctx->nibble = lowNbl;
- 1: 2043: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2044: *data |= type << 4;
- 1: 2045: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2046: }
- 3: 2047: type = 0;
- -: 2048: } // if type
- -: 2049:
- 15: 2050: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/PACKED);
-call 0 returned 100%
- -: 2051: // stop packing when packCount == 0
- 15: 2052: packCount--;
- 15: 2053: if (!packCount) pack = false;
+ 2: 2080: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2081: }
+ -: 2082: else {
+ -: 2083: // high nibble
+ -: 2084: // store type in high nibble
+ 1: 2085: ctx->nibble = lowNbl;
+ 1: 2086: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2087: *data |= type << 4;
+ 1: 2088: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2089: }
+ 3: 2090: type = 0;
+ -: 2091: } // if type
+ -: 2092:
+ 15: 2093: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/PACKED);
+call 0 returned 100%
+ -: 2094: // stop packing when packCount == 0
+ 15: 2095: packCount--;
+ 15: 2096: if (!packCount) pack = false;
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- -: 2054: } // if pack
- -: 2055: else
- 5: 2056: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/NOPACKING);
+ -: 2097: } // if pack
+ -: 2098: else
+ 5: 2099: dictNetSerial(r, (sDictt *)(e->data), ctx, /*packing=*/NOPACKING);
call 0 returned 100%
- 20: 2057: break;
- -: 2058: case DOUBLE:
- 12: 2059: if (pack) {
+ 20: 2100: break;
+ -: 2101: case DOUBLE:
+ 12: 2102: if (pack) {
branch 0 taken 83% (fallthrough)
branch 1 taken 17%
- 10: 2060: if (type) {
+ 10: 2103: if (type) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- -: 2061: // this is the first packed element
- 2: 2062: if (ctx->nibble == lowNbl) {
+ -: 2104: // this is the first packed element
+ 2: 2105: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2063: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2064: }
- -: 2065: else {
- -: 2066: // high nibble
- -: 2067: // store type in high nibble
- 1: 2068: ctx->nibble = lowNbl;
- 1: 2069: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2070: *data |= type << 4;
- 1: 2071: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2072: }
- 2: 2073: type = 0;
- -: 2074: } // if type
- -: 2075:
- 10: 2076: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 returned 100%
- -: 2077: // stop packing when packCount == 0
- 10: 2078: packCount--;
- 10: 2079: if (!packCount) pack = false;
+ 1: 2106: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2107: }
+ -: 2108: else {
+ -: 2109: // high nibble
+ -: 2110: // store type in high nibble
+ 1: 2111: ctx->nibble = lowNbl;
+ 1: 2112: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2113: *data |= type << 4;
+ 1: 2114: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2115: }
+ 2: 2116: type = 0;
+ -: 2117: } // if type
+ -: 2118:
+ 10: 2119: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 returned 100%
+ -: 2120: // stop packing when packCount == 0
+ 10: 2121: packCount--;
+ 10: 2122: if (!packCount) pack = false;
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- -: 2080: } // if pack
- -: 2081: else {
- 2: 2082: if (ctx->nibble == lowNbl) {
+ -: 2123: } // if pack
+ -: 2124: else {
+ 2: 2125: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2083: storeTypeOnly(e->data);
-call 0 returned 100%
- -: 2084: }
- -: 2085: else {
- -: 2086: // high nibble
- 1: 2087: storeTypeInHighNbl(e->data);
- -: 2088: }
- 2: 2089: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
-call 0 returned 100%
- -: 2090: }
- 12: 2091: break;
- -: 2092: case INT:
- 32: 2093: if (pack) {
+ 1: 2126: storeTypeOnly(e->data);
+call 0 returned 100%
+ -: 2127: }
+ -: 2128: else {
+ -: 2129: // high nibble
+ 1: 2130: storeTypeInHighNbl(e->data);
+ -: 2131: }
+ 2: 2132: sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
+call 0 returned 100%
+ -: 2133: }
+ 12: 2134: break;
+ -: 2135: case INT:
+ 32: 2136: if (pack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 2094: if (type) {
+ 8: 2137: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2095: // this is the first packed element
- 2: 2096: if (ctx->nibble == lowNbl) {
+ -: 2138: // this is the first packed element
+ 2: 2139: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2097: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2098: }
- -: 2099: else {
- -: 2100: // high nibble
- -: 2101: // store type in high nibble
- 1: 2102: ctx->nibble = lowNbl;
- 1: 2103: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2104: *data |= type << 4;
- 1: 2105: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2106: }
- 2: 2107: type = 0;
- -: 2108: } // if type
- -: 2109:
- 8: 2110: i64 v = ((sIntt *)(e->data))->value;
- 8: 2111: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2112: // stop packing when packCount == 0
- 8: 2113: packCount--;
- 8: 2114: if (!packCount) pack = false;
+ 1: 2140: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2141: }
+ -: 2142: else {
+ -: 2143: // high nibble
+ -: 2144: // store type in high nibble
+ 1: 2145: ctx->nibble = lowNbl;
+ 1: 2146: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2147: *data |= type << 4;
+ 1: 2148: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2149: }
+ 2: 2150: type = 0;
+ -: 2151: } // if type
+ -: 2152:
+ 8: 2153: i64 v = ((sIntt *)(e->data))->value;
+ 8: 2154: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2155: // stop packing when packCount == 0
+ 8: 2156: packCount--;
+ 8: 2157: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2115: } // if pack
- -: 2116: else {
- -: 2117: // encode int to varint
- -: 2118: // v is int64_t to convert to varint
- 24: 2119: i64 v = ((sIntt *)(e->data))->value;
- 24: 2120: if (ctx->nibble == lowNbl) {
+ -: 2158: } // if pack
+ -: 2159: else {
+ -: 2160: // encode int to varint
+ -: 2161: // v is int64_t to convert to varint
+ 24: 2162: i64 v = ((sIntt *)(e->data))->value;
+ 24: 2163: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- -: 2121: // encode v with arithmetic shifts
- 12: 2122: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2123: }
- -: 2124: else {
- -: 2125: // high nibble
- 12: 2126: storeTypeInHighNbl(e->data);
- 12: 2127: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2128: }
- -: 2129: }
- 32: 2130: break;
- -: 2131: case STRING:
- 22: 2132: if (pack) {
+ -: 2164: // encode v with arithmetic shifts
+ 12: 2165: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2166: }
+ -: 2167: else {
+ -: 2168: // high nibble
+ 12: 2169: storeTypeInHighNbl(e->data);
+ 12: 2170: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2171: }
+ -: 2172: }
+ 32: 2173: break;
+ -: 2174: case STRING:
+ 22: 2175: if (pack) {
branch 0 taken 36% (fallthrough)
branch 1 taken 64%
- 8: 2133: if (type) {
+ 8: 2176: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2134: // this is the first packed element
- 2: 2135: if (ctx->nibble == lowNbl) {
+ -: 2177: // this is the first packed element
+ 2: 2178: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2136: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2137: }
- -: 2138: else {
- -: 2139: // high nibble
- -: 2140: // store type in high nibble
- 1: 2141: ctx->nibble = lowNbl;
- 1: 2142: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2143: *data |= type << 4;
- 1: 2144: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2145: }
- 2: 2146: type = 0;
- -: 2147: } // if type
- -: 2148:
- 8: 2149: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
-call 0 returned 100%
- -: 2150: // stop packing when packCount == 0
- 8: 2151: packCount--;
- 8: 2152: if (!packCount) pack = false;
+ 1: 2179: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2180: }
+ -: 2181: else {
+ -: 2182: // high nibble
+ -: 2183: // store type in high nibble
+ 1: 2184: ctx->nibble = lowNbl;
+ 1: 2185: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2186: *data |= type << 4;
+ 1: 2187: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2188: }
+ 2: 2189: type = 0;
+ -: 2190: } // if type
+ -: 2191:
+ 8: 2192: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+call 0 returned 100%
+ -: 2193: // stop packing when packCount == 0
+ 8: 2194: packCount--;
+ 8: 2195: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2153: } // if pack
- -: 2154: else {
- 14: 2155: if (ctx->nibble == lowNbl) {
+ -: 2196: } // if pack
+ -: 2197: else {
+ 14: 2198: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 13: 2156: storeTypeOnly(e->data);
-call 0 returned 100%
- -: 2157: }
- -: 2158: else {
- -: 2159: // high nibble
- 1: 2160: storeTypeInHighNbl(e->data);
- -: 2161: }
- 14: 2162: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
-call 0 returned 100%
- -: 2163: }
- 22: 2164: break;
- -: 2165: case ARRAY:
- 13: 2166: if (pack) {
+ 13: 2199: storeTypeOnly(e->data);
+call 0 returned 100%
+ -: 2200: }
+ -: 2201: else {
+ -: 2202: // high nibble
+ 1: 2203: storeTypeInHighNbl(e->data);
+ -: 2204: }
+ 14: 2205: sBytesPushBuffer(r, &((sStringt *)(e->data))->data, sizeof(sStringt) + strlen(&(((sStringt *)(e->data))->data)) -1);
+call 0 returned 100%
+ -: 2206: }
+ 22: 2207: break;
+ -: 2208: case ARRAY:
+ 13: 2209: if (pack) {
branch 0 taken 62% (fallthrough)
branch 1 taken 38%
- 8: 2167: if (type) {
+ 8: 2210: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2168: // this is the first packed element
- 2: 2169: if (ctx->nibble == lowNbl) {
+ -: 2211: // this is the first packed element
+ 2: 2212: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2170: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2171: }
- -: 2172: else {
- -: 2173: // high nibble
- -: 2174: // store type in high nibble
- 1: 2175: ctx->nibble = lowNbl;
- 1: 2176: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2177: *data |= type << 4;
- 1: 2178: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2179: }
- 2: 2180: type = 0;
- -: 2181: } // if type
- -: 2182:
- 8: 2183: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/PACKED);
-call 0 returned 100%
- -: 2184: // stop packing when packCount == 0
- 8: 2185: packCount--;
- 8: 2186: if (!packCount) pack = false;
+ 1: 2213: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2214: }
+ -: 2215: else {
+ -: 2216: // high nibble
+ -: 2217: // store type in high nibble
+ 1: 2218: ctx->nibble = lowNbl;
+ 1: 2219: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2220: *data |= type << 4;
+ 1: 2221: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2222: }
+ 2: 2223: type = 0;
+ -: 2224: } // if type
+ -: 2225:
+ 8: 2226: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/PACKED);
+call 0 returned 100%
+ -: 2227: // stop packing when packCount == 0
+ 8: 2228: packCount--;
+ 8: 2229: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2187: } // if pack
- -: 2188: else
- 5: 2189: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/NOPACKING);
-call 0 returned 100%
- 13: 2190: break;
- -: 2191: case BYTES:
- #####: 2192: if (pack) {
-branch 0 never executed
-branch 1 never executed
- #####: 2193: if (type) {
-branch 0 never executed
-branch 1 never executed
- -: 2194: // this is the first packed element
- #####: 2195: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 2196: uintToNetTypeVarint(r, type, packCount);
-call 0 never executed
- -: 2197: }
- -: 2198: else {
- -: 2199: // high nibble
- -: 2200: // store type in high nibble
- #####: 2201: ctx->nibble = lowNbl;
- #####: 2202: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 2203: *data |= type << 4;
- #####: 2204: uintToVarint(r, packCount);
-call 0 never executed
- -: 2205: }
- #####: 2206: type = 0;
- -: 2207: } // if type
- -: 2208:
- #####: 2209: B = (sBytest *)(e->data);
- #####: 2210: uintToVarint(r, B->count);
-call 0 never executed
- #####: 2211: sBytesPushBuffer(r, &(B->data), B->count);
-call 0 never executed
- -: 2212: // stop packing when packCount == 0
- #####: 2213: packCount--;
- #####: 2214: if (!packCount) pack = false;
-branch 0 never executed
-branch 1 never executed
- -: 2215: } // if pack
- -: 2216: else {
- #####: 2217: B = (sBytest *)(e->data);
- #####: 2218: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 2219: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
-call 0 never executed
- -: 2220: }
- -: 2221: else {
- -: 2222: // high nibble
- #####: 2223: storeTypeInHighNbl(e->data);
- #####: 2224: uintToVarint(r, B->count);
-call 0 never executed
- -: 2225: }
- #####: 2226: sBytesPushBuffer(r, &(B->data), B->count);
-call 0 never executed
- -: 2227: }
- #####: 2228: break;
- -: 2229: }
- -: 2230: }
- -: 2231: }
- 54: 2232: ret;
- -: 2233:}
- -: 2234:
- -: 2235:/**
- -: 2236: * serialize array
- -: 2237: *
- -: 2238: * the serialized array is pushed to r.
- -: 2239: * All elements are serialized recursively
- -: 2240: *
- -: 2241: * the data in containers is not serialized
- -: 2242: *
- -: 2243: * \param
- -: 2244: * r small bytes object
- -: 2245: * array to serialize
- -: 2246: */
-function arrayNetSerial called 71 returned 100% blocks executed 86%
- 71: 2247:internal void arrayNetSerial(sBytest **r, sArrayt *array, contextt *ctx, packingT packing) {
- 71: 2248: sBytest *B = NULL;
- 71: 2249: char *data = NULL;
- -: 2250:
- -: 2251: // check if all elements have same type
- 71: 2252: bool allElementsHaveSameType = true;
- 71: 2253: bool foundFirstType = false;
- 71: 2254: char type = 0;
- -: 2255:
- 213: 2256: {forEachSArray(array, e) {
+ -: 2230: } // if pack
+ -: 2231: else
+ 5: 2232: arrayNetSerial(r, (sArrayt *)(e->data), ctx, /*packing=*/NOPACKING);
+call 0 returned 100%
+ 13: 2233: break;
+ -: 2234: case BYTES:
+ #####: 2235: if (pack) {
+branch 0 never executed
+branch 1 never executed
+ #####: 2236: if (type) {
+branch 0 never executed
+branch 1 never executed
+ -: 2237: // this is the first packed element
+ #####: 2238: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 2239: uintToNetTypeVarint(r, type, packCount);
+call 0 never executed
+ -: 2240: }
+ -: 2241: else {
+ -: 2242: // high nibble
+ -: 2243: // store type in high nibble
+ #####: 2244: ctx->nibble = lowNbl;
+ #####: 2245: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 2246: *data |= type << 4;
+ #####: 2247: uintToVarint(r, packCount);
+call 0 never executed
+ -: 2248: }
+ #####: 2249: type = 0;
+ -: 2250: } // if type
+ -: 2251:
+ #####: 2252: B = (sBytest *)(e->data);
+ #####: 2253: uintToVarint(r, B->count);
+call 0 never executed
+ #####: 2254: sBytesPushBuffer(r, &(B->data), B->count);
+call 0 never executed
+ -: 2255: // stop packing when packCount == 0
+ #####: 2256: packCount--;
+ #####: 2257: if (!packCount) pack = false;
+branch 0 never executed
+branch 1 never executed
+ -: 2258: } // if pack
+ -: 2259: else {
+ #####: 2260: B = (sBytest *)(e->data);
+ #####: 2261: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 2262: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->data->type], B->count);
+call 0 never executed
+ -: 2263: }
+ -: 2264: else {
+ -: 2265: // high nibble
+ #####: 2266: storeTypeInHighNbl(e->data);
+ #####: 2267: uintToVarint(r, B->count);
+call 0 never executed
+ -: 2268: }
+ #####: 2269: sBytesPushBuffer(r, &(B->data), B->count);
+call 0 never executed
+ -: 2270: }
+ #####: 2271: break;
+ -: 2272: }
+ -: 2273: }
+ -: 2274: }
+ 54: 2275: ret;
+ -: 2276:}
+ -: 2277:
+ -: 2278:/**
+ -: 2279: * serialize array
+ -: 2280: *
+ -: 2281: * the serialized array is pushed to r.
+ -: 2282: * All elements are serialized recursively
+ -: 2283: *
+ -: 2284: * the data in containers is not serialized
+ -: 2285: *
+ -: 2286: * \param
+ -: 2287: * r small bytes object
+ -: 2288: * array to serialize
+ -: 2289: */
+function arrayNetSerial called 73 returned 100% blocks executed 86%
+ 73: 2290:internal void arrayNetSerial(sBytest **r, sArrayt *array, contextt *ctx, packingT packing) {
+ 73: 2291: sBytest *B = NULL;
+ 73: 2292: char *data = NULL;
+ -: 2293:
+ -: 2294: // check if all elements have same type
+ -: 2295: // then set array type normal or uniform
+ -: 2296: // array and dict have to be checked recursively to know if they are normal or uniform
+ 73: 2297: bool allElementsHaveSameType = true;
+ 73: 2298: bool foundFirstType = false;
+ 73: 2299: char type = 0;
+ -: 2300:
+ -: 2301: // get first element type
+ -: 2302: // compare to other element type
+ -: 2303: // null element are interpreted as undefined
+ 217: 2304: {forEachSArray(array, e) {
branch 0 taken 82%
branch 1 taken 18% (fallthrough)
- 174: 2257: if (!e) {
+ 177: 2305: if (!e) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 2258: if (foundFirstType) {
+ #####: 2306: if (foundFirstType) {
branch 0 never executed
branch 1 never executed
- #####: 2259: if (type != S_UNDEFINED) {
+ #####: 2307: if (type != S_UNDEFINED) {
branch 0 never executed
branch 1 never executed
- #####: 2260: allElementsHaveSameType = false;
- #####: 2261: break;
- -: 2262: }
- -: 2263: }
- -: 2264: else {
- #####: 2265: type = S_UNDEFINED;
- #####: 2266: foundFirstType = true;
- -: 2267: }
- -: 2268: }
- -: 2269: else {
- 174: 2270: if (foundFirstType) {
+ #####: 2308: allElementsHaveSameType = false;
+ #####: 2309: break;
+ -: 2310: }
+ -: 2311: }
+ -: 2312: else {
+ #####: 2313: type = S_UNDEFINED;
+ #####: 2314: foundFirstType = true;
+ -: 2315: }
+ -: 2316: }
+ -: 2317: else {
+ 177: 2318: if (foundFirstType) {
branch 0 taken 61% (fallthrough)
branch 1 taken 39%
- -: 2271: u8 nextType;
- 107: 2272: switch(e->type) {
-branch 0 taken 7%
+ -: 2319: u8 nextType;
+ 108: 2320: switch(e->type) {
+branch 0 taken 6%
branch 1 taken 10%
branch 2 taken 83%
- -: 2273: case DICT:
- 7: 2274: nextType = isDictUniform((sDictt*)e);
-call 0 returned 100%
- 7: 2275: break;
- -: 2276: case ARRAY:
- 11: 2277: nextType = isArrayUniform((sArrayt*)e);
-call 0 returned 100%
- 11: 2278: break;
- -: 2279: default:
- 89: 2280: nextType = NET_SERIAL_TYPES[(u8)e->type];
- -: 2281: }
- 107: 2282: if (nextType != type) {
-branch 0 taken 30% (fallthrough)
-branch 1 taken 70%
- 32: 2283: allElementsHaveSameType = false;
- 32: 2284: break;
- -: 2285: }
- -: 2286: }
- -: 2287: else {
- 67: 2288: switch(e->type) {
-branch 0 taken 6%
-branch 1 taken 7%
-branch 2 taken 87%
- -: 2289: case DICT:
- 4: 2290: type = isDictUniform((sDictt*)e);
-call 0 returned 100%
- 4: 2291: break;
- -: 2292: case ARRAY:
- 5: 2293: type = isArrayUniform((sArrayt*)e);
-call 0 returned 100%
- 5: 2294: break;
- -: 2295: default:
- 58: 2296: type = NET_SERIAL_TYPES[(u8)e->type];
- -: 2297: }
- 67: 2298: foundFirstType = true;
- -: 2299: }
- -: 2300: }
- -: 2301: }}
- -: 2302:
- 71: 2303: if (allElementsHaveSameType) {
+ -: 2321: case DICT:
+ 7: 2322: nextType = isDictUniform((sDictt*)e);
+call 0 returned 100%
+ 7: 2323: break;
+ -: 2324: case ARRAY:
+ 11: 2325: nextType = isArrayUniform((sArrayt*)e);
+call 0 returned 100%
+ 11: 2326: break;
+ -: 2327: default:
+ 90: 2328: nextType = NET_SERIAL_TYPES[(u8)e->type];
+ -: 2329: }
+ 108: 2330: if (nextType != type) {
+branch 0 taken 31% (fallthrough)
+branch 1 taken 69%
+ 33: 2331: allElementsHaveSameType = false;
+ 33: 2332: break;
+ -: 2333: }
+ -: 2334: }
+ -: 2335: else {
+ 69: 2336: switch(e->type) {
+branch 0 taken 7%
+branch 1 taken 9%
+branch 2 taken 84%
+ -: 2337: case DICT:
+ 5: 2338: type = isDictUniform((sDictt*)e);
+call 0 returned 100%
+ 5: 2339: break;
+ -: 2340: case ARRAY:
+ 6: 2341: type = isArrayUniform((sArrayt*)e);
+call 0 returned 100%
+ 6: 2342: break;
+ -: 2343: default:
+ 58: 2344: type = NET_SERIAL_TYPES[(u8)e->type];
+ -: 2345: }
+ 69: 2346: foundFirstType = true;
+ -: 2347: }
+ -: 2348: }
+ -: 2349: }}
+ -: 2350:
+ 73: 2351: if (allElementsHaveSameType) {
branch 0 taken 55% (fallthrough)
branch 1 taken 45%
- -: 2304: // pack array
- 39: 2305: if (packing == PACKED) {
-branch 0 taken 41% (fallthrough)
-branch 1 taken 59%
- -: 2306: // uniform array can't be packed
- -: 2307: // because there is only one type of packed arrays
- 16: 2308: goto normalArray;
- -: 2309: }
- 23: 2310: elif (packing == UNIFORM) {
-branch 0 taken 9% (fallthrough)
-branch 1 taken 91%
- 2: 2311: uintToNetTypeVarint(r, type, array->count);
+ -: 2352: // uniform array
+ -: 2353: // encode type and element count
+ -: 2354:
+ -: 2355: // in pack array
+ 40: 2356: if (packing == PACKED) {
+branch 0 taken 40% (fallthrough)
+branch 1 taken 60%
+ -: 2357: // uniform array can't be packed
+ -: 2358: // because there is only one type of packed arrays
+ 16: 2359: goto normalArray;
+ -: 2360: }
+ 24: 2361: elif (packing == UNIFORM) {
+branch 0 taken 8% (fallthrough)
+branch 1 taken 92%
+ -: 2362: // when the packing is uniform, there is no need to encode UNIFORM_ARRAY since all elements have this type
+ 2: 2363: uintToNetTypeVarint(r, type, array->count);
call 0 returned 100%
- -: 2312: }
- -: 2313: else {
- 21: 2314: if (ctx->nibble == lowNbl) {
-branch 0 taken 76% (fallthrough)
-branch 1 taken 24%
- 16: 2315: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
-call 0 returned 100%
- 16: 2316: uintToVarint(r, array->count);
-call 0 returned 100%
- -: 2317: }
- -: 2318: else {
- -: 2319: // high nibble
- 5: 2320: ctx->nibble = lowNbl;
- 5: 2321: data = (char *)&((*r)->data) + ctx->nblOffset;
- 5: 2322: *data |= UNIFORM_ARRAY << 4;
- 5: 2323: uintToNetTypeVarint(r, type, array->count);
-call 0 returned 100%
- -: 2324: }
- -: 2325: }
- -: 2326:
- 23: 2327: switch(type) {
-branch 0 taken 9%
-branch 1 taken 9%
+ -: 2364: }
+ -: 2365: else {
+ 22: 2366: if (ctx->nibble == lowNbl) {
+branch 0 taken 77% (fallthrough)
+branch 1 taken 23%
+ 17: 2367: sBytesPush(r, (type << 4) + UNIFORM_ARRAY);
+call 0 returned 100%
+ 17: 2368: uintToVarint(r, array->count);
+call 0 returned 100%
+ -: 2369: }
+ -: 2370: else {
+ -: 2371: // high nibble
+ 5: 2372: ctx->nibble = lowNbl;
+ 5: 2373: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 5: 2374: *data |= UNIFORM_ARRAY << 4;
+ 5: 2375: uintToNetTypeVarint(r, type, array->count);
+call 0 returned 100%
+ -: 2376: }
+ -: 2377: }
+ -: 2378:
+ -: 2379: // encode all element values
+ 24: 2380: switch(type) {
+branch 0 taken 8%
+branch 1 taken 8%
branch 2 taken 4%
-branch 3 taken 48%
+branch 3 taken 46%
branch 4 taken 4%
-branch 5 taken 13%
+branch 5 taken 17%
branch 6 taken 0%
branch 7 taken 13%
- -: 2328: case S_BOOL:
- 16: 2329: {forEachSArray(array, e) {
+ -: 2381: case S_BOOL:
+ 16: 2382: {forEachSArray(array, e) {
branch 0 taken 88%
branch 1 taken 13% (fallthrough)
- 14: 2330: if (!ctx->boolOffset) {
+ 14: 2383: if (!ctx->boolOffset) {
branch 0 taken 14% (fallthrough)
branch 1 taken 86%
- -: 2331: // new packed bools
- 2: 2332: storeNew8bPackedBool(e);
+ -: 2384: // new packed bools
+ 2: 2385: storeNew8bPackedBool(e);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 2333: }
- -: 2334: else {
- -: 2335: // there was a bool before this one, fill bits in nibbles
- 12: 2336: if (ctx->boolShift == 8) {
+ -: 2386: }
+ -: 2387: else {
+ -: 2388: // there was a bool before this one, fill bits in nibbles
+ 12: 2389: if (ctx->boolShift == 8) {
branch 0 taken 8% (fallthrough)
branch 1 taken 92%
- -: 2337: // previous packed bool is full
- -: 2338: // next byte is the new packed bools
- 1: 2339: storeNew8bPackedBool(e);
+ -: 2390: // previous packed bool is full
+ -: 2391: // next byte is the new packed bools
+ 1: 2392: storeNew8bPackedBool(e);
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
call 2 returned 100%
- -: 2340: }
- -: 2341: else {
- 11: 2342: storeBool(e);
+ -: 2393: }
+ -: 2394: else {
+ 11: 2395: storeBool(e);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
- -: 2343: }
- -: 2344: }
- -: 2345: }}
- 2: 2346: break;
- -: 2347: case S_DICT:
- -: 2348: case UNIFORM_DICT:
- 6: 2349: {forEachSArray(array, e) {
+ -: 2396: }
+ -: 2397: }
+ -: 2398: }}
+ 2: 2399: break;
+ -: 2400: case S_DICT:
+ -: 2401: case UNIFORM_DICT:
+ 6: 2402: {forEachSArray(array, e) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 4: 2350: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/UNIFORM);
+ 4: 2403: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/UNIFORM);
call 0 returned 100%
- -: 2351: }}
- 2: 2352: break;
- -: 2353: case S_DOUBLE:
- 4: 2354: {forEachSArray(array, e) {
+ -: 2404: }}
+ 2: 2405: break;
+ -: 2406: case S_DOUBLE:
+ 4: 2407: {forEachSArray(array, e) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 2355: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+ 3: 2408: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
call 0 returned 100%
- -: 2356: }}
- 1: 2357: break;
- -: 2358: case S_INT:
- 49: 2359: {forEachSArray(array, e) {
+ -: 2409: }}
+ 1: 2410: break;
+ -: 2411: case S_INT:
+ 49: 2412: {forEachSArray(array, e) {
branch 0 taken 78%
branch 1 taken 22% (fallthrough)
- 38: 2360: i64 v = ((sIntt *)e)->value;
- 38: 2361: uintToVarint(r, (v << 1) ^ (v >> 63));
+ 38: 2413: i64 v = ((sIntt *)e)->value;
+ 38: 2414: uintToVarint(r, (v << 1) ^ (v >> 63));
call 0 returned 100%
- -: 2362: }}
- 11: 2363: break;
- -: 2364: case S_STRING:
- 4: 2365: {forEachSArray(array, e) {
+ -: 2415: }}
+ 11: 2416: break;
+ -: 2417: case S_STRING:
+ 4: 2418: {forEachSArray(array, e) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 2366: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+ 3: 2419: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
call 0 returned 100%
- -: 2367: }}
- 1: 2368: break;
- -: 2369: case S_ARRAY:
- -: 2370: case UNIFORM_ARRAY:
- 8: 2371: {forEachSArray(array, e) {
-branch 0 taken 63%
-branch 1 taken 38% (fallthrough)
- 5: 2372: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/UNIFORM);
+ -: 2420: }}
+ 1: 2421: break;
+ -: 2422: case S_ARRAY:
+ -: 2423: case UNIFORM_ARRAY:
+ 10: 2424: {forEachSArray(array, e) {
+branch 0 taken 60%
+branch 1 taken 40% (fallthrough)
+ 6: 2425: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/UNIFORM);
call 0 returned 100%
- -: 2373: }}
- 3: 2374: break;
- -: 2375: case S_BYTES:
- #####: 2376: {forEachSArray(array, e) {
+ -: 2426: }}
+ 4: 2427: break;
+ -: 2428: case S_BYTES:
+ #####: 2429: {forEachSArray(array, e) {
branch 0 never executed
branch 1 never executed
- #####: 2377: B = (sBytest *)e;
- #####: 2378: uintToVarint(r, B->count);
+ #####: 2430: B = (sBytest *)e;
+ #####: 2431: uintToVarint(r, B->count);
call 0 never executed
- #####: 2379: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 2432: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 2380: }}
- #####: 2381: break;
- -: 2382: }
- 23: 2383: ret;
- -: 2384: }
- -: 2385:
- -: 2386: normalArray:
- 48: 2387: if (packing == PACKED or packing == UNIFORM) {
+ -: 2433: }}
+ #####: 2434: break;
+ -: 2435: }
+ 24: 2436: ret;
+ -: 2437: }
+ -: 2438:
+ -: 2439: normalArray:
+ -: 2440: // encode type and element count
+ 49: 2441: if (packing == PACKED or packing == UNIFORM) {
branch 0 taken 67% (fallthrough)
branch 1 taken 33%
-branch 2 taken 16% (fallthrough)
-branch 3 taken 84%
- 21: 2388: uintToVarint(r, array->count);
-call 0 returned 100%
- -: 2389: }
- -: 2390: else {
- 27: 2391: if (ctx->nibble == lowNbl) {
+branch 2 taken 18% (fallthrough)
+branch 3 taken 82%
+ -: 2442: // when the packing is packed or uniform, there is no need to encode ARRAY type since all elements have this type
+ 22: 2443: uintToVarint(r, array->count);
+call 0 returned 100%
+ -: 2444: }
+ -: 2445: else {
+ 27: 2446: if (ctx->nibble == lowNbl) {
branch 0 taken 96% (fallthrough)
branch 1 taken 4%
- 26: 2392: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
-call 0 returned 100%
- -: 2393: }
- -: 2394: else {
- -: 2395: // high nibble
- 1: 2396: storeTypeInHighNbl(array);
- 1: 2397: uintToVarint(r, array->count);
-call 0 returned 100%
- -: 2398: }
- -: 2399: }
- -: 2400:
- 48: 2401: bool pack = false;
- -: 2402: size_t packCount;
- 198: 2403: enumerateSArray(array, e, eIdx) {
+ 26: 2447: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)array->type], array->count);
+call 0 returned 100%
+ -: 2448: }
+ -: 2449: else {
+ -: 2450: // high nibble
+ 1: 2451: storeTypeInHighNbl(array);
+ 1: 2452: uintToVarint(r, array->count);
+call 0 returned 100%
+ -: 2453: }
+ -: 2454: }
+ -: 2455:
+ 49: 2456: bool pack = false;
+ -: 2457: size_t packCount;
+ 203: 2458: enumerateSArray(array, e, eIdx) {
branch 0 taken 76%
branch 1 taken 24% (fallthrough)
- 150: 2404: if (!e) {
+ 154: 2459: if (!e) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 2405: // empty slots are represented as undefined elements
- #####: 2406: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 2407: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
-call 0 never executed
- #####: 2408: ctx->nibble = highNbl;
- #####: 2409: ctx->nblOffset = (*r)->count -1;
- -: 2410: }
- -: 2411: else {
- -: 2412: // high nibble
- #####: 2413: ctx->nibble = lowNbl;
- #####: 2414: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 2415: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
- -: 2416: }
- -: 2417: }
- -: 2418: else {
- 150: 2419: if (!pack) {
-branch 0 taken 80% (fallthrough)
-branch 1 taken 20%
- -: 2420: // scan array for packing
- 120: 2421: if ((array->count - eIdx) > 3) {
-branch 0 taken 33% (fallthrough)
+ -: 2460: // empty slots are represented as undefined elements
+ #####: 2461: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 2462: sBytesPush(r, NET_SERIAL_TYPES[UNDEFINED]);
+call 0 never executed
+ #####: 2463: ctx->nibble = highNbl;
+ #####: 2464: ctx->nblOffset = (*r)->count -1;
+ -: 2465: }
+ -: 2466: else {
+ -: 2467: // high nibble
+ #####: 2468: ctx->nibble = lowNbl;
+ #####: 2469: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 2470: *data |= NET_SERIAL_TYPES[UNDEFINED] << 4;
+ -: 2471: }
+ -: 2472: }
+ -: 2473: else {
+ 154: 2474: if (!pack) {
+branch 0 taken 81% (fallthrough)
+branch 1 taken 19%
+ -: 2475: // scan array for packing
+ 124: 2476: if ((array->count - eIdx) > 3) {
+branch 0 taken 32% (fallthrough)
branch 1 taken 68%
- -: 2422: // at least 4 elements, less than that is not worth it
- 39: 2423: if ( e->type == DICT
-branch 0 taken 92% (fallthrough)
-branch 1 taken 8%
- 36: 2424: or e->type == DOUBLE
+ -: 2477: // at least 4 elements, less than that is not worth it
+ 40: 2478: if ( e->type == DICT
+branch 0 taken 90% (fallthrough)
+branch 1 taken 10%
+ 36: 2479: or e->type == DOUBLE
branch 0 taken 94% (fallthrough)
branch 1 taken 6%
- 34: 2425: or e->type == INT
+ 34: 2480: or e->type == INT
branch 0 taken 91% (fallthrough)
branch 1 taken 9%
- 31: 2426: or e->type == STRING
+ 31: 2481: or e->type == STRING
branch 0 taken 94% (fallthrough)
branch 1 taken 6%
- 29: 2427: or e->type == ARRAY
+ 29: 2482: or e->type == ARRAY
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 27: 2428: or e->type == BYTES) {
+ 27: 2483: or e->type == BYTES) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 12: 2429: type = e->type;
- 12: 2430: packCount = 1;
- 12: 2431: smallt *element = ((smallt **) &((array)->data))[eIdx];
- 45: 2432: for (size_t i = eIdx+1; i < (array)->count ; i++, element = ((smallt **) &((array)->data))[i]) {
+ 13: 2484: type = e->type;
+ 13: 2485: packCount = 1;
+ 13: 2486: smallt *element = ((smallt **) &((array)->data))[eIdx+1];
+ 45: 2487: for (size_t i = eIdx+1; i < (array)->count ; i++, element = ((smallt **) &((array)->data))[i]) {
branch 0 taken 100%
branch 1 taken 0% (fallthrough)
- 45: 2433: if (!element) {
+ 45: 2488: if (!element) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 2434: // null element are undefined
- #####: 2435: break;
- -: 2436: }
- -: 2437: else {
- 45: 2438: if (element->type != type) {
-branch 0 taken 27% (fallthrough)
-branch 1 taken 73%
- 12: 2439: break;
- -: 2440: }
- 33: 2441: packCount++;
- -: 2442: } // if element
- -: 2443: } // for
- 12: 2444: if (packCount > 3) {
-branch 0 taken 83% (fallthrough)
-branch 1 taken 17%
- 10: 2445: type = PACKED_NET_SERIAL_TYPES[(u8)type];
- 10: 2446: pack = true;
- -: 2447: }
- -: 2448: } // test current element type
- -: 2449: } // is array big enough
- -: 2450: } // not already packing
- -: 2451:
- 150: 2452: switch(e->type) {
-branch 0 taken 18%
+ -: 2489: // null element are undefined
+ #####: 2490: break;
+ -: 2491: }
+ -: 2492: else {
+ 45: 2493: if (element->type != type) {
+branch 0 taken 29% (fallthrough)
+branch 1 taken 71%
+ 13: 2494: break;
+ -: 2495: }
+ 32: 2496: packCount++;
+ -: 2497: } // if element
+ -: 2498: } // for
+ 13: 2499: if (packCount > 3) {
+branch 0 taken 77% (fallthrough)
branch 1 taken 23%
-branch 2 taken 8%
-branch 3 taken 7%
-branch 4 taken 20%
+ 10: 2500: type = PACKED_NET_SERIAL_TYPES[(u8)type];
+ 10: 2501: pack = true;
+ -: 2502: }
+ -: 2503: } // test current element type
+ -: 2504: } // is array big enough
+ -: 2505: } // not already packing
+ -: 2506:
+ -: 2507: // encode element value
+ 154: 2508: switch(e->type) {
+branch 0 taken 18%
+branch 1 taken 22%
+branch 2 taken 10%
+branch 3 taken 6%
+branch 4 taken 19%
branch 5 taken 14%
-branch 6 taken 11%
+branch 6 taken 10%
branch 7 taken 0%
branch 8 taken 0%
- -: 2453: case UNDEFINED:
- -: 2454: case CONTAINER:
- 27: 2455: if (ctx->nibble == lowNbl) {
+ -: 2509: case UNDEFINED:
+ -: 2510: case CONTAINER:
+ 28: 2511: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 25: 2456: storeTypeOnly(e);
-call 0 returned 100%
- -: 2457: }
- -: 2458: else {
- -: 2459: // high nibble
- 2: 2460: storeTypeInHighNbl(e);
- -: 2461: }
- 27: 2462: break;
- -: 2463: case BOOL:
- 34: 2464: if (!ctx->boolOffset) {
+ 26: 2512: storeTypeOnly(e);
+call 0 returned 100%
+ -: 2513: }
+ -: 2514: else {
+ -: 2515: // high nibble
+ 2: 2516: storeTypeInHighNbl(e);
+ -: 2517: }
+ 28: 2518: break;
+ -: 2519: case BOOL:
+ 34: 2520: if (!ctx->boolOffset) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- -: 2465: // new packed bools
- 6: 2466: if (ctx->nibble == lowNbl) {
+ -: 2521: // new packed bools
+ 6: 2522: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 3: 2467: storeNew4bPackedBool(e);
+ 3: 2523: storeNew4bPackedBool(e);
branch 0 taken 67% (fallthrough)
branch 1 taken 33%
call 2 returned 100%
- -: 2468: }
- -: 2469: else {
- -: 2470: // high nibble, next byte is packed bools
- 3: 2471: storeTypeInHighNbl(e);
- 3: 2472: storeNew8bPackedBool(e);
+ -: 2524: }
+ -: 2525: else {
+ -: 2526: // high nibble, next byte is packed bools
+ 3: 2527: storeTypeInHighNbl(e);
+ 3: 2528: storeNew8bPackedBool(e);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 2473: }
- -: 2474: }
- -: 2475: else {
- -: 2476: // there was a bool before this one, fill bits in nibbles
- 28: 2477: if (ctx->nibble == lowNbl) {
+ -: 2529: }
+ -: 2530: }
+ -: 2531: else {
+ -: 2532: // there was a bool before this one, fill bits in nibbles
+ 28: 2533: if (ctx->nibble == lowNbl) {
branch 0 taken 61% (fallthrough)
branch 1 taken 39%
- 17: 2478: if (ctx->boolShift == 8) {
+ 17: 2534: if (ctx->boolShift == 8) {
branch 0 taken 12% (fallthrough)
branch 1 taken 88%
- -: 2479: // previous packed bool is full
- -: 2480: // this byte is the new packed bools
- 2: 2481: storeNew4bPackedBool(e);
+ -: 2535: // previous packed bool is full
+ -: 2536: // this byte is the new packed bools
+ 2: 2537: storeNew4bPackedBool(e);
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
call 2 returned 100%
- -: 2482: }
- -: 2483: else {
- 15: 2484: storeTypeOnly(e);
+ -: 2538: }
+ -: 2539: else {
+ 15: 2540: storeTypeOnly(e);
call 0 returned 100%
- 15: 2485: storeBool(e);
+ 15: 2541: storeBool(e);
branch 0 taken 53% (fallthrough)
branch 1 taken 47%
- -: 2486: }
- -: 2487: }
- -: 2488: else {
- -: 2489: // high nibble
- 11: 2490: storeTypeInHighNbl(e);
- 11: 2491: if (ctx->boolShift == 8) {
+ -: 2542: }
+ -: 2543: }
+ -: 2544: else {
+ -: 2545: // high nibble
+ 11: 2546: storeTypeInHighNbl(e);
+ 11: 2547: if (ctx->boolShift == 8) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- -: 2492: // previous packed bool is full
- -: 2493: // next byte is the new packed bools
- 2: 2494: storeNew8bPackedBool(e);
+ -: 2548: // previous packed bool is full
+ -: 2549: // next byte is the new packed bools
+ 2: 2550: storeNew8bPackedBool(e);
branch 0 taken 100% (fallthrough)
branch 1 taken 0%
call 2 returned 100%
- -: 2495: }
- -: 2496: else {
- 9: 2497: storeBool(e);
+ -: 2551: }
+ -: 2552: else {
+ 9: 2553: storeBool(e);
branch 0 taken 78% (fallthrough)
branch 1 taken 22%
- -: 2498: }
- -: 2499: }
- -: 2500: }
- 34: 2501: break;
- -: 2502: case DICT:
- 12: 2503: if (pack) {
-branch 0 taken 67% (fallthrough)
-branch 1 taken 33%
- 8: 2504: if (type) {
+ -: 2554: }
+ -: 2555: }
+ -: 2556: }
+ 34: 2557: break;
+ -: 2558: case DICT:
+ 15: 2559: if (pack) {
+branch 0 taken 53% (fallthrough)
+branch 1 taken 47%
+ 8: 2560: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2505: // this is the first packed element
- 2: 2506: if (ctx->nibble == lowNbl) {
+ -: 2561: // this is the first packed element
+ 2: 2562: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2507: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2508: }
- -: 2509: else {
- -: 2510: // high nibble
- -: 2511: // store type in high nibble
- 1: 2512: ctx->nibble = lowNbl;
- 1: 2513: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2514: *data |= type << 4;
- 1: 2515: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2516: }
- 2: 2517: type = 0;
- -: 2518: } // if type
- -: 2519:
- 8: 2520: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/PACKED);
-call 0 returned 100%
- -: 2521: // stop packing when packCount == 0
- 8: 2522: packCount--;
- 8: 2523: if (!packCount) pack = false;
+ 1: 2563: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2564: }
+ -: 2565: else {
+ -: 2566: // high nibble
+ -: 2567: // store type in high nibble
+ 1: 2568: ctx->nibble = lowNbl;
+ 1: 2569: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2570: *data |= type << 4;
+ 1: 2571: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2572: }
+ 2: 2573: type = 0;
+ -: 2574: } // if type
+ -: 2575:
+ 8: 2576: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/PACKED);
+call 0 returned 100%
+ -: 2577: // stop packing when packCount == 0
+ 8: 2578: packCount--;
+ 8: 2579: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2524: } // if pack
- -: 2525: else
- 4: 2526: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/NOPACKING);
+ -: 2580: } // if pack
+ -: 2581: else
+ 7: 2582: dictNetSerial(r, (sDictt *)e, ctx, /*packing=*/NOPACKING);
call 0 returned 100%
- 12: 2527: break;
- -: 2528: case DOUBLE:
- 10: 2529: if (pack) {
+ 15: 2583: break;
+ -: 2584: case DOUBLE:
+ 10: 2585: if (pack) {
branch 0 taken 80% (fallthrough)
branch 1 taken 20%
- 8: 2530: if (type) {
+ 8: 2586: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2531: // this is the first packed element
- 2: 2532: if (ctx->nibble == lowNbl) {
+ -: 2587: // this is the first packed element
+ 2: 2588: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2533: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2534: }
- -: 2535: else {
- -: 2536: // high nibble
- -: 2537: // store type in high nibble
- 1: 2538: ctx->nibble = lowNbl;
- 1: 2539: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2540: *data |= type << 4;
- 1: 2541: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2542: }
- 2: 2543: type = 0;
- -: 2544: } // if type
- -: 2545:
- 8: 2546: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
-call 0 returned 100%
- -: 2547: // stop packing when packCount == 0
- 8: 2548: packCount--;
- 8: 2549: if (!packCount) pack = false;
+ 1: 2589: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2590: }
+ -: 2591: else {
+ -: 2592: // high nibble
+ -: 2593: // store type in high nibble
+ 1: 2594: ctx->nibble = lowNbl;
+ 1: 2595: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2596: *data |= type << 4;
+ 1: 2597: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2598: }
+ 2: 2599: type = 0;
+ -: 2600: } // if type
+ -: 2601:
+ 8: 2602: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+call 0 returned 100%
+ -: 2603: // stop packing when packCount == 0
+ 8: 2604: packCount--;
+ 8: 2605: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2550: } // if pack
- -: 2551: else {
- 2: 2552: if (ctx->nibble == lowNbl) {
+ -: 2606: } // if pack
+ -: 2607: else {
+ 2: 2608: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2553: storeTypeOnly(e);
-call 0 returned 100%
- -: 2554: }
- -: 2555: else {
- -: 2556: // high nibble
- 1: 2557: storeTypeInHighNbl(e);
- -: 2558: }
- 2: 2559: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
-call 0 returned 100%
- -: 2560: }
- 10: 2561: break;
- -: 2562: case INT:
- 30: 2563: if (pack) {
+ 1: 2609: storeTypeOnly(e);
+call 0 returned 100%
+ -: 2610: }
+ -: 2611: else {
+ -: 2612: // high nibble
+ 1: 2613: storeTypeInHighNbl(e);
+ -: 2614: }
+ 2: 2615: sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
+call 0 returned 100%
+ -: 2616: }
+ 10: 2617: break;
+ -: 2618: case INT:
+ 30: 2619: if (pack) {
branch 0 taken 27% (fallthrough)
branch 1 taken 73%
- 8: 2564: if (type) {
+ 8: 2620: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2565: // this is the first packed element
- 2: 2566: if (ctx->nibble == lowNbl) {
+ -: 2621: // this is the first packed element
+ 2: 2622: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2567: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2568: }
- -: 2569: else {
- -: 2570: // high nibble
- -: 2571: // store type in high nibble
- 1: 2572: ctx->nibble = lowNbl;
- 1: 2573: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2574: *data |= type << 4;
- 1: 2575: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2576: }
- 2: 2577: type = 0;
- -: 2578: } // if type
- -: 2579:
- 8: 2580: i64 v = ((sIntt *)&(e->type))->value;
- 8: 2581: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2582: // stop packing when packCount == 0
- 8: 2583: packCount--;
- 8: 2584: if (!packCount) pack = false;
+ 1: 2623: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2624: }
+ -: 2625: else {
+ -: 2626: // high nibble
+ -: 2627: // store type in high nibble
+ 1: 2628: ctx->nibble = lowNbl;
+ 1: 2629: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2630: *data |= type << 4;
+ 1: 2631: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2632: }
+ 2: 2633: type = 0;
+ -: 2634: } // if type
+ -: 2635:
+ 8: 2636: i64 v = ((sIntt *)&(e->type))->value;
+ 8: 2637: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2638: // stop packing when packCount == 0
+ 8: 2639: packCount--;
+ 8: 2640: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2585: } // if pack
- -: 2586: else {
- -: 2587: // encode int to varint
- -: 2588: // v is int64_t to convert to varint
- 22: 2589: i64 v = ((sIntt *)&(e->type))->value;
- 22: 2590: if (ctx->nibble == lowNbl) {
+ -: 2641: } // if pack
+ -: 2642: else {
+ -: 2643: // encode int to varint
+ -: 2644: // v is int64_t to convert to varint
+ 22: 2645: i64 v = ((sIntt *)&(e->type))->value;
+ 22: 2646: if (ctx->nibble == lowNbl) {
branch 0 taken 82% (fallthrough)
branch 1 taken 18%
- -: 2591: // encode v with arithmetic shifts
- 18: 2592: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2593: }
- -: 2594: else {
- -: 2595: // high nibble
- 4: 2596: storeTypeInHighNbl(e);
- 4: 2597: uintToVarint(r, (v << 1) ^ (v >> 63));
-call 0 returned 100%
- -: 2598: }
- -: 2599: }
- 30: 2600: break;
- -: 2601: case STRING:
- 21: 2602: if (pack) {
+ -: 2647: // encode v with arithmetic shifts
+ 18: 2648: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2649: }
+ -: 2650: else {
+ -: 2651: // high nibble
+ 4: 2652: storeTypeInHighNbl(e);
+ 4: 2653: uintToVarint(r, (v << 1) ^ (v >> 63));
+call 0 returned 100%
+ -: 2654: }
+ -: 2655: }
+ 30: 2656: break;
+ -: 2657: case STRING:
+ 21: 2658: if (pack) {
branch 0 taken 38% (fallthrough)
branch 1 taken 62%
- 8: 2603: if (type) {
+ 8: 2659: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2604: // this is the first packed element
- 2: 2605: if (ctx->nibble == lowNbl) {
+ -: 2660: // this is the first packed element
+ 2: 2661: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2606: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2607: }
- -: 2608: else {
- -: 2609: // high nibble
- -: 2610: // store type in high nibble
- 1: 2611: ctx->nibble = lowNbl;
- 1: 2612: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2613: *data |= type << 4;
- 1: 2614: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2615: }
- 2: 2616: type = 0;
- -: 2617: } // if type
- -: 2618:
- 8: 2619: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
-call 0 returned 100%
- -: 2620: // stop packing when packCount == 0
- 8: 2621: packCount--;
- 8: 2622: if (!packCount) pack = false;
+ 1: 2662: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2663: }
+ -: 2664: else {
+ -: 2665: // high nibble
+ -: 2666: // store type in high nibble
+ 1: 2667: ctx->nibble = lowNbl;
+ 1: 2668: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2669: *data |= type << 4;
+ 1: 2670: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2671: }
+ 2: 2672: type = 0;
+ -: 2673: } // if type
+ -: 2674:
+ 8: 2675: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+call 0 returned 100%
+ -: 2676: // stop packing when packCount == 0
+ 8: 2677: packCount--;
+ 8: 2678: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2623: } // if pack
- -: 2624: else {
- 13: 2625: if (ctx->nibble == lowNbl) {
+ -: 2679: } // if pack
+ -: 2680: else {
+ 13: 2681: if (ctx->nibble == lowNbl) {
branch 0 taken 69% (fallthrough)
branch 1 taken 31%
- 9: 2626: storeTypeOnly(e);
-call 0 returned 100%
- -: 2627: }
- -: 2628: else {
- -: 2629: // high nibble
- 4: 2630: storeTypeInHighNbl(e);
- -: 2631: }
- 13: 2632: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
-call 0 returned 100%
- -: 2633: }
- 21: 2634: break;
- -: 2635: case ARRAY:
- 16: 2636: if (pack) {
+ 9: 2682: storeTypeOnly(e);
+call 0 returned 100%
+ -: 2683: }
+ -: 2684: else {
+ -: 2685: // high nibble
+ 4: 2686: storeTypeInHighNbl(e);
+ -: 2687: }
+ 13: 2688: sBytesPushBuffer(r, &((sStringt *)e)->data, sizeof(sStringt) + strlen(&(((sStringt *)e)->data)) -1);
+call 0 returned 100%
+ -: 2689: }
+ 21: 2690: break;
+ -: 2691: case ARRAY:
+ 16: 2692: if (pack) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 8: 2637: if (type) {
+ 8: 2693: if (type) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2638: // this is the first packed element
- 2: 2639: if (ctx->nibble == lowNbl) {
+ -: 2694: // this is the first packed element
+ 2: 2695: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 2640: uintToNetTypeVarint(r, type, packCount);
-call 0 returned 100%
- -: 2641: }
- -: 2642: else {
- -: 2643: // high nibble
- -: 2644: // store type in high nibble
- 1: 2645: ctx->nibble = lowNbl;
- 1: 2646: data = (char *)&((*r)->data) + ctx->nblOffset;
- 1: 2647: *data |= type << 4;
- 1: 2648: uintToVarint(r, packCount);
-call 0 returned 100%
- -: 2649: }
- 2: 2650: type = 0;
- -: 2651: } // if type
- -: 2652:
- 8: 2653: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/PACKED);
-call 0 returned 100%
- -: 2654: // stop packing when packCount == 0
- 8: 2655: packCount--;
- 8: 2656: if (!packCount) pack = false;
+ 1: 2696: uintToNetTypeVarint(r, type, packCount);
+call 0 returned 100%
+ -: 2697: }
+ -: 2698: else {
+ -: 2699: // high nibble
+ -: 2700: // store type in high nibble
+ 1: 2701: ctx->nibble = lowNbl;
+ 1: 2702: data = (char *)&((*r)->data) + ctx->nblOffset;
+ 1: 2703: *data |= type << 4;
+ 1: 2704: uintToVarint(r, packCount);
+call 0 returned 100%
+ -: 2705: }
+ 2: 2706: type = 0;
+ -: 2707: } // if type
+ -: 2708:
+ 8: 2709: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/PACKED);
+call 0 returned 100%
+ -: 2710: // stop packing when packCount == 0
+ 8: 2711: packCount--;
+ 8: 2712: if (!packCount) pack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- -: 2657: } // if pack
- -: 2658: else
- 8: 2659: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/NOPACKING);
+ -: 2713: } // if pack
+ -: 2714: else
+ 8: 2715: arrayNetSerial(r, (sArrayt *)e, ctx, /*packing=*/NOPACKING);
call 0 returned 100%
- 16: 2660: break;
- -: 2661: case BYTES:
- #####: 2662: if (pack) {
+ 16: 2716: break;
+ -: 2717: case BYTES:
+ #####: 2718: if (pack) {
branch 0 never executed
branch 1 never executed
- #####: 2663: if (type) {
+ #####: 2719: if (type) {
branch 0 never executed
branch 1 never executed
- -: 2664: // this is the first packed element
- #####: 2665: if (ctx->nibble == lowNbl) {
+ -: 2720: // this is the first packed element
+ #####: 2721: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 2666: uintToNetTypeVarint(r, type, packCount);
+ #####: 2722: uintToNetTypeVarint(r, type, packCount);
call 0 never executed
- -: 2667: }
- -: 2668: else {
- -: 2669: // high nibble
- -: 2670: // store type in high nibble
- #####: 2671: ctx->nibble = lowNbl;
- #####: 2672: data = (char *)&((*r)->data) + ctx->nblOffset;
- #####: 2673: *data |= type << 4;
- #####: 2674: uintToVarint(r, packCount);
+ -: 2723: }
+ -: 2724: else {
+ -: 2725: // high nibble
+ -: 2726: // store type in high nibble
+ #####: 2727: ctx->nibble = lowNbl;
+ #####: 2728: data = (char *)&((*r)->data) + ctx->nblOffset;
+ #####: 2729: *data |= type << 4;
+ #####: 2730: uintToVarint(r, packCount);
call 0 never executed
- -: 2675: }
- #####: 2676: type = 0;
- -: 2677: } // if type
- -: 2678:
- #####: 2679: B = (sBytest *)e;
- #####: 2680: uintToVarint(r, B->count);
+ -: 2731: }
+ #####: 2732: type = 0;
+ -: 2733: } // if type
+ -: 2734:
+ #####: 2735: B = (sBytest *)e;
+ #####: 2736: uintToVarint(r, B->count);
call 0 never executed
- #####: 2681: sBytesPushBuffer(r, &(B->data), B->count);
+ #####: 2737: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 2682: // stop packing when packCount == 0
- #####: 2683: packCount--;
- #####: 2684: if (!packCount) pack = false;
+ -: 2738: // stop packing when packCount == 0
+ #####: 2739: packCount--;
+ #####: 2740: if (!packCount) pack = false;
branch 0 never executed
branch 1 never executed
- -: 2685: } // if pack
- -: 2686: else {
- #####: 2687: B = (sBytest *)e;
- #####: 2688: if (ctx->nibble == lowNbl) {
+ -: 2741: } // if pack
+ -: 2742: else {
+ #####: 2743: B = (sBytest *)e;
+ #####: 2744: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 2689: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
+ #####: 2745: uintToNetTypeVarint(r, NET_SERIAL_TYPES[(u8)e->type], B->count);
call 0 never executed
- -: 2690: }
- -: 2691: else {
- -: 2692: // high nibble
- #####: 2693: storeTypeInHighNbl(e);
- #####: 2694: uintToVarint(r, B->count);
+ -: 2746: }
+ -: 2747: else {
+ -: 2748: // high nibble
+ #####: 2749: storeTypeInHighNbl(e);
+ #####: 2750: uintToVarint(r, B->count);
call 0 never executed
- -: 2695: }
- #####: 2696: sBytesPushBuffer(r, &(B->data), B->count);
+ -: 2751: }
+ #####: 2752: sBytesPushBuffer(r, &(B->data), B->count);
call 0 never executed
- -: 2697: }
- #####: 2698: break;
- -: 2699: }
- -: 2700: }
- -: 2701: }
- 48: 2702: ret;
- -: 2703:}
- -: 2704:
-function serialNetSerial called 76 returned 100% blocks executed 80%
- 76: 2705:internal smallBytest* serialNetSerial(smallJsont *self) {
- -: 2706:
- 76: 2707: smallt *o = getsoG(self);
+ -: 2753: }
+ #####: 2754: break;
+ -: 2755: }
+ -: 2756: }
+ -: 2757: }
+ 49: 2758: ret;
+ -: 2759:}
+ -: 2760:
+function serialNetSerial called 77 returned 100% blocks executed 80%
+ 77: 2761:internal smallBytest* serialNetSerial(smallJsont *self) {
+ -: 2762:
+ 77: 2763: smallt *o = getsoG(self);
call 0 returned 100%
- -: 2708:
- 76: 2709: if (o == NULL)
+ -: 2764:
+ 77: 2765: if (o == NULL)
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 2710: ret NULL;
- -: 2711:
- 76: 2712: sBytest *B = netSerial(o);
+ #####: 2766: ret NULL;
+ -: 2767:
+ 77: 2768: sBytest *B = netSerial(o);
call 0 returned 100%
- -: 2713:
- 76: 2714: if (!B) {
+ -: 2769:
+ 77: 2770: if (!B) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 2715: ret NULL;
- -: 2716: }
- -: 2717:
- 76: 2718: createAllocateSmallBytes(r);
-call 0 returned 100%
- 76: 2719: r->B = B;
- 76: 2720: ret r;
- -: 2721:}
- -: 2722:
- -: 2723:// -------------------------------------
- -: 2724:// Deserializers
- -: 2725:
+ #####: 2771: ret NULL;
+ -: 2772: }
+ -: 2773:
+ 77: 2774: createAllocateSmallBytes(r);
+call 0 returned 100%
+ 77: 2775: r->B = B;
+ 77: 2776: ret r;
+ -: 2777:}
+ -: 2778:
+ -: 2779:// -------------------------------------
+ -: 2780:// Deserializers
+ -: 2781:
+ -: 2782:// level 0
+ -: 2783:// like smallJson with ints and length encoded as varints
+ -: 2784:
+ -: 2785:/**
+ -: 2786: * deserializer top function
+ -: 2787: */
function netDeserialLevel0 called 0 returned 0% blocks executed 0%
- #####: 2726:internal smallt* netDeserialLevel0(sBytest *obj) {
- #####: 2727: smallt *r = NULL;
- #####: 2728: double *D = NULL;
- #####: 2729: char *s = NULL;
- #####: 2730: sBytest *B = NULL;
- -: 2731: uint32_t count;
- #####: 2732: char *data = NULL;
- -: 2733:
- #####: 2734: switch(obj->data & 0xF) {
+ #####: 2788:internal smallt* netDeserialLevel0(sBytest *obj) {
+ #####: 2789: smallt *r = NULL;
+ #####: 2790: double *D = NULL;
+ #####: 2791: char *s = NULL;
+ #####: 2792: sBytest *B = NULL;
+ -: 2793: uint32_t count;
+ #####: 2794: char *data = NULL;
+ -: 2795:
+ #####: 2796: switch(obj->data & 0xF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4077,103 +4139,103 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 2735: case S_UNDEFINED:
- #####: 2736: r = (smallt *) allocSUndefined();
-call 0 never executed
- #####: 2737: break;
- -: 2738: case S_BOOL:
- #####: 2739: r = (smallt *) allocSBool(obj->data & 0x10);
-call 0 never executed
- #####: 2740: break;
- -: 2741: case S_DICT:
- #####: 2742: data = (char *)&(obj->data);
- #####: 2743: dictNetDeserialLevel0((sDictt **)&r, &data);
-call 0 never executed
- #####: 2744: break;
- -: 2745: case S_DOUBLE:
- #####: 2746: data = &(obj->data)+1;
- #####: 2747: D = (double *)data;
- #####: 2748: r = (smallt *) allocSDouble(*D);
-call 0 never executed
- #####: 2749: break;
- -: 2750: case S_INT:
- #####: 2751: data = &(obj->data);
- #####: 2752: i64 v = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 2753: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 2754: r = (smallt *) allocSInt(v);
-call 0 never executed
- #####: 2755: break;
- -: 2756: case S_STRING:
- #####: 2757: s = (char *)&(obj->data)+1;
- #####: 2758: r = (smallt *) allocSStringTiny(s);
-call 0 never executed
- #####: 2759: break;
- -: 2760: case S_ARRAY:
- #####: 2761: data = (char *)&(obj->data);
- #####: 2762: arrayNetDeserialLevel0((sArrayt **)&r, &data);
-call 0 never executed
- #####: 2763: break;
- -: 2764: case S_BYTES:
- #####: 2765: B = allocSBytes();
-call 0 never executed
- #####: 2766: data = &(obj->data);
- #####: 2767: count = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 2768: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 2769: r = (smallt *)B;
- #####: 2770: break;
- -: 2771: }
- -: 2772:
- #####: 2773: ret r;
- -: 2774:}
- -: 2775:
- -: 2776:/**
- -: 2777: * deserialize dictionary from data
- -: 2778: *
- -: 2779: * a new dictionary is allocated
- -: 2780: *
- -: 2781: * \param
- -: 2782: * dict dictionary holding the elements
- -: 2783: * data serialized dictionary
- -: 2784: */
+ -: 2797: case S_UNDEFINED:
+ #####: 2798: r = (smallt *) allocSUndefined();
+call 0 never executed
+ #####: 2799: break;
+ -: 2800: case S_BOOL:
+ #####: 2801: r = (smallt *) allocSBool(obj->data & 0x10);
+call 0 never executed
+ #####: 2802: break;
+ -: 2803: case S_DICT:
+ #####: 2804: data = (char *)&(obj->data);
+ #####: 2805: dictNetDeserialLevel0((sDictt **)&r, &data);
+call 0 never executed
+ #####: 2806: break;
+ -: 2807: case S_DOUBLE:
+ #####: 2808: data = &(obj->data)+1;
+ #####: 2809: D = (double *)data;
+ #####: 2810: r = (smallt *) allocSDouble(*D);
+call 0 never executed
+ #####: 2811: break;
+ -: 2812: case S_INT:
+ #####: 2813: data = &(obj->data);
+ #####: 2814: i64 v = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 2815: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 2816: r = (smallt *) allocSInt(v);
+call 0 never executed
+ #####: 2817: break;
+ -: 2818: case S_STRING:
+ #####: 2819: s = (char *)&(obj->data)+1;
+ #####: 2820: r = (smallt *) allocSStringTiny(s);
+call 0 never executed
+ #####: 2821: break;
+ -: 2822: case S_ARRAY:
+ #####: 2823: data = (char *)&(obj->data);
+ #####: 2824: arrayNetDeserialLevel0((sArrayt **)&r, &data);
+call 0 never executed
+ #####: 2825: break;
+ -: 2826: case S_BYTES:
+ #####: 2827: B = allocSBytes();
+call 0 never executed
+ #####: 2828: data = &(obj->data);
+ #####: 2829: count = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 2830: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 2831: r = (smallt *)B;
+ #####: 2832: break;
+ -: 2833: }
+ -: 2834:
+ #####: 2835: ret r;
+ -: 2836:}
+ -: 2837:
+ -: 2838:/**
+ -: 2839: * deserialize dictionary from data
+ -: 2840: *
+ -: 2841: * a new dictionary is allocated
+ -: 2842: *
+ -: 2843: * \param
+ -: 2844: * dict dictionary holding the elements
+ -: 2845: * data serialized dictionary
+ -: 2846: */
function dictNetDeserialLevel0 called 0 returned 0% blocks executed 0%
- #####: 2785:internal void dictNetDeserialLevel0(sDictt **dict, char **data) {
- #####: 2786: sUndefinedt *u = NULL;
- #####: 2787: sBoolt *bo = NULL;
- #####: 2788: double *D = NULL;
- #####: 2789: sDoublet *Do = NULL;
- #####: 2790: sDictt *d = NULL;
- #####: 2791: sIntt *io = NULL;
- #####: 2792: char *s = NULL;
- #####: 2793: sStringt *so = NULL;
- #####: 2794: sArrayt *a = NULL;
- #####: 2795: sBytest *B = NULL;
- -: 2796: uint32_t count;
- -: 2797: uint32_t dictCount;
- -: 2798:
- #####: 2799: dictCount = netTypeVarintToUint((u8**)data);
-call 0 never executed
- -: 2800:
- #####: 2801: if (!dictCount) {
-branch 0 never executed
-branch 1 never executed
- #####: 2802: *dict = allocSDict();
-call 0 never executed
- #####: 2803: ret;
- -: 2804: }
- -: 2805:
- #####: 2806: loop(dictCount) {
-branch 0 never executed
-branch 1 never executed
- -: 2807: char type;
- -: 2808: char *key;
- #####: 2809: key = *data;
- #####: 2810: *data += strlen(key)+1;
- #####: 2811: type = **data;
- -: 2812:
- #####: 2813: switch(type & 0xF) {
+ #####: 2847:internal void dictNetDeserialLevel0(sDictt **dict, char **data) {
+ #####: 2848: sUndefinedt *u = NULL;
+ #####: 2849: sBoolt *bo = NULL;
+ #####: 2850: double *D = NULL;
+ #####: 2851: sDoublet *Do = NULL;
+ #####: 2852: sDictt *d = NULL;
+ #####: 2853: sIntt *io = NULL;
+ #####: 2854: char *s = NULL;
+ #####: 2855: sStringt *so = NULL;
+ #####: 2856: sArrayt *a = NULL;
+ #####: 2857: sBytest *B = NULL;
+ -: 2858: uint32_t count;
+ -: 2859: uint32_t dictCount;
+ -: 2860:
+ #####: 2861: dictCount = netTypeVarintToUint((u8**)data);
+call 0 never executed
+ -: 2862:
+ #####: 2863: if (!dictCount) {
+branch 0 never executed
+branch 1 never executed
+ #####: 2864: *dict = allocSDict();
+call 0 never executed
+ #####: 2865: ret;
+ -: 2866: }
+ -: 2867:
+ #####: 2868: loop(dictCount) {
+branch 0 never executed
+branch 1 never executed
+ -: 2869: char type;
+ -: 2870: char *key;
+ #####: 2871: key = *data;
+ #####: 2872: *data += strlen(key)+1;
+ #####: 2873: type = **data;
+ -: 2874:
+ #####: 2875: switch(type & 0xF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4183,119 +4245,119 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 2814: case S_UNDEFINED:
- #####: 2815: (*data)++;
- #####: 2816: u = allocSUndefined();
-call 0 never executed
- #####: 2817: sDictPushTiny(dict, key, (smallt *) u);
-call 0 never executed
- #####: 2818: break;
- -: 2819: case S_BOOL:
- #####: 2820: (*data)++;
- #####: 2821: bo = allocSBool(type & 0x10);
-call 0 never executed
- #####: 2822: sDictPushTiny(dict, key, (smallt *) bo);
-call 0 never executed
- #####: 2823: break;
- -: 2824: case S_DICT:
- #####: 2825: d = NULL;
- #####: 2826: dictNetDeserialLevel0(&d, data);
-call 0 never executed
- #####: 2827: sDictPushTiny(dict, key, (smallt *) d);
-call 0 never executed
- #####: 2828: break;
- -: 2829: case S_DOUBLE:
- #####: 2830: (*data)++;
- #####: 2831: D = (double *)(*data);
- #####: 2832: *data += sizeof(double);
- #####: 2833: Do = allocSDouble(*D);
-call 0 never executed
- #####: 2834: sDictPushTiny(dict, key, (smallt *) Do);
-call 0 never executed
- #####: 2835: break;
- -: 2836: case S_INT: {
- #####: 2837: i64 v = netTypeVarintToUint((u8**)data);
-call 0 never executed
- #####: 2838: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 2839: io = allocSInt(v);
-call 0 never executed
- #####: 2840: sDictPushTiny(dict, key, (smallt *) io);
-call 0 never executed
- -: 2841: }
- #####: 2842: break;
- -: 2843: case S_STRING:
- #####: 2844: (*data)++;
- #####: 2845: s = (char *)(*data);
- #####: 2846: *data += strlen(s)+1;
- #####: 2847: so = allocSStringTiny(s);
-call 0 never executed
- #####: 2848: sDictPushTiny(dict, key, (smallt *) so);
-call 0 never executed
- #####: 2849: break;
- -: 2850: case S_ARRAY:
- #####: 2851: a = NULL;
- #####: 2852: arrayNetDeserialLevel0(&a, data);
-call 0 never executed
- #####: 2853: sDictPushTiny(dict, key, (smallt *) a);
-call 0 never executed
- #####: 2854: break;
- -: 2855: case S_BYTES:
- #####: 2856: B = allocSBytes();
-call 0 never executed
- #####: 2857: count = netTypeVarintToUint((u8**)data);
-call 0 never executed
- #####: 2858: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 2859: *data += count;
- #####: 2860: sDictPushTiny(dict, key, (smallt *) B);
-call 0 never executed
- #####: 2861: break;
- -: 2862: }
- -: 2863: }
- -: 2864:}
- -: 2865:
- -: 2866:/**
- -: 2867: * deserialize array from data
- -: 2868: *
- -: 2869: * a new array is allocated
- -: 2870: *
- -: 2871: * \param
- -: 2872: * array holding the elements
- -: 2873: * data serialized dictionary
- -: 2874: */
+ -: 2876: case S_UNDEFINED:
+ #####: 2877: (*data)++;
+ #####: 2878: u = allocSUndefined();
+call 0 never executed
+ #####: 2879: sDictPushTiny(dict, key, (smallt *) u);
+call 0 never executed
+ #####: 2880: break;
+ -: 2881: case S_BOOL:
+ #####: 2882: (*data)++;
+ #####: 2883: bo = allocSBool(type & 0x10);
+call 0 never executed
+ #####: 2884: sDictPushTiny(dict, key, (smallt *) bo);
+call 0 never executed
+ #####: 2885: break;
+ -: 2886: case S_DICT:
+ #####: 2887: d = NULL;
+ #####: 2888: dictNetDeserialLevel0(&d, data);
+call 0 never executed
+ #####: 2889: sDictPushTiny(dict, key, (smallt *) d);
+call 0 never executed
+ #####: 2890: break;
+ -: 2891: case S_DOUBLE:
+ #####: 2892: (*data)++;
+ #####: 2893: D = (double *)(*data);
+ #####: 2894: *data += sizeof(double);
+ #####: 2895: Do = allocSDouble(*D);
+call 0 never executed
+ #####: 2896: sDictPushTiny(dict, key, (smallt *) Do);
+call 0 never executed
+ #####: 2897: break;
+ -: 2898: case S_INT: {
+ #####: 2899: i64 v = netTypeVarintToUint((u8**)data);
+call 0 never executed
+ #####: 2900: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 2901: io = allocSInt(v);
+call 0 never executed
+ #####: 2902: sDictPushTiny(dict, key, (smallt *) io);
+call 0 never executed
+ -: 2903: }
+ #####: 2904: break;
+ -: 2905: case S_STRING:
+ #####: 2906: (*data)++;
+ #####: 2907: s = (char *)(*data);
+ #####: 2908: *data += strlen(s)+1;
+ #####: 2909: so = allocSStringTiny(s);
+call 0 never executed
+ #####: 2910: sDictPushTiny(dict, key, (smallt *) so);
+call 0 never executed
+ #####: 2911: break;
+ -: 2912: case S_ARRAY:
+ #####: 2913: a = NULL;
+ #####: 2914: arrayNetDeserialLevel0(&a, data);
+call 0 never executed
+ #####: 2915: sDictPushTiny(dict, key, (smallt *) a);
+call 0 never executed
+ #####: 2916: break;
+ -: 2917: case S_BYTES:
+ #####: 2918: B = allocSBytes();
+call 0 never executed
+ #####: 2919: count = netTypeVarintToUint((u8**)data);
+call 0 never executed
+ #####: 2920: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 2921: *data += count;
+ #####: 2922: sDictPushTiny(dict, key, (smallt *) B);
+call 0 never executed
+ #####: 2923: break;
+ -: 2924: }
+ -: 2925: }
+ -: 2926:}
+ -: 2927:
+ -: 2928:/**
+ -: 2929: * deserialize array from data
+ -: 2930: *
+ -: 2931: * a new array is allocated
+ -: 2932: *
+ -: 2933: * \param
+ -: 2934: * array holding the elements
+ -: 2935: * data serialized dictionary
+ -: 2936: */
function arrayNetDeserialLevel0 called 0 returned 0% blocks executed 0%
- #####: 2875:internal void arrayNetDeserialLevel0(sArrayt **array, char **data) {
- #####: 2876: sUndefinedt *u = NULL;
- #####: 2877: sBoolt *bo = NULL;
- #####: 2878: double *D = NULL;
- #####: 2879: sDoublet *Do = NULL;
- #####: 2880: sDictt *d = NULL;
- #####: 2881: sIntt *io = NULL;
- #####: 2882: char *s = NULL;
- #####: 2883: sStringt *so = NULL;
- #####: 2884: sArrayt *a = NULL;
- #####: 2885: sBytest *B = NULL;
- -: 2886: uint32_t count;
- -: 2887: uint32_t arrayCount;
- -: 2888:
- #####: 2889: arrayCount = netTypeVarintToUint((u8**)data);
+ #####: 2937:internal void arrayNetDeserialLevel0(sArrayt **array, char **data) {
+ #####: 2938: sUndefinedt *u = NULL;
+ #####: 2939: sBoolt *bo = NULL;
+ #####: 2940: double *D = NULL;
+ #####: 2941: sDoublet *Do = NULL;
+ #####: 2942: sDictt *d = NULL;
+ #####: 2943: sIntt *io = NULL;
+ #####: 2944: char *s = NULL;
+ #####: 2945: sStringt *so = NULL;
+ #####: 2946: sArrayt *a = NULL;
+ #####: 2947: sBytest *B = NULL;
+ -: 2948: uint32_t count;
+ -: 2949: uint32_t arrayCount;
+ -: 2950:
+ #####: 2951: arrayCount = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 2890:
- #####: 2891: if (!arrayCount) {
+ -: 2952:
+ #####: 2953: if (!arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 2892: *array = allocSArray();;
+ #####: 2954: *array = allocSArray();;
call 0 never executed
- #####: 2893: ret;
- -: 2894: }
- -: 2895:
- #####: 2896: loop(arrayCount) {
+ #####: 2955: ret;
+ -: 2956: }
+ -: 2957:
+ #####: 2958: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- -: 2897: char type;
- #####: 2898: type = **data;
- -: 2899:
- #####: 2900: switch(type & 0xF) {
+ -: 2959: char type;
+ #####: 2960: type = **data;
+ -: 2961:
+ #####: 2962: switch(type & 0xF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4305,117 +4367,121 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 2901: case S_UNDEFINED:
- #####: 2902: (*data)++;
- #####: 2903: u = allocSUndefined();
+ -: 2963: case S_UNDEFINED:
+ #####: 2964: (*data)++;
+ #####: 2965: u = allocSUndefined();
call 0 never executed
- #####: 2904: sArrayPushTiny(array, (smallt *) u);
+ #####: 2966: sArrayPushTiny(array, (smallt *) u);
call 0 never executed
- #####: 2905: break;
- -: 2906: case S_BOOL:
- #####: 2907: (*data)++;
- #####: 2908: bo = allocSBool(type & 0x10);
+ #####: 2967: break;
+ -: 2968: case S_BOOL:
+ #####: 2969: (*data)++;
+ #####: 2970: bo = allocSBool(type & 0x10);
call 0 never executed
- #####: 2909: sArrayPushTiny(array, (smallt *) bo);
+ #####: 2971: sArrayPushTiny(array, (smallt *) bo);
call 0 never executed
- #####: 2910: break;
- -: 2911: case S_DICT:
- #####: 2912: d = NULL;
- #####: 2913: dictNetDeserialLevel0(&d, data);
+ #####: 2972: break;
+ -: 2973: case S_DICT:
+ #####: 2974: d = NULL;
+ #####: 2975: dictNetDeserialLevel0(&d, data);
call 0 never executed
- #####: 2914: sArrayPushTiny(array, (smallt *) d);
+ #####: 2976: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- #####: 2915: break;
- -: 2916: case S_DOUBLE:
- #####: 2917: (*data)++;
- #####: 2918: D = (double *)(*data);
- #####: 2919: *data += sizeof(double);
- #####: 2920: Do = allocSDouble(*D);
+ #####: 2977: break;
+ -: 2978: case S_DOUBLE:
+ #####: 2979: (*data)++;
+ #####: 2980: D = (double *)(*data);
+ #####: 2981: *data += sizeof(double);
+ #####: 2982: Do = allocSDouble(*D);
call 0 never executed
- #####: 2921: sArrayPushTiny(array, (smallt *) Do);
+ #####: 2983: sArrayPushTiny(array, (smallt *) Do);
call 0 never executed
- #####: 2922: break;
- -: 2923: case S_INT: {
- #####: 2924: i64 v = netTypeVarintToUint((u8**)data);
+ #####: 2984: break;
+ -: 2985: case S_INT: {
+ #####: 2986: i64 v = netTypeVarintToUint((u8**)data);
call 0 never executed
- #####: 2925: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 2926: io = allocSInt(v);
+ #####: 2987: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 2988: io = allocSInt(v);
call 0 never executed
- #####: 2927: sArrayPushTiny(array, (smallt *) io);
+ #####: 2989: sArrayPushTiny(array, (smallt *) io);
call 0 never executed
- -: 2928: }
- #####: 2929: break;
- -: 2930: case S_STRING:
- #####: 2931: (*data)++;
- #####: 2932: s = (char *)(*data);
- #####: 2933: *data += strlen(s)+1;
- #####: 2934: so = allocSStringTiny(s);
+ -: 2990: }
+ #####: 2991: break;
+ -: 2992: case S_STRING:
+ #####: 2993: (*data)++;
+ #####: 2994: s = (char *)(*data);
+ #####: 2995: *data += strlen(s)+1;
+ #####: 2996: so = allocSStringTiny(s);
call 0 never executed
- #####: 2935: sArrayPushTiny(array, (smallt *) so);
+ #####: 2997: sArrayPushTiny(array, (smallt *) so);
call 0 never executed
- #####: 2936: break;
- -: 2937: case S_ARRAY:
- #####: 2938: a = NULL;
- #####: 2939: arrayNetDeserialLevel0(&a, data);
+ #####: 2998: break;
+ -: 2999: case S_ARRAY:
+ #####: 3000: a = NULL;
+ #####: 3001: arrayNetDeserialLevel0(&a, data);
call 0 never executed
- #####: 2940: sArrayPushTiny(array, (smallt *) a);
+ #####: 3002: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- #####: 2941: break;
- -: 2942: case S_BYTES:
- #####: 2943: B = allocSBytes();
+ #####: 3003: break;
+ -: 3004: case S_BYTES:
+ #####: 3005: B = allocSBytes();
call 0 never executed
- #####: 2944: count = netTypeVarintToUint((u8**)data);
+ #####: 3006: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- #####: 2945: sBytesPushBuffer(&B, data, count);
+ #####: 3007: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 2946: *data += count;
- #####: 2947: sArrayPushTiny(array, (smallt *) B);
+ #####: 3008: *data += count;
+ #####: 3009: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- #####: 2948: break;
- -: 2949: }
- -: 2950: }
- -: 2951:}
- -: 2952:
+ #####: 3010: break;
+ -: 3011: }
+ -: 3012: }
+ -: 3013:}
+ -: 3014:
function deserialNetSerialLevel0 called 0 returned 0% blocks executed 0%
- #####: 2953:internal smallJsont* deserialNetSerialLevel0(smallJsont *self, smallBytest *data) {
- -: 2954:
- #####: 2955: if (!data) {
+ #####: 3015:internal smallJsont* deserialNetSerialLevel0(smallJsont *self, smallBytest *data) {
+ -: 3016:
+ #####: 3017: if (!data) {
branch 0 never executed
branch 1 never executed
- #####: 2956: ret self;
- -: 2957: }
- -: 2958:
- #####: 2959: smallt *o = netDeserialLevel0(data->B);
+ #####: 3018: ret self;
+ -: 3019: }
+ -: 3020:
+ #####: 3021: smallt *o = netDeserialLevel0(data->B);
call 0 never executed
- -: 2960:
- #####: 2961: if (!o) {
+ -: 3022:
+ #####: 3023: if (!o) {
branch 0 never executed
branch 1 never executed
- #####: 2962: ret self;
- -: 2963: }
- -: 2964:
- #####: 2965: freeG(self);
-call 0 never executed
- -: 2966:
- #####: 2967: setsoG(self, o);
-call 0 never executed
- -: 2968:
- #####: 2969: ret self;
- -: 2970:}
- -: 2971:
- -: 2972:// level 1
- -: 2973:
+ #####: 3024: ret self;
+ -: 3025: }
+ -: 3026:
+ #####: 3027: freeG(self);
+call 0 never executed
+ -: 3028:
+ #####: 3029: setsoG(self, o);
+call 0 never executed
+ -: 3030:
+ #####: 3031: ret self;
+ -: 3032:}
+ -: 3033:
+ -: 3034:// level 1
+ -: 3035:// like level 0 with type encoded in nibbles and bools are packed
+ -: 3036:
+ -: 3037:/**
+ -: 3038: * deserializer top function
+ -: 3039: */
function netDeserialLevel1 called 0 returned 0% blocks executed 0%
- #####: 2974:internal smallt* netDeserialLevel1(sBytest *obj) {
- #####: 2975: smallt *r = NULL;
- #####: 2976: double *D = NULL;
- #####: 2977: char *s = NULL;
- #####: 2978: sBytest *B = NULL;
- -: 2979: uint32_t count;
- #####: 2980: char *data = NULL;
- #####: 2981: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
- -: 2982:
- #####: 2983: switch(obj->data & 0xF) {
+ #####: 3040:internal smallt* netDeserialLevel1(sBytest *obj) {
+ #####: 3041: smallt *r = NULL;
+ #####: 3042: double *D = NULL;
+ #####: 3043: char *s = NULL;
+ #####: 3044: sBytest *B = NULL;
+ -: 3045: uint32_t count;
+ #####: 3046: char *data = NULL;
+ #####: 3047: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
+ -: 3048:
+ #####: 3049: switch(obj->data & 0xF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4425,130 +4491,130 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 2984: case S_UNDEFINED:
- #####: 2985: r = (smallt *) allocSUndefined();
-call 0 never executed
- #####: 2986: break;
- -: 2987: case S_BOOL:
- #####: 2988: r = (smallt *) allocSBool(obj->data & 0x10);
-call 0 never executed
- #####: 2989: break;
- -: 2990: case S_DICT:
- #####: 2991: data = (char *)&(obj->data);
- -: 2992: //debug - ctx.dbuf = (u8*) data;
- #####: 2993: dictNetDeserialLevel1((sDictt **)&r, (u8**)&data, &ctx);
-call 0 never executed
- #####: 2994: break;
- -: 2995: case S_DOUBLE:
- #####: 2996: data = &(obj->data)+1;
- #####: 2997: D = (double *)data;
- #####: 2998: r = (smallt *) allocSDouble(*D);
-call 0 never executed
- #####: 2999: break;
- -: 3000: case S_INT:
- #####: 3001: data = &(obj->data);
- #####: 3002: i64 v = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 3003: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3004: r = (smallt *) allocSInt(v);
-call 0 never executed
- #####: 3005: break;
- -: 3006: case S_STRING:
- #####: 3007: s = (char *)&(obj->data)+1;
- #####: 3008: r = (smallt *) allocSStringTiny(s);
-call 0 never executed
- #####: 3009: break;
- -: 3010: case S_ARRAY:
- #####: 3011: data = (char *)&(obj->data);
- -: 3012: //debug - ctx.dbuf = (u8*) data;
- #####: 3013: arrayNetDeserialLevel1((sArrayt **)&r, (u8**)&data, &ctx);
-call 0 never executed
- #####: 3014: break;
- -: 3015: case S_BYTES:
- #####: 3016: B = allocSBytes();
-call 0 never executed
- #####: 3017: data = &(obj->data);
- #####: 3018: count = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 3019: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 3020: r = (smallt *)B;
- #####: 3021: break;
- -: 3022: }
- -: 3023:
- #####: 3024: ret r;
- -: 3025:}
- -: 3026:
- -: 3027:/**
- -: 3028: * deserialize dictionary from data
- -: 3029: *
- -: 3030: * a new dictionary is allocated
- -: 3031: *
- -: 3032: * \param
- -: 3033: * dict dictionary holding the elements
- -: 3034: * data serialized dictionary
- -: 3035: */
+ -: 3050: case S_UNDEFINED:
+ #####: 3051: r = (smallt *) allocSUndefined();
+call 0 never executed
+ #####: 3052: break;
+ -: 3053: case S_BOOL:
+ #####: 3054: r = (smallt *) allocSBool(obj->data & 0x10);
+call 0 never executed
+ #####: 3055: break;
+ -: 3056: case S_DICT:
+ #####: 3057: data = (char *)&(obj->data);
+ -: 3058: //debug - ctx.dbuf = (u8*) data;
+ #####: 3059: dictNetDeserialLevel1((sDictt **)&r, (u8**)&data, &ctx);
+call 0 never executed
+ #####: 3060: break;
+ -: 3061: case S_DOUBLE:
+ #####: 3062: data = &(obj->data)+1;
+ #####: 3063: D = (double *)data;
+ #####: 3064: r = (smallt *) allocSDouble(*D);
+call 0 never executed
+ #####: 3065: break;
+ -: 3066: case S_INT:
+ #####: 3067: data = &(obj->data);
+ #####: 3068: i64 v = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 3069: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3070: r = (smallt *) allocSInt(v);
+call 0 never executed
+ #####: 3071: break;
+ -: 3072: case S_STRING:
+ #####: 3073: s = (char *)&(obj->data)+1;
+ #####: 3074: r = (smallt *) allocSStringTiny(s);
+call 0 never executed
+ #####: 3075: break;
+ -: 3076: case S_ARRAY:
+ #####: 3077: data = (char *)&(obj->data);
+ -: 3078: //debug - ctx.dbuf = (u8*) data;
+ #####: 3079: arrayNetDeserialLevel1((sArrayt **)&r, (u8**)&data, &ctx);
+call 0 never executed
+ #####: 3080: break;
+ -: 3081: case S_BYTES:
+ #####: 3082: B = allocSBytes();
+call 0 never executed
+ #####: 3083: data = &(obj->data);
+ #####: 3084: count = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 3085: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 3086: r = (smallt *)B;
+ #####: 3087: break;
+ -: 3088: }
+ -: 3089:
+ #####: 3090: ret r;
+ -: 3091:}
+ -: 3092:
+ -: 3093:/**
+ -: 3094: * deserialize dictionary from data
+ -: 3095: *
+ -: 3096: * a new dictionary is allocated
+ -: 3097: *
+ -: 3098: * \param
+ -: 3099: * dict dictionary holding the elements
+ -: 3100: * data serialized dictionary
+ -: 3101: */
function dictNetDeserialLevel1 called 0 returned 0% blocks executed 0%
- #####: 3036:internal void dictNetDeserialLevel1(sDictt **dict, u8 **data, contextt *ctx) {
- #####: 3037: sUndefinedt *u = NULL;
- #####: 3038: sBoolt *bo = NULL;
- #####: 3039: double *D = NULL;
- #####: 3040: sDoublet *Do = NULL;
- #####: 3041: sDictt *d = NULL;
- #####: 3042: sIntt *io = NULL;
- #####: 3043: char *s = NULL;
- #####: 3044: sStringt *so = NULL;
- #####: 3045: sArrayt *a = NULL;
- #####: 3046: sBytest *B = NULL;
- -: 3047: uint32_t count;
- -: 3048: uint32_t dictCount;
- -: 3049:
- #####: 3050: if (ctx->nibble == lowNbl) {
+ #####: 3102:internal void dictNetDeserialLevel1(sDictt **dict, u8 **data, contextt *ctx) {
+ #####: 3103: sUndefinedt *u = NULL;
+ #####: 3104: sBoolt *bo = NULL;
+ #####: 3105: double *D = NULL;
+ #####: 3106: sDoublet *Do = NULL;
+ #####: 3107: sDictt *d = NULL;
+ #####: 3108: sIntt *io = NULL;
+ #####: 3109: char *s = NULL;
+ #####: 3110: sStringt *so = NULL;
+ #####: 3111: sArrayt *a = NULL;
+ #####: 3112: sBytest *B = NULL;
+ -: 3113: uint32_t count;
+ -: 3114: uint32_t dictCount;
+ -: 3115:
+ #####: 3116: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3051: dictCount = netTypeVarintToUint(data);
+ #####: 3117: dictCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3052: }
- -: 3053: else {
- -: 3054: // high nibble
- -: 3055: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
- -: 3056: #define readTypeInHighNbl\
- -: 3057: ctx->nibble = lowNbl;\
- -: 3058: if (ctx->nblAddr == *data)\
- -: 3059: /* data points to the type, next byte is count */\
- -: 3060: (*data)++
- #####: 3061: readTypeInHighNbl;
+ -: 3118: }
+ -: 3119: else {
+ -: 3120: // high nibble
+ -: 3121: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
+ -: 3122: #define readTypeInHighNbl\
+ -: 3123: ctx->nibble = lowNbl;\
+ -: 3124: if (ctx->nblAddr == *data)\
+ -: 3125: /* data points to the type, next byte is count */\
+ -: 3126: (*data)++
+ #####: 3127: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3062: dictCount = varintToUint(data);
+ #####: 3128: dictCount = varintToUint(data);
call 0 never executed
- -: 3063: }
- -: 3064:
- #####: 3065: if (!dictCount) {
+ -: 3129: }
+ -: 3130:
+ #####: 3131: if (!dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3066: *dict = allocSDict();
+ #####: 3132: *dict = allocSDict();
call 0 never executed
- #####: 3067: ret;
- -: 3068: }
- -: 3069:
- #####: 3070: loop(dictCount) {
+ #####: 3133: ret;
+ -: 3134: }
+ -: 3135:
+ #####: 3136: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3071: char *key = (char*)*data;
- #####: 3072: *data += strlen(key)+1;
- -: 3073: char type;
- #####: 3074: if (ctx->nibble == lowNbl) {
+ #####: 3137: char *key = (char*)*data;
+ #####: 3138: *data += strlen(key)+1;
+ -: 3139: char type;
+ #####: 3140: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3075: type = (**data) & 0xF;
- -: 3076: }
- -: 3077: else {
- -: 3078: // high nibble
- #####: 3079: type = (*ctx->nblAddr) >> 4;
- -: 3080: }
- -: 3081:
- #####: 3082: switch(type) {
+ #####: 3141: type = (**data) & 0xF;
+ -: 3142: }
+ -: 3143: else {
+ -: 3144: // high nibble
+ #####: 3145: type = (*ctx->nblAddr) >> 4;
+ -: 3146: }
+ -: 3147:
+ #####: 3148: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4558,261 +4624,261 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 3083: case S_UNDEFINED:
- #####: 3084: if (ctx->nibble == lowNbl) {
+ -: 3149: case S_UNDEFINED:
+ #####: 3150: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 3085: #define readTypeOnly\
- -: 3086: ctx->nibble = highNbl;\
- -: 3087: ctx->nblAddr = *data;\
- -: 3088: (*data)++
- #####: 3089: readTypeOnly;
- -: 3090: }
- -: 3091: else {
- -: 3092: // high nibble
- #####: 3093: readTypeInHighNbl;
+ -: 3151: #define readTypeOnly\
+ -: 3152: ctx->nibble = highNbl;\
+ -: 3153: ctx->nblAddr = *data;\
+ -: 3154: (*data)++
+ #####: 3155: readTypeOnly;
+ -: 3156: }
+ -: 3157: else {
+ -: 3158: // high nibble
+ #####: 3159: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3094: }
- #####: 3095: u = allocSUndefined();
+ -: 3160: }
+ #####: 3161: u = allocSUndefined();
call 0 never executed
- #####: 3096: sDictPushTiny(dict, key, (smallt *) u);
+ #####: 3162: sDictPushTiny(dict, key, (smallt *) u);
call 0 never executed
- #####: 3097: break;
- -: 3098: case S_BOOL:
- #####: 3099: if (!ctx->boolAddr) {
+ #####: 3163: break;
+ -: 3164: case S_BOOL:
+ #####: 3165: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- -: 3100: // new packed bools
- #####: 3101: if (ctx->nibble == lowNbl) {
+ -: 3166: // new packed bools
+ #####: 3167: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 3102: #define read4bPackedBool\
- -: 3103: ctx->boolShift = 5;\
- -: 3104: ctx->boolAddr = *data;\
- -: 3105: (*data)++
- #####: 3106: read4bPackedBool;
- #####: 3107: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ -: 3168: #define read4bPackedBool\
+ -: 3169: ctx->boolShift = 5;\
+ -: 3170: ctx->boolAddr = *data;\
+ -: 3171: (*data)++
+ #####: 3172: read4bPackedBool;
+ #####: 3173: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3108: }
- -: 3109: else {
- -: 3110: // high nibble
- #####: 3111: readTypeInHighNbl;
+ -: 3174: }
+ -: 3175: else {
+ -: 3176: // high nibble
+ #####: 3177: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3112: #define read8bPackedBool\
- -: 3113: ctx->boolShift = 1;\
- -: 3114: ctx->boolAddr = *data;\
- -: 3115: (*data)++
- #####: 3116: read8bPackedBool;
- #####: 3117: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ -: 3178: #define read8bPackedBool\
+ -: 3179: ctx->boolShift = 1;\
+ -: 3180: ctx->boolAddr = *data;\
+ -: 3181: (*data)++
+ #####: 3182: read8bPackedBool;
+ #####: 3183: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3118: }
- -: 3119: }
- -: 3120: else {
- -: 3121: // there was a bool before this one, read bits in nibbles
- #####: 3122: if (ctx->nibble == lowNbl) {
+ -: 3184: }
+ -: 3185: }
+ -: 3186: else {
+ -: 3187: // there was a bool before this one, read bits in nibbles
+ #####: 3188: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3123: if (ctx->boolShift == 8) {
+ #####: 3189: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3124: read4bPackedBool;
- #####: 3125: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3190: read4bPackedBool;
+ #####: 3191: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3126: }
- -: 3127: else {
- #####: 3128: readTypeOnly;
- #####: 3129: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3192: }
+ -: 3193: else {
+ #####: 3194: readTypeOnly;
+ #####: 3195: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3130: }
- -: 3131: }
- -: 3132: else {
- -: 3133: // high nibble
- #####: 3134: readTypeInHighNbl;
+ -: 3196: }
+ -: 3197: }
+ -: 3198: else {
+ -: 3199: // high nibble
+ #####: 3200: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3135: if (ctx->boolShift == 8) {
+ #####: 3201: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3136: read8bPackedBool;
- #####: 3137: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3202: read8bPackedBool;
+ #####: 3203: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3138: }
- -: 3139: else {
- -: 3140: // high nibble
- #####: 3141: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3204: }
+ -: 3205: else {
+ -: 3206: // high nibble
+ #####: 3207: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3142: }
- -: 3143: }
- -: 3144: }
- #####: 3145: sDictPushTiny(dict, key, (smallt *) bo);
+ -: 3208: }
+ -: 3209: }
+ -: 3210: }
+ #####: 3211: sDictPushTiny(dict, key, (smallt *) bo);
call 0 never executed
- #####: 3146: break;
- -: 3147: case S_DICT:
- #####: 3148: d = NULL;
- #####: 3149: dictNetDeserialLevel1(&d, data, ctx);
+ #####: 3212: break;
+ -: 3213: case S_DICT:
+ #####: 3214: d = NULL;
+ #####: 3215: dictNetDeserialLevel1(&d, data, ctx);
call 0 never executed
- #####: 3150: sDictPushTiny(dict, key, (smallt *) d);
+ #####: 3216: sDictPushTiny(dict, key, (smallt *) d);
call 0 never executed
- #####: 3151: break;
- -: 3152: case S_DOUBLE:
- #####: 3153: if (ctx->nibble == lowNbl) {
+ #####: 3217: break;
+ -: 3218: case S_DOUBLE:
+ #####: 3219: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3154: readTypeOnly;
- -: 3155: }
- -: 3156: else {
- -: 3157: // high nibble
- #####: 3158: readTypeInHighNbl;
+ #####: 3220: readTypeOnly;
+ -: 3221: }
+ -: 3222: else {
+ -: 3223: // high nibble
+ #####: 3224: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3159: }
- #####: 3160: D = (double *)(*data);
- #####: 3161: *data += sizeof(double);
- #####: 3162: Do = allocSDouble(*D);
+ -: 3225: }
+ #####: 3226: D = (double *)(*data);
+ #####: 3227: *data += sizeof(double);
+ #####: 3228: Do = allocSDouble(*D);
call 0 never executed
- #####: 3163: sDictPushTiny(dict, key, (smallt *) Do);
+ #####: 3229: sDictPushTiny(dict, key, (smallt *) Do);
call 0 never executed
- #####: 3164: break;
- -: 3165: case S_INT: {
- -: 3166: i64 v;
- #####: 3167: if (ctx->nibble == lowNbl) {
+ #####: 3230: break;
+ -: 3231: case S_INT: {
+ -: 3232: i64 v;
+ #####: 3233: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3168: v = netTypeVarintToUint((u8**)data);
+ #####: 3234: v = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3169: }
- -: 3170: else {
- -: 3171: // high nibble
- #####: 3172: readTypeInHighNbl;
+ -: 3235: }
+ -: 3236: else {
+ -: 3237: // high nibble
+ #####: 3238: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3173: v = varintToUint(data);
+ #####: 3239: v = varintToUint(data);
call 0 never executed
- -: 3174: }
- #####: 3175: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3176: io = allocSInt(v);
+ -: 3240: }
+ #####: 3241: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3242: io = allocSInt(v);
call 0 never executed
- #####: 3177: sDictPushTiny(dict, key, (smallt *) io);
+ #####: 3243: sDictPushTiny(dict, key, (smallt *) io);
call 0 never executed
- -: 3178: }
- #####: 3179: break;
- -: 3180: case S_STRING:
- #####: 3181: if (ctx->nibble == lowNbl) {
+ -: 3244: }
+ #####: 3245: break;
+ -: 3246: case S_STRING:
+ #####: 3247: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3182: readTypeOnly;
- -: 3183: }
- -: 3184: else {
- -: 3185: // high nibble
- #####: 3186: readTypeInHighNbl;
+ #####: 3248: readTypeOnly;
+ -: 3249: }
+ -: 3250: else {
+ -: 3251: // high nibble
+ #####: 3252: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3187: }
- #####: 3188: s = (char *)(*data);
- #####: 3189: *data += strlen(s)+1;
- #####: 3190: so = allocSStringTiny(s);
+ -: 3253: }
+ #####: 3254: s = (char *)(*data);
+ #####: 3255: *data += strlen(s)+1;
+ #####: 3256: so = allocSStringTiny(s);
call 0 never executed
- #####: 3191: sDictPushTiny(dict, key, (smallt *) so);
+ #####: 3257: sDictPushTiny(dict, key, (smallt *) so);
call 0 never executed
- #####: 3192: break;
- -: 3193: case S_ARRAY:
- #####: 3194: a = NULL;
- #####: 3195: arrayNetDeserialLevel1(&a, data, ctx);
+ #####: 3258: break;
+ -: 3259: case S_ARRAY:
+ #####: 3260: a = NULL;
+ #####: 3261: arrayNetDeserialLevel1(&a, data, ctx);
call 0 never executed
- #####: 3196: sDictPushTiny(dict, key, (smallt *) a);
+ #####: 3262: sDictPushTiny(dict, key, (smallt *) a);
call 0 never executed
- #####: 3197: break;
- -: 3198: case S_BYTES:
- #####: 3199: B = allocSBytes();
+ #####: 3263: break;
+ -: 3264: case S_BYTES:
+ #####: 3265: B = allocSBytes();
call 0 never executed
- #####: 3200: if (ctx->nibble == lowNbl) {
+ #####: 3266: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3201: count = netTypeVarintToUint((u8**)data);
+ #####: 3267: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3202: }
- -: 3203: else {
- -: 3204: // high nibble
- #####: 3205: readTypeInHighNbl;
+ -: 3268: }
+ -: 3269: else {
+ -: 3270: // high nibble
+ #####: 3271: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3206: count = varintToUint((u8**)data);
+ #####: 3272: count = varintToUint((u8**)data);
call 0 never executed
- -: 3207: }
- #####: 3208: sBytesPushBuffer(&B, data, count);
+ -: 3273: }
+ #####: 3274: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 3209: *data += count;
- #####: 3210: sDictPushTiny(dict, key, (smallt *) B);
+ #####: 3275: *data += count;
+ #####: 3276: sDictPushTiny(dict, key, (smallt *) B);
call 0 never executed
- #####: 3211: break;
- -: 3212: }
- -: 3213: }
- -: 3214:}
- -: 3215:
- -: 3216:/**
- -: 3217: * deserialize array from data
- -: 3218: *
- -: 3219: * a new array is allocated
- -: 3220: *
- -: 3221: * \param
- -: 3222: * array holding the elements
- -: 3223: * data serialized dictionary
- -: 3224: */
+ #####: 3277: break;
+ -: 3278: }
+ -: 3279: }
+ -: 3280:}
+ -: 3281:
+ -: 3282:/**
+ -: 3283: * deserialize array from data
+ -: 3284: *
+ -: 3285: * a new array is allocated
+ -: 3286: *
+ -: 3287: * \param
+ -: 3288: * array holding the elements
+ -: 3289: * data serialized dictionary
+ -: 3290: */
function arrayNetDeserialLevel1 called 0 returned 0% blocks executed 0%
- #####: 3225:internal void arrayNetDeserialLevel1(sArrayt **array, u8 **data, contextt *ctx) {
- #####: 3226: sUndefinedt *u = NULL;
- #####: 3227: sBoolt *bo = NULL;
- #####: 3228: double *D = NULL;
- #####: 3229: sDoublet *Do = NULL;
- #####: 3230: sDictt *d = NULL;
- #####: 3231: sIntt *io = NULL;
- #####: 3232: char *s = NULL;
- #####: 3233: sStringt *so = NULL;
- #####: 3234: sArrayt *a = NULL;
- #####: 3235: sBytest *B = NULL;
- -: 3236: uint32_t count;
- -: 3237: uint32_t arrayCount;
- -: 3238:
- #####: 3239: if (ctx->nibble == lowNbl) {
+ #####: 3291:internal void arrayNetDeserialLevel1(sArrayt **array, u8 **data, contextt *ctx) {
+ #####: 3292: sUndefinedt *u = NULL;
+ #####: 3293: sBoolt *bo = NULL;
+ #####: 3294: double *D = NULL;
+ #####: 3295: sDoublet *Do = NULL;
+ #####: 3296: sDictt *d = NULL;
+ #####: 3297: sIntt *io = NULL;
+ #####: 3298: char *s = NULL;
+ #####: 3299: sStringt *so = NULL;
+ #####: 3300: sArrayt *a = NULL;
+ #####: 3301: sBytest *B = NULL;
+ -: 3302: uint32_t count;
+ -: 3303: uint32_t arrayCount;
+ -: 3304:
+ #####: 3305: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3240: arrayCount = netTypeVarintToUint(data);
+ #####: 3306: arrayCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3241: }
- -: 3242: else {
- -: 3243: // high nibble
- #####: 3244: readTypeInHighNbl;
+ -: 3307: }
+ -: 3308: else {
+ -: 3309: // high nibble
+ #####: 3310: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3245: arrayCount = varintToUint(data);
+ #####: 3311: arrayCount = varintToUint(data);
call 0 never executed
- -: 3246: }
- -: 3247:
- #####: 3248: if (!arrayCount) {
+ -: 3312: }
+ -: 3313:
+ #####: 3314: if (!arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 3249: *array = allocSArray();;
+ #####: 3315: *array = allocSArray();;
call 0 never executed
- #####: 3250: ret;
- -: 3251: }
- -: 3252:
- #####: 3253: loop(arrayCount) {
+ #####: 3316: ret;
+ -: 3317: }
+ -: 3318:
+ #####: 3319: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- -: 3254: char type;
- #####: 3255: if (ctx->nibble == lowNbl) {
+ -: 3320: char type;
+ #####: 3321: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3256: type = (**data) & 0xF;
- -: 3257: }
- -: 3258: else {
- -: 3259: // high nibble
- #####: 3260: type = (*ctx->nblAddr) >> 4;
- -: 3261: }
- -: 3262:
- #####: 3263: switch(type) {
+ #####: 3322: type = (**data) & 0xF;
+ -: 3323: }
+ -: 3324: else {
+ -: 3325: // high nibble
+ #####: 3326: type = (*ctx->nblAddr) >> 4;
+ -: 3327: }
+ -: 3328:
+ #####: 3329: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -4822,226 +4888,230 @@ branch 5 never executed
branch 6 never executed
branch 7 never executed
branch 8 never executed
- -: 3264: case S_UNDEFINED:
- #####: 3265: if (ctx->nibble == lowNbl) {
+ -: 3330: case S_UNDEFINED:
+ #####: 3331: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3266: readTypeOnly;
- -: 3267: }
- -: 3268: else {
- -: 3269: // high nibble
- #####: 3270: readTypeInHighNbl;
+ #####: 3332: readTypeOnly;
+ -: 3333: }
+ -: 3334: else {
+ -: 3335: // high nibble
+ #####: 3336: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3271: }
- #####: 3272: u = allocSUndefined();
+ -: 3337: }
+ #####: 3338: u = allocSUndefined();
call 0 never executed
- #####: 3273: sArrayPushTiny(array, (smallt *) u);
+ #####: 3339: sArrayPushTiny(array, (smallt *) u);
call 0 never executed
- #####: 3274: break;
- -: 3275: case S_BOOL:
- #####: 3276: if (!ctx->boolAddr) {
+ #####: 3340: break;
+ -: 3341: case S_BOOL:
+ #####: 3342: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- -: 3277: // new packed bools
- #####: 3278: if (ctx->nibble == lowNbl) {
+ -: 3343: // new packed bools
+ #####: 3344: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3279: read4bPackedBool;
- #####: 3280: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3345: read4bPackedBool;
+ #####: 3346: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3281: }
- -: 3282: else {
- -: 3283: // high nibble
- #####: 3284: readTypeInHighNbl;
+ -: 3347: }
+ -: 3348: else {
+ -: 3349: // high nibble
+ #####: 3350: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3285: read8bPackedBool;
- #####: 3286: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3351: read8bPackedBool;
+ #####: 3352: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3287: }
- -: 3288: }
- -: 3289: else {
- -: 3290: // there was a bool before this one, read bits in nibbles
- #####: 3291: if (ctx->nibble == lowNbl) {
+ -: 3353: }
+ -: 3354: }
+ -: 3355: else {
+ -: 3356: // there was a bool before this one, read bits in nibbles
+ #####: 3357: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3292: if (ctx->boolShift == 8) {
+ #####: 3358: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3293: read4bPackedBool;
- #####: 3294: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3359: read4bPackedBool;
+ #####: 3360: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3295: }
- -: 3296: else {
- #####: 3297: readTypeOnly;
- #####: 3298: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3361: }
+ -: 3362: else {
+ #####: 3363: readTypeOnly;
+ #####: 3364: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3299: }
- -: 3300: }
- -: 3301: else {
- -: 3302: // high nibble
- #####: 3303: readTypeInHighNbl;
+ -: 3365: }
+ -: 3366: }
+ -: 3367: else {
+ -: 3368: // high nibble
+ #####: 3369: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3304: if (ctx->boolShift == 8) {
+ #####: 3370: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3305: read8bPackedBool;
- #####: 3306: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3371: read8bPackedBool;
+ #####: 3372: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3307: }
- -: 3308: else {
- #####: 3309: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3373: }
+ -: 3374: else {
+ #####: 3375: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3310: }
- -: 3311: }
- -: 3312: }
- #####: 3313: sArrayPushTiny(array, (smallt *) bo);
+ -: 3376: }
+ -: 3377: }
+ -: 3378: }
+ #####: 3379: sArrayPushTiny(array, (smallt *) bo);
call 0 never executed
- #####: 3314: break;
- -: 3315: case S_DICT:
- #####: 3316: d = NULL;
- #####: 3317: dictNetDeserialLevel1(&d, data, ctx);
+ #####: 3380: break;
+ -: 3381: case S_DICT:
+ #####: 3382: d = NULL;
+ #####: 3383: dictNetDeserialLevel1(&d, data, ctx);
call 0 never executed
- #####: 3318: sArrayPushTiny(array, (smallt *) d);
+ #####: 3384: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- #####: 3319: break;
- -: 3320: case S_DOUBLE:
- #####: 3321: if (ctx->nibble == lowNbl) {
+ #####: 3385: break;
+ -: 3386: case S_DOUBLE:
+ #####: 3387: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3322: readTypeOnly;
- -: 3323: }
- -: 3324: else {
- -: 3325: // high nibble
- #####: 3326: readTypeInHighNbl;
+ #####: 3388: readTypeOnly;
+ -: 3389: }
+ -: 3390: else {
+ -: 3391: // high nibble
+ #####: 3392: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3327: }
- #####: 3328: D = (double *)(*data);
- #####: 3329: *data += sizeof(double);
- #####: 3330: Do = allocSDouble(*D);
+ -: 3393: }
+ #####: 3394: D = (double *)(*data);
+ #####: 3395: *data += sizeof(double);
+ #####: 3396: Do = allocSDouble(*D);
call 0 never executed
- #####: 3331: sArrayPushTiny(array, (smallt *) Do);
+ #####: 3397: sArrayPushTiny(array, (smallt *) Do);
call 0 never executed
- #####: 3332: break;
- -: 3333: case S_INT: {
- -: 3334: i64 v;
- #####: 3335: if (ctx->nibble == lowNbl) {
+ #####: 3398: break;
+ -: 3399: case S_INT: {
+ -: 3400: i64 v;
+ #####: 3401: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3336: v = netTypeVarintToUint((u8**)data);
+ #####: 3402: v = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3337: }
- -: 3338: else {
- -: 3339: // high nibble
- #####: 3340: readTypeInHighNbl;
+ -: 3403: }
+ -: 3404: else {
+ -: 3405: // high nibble
+ #####: 3406: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3341: v = varintToUint(data);
+ #####: 3407: v = varintToUint(data);
call 0 never executed
- -: 3342: }
- #####: 3343: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3344: io = allocSInt(v);
+ -: 3408: }
+ #####: 3409: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3410: io = allocSInt(v);
call 0 never executed
- #####: 3345: sArrayPushTiny(array, (smallt *) io);
+ #####: 3411: sArrayPushTiny(array, (smallt *) io);
call 0 never executed
- -: 3346: }
- #####: 3347: break;
- -: 3348: case S_STRING:
- #####: 3349: if (ctx->nibble == lowNbl) {
+ -: 3412: }
+ #####: 3413: break;
+ -: 3414: case S_STRING:
+ #####: 3415: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3350: readTypeOnly;
- -: 3351: }
- -: 3352: else {
- -: 3353: // high nibble
- #####: 3354: readTypeInHighNbl;
+ #####: 3416: readTypeOnly;
+ -: 3417: }
+ -: 3418: else {
+ -: 3419: // high nibble
+ #####: 3420: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3355: }
- #####: 3356: s = (char *)(*data);
- #####: 3357: *data += strlen(s)+1;
- #####: 3358: so = allocSStringTiny(s);
+ -: 3421: }
+ #####: 3422: s = (char *)(*data);
+ #####: 3423: *data += strlen(s)+1;
+ #####: 3424: so = allocSStringTiny(s);
call 0 never executed
- #####: 3359: sArrayPushTiny(array, (smallt *) so);
+ #####: 3425: sArrayPushTiny(array, (smallt *) so);
call 0 never executed
- #####: 3360: break;
- -: 3361: case S_ARRAY:
- #####: 3362: a = NULL;
- #####: 3363: arrayNetDeserialLevel1(&a, data, ctx);
+ #####: 3426: break;
+ -: 3427: case S_ARRAY:
+ #####: 3428: a = NULL;
+ #####: 3429: arrayNetDeserialLevel1(&a, data, ctx);
call 0 never executed
- #####: 3364: sArrayPushTiny(array, (smallt *) a);
+ #####: 3430: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- #####: 3365: break;
- -: 3366: case S_BYTES:
- #####: 3367: B = allocSBytes();
+ #####: 3431: break;
+ -: 3432: case S_BYTES:
+ #####: 3433: B = allocSBytes();
call 0 never executed
- #####: 3368: if (ctx->nibble == lowNbl) {
+ #####: 3434: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3369: count = netTypeVarintToUint((u8**)data);
+ #####: 3435: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3370: }
- -: 3371: else {
- -: 3372: // high nibble
- #####: 3373: readTypeInHighNbl;
+ -: 3436: }
+ -: 3437: else {
+ -: 3438: // high nibble
+ #####: 3439: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3374: count = varintToUint((u8**)data);
+ #####: 3440: count = varintToUint((u8**)data);
call 0 never executed
- -: 3375: }
- #####: 3376: sBytesPushBuffer(&B, data, count);
+ -: 3441: }
+ #####: 3442: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 3377: *data += count;
- #####: 3378: sArrayPushTiny(array, (smallt *) B);
+ #####: 3443: *data += count;
+ #####: 3444: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- #####: 3379: break;
- -: 3380: }
- -: 3381: }
- -: 3382:}
- -: 3383:
+ #####: 3445: break;
+ -: 3446: }
+ -: 3447: }
+ -: 3448:}
+ -: 3449:
function deserialNetSerialLevel1 called 0 returned 0% blocks executed 0%
- #####: 3384:internal smallJsont* deserialNetSerialLevel1(smallJsont *self, smallBytest *data) {
- -: 3385:
- #####: 3386: if (!data) {
-branch 0 never executed
-branch 1 never executed
- #####: 3387: ret self;
- -: 3388: }
- -: 3389:
- #####: 3390: smallt *o = netDeserialLevel1(data->B);
-call 0 never executed
- -: 3391:
- #####: 3392: if (!o) {
-branch 0 never executed
-branch 1 never executed
- #####: 3393: ret self;
- -: 3394: }
- -: 3395:
- #####: 3396: freeG(self);
-call 0 never executed
- -: 3397:
- #####: 3398: setsoG(self, o);
-call 0 never executed
- -: 3399:
- #####: 3400: ret self;
- -: 3401:}
- -: 3402:
- -: 3403:// level 2
- -: 3404:
+ #####: 3450:internal smallJsont* deserialNetSerialLevel1(smallJsont *self, smallBytest *data) {
+ -: 3451:
+ #####: 3452: if (!data) {
+branch 0 never executed
+branch 1 never executed
+ #####: 3453: ret self;
+ -: 3454: }
+ -: 3455:
+ #####: 3456: smallt *o = netDeserialLevel1(data->B);
+call 0 never executed
+ -: 3457:
+ #####: 3458: if (!o) {
+branch 0 never executed
+branch 1 never executed
+ #####: 3459: ret self;
+ -: 3460: }
+ -: 3461:
+ #####: 3462: freeG(self);
+call 0 never executed
+ -: 3463:
+ #####: 3464: setsoG(self, o);
+call 0 never executed
+ -: 3465:
+ #####: 3466: ret self;
+ -: 3467:}
+ -: 3468:
+ -: 3469:// level 2
+ -: 3470:// like level 1, arrays are set to uniform when all elements are same type
+ -: 3471:
+ -: 3472:/**
+ -: 3473: * deserializer top function
+ -: 3474: */
function netDeserialLevel2 called 0 returned 0% blocks executed 0%
- #####: 3405:internal smallt* netDeserialLevel2(sBytest *obj) {
- #####: 3406: smallt *r = NULL;
- #####: 3407: double *D = NULL;
- #####: 3408: char *s = NULL;
- #####: 3409: sBytest *B = NULL;
- -: 3410: uint32_t count;
- #####: 3411: char *data = NULL;
- #####: 3412: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
- -: 3413:
- #####: 3414: switch(obj->data & 0xF) {
+ #####: 3475:internal smallt* netDeserialLevel2(sBytest *obj) {
+ #####: 3476: smallt *r = NULL;
+ #####: 3477: double *D = NULL;
+ #####: 3478: char *s = NULL;
+ #####: 3479: sBytest *B = NULL;
+ -: 3480: uint32_t count;
+ #####: 3481: char *data = NULL;
+ #####: 3482: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
+ -: 3483:
+ #####: 3484: switch(obj->data & 0xF) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -5053,150 +5123,150 @@ branch 7 never executed
branch 8 never executed
branch 9 never executed
branch 10 never executed
- -: 3415: case S_UNDEFINED:
- #####: 3416: r = (smallt *) allocSUndefined();
-call 0 never executed
- #####: 3417: break;
- -: 3418: case S_BOOL:
- #####: 3419: r = (smallt *) allocSBool(obj->data & 0x10);
-call 0 never executed
- #####: 3420: break;
- -: 3421: case S_DICT:
- #####: 3422: data = (char *)&(obj->data);
- -: 3423: //debug - ctx.dbuf = (u8*) data;
- #####: 3424: dictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 never executed
- #####: 3425: break;
- -: 3426: case S_DOUBLE:
- #####: 3427: data = &(obj->data)+1;
- #####: 3428: D = (double *)data;
- #####: 3429: r = (smallt *) allocSDouble(*D);
-call 0 never executed
- #####: 3430: break;
- -: 3431: case S_INT:
- #####: 3432: data = &(obj->data);
- #####: 3433: i64 v = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 3434: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3435: r = (smallt *) allocSInt(v);
-call 0 never executed
- #####: 3436: break;
- -: 3437: case S_STRING:
- #####: 3438: s = (char *)&(obj->data)+1;
- #####: 3439: r = (smallt *) allocSStringTiny(s);
-call 0 never executed
- #####: 3440: break;
- -: 3441: case S_ARRAY:
- #####: 3442: data = (char *)&(obj->data);
- -: 3443: //debug - ctx.dbuf = (u8*) data;
- #####: 3444: arrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 never executed
- #####: 3445: break;
- -: 3446: case S_BYTES:
- #####: 3447: B = allocSBytes();
-call 0 never executed
- #####: 3448: data = &(obj->data);
- #####: 3449: count = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 3450: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 3451: r = (smallt *)B;
- #####: 3452: break;
- -: 3453: case UNIFORM_DICT:
- #####: 3454: data = (char *)&(obj->data);
- -: 3455: //debug - ctx.dbuf = (u8*) data;
- #####: 3456: uniformDictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 never executed
- #####: 3457: break;
- -: 3458: case UNIFORM_ARRAY:
- #####: 3459: data = (char *)&(obj->data);
- -: 3460: //debug - ctx.dbuf = (u8*) data;
- #####: 3461: uniformArrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 never executed
- #####: 3462: break;
- -: 3463: }
- -: 3464:
- #####: 3465: ret r;
- -: 3466:}
- -: 3467:
- -: 3468:/**
- -: 3469: * deserialize dictionary from data
- -: 3470: *
- -: 3471: * a new dictionary is allocated
- -: 3472: *
- -: 3473: * \param
- -: 3474: * dict dictionary holding the elements
- -: 3475: * data serialized dictionary
- -: 3476: */
+ -: 3485: case S_UNDEFINED:
+ #####: 3486: r = (smallt *) allocSUndefined();
+call 0 never executed
+ #####: 3487: break;
+ -: 3488: case S_BOOL:
+ #####: 3489: r = (smallt *) allocSBool(obj->data & 0x10);
+call 0 never executed
+ #####: 3490: break;
+ -: 3491: case S_DICT:
+ #####: 3492: data = (char *)&(obj->data);
+ -: 3493: //debug - ctx.dbuf = (u8*) data;
+ #####: 3494: dictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 3495: break;
+ -: 3496: case S_DOUBLE:
+ #####: 3497: data = &(obj->data)+1;
+ #####: 3498: D = (double *)data;
+ #####: 3499: r = (smallt *) allocSDouble(*D);
+call 0 never executed
+ #####: 3500: break;
+ -: 3501: case S_INT:
+ #####: 3502: data = &(obj->data);
+ #####: 3503: i64 v = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 3504: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3505: r = (smallt *) allocSInt(v);
+call 0 never executed
+ #####: 3506: break;
+ -: 3507: case S_STRING:
+ #####: 3508: s = (char *)&(obj->data)+1;
+ #####: 3509: r = (smallt *) allocSStringTiny(s);
+call 0 never executed
+ #####: 3510: break;
+ -: 3511: case S_ARRAY:
+ #####: 3512: data = (char *)&(obj->data);
+ -: 3513: //debug - ctx.dbuf = (u8*) data;
+ #####: 3514: arrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 3515: break;
+ -: 3516: case S_BYTES:
+ #####: 3517: B = allocSBytes();
+call 0 never executed
+ #####: 3518: data = &(obj->data);
+ #####: 3519: count = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 3520: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 3521: r = (smallt *)B;
+ #####: 3522: break;
+ -: 3523: case UNIFORM_DICT:
+ #####: 3524: data = (char *)&(obj->data);
+ -: 3525: //debug - ctx.dbuf = (u8*) data;
+ #####: 3526: uniformDictNetDeserialLevel2((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 3527: break;
+ -: 3528: case UNIFORM_ARRAY:
+ #####: 3529: data = (char *)&(obj->data);
+ -: 3530: //debug - ctx.dbuf = (u8*) data;
+ #####: 3531: uniformArrayNetDeserialLevel2((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 never executed
+ #####: 3532: break;
+ -: 3533: }
+ -: 3534:
+ #####: 3535: ret r;
+ -: 3536:}
+ -: 3537:
+ -: 3538:/**
+ -: 3539: * deserialize dictionary from data
+ -: 3540: *
+ -: 3541: * a new dictionary is allocated
+ -: 3542: *
+ -: 3543: * \param
+ -: 3544: * dict dictionary holding the elements
+ -: 3545: * data serialized dictionary
+ -: 3546: */
function dictNetDeserialLevel2 called 0 returned 0% blocks executed 0%
- #####: 3477:internal void dictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
- #####: 3478: sUndefinedt *u = NULL;
- #####: 3479: sBoolt *bo = NULL;
- #####: 3480: double *D = NULL;
- #####: 3481: sDoublet *Do = NULL;
- #####: 3482: sDictt *d = NULL;
- #####: 3483: sIntt *io = NULL;
- #####: 3484: char *s = NULL;
- #####: 3485: sStringt *so = NULL;
- #####: 3486: sArrayt *a = NULL;
- #####: 3487: sBytest *B = NULL;
- -: 3488: uint32_t count;
- -: 3489: uint32_t dictCount;
- -: 3490:
- #####: 3491: if (packed) {
+ #####: 3547:internal void dictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
+ #####: 3548: sUndefinedt *u = NULL;
+ #####: 3549: sBoolt *bo = NULL;
+ #####: 3550: double *D = NULL;
+ #####: 3551: sDoublet *Do = NULL;
+ #####: 3552: sDictt *d = NULL;
+ #####: 3553: sIntt *io = NULL;
+ #####: 3554: char *s = NULL;
+ #####: 3555: sStringt *so = NULL;
+ #####: 3556: sArrayt *a = NULL;
+ #####: 3557: sBytest *B = NULL;
+ -: 3558: uint32_t count;
+ -: 3559: uint32_t dictCount;
+ -: 3560:
+ #####: 3561: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 3492: dictCount = varintToUint(data);
+ #####: 3562: dictCount = varintToUint(data);
call 0 never executed
- -: 3493: }
- -: 3494: else {
- #####: 3495: if (ctx->nibble == lowNbl) {
+ -: 3563: }
+ -: 3564: else {
+ #####: 3565: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3496: dictCount = netTypeVarintToUint(data);
+ #####: 3566: dictCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3497: }
- -: 3498: else {
- -: 3499: // high nibble
- -: 3500: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
- -: 3501: #define readTypeInHighNbl\
- -: 3502: ctx->nibble = lowNbl;\
- -: 3503: if (ctx->nblAddr == *data)\
- -: 3504: /* data points to the type, next byte is count */\
- -: 3505: (*data)++
- #####: 3506: readTypeInHighNbl;
+ -: 3567: }
+ -: 3568: else {
+ -: 3569: // high nibble
+ -: 3570: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
+ -: 3571: #define readTypeInHighNbl\
+ -: 3572: ctx->nibble = lowNbl;\
+ -: 3573: if (ctx->nblAddr == *data)\
+ -: 3574: /* data points to the type, next byte is count */\
+ -: 3575: (*data)++
+ #####: 3576: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3507: dictCount = varintToUint(data);
+ #####: 3577: dictCount = varintToUint(data);
call 0 never executed
- -: 3508: }
- -: 3509: }
- -: 3510:
- #####: 3511: if (!dictCount) {
+ -: 3578: }
+ -: 3579: }
+ -: 3580:
+ #####: 3581: if (!dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3512: *dict = allocSDict();
+ #####: 3582: *dict = allocSDict();
call 0 never executed
- #####: 3513: ret;
- -: 3514: }
- -: 3515:
- #####: 3516: loop(dictCount) {
+ #####: 3583: ret;
+ -: 3584: }
+ -: 3585:
+ #####: 3586: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3517: char *key = (char*)*data;
- #####: 3518: *data += strlen(key)+1;
- -: 3519: char type;
- #####: 3520: if (ctx->nibble == lowNbl) {
+ #####: 3587: char *key = (char*)*data;
+ #####: 3588: *data += strlen(key)+1;
+ -: 3589: char type;
+ #####: 3590: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3521: type = (**data) & 0xF;
- -: 3522: }
- -: 3523: else {
- -: 3524: // high nibble
- #####: 3525: type = (*ctx->nblAddr) >> 4;
- -: 3526: }
- -: 3527:
- #####: 3528: switch(type) {
+ #####: 3591: type = (**data) & 0xF;
+ -: 3592: }
+ -: 3593: else {
+ -: 3594: // high nibble
+ #####: 3595: type = (*ctx->nblAddr) >> 4;
+ -: 3596: }
+ -: 3597:
+ #####: 3598: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -5208,274 +5278,274 @@ branch 7 never executed
branch 8 never executed
branch 9 never executed
branch 10 never executed
- -: 3529: case S_UNDEFINED:
- #####: 3530: if (ctx->nibble == lowNbl) {
+ -: 3599: case S_UNDEFINED:
+ #####: 3600: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 3531: #define readTypeOnly\
- -: 3532: ctx->nibble = highNbl;\
- -: 3533: ctx->nblAddr = *data;\
- -: 3534: (*data)++
- #####: 3535: readTypeOnly;
- -: 3536: }
- -: 3537: else {
- -: 3538: // high nibble
- #####: 3539: readTypeInHighNbl;
+ -: 3601: #define readTypeOnly\
+ -: 3602: ctx->nibble = highNbl;\
+ -: 3603: ctx->nblAddr = *data;\
+ -: 3604: (*data)++
+ #####: 3605: readTypeOnly;
+ -: 3606: }
+ -: 3607: else {
+ -: 3608: // high nibble
+ #####: 3609: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3540: }
- #####: 3541: u = allocSUndefined();
+ -: 3610: }
+ #####: 3611: u = allocSUndefined();
call 0 never executed
- #####: 3542: sDictPushTiny(dict, key, (smallt *) u);
+ #####: 3612: sDictPushTiny(dict, key, (smallt *) u);
call 0 never executed
- #####: 3543: break;
- -: 3544: case S_BOOL:
- #####: 3545: if (!ctx->boolAddr) {
+ #####: 3613: break;
+ -: 3614: case S_BOOL:
+ #####: 3615: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- -: 3546: // new packed bools
- #####: 3547: if (ctx->nibble == lowNbl) {
+ -: 3616: // new packed bools
+ #####: 3617: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- -: 3548: #define read4bPackedBool\
- -: 3549: ctx->boolShift = 5;\
- -: 3550: ctx->boolAddr = *data;\
- -: 3551: (*data)++
- #####: 3552: read4bPackedBool;
- #####: 3553: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ -: 3618: #define read4bPackedBool\
+ -: 3619: ctx->boolShift = 5;\
+ -: 3620: ctx->boolAddr = *data;\
+ -: 3621: (*data)++
+ #####: 3622: read4bPackedBool;
+ #####: 3623: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3554: }
- -: 3555: else {
- -: 3556: // high nibble
- #####: 3557: readTypeInHighNbl;
+ -: 3624: }
+ -: 3625: else {
+ -: 3626: // high nibble
+ #####: 3627: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3558: #define read8bPackedBool\
- -: 3559: ctx->boolShift = 1;\
- -: 3560: ctx->boolAddr = *data;\
- -: 3561: (*data)++
- #####: 3562: read8bPackedBool;
- #####: 3563: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ -: 3628: #define read8bPackedBool\
+ -: 3629: ctx->boolShift = 1;\
+ -: 3630: ctx->boolAddr = *data;\
+ -: 3631: (*data)++
+ #####: 3632: read8bPackedBool;
+ #####: 3633: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3564: }
- -: 3565: }
- -: 3566: else {
- -: 3567: // there was a bool before this one, read bits in nibbles
- #####: 3568: if (ctx->nibble == lowNbl) {
+ -: 3634: }
+ -: 3635: }
+ -: 3636: else {
+ -: 3637: // there was a bool before this one, read bits in nibbles
+ #####: 3638: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3569: if (ctx->boolShift == 8) {
+ #####: 3639: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3570: read4bPackedBool;
- #####: 3571: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3640: read4bPackedBool;
+ #####: 3641: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3572: }
- -: 3573: else {
- #####: 3574: readTypeOnly;
- #####: 3575: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3642: }
+ -: 3643: else {
+ #####: 3644: readTypeOnly;
+ #####: 3645: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3576: }
- -: 3577: }
- -: 3578: else {
- -: 3579: // high nibble
- #####: 3580: readTypeInHighNbl;
+ -: 3646: }
+ -: 3647: }
+ -: 3648: else {
+ -: 3649: // high nibble
+ #####: 3650: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3581: if (ctx->boolShift == 8) {
+ #####: 3651: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3582: read8bPackedBool;
- #####: 3583: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3652: read8bPackedBool;
+ #####: 3653: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3584: }
- -: 3585: else {
- -: 3586: // high nibble
- #####: 3587: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3654: }
+ -: 3655: else {
+ -: 3656: // high nibble
+ #####: 3657: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3588: }
- -: 3589: }
- -: 3590: }
- #####: 3591: sDictPushTiny(dict, key, (smallt *) bo);
+ -: 3658: }
+ -: 3659: }
+ -: 3660: }
+ #####: 3661: sDictPushTiny(dict, key, (smallt *) bo);
call 0 never executed
- #####: 3592: break;
- -: 3593: case S_DICT:
- #####: 3594: d = NULL;
- #####: 3595: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
+ #####: 3662: break;
+ -: 3663: case S_DICT:
+ #####: 3664: d = NULL;
+ #####: 3665: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3596: sDictPushTiny(dict, key, (smallt *) d);
+ #####: 3666: sDictPushTiny(dict, key, (smallt *) d);
call 0 never executed
- #####: 3597: break;
- -: 3598: case S_DOUBLE:
- #####: 3599: if (ctx->nibble == lowNbl) {
+ #####: 3667: break;
+ -: 3668: case S_DOUBLE:
+ #####: 3669: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3600: readTypeOnly;
- -: 3601: }
- -: 3602: else {
- -: 3603: // high nibble
- #####: 3604: readTypeInHighNbl;
+ #####: 3670: readTypeOnly;
+ -: 3671: }
+ -: 3672: else {
+ -: 3673: // high nibble
+ #####: 3674: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3605: }
- #####: 3606: D = (double *)(*data);
- #####: 3607: *data += sizeof(double);
- #####: 3608: Do = allocSDouble(*D);
+ -: 3675: }
+ #####: 3676: D = (double *)(*data);
+ #####: 3677: *data += sizeof(double);
+ #####: 3678: Do = allocSDouble(*D);
call 0 never executed
- #####: 3609: sDictPushTiny(dict, key, (smallt *) Do);
+ #####: 3679: sDictPushTiny(dict, key, (smallt *) Do);
call 0 never executed
- #####: 3610: break;
- -: 3611: case S_INT: {
- -: 3612: i64 v;
- #####: 3613: if (ctx->nibble == lowNbl) {
+ #####: 3680: break;
+ -: 3681: case S_INT: {
+ -: 3682: i64 v;
+ #####: 3683: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3614: v = netTypeVarintToUint((u8**)data);
+ #####: 3684: v = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3615: }
- -: 3616: else {
- -: 3617: // high nibble
- #####: 3618: readTypeInHighNbl;
+ -: 3685: }
+ -: 3686: else {
+ -: 3687: // high nibble
+ #####: 3688: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3619: v = varintToUint(data);
+ #####: 3689: v = varintToUint(data);
call 0 never executed
- -: 3620: }
- #####: 3621: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3622: io = allocSInt(v);
+ -: 3690: }
+ #####: 3691: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3692: io = allocSInt(v);
call 0 never executed
- #####: 3623: sDictPushTiny(dict, key, (smallt *) io);
+ #####: 3693: sDictPushTiny(dict, key, (smallt *) io);
call 0 never executed
- -: 3624: }
- #####: 3625: break;
- -: 3626: case S_STRING:
- #####: 3627: if (ctx->nibble == lowNbl) {
+ -: 3694: }
+ #####: 3695: break;
+ -: 3696: case S_STRING:
+ #####: 3697: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3628: readTypeOnly;
- -: 3629: }
- -: 3630: else {
- -: 3631: // high nibble
- #####: 3632: readTypeInHighNbl;
+ #####: 3698: readTypeOnly;
+ -: 3699: }
+ -: 3700: else {
+ -: 3701: // high nibble
+ #####: 3702: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3633: }
- #####: 3634: s = (char *)(*data);
- #####: 3635: *data += strlen(s)+1;
- #####: 3636: so = allocSStringTiny(s);
+ -: 3703: }
+ #####: 3704: s = (char *)(*data);
+ #####: 3705: *data += strlen(s)+1;
+ #####: 3706: so = allocSStringTiny(s);
call 0 never executed
- #####: 3637: sDictPushTiny(dict, key, (smallt *) so);
+ #####: 3707: sDictPushTiny(dict, key, (smallt *) so);
call 0 never executed
- #####: 3638: break;
- -: 3639: case S_ARRAY:
- #####: 3640: a = NULL;
- #####: 3641: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
+ #####: 3708: break;
+ -: 3709: case S_ARRAY:
+ #####: 3710: a = NULL;
+ #####: 3711: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3642: sDictPushTiny(dict, key, (smallt *) a);
+ #####: 3712: sDictPushTiny(dict, key, (smallt *) a);
call 0 never executed
- #####: 3643: break;
- -: 3644: case S_BYTES:
- #####: 3645: B = allocSBytes();
+ #####: 3713: break;
+ -: 3714: case S_BYTES:
+ #####: 3715: B = allocSBytes();
call 0 never executed
- #####: 3646: if (ctx->nibble == lowNbl) {
+ #####: 3716: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3647: count = netTypeVarintToUint((u8**)data);
+ #####: 3717: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3648: }
- -: 3649: else {
- -: 3650: // high nibble
- #####: 3651: readTypeInHighNbl;
+ -: 3718: }
+ -: 3719: else {
+ -: 3720: // high nibble
+ #####: 3721: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3652: count = varintToUint((u8**)data);
+ #####: 3722: count = varintToUint((u8**)data);
call 0 never executed
- -: 3653: }
- #####: 3654: sBytesPushBuffer(&B, data, count);
+ -: 3723: }
+ #####: 3724: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 3655: *data += count;
- #####: 3656: sDictPushTiny(dict, key, (smallt *) B);
+ #####: 3725: *data += count;
+ #####: 3726: sDictPushTiny(dict, key, (smallt *) B);
call 0 never executed
- #####: 3657: break;
- -: 3658: case UNIFORM_DICT:
- #####: 3659: d = NULL;
- #####: 3660: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
+ #####: 3727: break;
+ -: 3728: case UNIFORM_DICT:
+ #####: 3729: d = NULL;
+ #####: 3730: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3661: sDictPushTiny(dict, key, (smallt *) d);
+ #####: 3731: sDictPushTiny(dict, key, (smallt *) d);
call 0 never executed
- #####: 3662: break;
- -: 3663: case UNIFORM_ARRAY:
- #####: 3664: a = NULL;
- #####: 3665: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
+ #####: 3732: break;
+ -: 3733: case UNIFORM_ARRAY:
+ #####: 3734: a = NULL;
+ #####: 3735: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3666: sDictPushTiny(dict, key, (smallt *) a);
+ #####: 3736: sDictPushTiny(dict, key, (smallt *) a);
call 0 never executed
- #####: 3667: break;
- -: 3668: }
- -: 3669: }
- -: 3670:}
- -: 3671:
- -: 3672:/**
- -: 3673: * deserialize dictionary from data
- -: 3674: *
- -: 3675: * a new dictionary is allocated
- -: 3676: *
- -: 3677: * \param
- -: 3678: * dict dictionary holding the elements
- -: 3679: * data serialized dictionary
- -: 3680: */
+ #####: 3737: break;
+ -: 3738: }
+ -: 3739: }
+ -: 3740:}
+ -: 3741:
+ -: 3742:/**
+ -: 3743: * deserialize dictionary from data
+ -: 3744: *
+ -: 3745: * a new dictionary is allocated
+ -: 3746: *
+ -: 3747: * \param
+ -: 3748: * dict dictionary holding the elements
+ -: 3749: * data serialized dictionary
+ -: 3750: */
function uniformDictNetDeserialLevel2 called 0 returned 0% blocks executed 0%
- #####: 3681:internal void uniformDictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
- #####: 3682: sUndefinedt *u = NULL;
- #####: 3683: sBoolt *bo = NULL;
- #####: 3684: double *D = NULL;
- #####: 3685: sDoublet *Do = NULL;
- #####: 3686: sDictt *d = NULL;
- #####: 3687: sIntt *io = NULL;
- #####: 3688: char *s = NULL;
- #####: 3689: sStringt *so = NULL;
- #####: 3690: sArrayt *a = NULL;
- #####: 3691: sBytest *B = NULL;
- -: 3692: uint32_t count;
- -: 3693: uint32_t dictCount;
- -: 3694: u8 type;
- -: 3695:
- #####: 3696: if (packed) {
+ #####: 3751:internal void uniformDictNetDeserialLevel2(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
+ #####: 3752: sUndefinedt *u = NULL;
+ #####: 3753: sBoolt *bo = NULL;
+ #####: 3754: double *D = NULL;
+ #####: 3755: sDoublet *Do = NULL;
+ #####: 3756: sDictt *d = NULL;
+ #####: 3757: sIntt *io = NULL;
+ #####: 3758: char *s = NULL;
+ #####: 3759: sStringt *so = NULL;
+ #####: 3760: sArrayt *a = NULL;
+ #####: 3761: sBytest *B = NULL;
+ -: 3762: uint32_t count;
+ -: 3763: uint32_t dictCount;
+ -: 3764: u8 type;
+ -: 3765:
+ #####: 3766: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 3697: type = (**data) & 0xF;
- #####: 3698: dictCount = netTypeVarintToUint(data);
+ #####: 3767: type = (**data) & 0xF;
+ #####: 3768: dictCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3699: }
- -: 3700: else {
- #####: 3701: if (ctx->nibble == lowNbl) {
+ -: 3769: }
+ -: 3770: else {
+ #####: 3771: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3702: type = (**data) >> 4;
- #####: 3703: (*data)++;
- #####: 3704: dictCount = varintToUint(data);
+ #####: 3772: type = (**data) >> 4;
+ #####: 3773: (*data)++;
+ #####: 3774: dictCount = varintToUint(data);
call 0 never executed
- -: 3705: }
- -: 3706: else {
- #####: 3707: readTypeInHighNbl;
+ -: 3775: }
+ -: 3776: else {
+ #####: 3777: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3708: type = (**data) & 0xF;
- #####: 3709: dictCount = netTypeVarintToUint(data);
+ #####: 3778: type = (**data) & 0xF;
+ #####: 3779: dictCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3710: }
- -: 3711: }
- -: 3712:
- #####: 3713: if (!dictCount) {
+ -: 3780: }
+ -: 3781: }
+ -: 3782:
+ #####: 3783: if (!dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3714: *dict = allocSDict();
+ #####: 3784: *dict = allocSDict();
call 0 never executed
- #####: 3715: ret;
- -: 3716: }
- -: 3717:
- -: 3718:
- #####: 3719: switch(type) {
+ #####: 3785: ret;
+ -: 3786: }
+ -: 3787:
+ -: 3788:
+ #####: 3789: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -5487,237 +5557,237 @@ branch 7 never executed
branch 8 never executed
branch 9 never executed
branch 10 never executed
- -: 3720: case S_UNDEFINED:
- #####: 3721: loop(dictCount) {
+ -: 3790: case S_UNDEFINED:
+ #####: 3791: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3722: char *key = (char*)*data;
- #####: 3723: *data += strlen(key)+1;
- #####: 3724: u = allocSUndefined();
+ #####: 3792: char *key = (char*)*data;
+ #####: 3793: *data += strlen(key)+1;
+ #####: 3794: u = allocSUndefined();
call 0 never executed
- #####: 3725: sDictPushTiny(dict, key, (smallt *) u);
+ #####: 3795: sDictPushTiny(dict, key, (smallt *) u);
call 0 never executed
- -: 3726: }
- #####: 3727: break;
- -: 3728: case S_BOOL:
- #####: 3729: loop(dictCount) {
+ -: 3796: }
+ #####: 3797: break;
+ -: 3798: case S_BOOL:
+ #####: 3799: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3730: char *key = (char*)*data;
- #####: 3731: *data += strlen(key)+1;
- #####: 3732: if (!ctx->boolAddr) {
+ #####: 3800: char *key = (char*)*data;
+ #####: 3801: *data += strlen(key)+1;
+ #####: 3802: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- #####: 3733: read8bPackedBool;
- #####: 3734: ctx->boolShift = 0;
- -: 3735: }
- #####: 3736: if (ctx->boolShift == 8) {
+ #####: 3803: read8bPackedBool;
+ #####: 3804: ctx->boolShift = 0;
+ -: 3805: }
+ #####: 3806: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3737: readTypeInHighNbl;
+ #####: 3807: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3738: read8bPackedBool;
- #####: 3739: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3808: read8bPackedBool;
+ #####: 3809: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3740: }
- -: 3741: else {
- -: 3742: // high nibble
- #####: 3743: readTypeInHighNbl;
+ -: 3810: }
+ -: 3811: else {
+ -: 3812: // high nibble
+ #####: 3813: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3744: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ #####: 3814: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3745: }
- #####: 3746: sDictPushTiny(dict, key, (smallt *) bo);
+ -: 3815: }
+ #####: 3816: sDictPushTiny(dict, key, (smallt *) bo);
call 0 never executed
- -: 3747: }
- #####: 3748: break;
- -: 3749: case S_DICT:
- #####: 3750: loop(dictCount) {
+ -: 3817: }
+ #####: 3818: break;
+ -: 3819: case S_DICT:
+ #####: 3820: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3751: char *key = (char*)*data;
- #####: 3752: *data += strlen(key)+1;
- #####: 3753: d = NULL;
- #####: 3754: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
+ #####: 3821: char *key = (char*)*data;
+ #####: 3822: *data += strlen(key)+1;
+ #####: 3823: d = NULL;
+ #####: 3824: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 3755: sDictPushTiny(dict, key, (smallt *) d);
+ #####: 3825: sDictPushTiny(dict, key, (smallt *) d);
call 0 never executed
- -: 3756: }
- #####: 3757: break;
- -: 3758: case S_DOUBLE:
- #####: 3759: loop(dictCount) {
+ -: 3826: }
+ #####: 3827: break;
+ -: 3828: case S_DOUBLE:
+ #####: 3829: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3760: char *key = (char*)*data;
- #####: 3761: *data += strlen(key)+1;
- #####: 3762: D = (double *)(*data);
- #####: 3763: *data += sizeof(double);
- #####: 3764: Do = allocSDouble(*D);
+ #####: 3830: char *key = (char*)*data;
+ #####: 3831: *data += strlen(key)+1;
+ #####: 3832: D = (double *)(*data);
+ #####: 3833: *data += sizeof(double);
+ #####: 3834: Do = allocSDouble(*D);
call 0 never executed
- #####: 3765: sDictPushTiny(dict, key, (smallt *) Do);
+ #####: 3835: sDictPushTiny(dict, key, (smallt *) Do);
call 0 never executed
- -: 3766: }
- #####: 3767: break;
- -: 3768: case S_INT:
- #####: 3769: loop(dictCount) {
+ -: 3836: }
+ #####: 3837: break;
+ -: 3838: case S_INT:
+ #####: 3839: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3770: char *key = (char*)*data;
- #####: 3771: *data += strlen(key)+1;
- #####: 3772: i64 v = varintToUint(data);
+ #####: 3840: char *key = (char*)*data;
+ #####: 3841: *data += strlen(key)+1;
+ #####: 3842: i64 v = varintToUint(data);
call 0 never executed
- #####: 3773: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3774: io = allocSInt(v);
+ #####: 3843: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 3844: io = allocSInt(v);
call 0 never executed
- #####: 3775: sDictPushTiny(dict, key, (smallt *) io);
+ #####: 3845: sDictPushTiny(dict, key, (smallt *) io);
call 0 never executed
- -: 3776: }
- #####: 3777: break;
- -: 3778: case S_STRING:
- #####: 3779: loop(dictCount) {
+ -: 3846: }
+ #####: 3847: break;
+ -: 3848: case S_STRING:
+ #####: 3849: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3780: char *key = (char*)*data;
- #####: 3781: *data += strlen(key)+1;
- #####: 3782: s = (char *)(*data);
- #####: 3783: *data += strlen(s)+1;
- #####: 3784: so = allocSStringTiny(s);
+ #####: 3850: char *key = (char*)*data;
+ #####: 3851: *data += strlen(key)+1;
+ #####: 3852: s = (char *)(*data);
+ #####: 3853: *data += strlen(s)+1;
+ #####: 3854: so = allocSStringTiny(s);
call 0 never executed
- #####: 3785: sDictPushTiny(dict, key, (smallt *) so);
+ #####: 3855: sDictPushTiny(dict, key, (smallt *) so);
call 0 never executed
- -: 3786: }
- #####: 3787: break;
- -: 3788: case S_ARRAY:
- #####: 3789: loop(dictCount) {
+ -: 3856: }
+ #####: 3857: break;
+ -: 3858: case S_ARRAY:
+ #####: 3859: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3790: char *key = (char*)*data;
- #####: 3791: *data += strlen(key)+1;
- #####: 3792: a = NULL;
- #####: 3793: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
+ #####: 3860: char *key = (char*)*data;
+ #####: 3861: *data += strlen(key)+1;
+ #####: 3862: a = NULL;
+ #####: 3863: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 3794: sDictPushTiny(dict, key, (smallt *) a);
+ #####: 3864: sDictPushTiny(dict, key, (smallt *) a);
call 0 never executed
- -: 3795: }
- #####: 3796: break;
- -: 3797: case S_BYTES:
- #####: 3798: loop(dictCount) {
+ -: 3865: }
+ #####: 3866: break;
+ -: 3867: case S_BYTES:
+ #####: 3868: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3799: char *key = (char*)*data;
- #####: 3800: *data += strlen(key)+1;
- #####: 3801: B = allocSBytes();
+ #####: 3869: char *key = (char*)*data;
+ #####: 3870: *data += strlen(key)+1;
+ #####: 3871: B = allocSBytes();
call 0 never executed
- #####: 3802: count = varintToUint((u8**)data);
+ #####: 3872: count = varintToUint((u8**)data);
call 0 never executed
- #####: 3803: sBytesPushBuffer(&B, data, count);
+ #####: 3873: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 3804: *data += count;
- #####: 3805: sDictPushTiny(dict, key, (smallt *) B);
+ #####: 3874: *data += count;
+ #####: 3875: sDictPushTiny(dict, key, (smallt *) B);
call 0 never executed
- -: 3806: }
- #####: 3807: break;
- -: 3808: case UNIFORM_DICT:
- #####: 3809: loop(dictCount) {
+ -: 3876: }
+ #####: 3877: break;
+ -: 3878: case UNIFORM_DICT:
+ #####: 3879: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3810: char *key = (char*)*data;
- #####: 3811: *data += strlen(key)+1;
- #####: 3812: d = NULL;
- #####: 3813: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
+ #####: 3880: char *key = (char*)*data;
+ #####: 3881: *data += strlen(key)+1;
+ #####: 3882: d = NULL;
+ #####: 3883: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 3814: sDictPushTiny(dict, key, (smallt *) d);
+ #####: 3884: sDictPushTiny(dict, key, (smallt *) d);
call 0 never executed
- -: 3815: }
- #####: 3816: break;
- -: 3817: case UNIFORM_ARRAY:
- #####: 3818: loop(dictCount) {
+ -: 3885: }
+ #####: 3886: break;
+ -: 3887: case UNIFORM_ARRAY:
+ #####: 3888: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 3819: char *key = (char*)*data;
- #####: 3820: *data += strlen(key)+1;
- #####: 3821: a = NULL;
- #####: 3822: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
+ #####: 3889: char *key = (char*)*data;
+ #####: 3890: *data += strlen(key)+1;
+ #####: 3891: a = NULL;
+ #####: 3892: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 3823: sDictPushTiny(dict, key, (smallt *) a);
+ #####: 3893: sDictPushTiny(dict, key, (smallt *) a);
call 0 never executed
- -: 3824: }
- #####: 3825: break;
- -: 3826: }
- -: 3827:}
- -: 3828:
- -: 3829:/**
- -: 3830: * deserialize array from data
- -: 3831: *
- -: 3832: * a new array is allocated
- -: 3833: *
- -: 3834: * \param
- -: 3835: * array holding the elements
- -: 3836: * data serialized dictionary
- -: 3837: */
+ -: 3894: }
+ #####: 3895: break;
+ -: 3896: }
+ -: 3897:}
+ -: 3898:
+ -: 3899:/**
+ -: 3900: * deserialize array from data
+ -: 3901: *
+ -: 3902: * a new array is allocated
+ -: 3903: *
+ -: 3904: * \param
+ -: 3905: * array holding the elements
+ -: 3906: * data serialized dictionary
+ -: 3907: */
function arrayNetDeserialLevel2 called 0 returned 0% blocks executed 0%
- #####: 3838:internal void arrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
- #####: 3839: sUndefinedt *u = NULL;
- #####: 3840: sBoolt *bo = NULL;
- #####: 3841: double *D = NULL;
- #####: 3842: sDoublet *Do = NULL;
- #####: 3843: sDictt *d = NULL;
- #####: 3844: sIntt *io = NULL;
- #####: 3845: char *s = NULL;
- #####: 3846: sStringt *so = NULL;
- #####: 3847: sArrayt *a = NULL;
- #####: 3848: sBytest *B = NULL;
- -: 3849: uint32_t count;
- -: 3850: uint32_t arrayCount;
- -: 3851:
- #####: 3852: if (packed) {
+ #####: 3908:internal void arrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
+ #####: 3909: sUndefinedt *u = NULL;
+ #####: 3910: sBoolt *bo = NULL;
+ #####: 3911: double *D = NULL;
+ #####: 3912: sDoublet *Do = NULL;
+ #####: 3913: sDictt *d = NULL;
+ #####: 3914: sIntt *io = NULL;
+ #####: 3915: char *s = NULL;
+ #####: 3916: sStringt *so = NULL;
+ #####: 3917: sArrayt *a = NULL;
+ #####: 3918: sBytest *B = NULL;
+ -: 3919: uint32_t count;
+ -: 3920: uint32_t arrayCount;
+ -: 3921:
+ #####: 3922: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 3853: arrayCount = varintToUint(data);
+ #####: 3923: arrayCount = varintToUint(data);
call 0 never executed
- -: 3854: }
- -: 3855: else {
- #####: 3856: if (ctx->nibble == lowNbl) {
+ -: 3924: }
+ -: 3925: else {
+ #####: 3926: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3857: arrayCount = netTypeVarintToUint(data);
+ #####: 3927: arrayCount = netTypeVarintToUint(data);
call 0 never executed
- -: 3858: }
- -: 3859: else {
- -: 3860: // high nibble
- #####: 3861: readTypeInHighNbl;
+ -: 3928: }
+ -: 3929: else {
+ -: 3930: // high nibble
+ #####: 3931: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3862: arrayCount = varintToUint(data);
+ #####: 3932: arrayCount = varintToUint(data);
call 0 never executed
- -: 3863: }
- -: 3864: }
- -: 3865:
- #####: 3866: if (!arrayCount) {
+ -: 3933: }
+ -: 3934: }
+ -: 3935:
+ #####: 3936: if (!arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 3867: *array = allocSArray();;
+ #####: 3937: *array = allocSArray();;
call 0 never executed
- #####: 3868: ret;
- -: 3869: }
- -: 3870:
- #####: 3871: loop(arrayCount) {
+ #####: 3938: ret;
+ -: 3939: }
+ -: 3940:
+ #####: 3941: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- -: 3872: char type;
- #####: 3873: if (ctx->nibble == lowNbl) {
+ -: 3942: char type;
+ #####: 3943: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3874: type = (**data) & 0xF;
- -: 3875: }
- -: 3876: else {
- -: 3877: // high nibble
- #####: 3878: type = (*ctx->nblAddr) >> 4;
- -: 3879: }
- -: 3880:
- #####: 3881: switch(type) {
+ #####: 3944: type = (**data) & 0xF;
+ -: 3945: }
+ -: 3946: else {
+ -: 3947: // high nibble
+ #####: 3948: type = (*ctx->nblAddr) >> 4;
+ -: 3949: }
+ -: 3950:
+ #####: 3951: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -5729,251 +5799,251 @@ branch 7 never executed
branch 8 never executed
branch 9 never executed
branch 10 never executed
- -: 3882: case S_UNDEFINED:
- #####: 3883: if (ctx->nibble == lowNbl) {
+ -: 3952: case S_UNDEFINED:
+ #####: 3953: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3884: readTypeOnly;
- -: 3885: }
- -: 3886: else {
- -: 3887: // high nibble
- #####: 3888: readTypeInHighNbl;
+ #####: 3954: readTypeOnly;
+ -: 3955: }
+ -: 3956: else {
+ -: 3957: // high nibble
+ #####: 3958: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3889: }
- #####: 3890: u = allocSUndefined();
+ -: 3959: }
+ #####: 3960: u = allocSUndefined();
call 0 never executed
- #####: 3891: sArrayPushTiny(array, (smallt *) u);
+ #####: 3961: sArrayPushTiny(array, (smallt *) u);
call 0 never executed
- #####: 3892: break;
- -: 3893: case S_BOOL:
- #####: 3894: if (!ctx->boolAddr) {
+ #####: 3962: break;
+ -: 3963: case S_BOOL:
+ #####: 3964: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- -: 3895: // new packed bools
- #####: 3896: if (ctx->nibble == lowNbl) {
+ -: 3965: // new packed bools
+ #####: 3966: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3897: read4bPackedBool;
- #####: 3898: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3967: read4bPackedBool;
+ #####: 3968: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3899: }
- -: 3900: else {
- -: 3901: // high nibble
- #####: 3902: readTypeInHighNbl;
+ -: 3969: }
+ -: 3970: else {
+ -: 3971: // high nibble
+ #####: 3972: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3903: read8bPackedBool;
- #####: 3904: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3973: read8bPackedBool;
+ #####: 3974: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3905: }
- -: 3906: }
- -: 3907: else {
- -: 3908: // there was a bool before this one, read bits in nibbles
- #####: 3909: if (ctx->nibble == lowNbl) {
+ -: 3975: }
+ -: 3976: }
+ -: 3977: else {
+ -: 3978: // there was a bool before this one, read bits in nibbles
+ #####: 3979: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3910: if (ctx->boolShift == 8) {
+ #####: 3980: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3911: read4bPackedBool;
- #####: 3912: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ #####: 3981: read4bPackedBool;
+ #####: 3982: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 never executed
- -: 3913: }
- -: 3914: else {
- #####: 3915: readTypeOnly;
- #####: 3916: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3983: }
+ -: 3984: else {
+ #####: 3985: readTypeOnly;
+ #####: 3986: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3917: }
- -: 3918: }
- -: 3919: else {
- -: 3920: // high nibble
- #####: 3921: readTypeInHighNbl;
+ -: 3987: }
+ -: 3988: }
+ -: 3989: else {
+ -: 3990: // high nibble
+ #####: 3991: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3922: if (ctx->boolShift == 8) {
+ #####: 3992: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 3923: read8bPackedBool;
- #####: 3924: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 3993: read8bPackedBool;
+ #####: 3994: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 3925: }
- -: 3926: else {
- #####: 3927: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 3995: }
+ -: 3996: else {
+ #####: 3997: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 3928: }
- -: 3929: }
- -: 3930: }
- #####: 3931: sArrayPushTiny(array, (smallt *) bo);
+ -: 3998: }
+ -: 3999: }
+ -: 4000: }
+ #####: 4001: sArrayPushTiny(array, (smallt *) bo);
call 0 never executed
- #####: 3932: break;
- -: 3933: case S_DICT:
- #####: 3934: d = NULL;
- #####: 3935: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
+ #####: 4002: break;
+ -: 4003: case S_DICT:
+ #####: 4004: d = NULL;
+ #####: 4005: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3936: sArrayPushTiny(array, (smallt *) d);
+ #####: 4006: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- #####: 3937: break;
- -: 3938: case S_DOUBLE:
- #####: 3939: if (ctx->nibble == lowNbl) {
+ #####: 4007: break;
+ -: 4008: case S_DOUBLE:
+ #####: 4009: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3940: readTypeOnly;
- -: 3941: }
- -: 3942: else {
- -: 3943: // high nibble
- #####: 3944: readTypeInHighNbl;
+ #####: 4010: readTypeOnly;
+ -: 4011: }
+ -: 4012: else {
+ -: 4013: // high nibble
+ #####: 4014: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3945: }
- #####: 3946: D = (double *)(*data);
- #####: 3947: *data += sizeof(double);
- #####: 3948: Do = allocSDouble(*D);
+ -: 4015: }
+ #####: 4016: D = (double *)(*data);
+ #####: 4017: *data += sizeof(double);
+ #####: 4018: Do = allocSDouble(*D);
call 0 never executed
- #####: 3949: sArrayPushTiny(array, (smallt *) Do);
+ #####: 4019: sArrayPushTiny(array, (smallt *) Do);
call 0 never executed
- #####: 3950: break;
- -: 3951: case S_INT: {
- -: 3952: i64 v;
- #####: 3953: if (ctx->nibble == lowNbl) {
+ #####: 4020: break;
+ -: 4021: case S_INT: {
+ -: 4022: i64 v;
+ #####: 4023: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3954: v = netTypeVarintToUint((u8**)data);
+ #####: 4024: v = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3955: }
- -: 3956: else {
- -: 3957: // high nibble
- #####: 3958: readTypeInHighNbl;
+ -: 4025: }
+ -: 4026: else {
+ -: 4027: // high nibble
+ #####: 4028: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3959: v = varintToUint(data);
+ #####: 4029: v = varintToUint(data);
call 0 never executed
- -: 3960: }
- #####: 3961: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 3962: io = allocSInt(v);
+ -: 4030: }
+ #####: 4031: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 4032: io = allocSInt(v);
call 0 never executed
- #####: 3963: sArrayPushTiny(array, (smallt *) io);
+ #####: 4033: sArrayPushTiny(array, (smallt *) io);
call 0 never executed
- -: 3964: }
- #####: 3965: break;
- -: 3966: case S_STRING:
- #####: 3967: if (ctx->nibble == lowNbl) {
+ -: 4034: }
+ #####: 4035: break;
+ -: 4036: case S_STRING:
+ #####: 4037: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3968: readTypeOnly;
- -: 3969: }
- -: 3970: else {
- -: 3971: // high nibble
- #####: 3972: readTypeInHighNbl;
+ #####: 4038: readTypeOnly;
+ -: 4039: }
+ -: 4040: else {
+ -: 4041: // high nibble
+ #####: 4042: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- -: 3973: }
- #####: 3974: s = (char *)(*data);
- #####: 3975: *data += strlen(s)+1;
- #####: 3976: so = allocSStringTiny(s);
+ -: 4043: }
+ #####: 4044: s = (char *)(*data);
+ #####: 4045: *data += strlen(s)+1;
+ #####: 4046: so = allocSStringTiny(s);
call 0 never executed
- #####: 3977: sArrayPushTiny(array, (smallt *) so);
+ #####: 4047: sArrayPushTiny(array, (smallt *) so);
call 0 never executed
- #####: 3978: break;
- -: 3979: case S_ARRAY:
- #####: 3980: a = NULL;
- #####: 3981: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
+ #####: 4048: break;
+ -: 4049: case S_ARRAY:
+ #####: 4050: a = NULL;
+ #####: 4051: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 3982: sArrayPushTiny(array, (smallt *) a);
+ #####: 4052: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- #####: 3983: break;
- -: 3984: case S_BYTES:
- #####: 3985: B = allocSBytes();
+ #####: 4053: break;
+ -: 4054: case S_BYTES:
+ #####: 4055: B = allocSBytes();
call 0 never executed
- #####: 3986: if (ctx->nibble == lowNbl) {
+ #####: 4056: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 3987: count = netTypeVarintToUint((u8**)data);
+ #####: 4057: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 3988: }
- -: 3989: else {
- -: 3990: // high nibble
- #####: 3991: readTypeInHighNbl;
+ -: 4058: }
+ -: 4059: else {
+ -: 4060: // high nibble
+ #####: 4061: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 3992: count = varintToUint((u8**)data);
+ #####: 4062: count = varintToUint((u8**)data);
call 0 never executed
- -: 3993: }
- #####: 3994: sBytesPushBuffer(&B, data, count);
+ -: 4063: }
+ #####: 4064: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 3995: *data += count;
- #####: 3996: sArrayPushTiny(array, (smallt *) B);
+ #####: 4065: *data += count;
+ #####: 4066: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- #####: 3997: break;
- -: 3998: case UNIFORM_DICT:
- #####: 3999: d = NULL;
- #####: 4000: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
+ #####: 4067: break;
+ -: 4068: case UNIFORM_DICT:
+ #####: 4069: d = NULL;
+ #####: 4070: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 4001: sArrayPushTiny(array, (smallt *) d);
+ #####: 4071: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- #####: 4002: break;
- -: 4003: case UNIFORM_ARRAY:
- #####: 4004: a = NULL;
- #####: 4005: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
+ #####: 4072: break;
+ -: 4073: case UNIFORM_ARRAY:
+ #####: 4074: a = NULL;
+ #####: 4075: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/false);
call 0 never executed
- #####: 4006: sArrayPushTiny(array, (smallt *) a);
+ #####: 4076: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- #####: 4007: break;
- -: 4008: }
- -: 4009: }
- -: 4010:}
- -: 4011:
+ #####: 4077: break;
+ -: 4078: }
+ -: 4079: }
+ -: 4080:}
+ -: 4081:
function uniformArrayNetDeserialLevel2 called 0 returned 0% blocks executed 0%
- #####: 4012:internal void uniformArrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
- #####: 4013: sUndefinedt *u = NULL;
- #####: 4014: sBoolt *bo = NULL;
- #####: 4015: double *D = NULL;
- #####: 4016: sDoublet *Do = NULL;
- #####: 4017: sDictt *d = NULL;
- #####: 4018: sIntt *io = NULL;
- #####: 4019: char *s = NULL;
- #####: 4020: sStringt *so = NULL;
- #####: 4021: sArrayt *a = NULL;
- #####: 4022: sBytest *B = NULL;
- -: 4023: uint32_t count;
- -: 4024: uint32_t arrayCount;
- -: 4025: u8 type;
- -: 4026:
- #####: 4027: if (packed) {
+ #####: 4082:internal void uniformArrayNetDeserialLevel2(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
+ #####: 4083: sUndefinedt *u = NULL;
+ #####: 4084: sBoolt *bo = NULL;
+ #####: 4085: double *D = NULL;
+ #####: 4086: sDoublet *Do = NULL;
+ #####: 4087: sDictt *d = NULL;
+ #####: 4088: sIntt *io = NULL;
+ #####: 4089: char *s = NULL;
+ #####: 4090: sStringt *so = NULL;
+ #####: 4091: sArrayt *a = NULL;
+ #####: 4092: sBytest *B = NULL;
+ -: 4093: uint32_t count;
+ -: 4094: uint32_t arrayCount;
+ -: 4095: u8 type;
+ -: 4096:
+ #####: 4097: if (packed) {
branch 0 never executed
branch 1 never executed
- #####: 4028: type = (**data) & 0xF;
- #####: 4029: arrayCount = netTypeVarintToUint(data);
+ #####: 4098: type = (**data) & 0xF;
+ #####: 4099: arrayCount = netTypeVarintToUint(data);
call 0 never executed
- -: 4030: }
- -: 4031: else {
- #####: 4032: if (ctx->nibble == lowNbl) {
+ -: 4100: }
+ -: 4101: else {
+ #####: 4102: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 4033: type = (**data) >> 4;
- #####: 4034: (*data)++;
- #####: 4035: arrayCount = varintToUint(data);
+ #####: 4103: type = (**data) >> 4;
+ #####: 4104: (*data)++;
+ #####: 4105: arrayCount = varintToUint(data);
call 0 never executed
- -: 4036: }
- -: 4037: else {
- #####: 4038: readTypeInHighNbl;
+ -: 4106: }
+ -: 4107: else {
+ #####: 4108: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 4039: type = (**data) & 0xF;
- #####: 4040: arrayCount = netTypeVarintToUint(data);
+ #####: 4109: type = (**data) & 0xF;
+ #####: 4110: arrayCount = netTypeVarintToUint(data);
call 0 never executed
- -: 4041: }
- -: 4042: }
- -: 4043:
- #####: 4044: if (!arrayCount) {
+ -: 4111: }
+ -: 4112: }
+ -: 4113:
+ #####: 4114: if (!arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4045: *array = allocSArray();;
+ #####: 4115: *array = allocSArray();;
call 0 never executed
- #####: 4046: ret;
- -: 4047: }
- -: 4048:
- #####: 4049: switch(type) {
+ #####: 4116: ret;
+ -: 4117: }
+ -: 4118:
+ #####: 4119: switch(type) {
branch 0 never executed
branch 1 never executed
branch 2 never executed
@@ -5985,345 +6055,349 @@ branch 7 never executed
branch 8 never executed
branch 9 never executed
branch 10 never executed
- -: 4050: case S_UNDEFINED:
- #####: 4051: loop(arrayCount) {
+ -: 4120: case S_UNDEFINED:
+ #####: 4121: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4052: u = allocSUndefined();
+ #####: 4122: u = allocSUndefined();
call 0 never executed
- #####: 4053: sArrayPushTiny(array, (smallt *) u);
+ #####: 4123: sArrayPushTiny(array, (smallt *) u);
call 0 never executed
- -: 4054: }
- #####: 4055: break;
- -: 4056: case S_BOOL:
- #####: 4057: loop(arrayCount) {
+ -: 4124: }
+ #####: 4125: break;
+ -: 4126: case S_BOOL:
+ #####: 4127: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4058: if (!ctx->boolAddr) {
+ #####: 4128: if (!ctx->boolAddr) {
branch 0 never executed
branch 1 never executed
- #####: 4059: read8bPackedBool;
- #####: 4060: ctx->boolShift = 0;
- -: 4061: }
- #####: 4062: if (ctx->boolShift == 8) {
+ #####: 4129: read8bPackedBool;
+ #####: 4130: ctx->boolShift = 0;
+ -: 4131: }
+ #####: 4132: if (ctx->boolShift == 8) {
branch 0 never executed
branch 1 never executed
- #####: 4063: read8bPackedBool;
- #####: 4064: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ #####: 4133: read8bPackedBool;
+ #####: 4134: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 never executed
- -: 4065: }
- -: 4066: else {
- #####: 4067: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 4135: }
+ -: 4136: else {
+ #####: 4137: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 never executed
- -: 4068: }
- #####: 4069: sArrayPushTiny(array, (smallt *) bo);
+ -: 4138: }
+ #####: 4139: sArrayPushTiny(array, (smallt *) bo);
call 0 never executed
- -: 4070: }
- #####: 4071: break;
- -: 4072: case S_DICT:
- #####: 4073: loop(arrayCount) {
+ -: 4140: }
+ #####: 4141: break;
+ -: 4142: case S_DICT:
+ #####: 4143: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4074: d = NULL;
- #####: 4075: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
+ #####: 4144: d = NULL;
+ #####: 4145: dictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 4076: sArrayPushTiny(array, (smallt *) d);
+ #####: 4146: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- -: 4077: }
- #####: 4078: break;
- -: 4079: case S_DOUBLE:
- #####: 4080: loop(arrayCount) {
+ -: 4147: }
+ #####: 4148: break;
+ -: 4149: case S_DOUBLE:
+ #####: 4150: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4081: D = (double *)(*data);
- #####: 4082: *data += sizeof(double);
- #####: 4083: Do = allocSDouble(*D);
+ #####: 4151: D = (double *)(*data);
+ #####: 4152: *data += sizeof(double);
+ #####: 4153: Do = allocSDouble(*D);
call 0 never executed
- #####: 4084: sArrayPushTiny(array, (smallt *) Do);
+ #####: 4154: sArrayPushTiny(array, (smallt *) Do);
call 0 never executed
- -: 4085: }
- #####: 4086: break;
- -: 4087: case S_INT:
- #####: 4088: loop(arrayCount) {
+ -: 4155: }
+ #####: 4156: break;
+ -: 4157: case S_INT:
+ #####: 4158: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4089: i64 v = varintToUint(data);
+ #####: 4159: i64 v = varintToUint(data);
call 0 never executed
- #####: 4090: v = (v >> 1) ^ ((v << 63) >> 63);
- #####: 4091: io = allocSInt(v);
+ #####: 4160: v = (v >> 1) ^ ((v << 63) >> 63);
+ #####: 4161: io = allocSInt(v);
call 0 never executed
- #####: 4092: sArrayPushTiny(array, (smallt *) io);
+ #####: 4162: sArrayPushTiny(array, (smallt *) io);
call 0 never executed
- -: 4093: }
- #####: 4094: break;
- -: 4095: case S_STRING:
- #####: 4096: loop(arrayCount) {
+ -: 4163: }
+ #####: 4164: break;
+ -: 4165: case S_STRING:
+ #####: 4166: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4097: s = (char *)(*data);
- #####: 4098: *data += strlen(s)+1;
- #####: 4099: so = allocSStringTiny(s);
+ #####: 4167: s = (char *)(*data);
+ #####: 4168: *data += strlen(s)+1;
+ #####: 4169: so = allocSStringTiny(s);
call 0 never executed
- #####: 4100: sArrayPushTiny(array, (smallt *) so);
+ #####: 4170: sArrayPushTiny(array, (smallt *) so);
call 0 never executed
- -: 4101: }
- #####: 4102: break;
- -: 4103: case S_ARRAY:
- #####: 4104: loop(arrayCount) {
+ -: 4171: }
+ #####: 4172: break;
+ -: 4173: case S_ARRAY:
+ #####: 4174: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4105: a = NULL;
- #####: 4106: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
+ #####: 4175: a = NULL;
+ #####: 4176: arrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 4107: sArrayPushTiny(array, (smallt *) a);
+ #####: 4177: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- -: 4108: }
- #####: 4109: break;
- -: 4110: case S_BYTES:
- #####: 4111: loop(arrayCount) {
+ -: 4178: }
+ #####: 4179: break;
+ -: 4180: case S_BYTES:
+ #####: 4181: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4112: B = allocSBytes();
+ #####: 4182: B = allocSBytes();
call 0 never executed
- #####: 4113: count = varintToUint((u8**)data);
+ #####: 4183: count = varintToUint((u8**)data);
call 0 never executed
- #####: 4114: sBytesPushBuffer(&B, data, count);
+ #####: 4184: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 4115: *data += count;
- #####: 4116: sArrayPushTiny(array, (smallt *) B);
+ #####: 4185: *data += count;
+ #####: 4186: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- -: 4117: }
- #####: 4118: break;
- -: 4119: case UNIFORM_DICT:
- #####: 4120: loop(arrayCount) {
+ -: 4187: }
+ #####: 4188: break;
+ -: 4189: case UNIFORM_DICT:
+ #####: 4190: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4121: d = NULL;
- #####: 4122: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
+ #####: 4191: d = NULL;
+ #####: 4192: uniformDictNetDeserialLevel2(&d, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 4123: sArrayPushTiny(array, (smallt *) d);
+ #####: 4193: sArrayPushTiny(array, (smallt *) d);
call 0 never executed
- -: 4124: }
- #####: 4125: break;
- -: 4126: case UNIFORM_ARRAY:
- #####: 4127: loop(arrayCount) {
+ -: 4194: }
+ #####: 4195: break;
+ -: 4196: case UNIFORM_ARRAY:
+ #####: 4197: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 4128: a = NULL;
- #####: 4129: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
+ #####: 4198: a = NULL;
+ #####: 4199: uniformArrayNetDeserialLevel2(&a, data, ctx, /*packed=*/true);
call 0 never executed
- #####: 4130: sArrayPushTiny(array, (smallt *) a);
+ #####: 4200: sArrayPushTiny(array, (smallt *) a);
call 0 never executed
- -: 4131: }
- #####: 4132: break;
- -: 4133: }
- -: 4134:}
- -: 4135:
+ -: 4201: }
+ #####: 4202: break;
+ -: 4203: }
+ -: 4204:}
+ -: 4205:
function deserialNetSerialLevel2 called 0 returned 0% blocks executed 0%
- #####: 4136:internal smallJsont* deserialNetSerialLevel2(smallJsont *self, smallBytest *data) {
- -: 4137:
- #####: 4138: if (!data) {
-branch 0 never executed
-branch 1 never executed
- #####: 4139: ret self;
- -: 4140: }
- -: 4141:
- #####: 4142: smallt *o = netDeserialLevel2(data->B);
-call 0 never executed
- -: 4143:
- #####: 4144: if (!o) {
-branch 0 never executed
-branch 1 never executed
- #####: 4145: ret self;
- -: 4146: }
- -: 4147:
- #####: 4148: freeG(self);
-call 0 never executed
- -: 4149:
- #####: 4150: setsoG(self, o);
-call 0 never executed
- -: 4151:
- #####: 4152: ret self;
- -: 4153:}
- -: 4154:
- -: 4155:// level 3
- -: 4156:
-function netDeserial called 76 returned 100% blocks executed 85%
- 76: 4157:internal smallt* netDeserial(sBytest *obj) {
- 76: 4158: smallt *r = NULL;
- 76: 4159: double *D = NULL;
- 76: 4160: char *s = NULL;
- 76: 4161: sBytest *B = NULL;
- -: 4162: uint32_t count;
- 76: 4163: char *data = NULL;
- 76: 4164: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
- -: 4165:
- 76: 4166: switch(obj->data & 0xF) {
+ #####: 4206:internal smallJsont* deserialNetSerialLevel2(smallJsont *self, smallBytest *data) {
+ -: 4207:
+ #####: 4208: if (!data) {
+branch 0 never executed
+branch 1 never executed
+ #####: 4209: ret self;
+ -: 4210: }
+ -: 4211:
+ #####: 4212: smallt *o = netDeserialLevel2(data->B);
+call 0 never executed
+ -: 4213:
+ #####: 4214: if (!o) {
+branch 0 never executed
+branch 1 never executed
+ #####: 4215: ret self;
+ -: 4216: }
+ -: 4217:
+ #####: 4218: freeG(self);
+call 0 never executed
+ -: 4219:
+ #####: 4220: setsoG(self, o);
+call 0 never executed
+ -: 4221:
+ #####: 4222: ret self;
+ -: 4223:}
+ -: 4224:
+ -: 4225:// level 3
+ -: 4226:// like level 2, elements of identical type in a row are packed
+ -: 4227:
+ -: 4228:/**
+ -: 4229: * deserializer top function
+ -: 4230: */
+function netDeserial called 77 returned 100% blocks executed 85%
+ 77: 4231:internal smallt* netDeserial(sBytest *obj) {
+ 77: 4232: smallt *r = NULL;
+ 77: 4233: double *D = NULL;
+ 77: 4234: char *s = NULL;
+ 77: 4235: sBytest *B = NULL;
+ -: 4236: uint32_t count;
+ 77: 4237: char *data = NULL;
+ 77: 4238: contextt ctx = {.nibble=lowNbl, .nblAddr=NULL, .boolShift = 0, .boolAddr=NULL};
+ -: 4239:
+ 77: 4240: switch(obj->data & 0xF) {
branch 0 taken 1%
branch 1 taken 1%
-branch 2 taken 32%
+branch 2 taken 31%
branch 3 taken 1%
branch 4 taken 1%
branch 5 taken 1%
-branch 6 taken 32%
+branch 6 taken 31%
branch 7 taken 0%
branch 8 taken 16%
-branch 9 taken 14%
+branch 9 taken 16%
branch 10 taken 0%
- -: 4167: case S_UNDEFINED:
- 1: 4168: r = (smallt *) allocSUndefined();
-call 0 returned 100%
- 1: 4169: break;
- -: 4170: case S_BOOL:
- 1: 4171: r = (smallt *) allocSBool(obj->data & 0x10);
-call 0 returned 100%
- 1: 4172: break;
- -: 4173: case S_DICT:
- 24: 4174: data = (char *)&(obj->data);
- -: 4175: //debug - ctx.dbuf = (u8*) data;
- 24: 4176: dictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 returned 100%
- 24: 4177: break;
- -: 4178: case S_DOUBLE:
- 1: 4179: data = &(obj->data)+1;
- 1: 4180: D = (double *)data;
- 1: 4181: r = (smallt *) allocSDouble(*D);
-call 0 returned 100%
- 1: 4182: break;
- -: 4183: case S_INT:
- 1: 4184: data = &(obj->data);
- 1: 4185: i64 v = netTypeVarintToUint((u8**)&data);
-call 0 returned 100%
- 1: 4186: v = (v >> 1) ^ ((v << 63) >> 63);
- 1: 4187: r = (smallt *) allocSInt(v);
-call 0 returned 100%
- 1: 4188: break;
- -: 4189: case S_STRING:
- 1: 4190: s = (char *)&(obj->data)+1;
- 1: 4191: r = (smallt *) allocSStringTiny(s);
-call 0 returned 100%
- 1: 4192: break;
- -: 4193: case S_ARRAY:
- 24: 4194: data = (char *)&(obj->data);
- -: 4195: //debug - ctx.dbuf = (u8*) data;
- 24: 4196: arrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 returned 100%
- 24: 4197: break;
- -: 4198: case S_BYTES:
- #####: 4199: B = allocSBytes();
-call 0 never executed
- #####: 4200: data = &(obj->data);
- #####: 4201: count = netTypeVarintToUint((u8**)&data);
-call 0 never executed
- #####: 4202: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 4203: r = (smallt *)B;
- #####: 4204: break;
- -: 4205: case UNIFORM_DICT:
- 12: 4206: data = (char *)&(obj->data);
- -: 4207: //debug - ctx.dbuf = (u8*) data;
- 12: 4208: uniformDictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 returned 100%
- 12: 4209: break;
- -: 4210: case UNIFORM_ARRAY:
- 11: 4211: data = (char *)&(obj->data);
- -: 4212: //debug - ctx.dbuf = (u8*) data;
- 11: 4213: uniformArrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
-call 0 returned 100%
- 11: 4214: break;
- -: 4215: }
- -: 4216:
- 76: 4217: ret r;
- -: 4218:}
- -: 4219:
- -: 4220:/**
- -: 4221: * deserialize dictionary from data
- -: 4222: *
- -: 4223: * a new dictionary is allocated
- -: 4224: *
- -: 4225: * \param
- -: 4226: * dict dictionary holding the elements
- -: 4227: * data serialized dictionary
- -: 4228: */
+ -: 4241: case S_UNDEFINED:
+ 1: 4242: r = (smallt *) allocSUndefined();
+call 0 returned 100%
+ 1: 4243: break;
+ -: 4244: case S_BOOL:
+ 1: 4245: r = (smallt *) allocSBool(obj->data & 0x10);
+call 0 returned 100%
+ 1: 4246: break;
+ -: 4247: case S_DICT:
+ 24: 4248: data = (char *)&(obj->data);
+ -: 4249: //debug - ctx.dbuf = (u8*) data;
+ 24: 4250: dictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 returned 100%
+ 24: 4251: break;
+ -: 4252: case S_DOUBLE:
+ 1: 4253: data = &(obj->data)+1;
+ 1: 4254: D = (double *)data;
+ 1: 4255: r = (smallt *) allocSDouble(*D);
+call 0 returned 100%
+ 1: 4256: break;
+ -: 4257: case S_INT:
+ 1: 4258: data = &(obj->data);
+ 1: 4259: i64 v = netTypeVarintToUint((u8**)&data);
+call 0 returned 100%
+ 1: 4260: v = (v >> 1) ^ ((v << 63) >> 63);
+ 1: 4261: r = (smallt *) allocSInt(v);
+call 0 returned 100%
+ 1: 4262: break;
+ -: 4263: case S_STRING:
+ 1: 4264: s = (char *)&(obj->data)+1;
+ 1: 4265: r = (smallt *) allocSStringTiny(s);
+call 0 returned 100%
+ 1: 4266: break;
+ -: 4267: case S_ARRAY:
+ 24: 4268: data = (char *)&(obj->data);
+ -: 4269: //debug - ctx.dbuf = (u8*) data;
+ 24: 4270: arrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 returned 100%
+ 24: 4271: break;
+ -: 4272: case S_BYTES:
+ #####: 4273: B = allocSBytes();
+call 0 never executed
+ #####: 4274: data = &(obj->data);
+ #####: 4275: count = netTypeVarintToUint((u8**)&data);
+call 0 never executed
+ #####: 4276: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 4277: r = (smallt *)B;
+ #####: 4278: break;
+ -: 4279: case UNIFORM_DICT:
+ 12: 4280: data = (char *)&(obj->data);
+ -: 4281: //debug - ctx.dbuf = (u8*) data;
+ 12: 4282: uniformDictNetDeserial((sDictt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 returned 100%
+ 12: 4283: break;
+ -: 4284: case UNIFORM_ARRAY:
+ 12: 4285: data = (char *)&(obj->data);
+ -: 4286: //debug - ctx.dbuf = (u8*) data;
+ 12: 4287: uniformArrayNetDeserial((sArrayt **)&r, (u8**)&data, &ctx, /*packed=*/false);
+call 0 returned 100%
+ 12: 4288: break;
+ -: 4289: }
+ -: 4290:
+ 77: 4291: ret r;
+ -: 4292:}
+ -: 4293:
+ -: 4294:/**
+ -: 4295: * deserialize dictionary from data
+ -: 4296: *
+ -: 4297: * a new dictionary is allocated
+ -: 4298: *
+ -: 4299: * \param
+ -: 4300: * dict dictionary holding the elements
+ -: 4301: * data serialized dictionary
+ -: 4302: */
function dictNetDeserial called 54 returned 100% blocks executed 78%
- 54: 4229:internal void dictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
- 54: 4230: sUndefinedt *u = NULL;
- 54: 4231: sBoolt *bo = NULL;
- 54: 4232: double *D = NULL;
- 54: 4233: sDoublet *Do = NULL;
- 54: 4234: sDictt *d = NULL;
- 54: 4235: sIntt *io = NULL;
- 54: 4236: char *s = NULL;
- 54: 4237: sStringt *so = NULL;
- 54: 4238: sArrayt *a = NULL;
- 54: 4239: sBytest *B = NULL;
- -: 4240: uint32_t count;
- -: 4241: uint32_t dictCount;
- -: 4242:
- 54: 4243: if (packed) {
+ 54: 4303:internal void dictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
+ 54: 4304: sUndefinedt *u = NULL;
+ 54: 4305: sBoolt *bo = NULL;
+ 54: 4306: double *D = NULL;
+ 54: 4307: sDoublet *Do = NULL;
+ 54: 4308: sDictt *d = NULL;
+ 54: 4309: sIntt *io = NULL;
+ 54: 4310: char *s = NULL;
+ 54: 4311: sStringt *so = NULL;
+ 54: 4312: sArrayt *a = NULL;
+ 54: 4313: sBytest *B = NULL;
+ -: 4314: uint32_t count;
+ -: 4315: uint32_t dictCount;
+ -: 4316:
+ 54: 4317: if (packed) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 27: 4244: dictCount = varintToUint(data);
+ 27: 4318: dictCount = varintToUint(data);
call 0 returned 100%
- -: 4245: }
- -: 4246: else {
- 27: 4247: if (ctx->nibble == lowNbl) {
+ -: 4319: }
+ -: 4320: else {
+ 27: 4321: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 25: 4248: dictCount = netTypeVarintToUint(data);
-call 0 returned 100%
- -: 4249: }
- -: 4250: else {
- -: 4251: // high nibble
- -: 4252: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
- -: 4253: #define readTypeInHighNbl\
- -: 4254: ctx->nibble = lowNbl;\
- -: 4255: if (ctx->nblAddr == *data)\
- -: 4256: /* data points to the type, next byte is count */\
- -: 4257: (*data)++
- 2: 4258: readTypeInHighNbl;
+ 25: 4322: dictCount = netTypeVarintToUint(data);
+call 0 returned 100%
+ -: 4323: }
+ -: 4324: else {
+ -: 4325: // high nibble
+ -: 4326: // type = *(ctx->dbuf + ctx->nblOffset) >> 4;
+ -: 4327: #define readTypeInHighNbl\
+ -: 4328: ctx->nibble = lowNbl;\
+ -: 4329: if (ctx->nblAddr == *data)\
+ -: 4330: /* data points to the type, next byte is count */\
+ -: 4331: (*data)++
+ 2: 4332: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 2: 4259: dictCount = varintToUint(data);
+ 2: 4333: dictCount = varintToUint(data);
call 0 returned 100%
- -: 4260: }
- -: 4261: }
- -: 4262:
- 54: 4263: if (!dictCount) {
+ -: 4334: }
+ -: 4335: }
+ -: 4336:
+ 54: 4337: if (!dictCount) {
branch 0 taken 19% (fallthrough)
branch 1 taken 81%
- 10: 4264: *dict = allocSDict();
-call 0 returned 100%
- 10: 4265: ret;
- -: 4266: }
- -: 4267:
- 44: 4268: bool inPack = false;
- -: 4269: u8 packedType;
- -: 4270: size_t packCount;
- 200: 4271: loop(dictCount) {
+ 10: 4338: *dict = allocSDict();
+call 0 returned 100%
+ 10: 4339: ret;
+ -: 4340: }
+ -: 4341:
+ 44: 4342: bool inPack = false;
+ -: 4343: u8 packedType;
+ -: 4344: size_t packCount;
+ 200: 4345: loop(dictCount) {
branch 0 taken 78%
branch 1 taken 22% (fallthrough)
- 156: 4272: char *key = (char*)*data;
- 156: 4273: *data += strlen(key)+1;
- -: 4274: char type;
- 156: 4275: if (inPack) {
+ 156: 4346: char *key = (char*)*data;
+ 156: 4347: *data += strlen(key)+1;
+ -: 4348: char type;
+ 156: 4349: if (inPack) {
branch 0 taken 24% (fallthrough)
branch 1 taken 76%
- 38: 4276: type = packedType;
- -: 4277: }
- -: 4278: else {
- 118: 4279: if (ctx->nibble == lowNbl) {
+ 38: 4350: type = packedType;
+ -: 4351: }
+ -: 4352: else {
+ 118: 4353: if (ctx->nibble == lowNbl) {
branch 0 taken 67% (fallthrough)
branch 1 taken 33%
- 79: 4280: type = (**data) & 0xF;
- -: 4281: }
- -: 4282: else {
- -: 4283: // high nibble
- 39: 4284: type = (*ctx->nblAddr) >> 4;
- -: 4285: }
- -: 4286: }
- -: 4287:
- 156: 4288: switch(type) {
+ 79: 4354: type = (**data) & 0xF;
+ -: 4355: }
+ -: 4356: else {
+ -: 4357: // high nibble
+ 39: 4358: type = (*ctx->nblAddr) >> 4;
+ -: 4359: }
+ -: 4360: }
+ -: 4361:
+ 156: 4362: switch(type) {
branch 0 taken 17%
branch 1 taken 20%
branch 2 taken 1%
@@ -6341,741 +6415,741 @@ branch 13 taken 0%
branch 14 taken 3%
branch 15 taken 3%
branch 16 taken 0%
- -: 4289: case S_UNDEFINED:
- 26: 4290: if (ctx->nibble == lowNbl) {
+ -: 4363: case S_UNDEFINED:
+ 26: 4364: if (ctx->nibble == lowNbl) {
branch 0 taken 92% (fallthrough)
branch 1 taken 8%
- -: 4291: #define readTypeOnly\
- -: 4292: ctx->nibble = highNbl;\
- -: 4293: ctx->nblAddr = *data;\
- -: 4294: (*data)++
- 24: 4295: readTypeOnly;
- -: 4296: }
- -: 4297: else {
- -: 4298: // high nibble
- 2: 4299: readTypeInHighNbl;
+ -: 4365: #define readTypeOnly\
+ -: 4366: ctx->nibble = highNbl;\
+ -: 4367: ctx->nblAddr = *data;\
+ -: 4368: (*data)++
+ 24: 4369: readTypeOnly;
+ -: 4370: }
+ -: 4371: else {
+ -: 4372: // high nibble
+ 2: 4373: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4300: }
- 26: 4301: u = allocSUndefined();
+ -: 4374: }
+ 26: 4375: u = allocSUndefined();
call 0 returned 100%
- 26: 4302: sDictPushTiny(dict, key, (smallt *) u);
+ 26: 4376: sDictPushTiny(dict, key, (smallt *) u);
call 0 returned 100%
- 26: 4303: break;
- -: 4304: case S_BOOL:
- 31: 4305: if (!ctx->boolAddr) {
+ 26: 4377: break;
+ -: 4378: case S_BOOL:
+ 31: 4379: if (!ctx->boolAddr) {
branch 0 taken 16% (fallthrough)
branch 1 taken 84%
- -: 4306: // new packed bools
- 5: 4307: if (ctx->nibble == lowNbl) {
+ -: 4380: // new packed bools
+ 5: 4381: if (ctx->nibble == lowNbl) {
branch 0 taken 60% (fallthrough)
branch 1 taken 40%
- -: 4308: #define read4bPackedBool\
- -: 4309: ctx->boolShift = 5;\
- -: 4310: ctx->boolAddr = *data;\
- -: 4311: (*data)++
- 3: 4312: read4bPackedBool;
- 3: 4313: bo = allocSBool((*ctx->boolAddr) & 0x10);
-call 0 returned 100%
- -: 4314: }
- -: 4315: else {
- -: 4316: // high nibble
- 2: 4317: readTypeInHighNbl;
+ -: 4382: #define read4bPackedBool\
+ -: 4383: ctx->boolShift = 5;\
+ -: 4384: ctx->boolAddr = *data;\
+ -: 4385: (*data)++
+ 3: 4386: read4bPackedBool;
+ 3: 4387: bo = allocSBool((*ctx->boolAddr) & 0x10);
+call 0 returned 100%
+ -: 4388: }
+ -: 4389: else {
+ -: 4390: // high nibble
+ 2: 4391: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4318: #define read8bPackedBool\
- -: 4319: ctx->boolShift = 1;\
- -: 4320: ctx->boolAddr = *data;\
- -: 4321: (*data)++
- 2: 4322: read8bPackedBool;
- 2: 4323: bo = allocSBool((*ctx->boolAddr) & 0x1);
-call 0 returned 100%
- -: 4324: }
- -: 4325: }
- -: 4326: else {
- -: 4327: // there was a bool before this one, read bits in nibbles
- 26: 4328: if (ctx->nibble == lowNbl) {
+ -: 4392: #define read8bPackedBool\
+ -: 4393: ctx->boolShift = 1;\
+ -: 4394: ctx->boolAddr = *data;\
+ -: 4395: (*data)++
+ 2: 4396: read8bPackedBool;
+ 2: 4397: bo = allocSBool((*ctx->boolAddr) & 0x1);
+call 0 returned 100%
+ -: 4398: }
+ -: 4399: }
+ -: 4400: else {
+ -: 4401: // there was a bool before this one, read bits in nibbles
+ 26: 4402: if (ctx->nibble == lowNbl) {
branch 0 taken 58% (fallthrough)
branch 1 taken 42%
- 15: 4329: if (ctx->boolShift == 8) {
+ 15: 4403: if (ctx->boolShift == 8) {
branch 0 taken 7% (fallthrough)
branch 1 taken 93%
- 1: 4330: read4bPackedBool;
- 1: 4331: bo = allocSBool((*ctx->boolAddr) & 0x10);
-call 0 returned 100%
- -: 4332: }
- -: 4333: else {
- 14: 4334: readTypeOnly;
- 14: 4335: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
-call 0 returned 100%
- -: 4336: }
- -: 4337: }
- -: 4338: else {
- -: 4339: // high nibble
- 11: 4340: readTypeInHighNbl;
+ 1: 4404: read4bPackedBool;
+ 1: 4405: bo = allocSBool((*ctx->boolAddr) & 0x10);
+call 0 returned 100%
+ -: 4406: }
+ -: 4407: else {
+ 14: 4408: readTypeOnly;
+ 14: 4409: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+call 0 returned 100%
+ -: 4410: }
+ -: 4411: }
+ -: 4412: else {
+ -: 4413: // high nibble
+ 11: 4414: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 11: 4341: if (ctx->boolShift == 8) {
+ 11: 4415: if (ctx->boolShift == 8) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- 2: 4342: read8bPackedBool;
- 2: 4343: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ 2: 4416: read8bPackedBool;
+ 2: 4417: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 returned 100%
- -: 4344: }
- -: 4345: else {
- -: 4346: // high nibble
- 9: 4347: readTypeInHighNbl;
+ -: 4418: }
+ -: 4419: else {
+ -: 4420: // high nibble
+ 9: 4421: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 9: 4348: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ 9: 4422: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 returned 100%
- -: 4349: }
- -: 4350: }
- -: 4351: }
- 31: 4352: sDictPushTiny(dict, key, (smallt *) bo);
+ -: 4423: }
+ -: 4424: }
+ -: 4425: }
+ 31: 4426: sDictPushTiny(dict, key, (smallt *) bo);
call 0 returned 100%
- 31: 4353: break;
- -: 4354: case S_DICT:
- 1: 4355: d = NULL;
- 1: 4356: dictNetDeserial(&d, data, ctx, /*packed=*/false);
+ 31: 4427: break;
+ -: 4428: case S_DICT:
+ 1: 4429: d = NULL;
+ 1: 4430: dictNetDeserial(&d, data, ctx, /*packed=*/false);
call 0 returned 100%
- 1: 4357: sDictPushTiny(dict, key, (smallt *) d);
+ 1: 4431: sDictPushTiny(dict, key, (smallt *) d);
call 0 returned 100%
- 1: 4358: break;
- -: 4359: case S_DOUBLE:
- 2: 4360: if (ctx->nibble == lowNbl) {
+ 1: 4432: break;
+ -: 4433: case S_DOUBLE:
+ 2: 4434: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4361: readTypeOnly;
- -: 4362: }
- -: 4363: else {
- -: 4364: // high nibble
- 1: 4365: readTypeInHighNbl;
+ 1: 4435: readTypeOnly;
+ -: 4436: }
+ -: 4437: else {
+ -: 4438: // high nibble
+ 1: 4439: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4366: }
- 2: 4367: D = (double *)(*data);
- 2: 4368: *data += sizeof(double);
- 2: 4369: Do = allocSDouble(*D);
+ -: 4440: }
+ 2: 4441: D = (double *)(*data);
+ 2: 4442: *data += sizeof(double);
+ 2: 4443: Do = allocSDouble(*D);
call 0 returned 100%
- 2: 4370: sDictPushTiny(dict, key, (smallt *) Do);
+ 2: 4444: sDictPushTiny(dict, key, (smallt *) Do);
call 0 returned 100%
- 2: 4371: break;
- -: 4372: case S_INT: {
- -: 4373: i64 v;
- 24: 4374: if (ctx->nibble == lowNbl) {
+ 2: 4445: break;
+ -: 4446: case S_INT: {
+ -: 4447: i64 v;
+ 24: 4448: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 12: 4375: v = netTypeVarintToUint((u8**)data);
+ 12: 4449: v = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4376: }
- -: 4377: else {
- -: 4378: // high nibble
- 12: 4379: readTypeInHighNbl;
+ -: 4450: }
+ -: 4451: else {
+ -: 4452: // high nibble
+ 12: 4453: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 12: 4380: v = varintToUint(data);
+ 12: 4454: v = varintToUint(data);
call 0 returned 100%
- -: 4381: }
- 24: 4382: v = (v >> 1) ^ ((v << 63) >> 63);
- 24: 4383: io = allocSInt(v);
+ -: 4455: }
+ 24: 4456: v = (v >> 1) ^ ((v << 63) >> 63);
+ 24: 4457: io = allocSInt(v);
call 0 returned 100%
- 24: 4384: sDictPushTiny(dict, key, (smallt *) io);
+ 24: 4458: sDictPushTiny(dict, key, (smallt *) io);
call 0 returned 100%
- -: 4385: }
- 24: 4386: break;
- -: 4387: case S_STRING:
- 14: 4388: if (ctx->nibble == lowNbl) {
+ -: 4459: }
+ 24: 4460: break;
+ -: 4461: case S_STRING:
+ 14: 4462: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 13: 4389: readTypeOnly;
- -: 4390: }
- -: 4391: else {
- -: 4392: // high nibble
- 1: 4393: readTypeInHighNbl;
+ 13: 4463: readTypeOnly;
+ -: 4464: }
+ -: 4465: else {
+ -: 4466: // high nibble
+ 1: 4467: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4394: }
- 14: 4395: s = (char *)(*data);
- 14: 4396: *data += strlen(s)+1;
- 14: 4397: so = allocSStringTiny(s);
+ -: 4468: }
+ 14: 4469: s = (char *)(*data);
+ 14: 4470: *data += strlen(s)+1;
+ 14: 4471: so = allocSStringTiny(s);
call 0 returned 100%
- 14: 4398: sDictPushTiny(dict, key, (smallt *) so);
+ 14: 4472: sDictPushTiny(dict, key, (smallt *) so);
call 0 returned 100%
- 14: 4399: break;
- -: 4400: case S_ARRAY:
- 1: 4401: a = NULL;
- 1: 4402: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
+ 14: 4473: break;
+ -: 4474: case S_ARRAY:
+ 1: 4475: a = NULL;
+ 1: 4476: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
call 0 returned 100%
- 1: 4403: sDictPushTiny(dict, key, (smallt *) a);
+ 1: 4477: sDictPushTiny(dict, key, (smallt *) a);
call 0 returned 100%
- 1: 4404: break;
- -: 4405: case S_BYTES:
- #####: 4406: B = allocSBytes();
+ 1: 4478: break;
+ -: 4479: case S_BYTES:
+ #####: 4480: B = allocSBytes();
call 0 never executed
- #####: 4407: if (ctx->nibble == lowNbl) {
+ #####: 4481: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 4408: count = netTypeVarintToUint((u8**)data);
+ #####: 4482: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 4409: }
- -: 4410: else {
- -: 4411: // high nibble
- #####: 4412: readTypeInHighNbl;
+ -: 4483: }
+ -: 4484: else {
+ -: 4485: // high nibble
+ #####: 4486: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 4413: count = varintToUint((u8**)data);
+ #####: 4487: count = varintToUint((u8**)data);
call 0 never executed
- -: 4414: }
- #####: 4415: sBytesPushBuffer(&B, data, count);
+ -: 4488: }
+ #####: 4489: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 4416: *data += count;
- #####: 4417: sDictPushTiny(dict, key, (smallt *) B);
+ #####: 4490: *data += count;
+ #####: 4491: sDictPushTiny(dict, key, (smallt *) B);
call 0 never executed
- #####: 4418: break;
- -: 4419: case PK_DICT:
- 15: 4420: if (!inPack) {
+ #####: 4492: break;
+ -: 4493: case PK_DICT:
+ 15: 4494: if (!inPack) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- 3: 4421: inPack = true;
- 3: 4422: if (ctx->nibble == lowNbl) {
+ 3: 4495: inPack = true;
+ 3: 4496: if (ctx->nibble == lowNbl) {
branch 0 taken 67% (fallthrough)
branch 1 taken 33%
- 2: 4423: packCount = netTypeVarintToUint((u8**)data);
+ 2: 4497: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4424: }
- -: 4425: else {
- -: 4426: // high nibble
- 1: 4427: readTypeInHighNbl;
+ -: 4498: }
+ -: 4499: else {
+ -: 4500: // high nibble
+ 1: 4501: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4428: packCount = varintToUint((u8**)data);
+ 1: 4502: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4429: }
- 3: 4430: packedType = PK_DICT;
- -: 4431: }
- -: 4432:
- 15: 4433: d = NULL;
- 15: 4434: dictNetDeserial(&d, data, ctx, /*packed=*/true);
+ -: 4503: }
+ 3: 4504: packedType = PK_DICT;
+ -: 4505: }
+ -: 4506:
+ 15: 4507: d = NULL;
+ 15: 4508: dictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 15: 4435: sDictPushTiny(dict, key, (smallt *) d);
+ 15: 4509: sDictPushTiny(dict, key, (smallt *) d);
call 0 returned 100%
- -: 4436: // stop unpacking when packCount == 0
- 15: 4437: packCount--;
- 15: 4438: if (!packCount) inPack = false;
+ -: 4510: // stop unpacking when packCount == 0
+ 15: 4511: packCount--;
+ 15: 4512: if (!packCount) inPack = false;
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- 15: 4439: break;
- -: 4440: case PK_DOUBLE:
- 10: 4441: if (!inPack) {
+ 15: 4513: break;
+ -: 4514: case PK_DOUBLE:
+ 10: 4515: if (!inPack) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- 2: 4442: inPack = true;
- 2: 4443: if (ctx->nibble == lowNbl) {
+ 2: 4516: inPack = true;
+ 2: 4517: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4444: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4518: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4445: }
- -: 4446: else {
- -: 4447: // high nibble
- 1: 4448: readTypeInHighNbl;
+ -: 4519: }
+ -: 4520: else {
+ -: 4521: // high nibble
+ 1: 4522: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4449: packCount = varintToUint((u8**)data);
+ 1: 4523: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4450: }
- 2: 4451: packedType = PK_DOUBLE;
- -: 4452: }
- -: 4453:
- 10: 4454: D = (double *)(*data);
- 10: 4455: *data += sizeof(double);
- 10: 4456: Do = allocSDouble(*D);
-call 0 returned 100%
- 10: 4457: sDictPushTiny(dict, key, (smallt *) Do);
-call 0 returned 100%
- -: 4458: // stop unpacking when packCount == 0
- 10: 4459: packCount--;
- 10: 4460: if (!packCount) inPack = false;
+ -: 4524: }
+ 2: 4525: packedType = PK_DOUBLE;
+ -: 4526: }
+ -: 4527:
+ 10: 4528: D = (double *)(*data);
+ 10: 4529: *data += sizeof(double);
+ 10: 4530: Do = allocSDouble(*D);
+call 0 returned 100%
+ 10: 4531: sDictPushTiny(dict, key, (smallt *) Do);
+call 0 returned 100%
+ -: 4532: // stop unpacking when packCount == 0
+ 10: 4533: packCount--;
+ 10: 4534: if (!packCount) inPack = false;
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- 10: 4461: break;
- -: 4462: case PK_INT:
- 8: 4463: if (!inPack) {
+ 10: 4535: break;
+ -: 4536: case PK_INT:
+ 8: 4537: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4464: inPack = true;
- 2: 4465: if (ctx->nibble == lowNbl) {
+ 2: 4538: inPack = true;
+ 2: 4539: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4466: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4540: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4467: }
- -: 4468: else {
- -: 4469: // high nibble
- 1: 4470: readTypeInHighNbl;
+ -: 4541: }
+ -: 4542: else {
+ -: 4543: // high nibble
+ 1: 4544: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4471: packCount = varintToUint((u8**)data);
+ 1: 4545: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4472: }
- 2: 4473: packedType = PK_INT;
- -: 4474: }
- -: 4475:
- 8: 4476: i64 v = varintToUint(data);
+ -: 4546: }
+ 2: 4547: packedType = PK_INT;
+ -: 4548: }
+ -: 4549:
+ 8: 4550: i64 v = varintToUint(data);
call 0 returned 100%
- 8: 4477: v = (v >> 1) ^ ((v << 63) >> 63);
- 8: 4478: io = allocSInt(v);
+ 8: 4551: v = (v >> 1) ^ ((v << 63) >> 63);
+ 8: 4552: io = allocSInt(v);
call 0 returned 100%
- 8: 4479: sDictPushTiny(dict, key, (smallt *) io);
+ 8: 4553: sDictPushTiny(dict, key, (smallt *) io);
call 0 returned 100%
- -: 4480: // stop unpacking when packCount == 0
- 8: 4481: packCount--;
- 8: 4482: if (!packCount) inPack = false;
+ -: 4554: // stop unpacking when packCount == 0
+ 8: 4555: packCount--;
+ 8: 4556: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4483: break;
- -: 4484: case PK_STRING:
- 8: 4485: if (!inPack) {
+ 8: 4557: break;
+ -: 4558: case PK_STRING:
+ 8: 4559: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4486: inPack = true;
- 2: 4487: if (ctx->nibble == lowNbl) {
+ 2: 4560: inPack = true;
+ 2: 4561: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4488: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4562: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4489: }
- -: 4490: else {
- -: 4491: // high nibble
- 1: 4492: readTypeInHighNbl;
+ -: 4563: }
+ -: 4564: else {
+ -: 4565: // high nibble
+ 1: 4566: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4493: packCount = varintToUint((u8**)data);
+ 1: 4567: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4494: }
- 2: 4495: packedType = PK_STRING;
- -: 4496: }
- -: 4497:
- 8: 4498: s = (char *)(*data);
- 8: 4499: *data += strlen(s)+1;
- 8: 4500: so = allocSStringTiny(s);
+ -: 4568: }
+ 2: 4569: packedType = PK_STRING;
+ -: 4570: }
+ -: 4571:
+ 8: 4572: s = (char *)(*data);
+ 8: 4573: *data += strlen(s)+1;
+ 8: 4574: so = allocSStringTiny(s);
call 0 returned 100%
- 8: 4501: sDictPushTiny(dict, key, (smallt *) so);
+ 8: 4575: sDictPushTiny(dict, key, (smallt *) so);
call 0 returned 100%
- -: 4502: // stop unpacking when packCount == 0
- 8: 4503: packCount--;
- 8: 4504: if (!packCount) inPack = false;
+ -: 4576: // stop unpacking when packCount == 0
+ 8: 4577: packCount--;
+ 8: 4578: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4505: break;
- -: 4506: case PK_ARRAY:
- 8: 4507: if (!inPack) {
+ 8: 4579: break;
+ -: 4580: case PK_ARRAY:
+ 8: 4581: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4508: inPack = true;
- 2: 4509: if (ctx->nibble == lowNbl) {
+ 2: 4582: inPack = true;
+ 2: 4583: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4510: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4584: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4511: }
- -: 4512: else {
- -: 4513: // high nibble
- 1: 4514: readTypeInHighNbl;
+ -: 4585: }
+ -: 4586: else {
+ -: 4587: // high nibble
+ 1: 4588: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4515: packCount = varintToUint((u8**)data);
+ 1: 4589: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4516: }
- 2: 4517: packedType = PK_ARRAY;
- -: 4518: }
- -: 4519:
- 8: 4520: a = NULL;
- 8: 4521: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
+ -: 4590: }
+ 2: 4591: packedType = PK_ARRAY;
+ -: 4592: }
+ -: 4593:
+ 8: 4594: a = NULL;
+ 8: 4595: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
call 0 returned 100%
- 8: 4522: sDictPushTiny(dict, key, (smallt *) a);
+ 8: 4596: sDictPushTiny(dict, key, (smallt *) a);
call 0 returned 100%
- -: 4523: // stop unpacking when packCount == 0
- 8: 4524: packCount--;
- 8: 4525: if (!packCount) inPack = false;
+ -: 4597: // stop unpacking when packCount == 0
+ 8: 4598: packCount--;
+ 8: 4599: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4526: break;
- -: 4527: case PK_BYTES:
- #####: 4528: if (!inPack) {
-branch 0 never executed
-branch 1 never executed
- #####: 4529: inPack = true;
- #####: 4530: if (ctx->nibble == lowNbl) {
-branch 0 never executed
-branch 1 never executed
- #####: 4531: packCount = netTypeVarintToUint((u8**)data);
-call 0 never executed
- -: 4532: }
- -: 4533: else {
- -: 4534: // high nibble
- #####: 4535: readTypeInHighNbl;
-branch 0 never executed
-branch 1 never executed
- #####: 4536: packCount = varintToUint((u8**)data);
-call 0 never executed
- -: 4537: }
- #####: 4538: packedType = PK_BYTES;
- -: 4539: }
- -: 4540:
- #####: 4541: B = allocSBytes();
-call 0 never executed
- #####: 4542: count = varintToUint((u8**)data);
-call 0 never executed
- #####: 4543: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 4544: *data += count;
- #####: 4545: sDictPushTiny(dict, key, (smallt *) B);
-call 0 never executed
- -: 4546: // stop unpacking when packCount == 0
- #####: 4547: packCount--;
- #####: 4548: if (!packCount) inPack = false;
-branch 0 never executed
-branch 1 never executed
- #####: 4549: break;
- -: 4550: case UNIFORM_DICT:
- 4: 4551: d = NULL;
- 4: 4552: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
-call 0 returned 100%
- 4: 4553: sDictPushTiny(dict, key, (smallt *) d);
-call 0 returned 100%
- 4: 4554: break;
- -: 4555: case UNIFORM_ARRAY:
- 4: 4556: a = NULL;
- 4: 4557: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
-call 0 returned 100%
- 4: 4558: sDictPushTiny(dict, key, (smallt *) a);
-call 0 returned 100%
- 4: 4559: break;
- -: 4560: }
- -: 4561: }
- -: 4562:}
- -: 4563:
- -: 4564:/**
- -: 4565: * deserialize dictionary from data
- -: 4566: *
- -: 4567: * a new dictionary is allocated
- -: 4568: *
- -: 4569: * \param
- -: 4570: * dict dictionary holding the elements
- -: 4571: * data serialized dictionary
- -: 4572: */
-function uniformDictNetDeserial called 22 returned 100% blocks executed 87%
- 22: 4573:internal void uniformDictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
- 22: 4574: sUndefinedt *u = NULL;
- 22: 4575: sBoolt *bo = NULL;
- 22: 4576: double *D = NULL;
- 22: 4577: sDoublet *Do = NULL;
- 22: 4578: sDictt *d = NULL;
- 22: 4579: sIntt *io = NULL;
- 22: 4580: char *s = NULL;
- 22: 4581: sStringt *so = NULL;
- 22: 4582: sArrayt *a = NULL;
- 22: 4583: sBytest *B = NULL;
- -: 4584: uint32_t count;
- -: 4585: uint32_t dictCount;
- -: 4586: u8 type;
- -: 4587:
- 22: 4588: if (packed) {
-branch 0 taken 18% (fallthrough)
-branch 1 taken 82%
- 4: 4589: type = (**data) & 0xF;
- 4: 4590: dictCount = netTypeVarintToUint(data);
+ 8: 4600: break;
+ -: 4601: case PK_BYTES:
+ #####: 4602: if (!inPack) {
+branch 0 never executed
+branch 1 never executed
+ #####: 4603: inPack = true;
+ #####: 4604: if (ctx->nibble == lowNbl) {
+branch 0 never executed
+branch 1 never executed
+ #####: 4605: packCount = netTypeVarintToUint((u8**)data);
+call 0 never executed
+ -: 4606: }
+ -: 4607: else {
+ -: 4608: // high nibble
+ #####: 4609: readTypeInHighNbl;
+branch 0 never executed
+branch 1 never executed
+ #####: 4610: packCount = varintToUint((u8**)data);
+call 0 never executed
+ -: 4611: }
+ #####: 4612: packedType = PK_BYTES;
+ -: 4613: }
+ -: 4614:
+ #####: 4615: B = allocSBytes();
+call 0 never executed
+ #####: 4616: count = varintToUint((u8**)data);
+call 0 never executed
+ #####: 4617: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 4618: *data += count;
+ #####: 4619: sDictPushTiny(dict, key, (smallt *) B);
+call 0 never executed
+ -: 4620: // stop unpacking when packCount == 0
+ #####: 4621: packCount--;
+ #####: 4622: if (!packCount) inPack = false;
+branch 0 never executed
+branch 1 never executed
+ #####: 4623: break;
+ -: 4624: case UNIFORM_DICT:
+ 4: 4625: d = NULL;
+ 4: 4626: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
+call 0 returned 100%
+ 4: 4627: sDictPushTiny(dict, key, (smallt *) d);
+call 0 returned 100%
+ 4: 4628: break;
+ -: 4629: case UNIFORM_ARRAY:
+ 4: 4630: a = NULL;
+ 4: 4631: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
+call 0 returned 100%
+ 4: 4632: sDictPushTiny(dict, key, (smallt *) a);
+call 0 returned 100%
+ 4: 4633: break;
+ -: 4634: }
+ -: 4635: }
+ -: 4636:}
+ -: 4637:
+ -: 4638:/**
+ -: 4639: * deserialize dictionary from data
+ -: 4640: *
+ -: 4641: * a new dictionary is allocated
+ -: 4642: *
+ -: 4643: * \param
+ -: 4644: * dict dictionary holding the elements
+ -: 4645: * data serialized dictionary
+ -: 4646: */
+function uniformDictNetDeserial called 25 returned 100% blocks executed 87%
+ 25: 4647:internal void uniformDictNetDeserial(sDictt **dict, u8 **data, contextt *ctx, bool packed) {
+ 25: 4648: sUndefinedt *u = NULL;
+ 25: 4649: sBoolt *bo = NULL;
+ 25: 4650: double *D = NULL;
+ 25: 4651: sDoublet *Do = NULL;
+ 25: 4652: sDictt *d = NULL;
+ 25: 4653: sIntt *io = NULL;
+ 25: 4654: char *s = NULL;
+ 25: 4655: sStringt *so = NULL;
+ 25: 4656: sArrayt *a = NULL;
+ 25: 4657: sBytest *B = NULL;
+ -: 4658: uint32_t count;
+ -: 4659: uint32_t dictCount;
+ -: 4660: u8 type;
+ -: 4661:
+ 25: 4662: if (packed) {
+branch 0 taken 16% (fallthrough)
+branch 1 taken 84%
+ 4: 4663: type = (**data) & 0xF;
+ 4: 4664: dictCount = netTypeVarintToUint(data);
call 0 returned 100%
- -: 4591: }
- -: 4592: else {
- 18: 4593: if (ctx->nibble == lowNbl) {
-branch 0 taken 94% (fallthrough)
-branch 1 taken 6%
- 17: 4594: type = (**data) >> 4;
- 17: 4595: (*data)++;
- 17: 4596: dictCount = varintToUint(data);
+ -: 4665: }
+ -: 4666: else {
+ 21: 4667: if (ctx->nibble == lowNbl) {
+branch 0 taken 90% (fallthrough)
+branch 1 taken 10%
+ 19: 4668: type = (**data) >> 4;
+ 19: 4669: (*data)++;
+ 19: 4670: dictCount = varintToUint(data);
call 0 returned 100%
- -: 4597: }
- -: 4598: else {
- 1: 4599: readTypeInHighNbl;
+ -: 4671: }
+ -: 4672: else {
+ 2: 4673: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4600: type = (**data) & 0xF;
- 1: 4601: dictCount = netTypeVarintToUint(data);
-call 0 returned 100%
- -: 4602: }
- -: 4603: }
- -: 4604:
- 22: 4605: if (!dictCount) {
-branch 0 taken 5% (fallthrough)
-branch 1 taken 95%
- 1: 4606: *dict = allocSDict();
-call 0 returned 100%
- 1: 4607: ret;
- -: 4608: }
- -: 4609:
- -: 4610:
- 21: 4611: switch(type) {
-branch 0 taken 5%
-branch 1 taken 19%
-branch 2 taken 5%
-branch 3 taken 5%
-branch 4 taken 29%
-branch 5 taken 24%
-branch 6 taken 5%
+ 2: 4674: type = (**data) & 0xF;
+ 2: 4675: dictCount = netTypeVarintToUint(data);
+call 0 returned 100%
+ -: 4676: }
+ -: 4677: }
+ -: 4678:
+ 25: 4679: if (!dictCount) {
+branch 0 taken 4% (fallthrough)
+branch 1 taken 96%
+ 1: 4680: *dict = allocSDict();
+call 0 returned 100%
+ 1: 4681: ret;
+ -: 4682: }
+ -: 4683:
+ -: 4684:
+ 24: 4685: switch(type) {
+branch 0 taken 4%
+branch 1 taken 17%
+branch 2 taken 4%
+branch 3 taken 4%
+branch 4 taken 38%
+branch 5 taken 21%
+branch 6 taken 4%
branch 7 taken 0%
-branch 8 taken 5%
-branch 9 taken 5%
+branch 8 taken 4%
+branch 9 taken 4%
branch 10 taken 0%
- -: 4612: case S_UNDEFINED:
- 7: 4613: loop(dictCount) {
+ -: 4686: case S_UNDEFINED:
+ 7: 4687: loop(dictCount) {
branch 0 taken 86%
branch 1 taken 14% (fallthrough)
- 6: 4614: char *key = (char*)*data;
- 6: 4615: *data += strlen(key)+1;
- 6: 4616: u = allocSUndefined();
+ 6: 4688: char *key = (char*)*data;
+ 6: 4689: *data += strlen(key)+1;
+ 6: 4690: u = allocSUndefined();
call 0 returned 100%
- 6: 4617: sDictPushTiny(dict, key, (smallt *) u);
+ 6: 4691: sDictPushTiny(dict, key, (smallt *) u);
call 0 returned 100%
- -: 4618: }
- 1: 4619: break;
- -: 4620: case S_BOOL:
- 19: 4621: loop(dictCount) {
+ -: 4692: }
+ 1: 4693: break;
+ -: 4694: case S_BOOL:
+ 19: 4695: loop(dictCount) {
branch 0 taken 79%
branch 1 taken 21% (fallthrough)
- 15: 4622: char *key = (char*)*data;
- 15: 4623: *data += strlen(key)+1;
- 15: 4624: if (!ctx->boolAddr) {
+ 15: 4696: char *key = (char*)*data;
+ 15: 4697: *data += strlen(key)+1;
+ 15: 4698: if (!ctx->boolAddr) {
branch 0 taken 20% (fallthrough)
branch 1 taken 80%
- 3: 4625: read8bPackedBool;
- 3: 4626: ctx->boolShift = 0;
- -: 4627: }
- 15: 4628: if (ctx->boolShift == 8) {
+ 3: 4699: read8bPackedBool;
+ 3: 4700: ctx->boolShift = 0;
+ -: 4701: }
+ 15: 4702: if (ctx->boolShift == 8) {
branch 0 taken 7% (fallthrough)
branch 1 taken 93%
- 1: 4629: readTypeInHighNbl;
+ 1: 4703: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4630: read8bPackedBool;
- 1: 4631: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ 1: 4704: read8bPackedBool;
+ 1: 4705: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 returned 100%
- -: 4632: }
- -: 4633: else {
- -: 4634: // high nibble
- 14: 4635: readTypeInHighNbl;
+ -: 4706: }
+ -: 4707: else {
+ -: 4708: // high nibble
+ 14: 4709: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 14: 4636: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ 14: 4710: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 returned 100%
- -: 4637: }
- 15: 4638: sDictPushTiny(dict, key, (smallt *) bo);
+ -: 4711: }
+ 15: 4712: sDictPushTiny(dict, key, (smallt *) bo);
call 0 returned 100%
- -: 4639: }
- 4: 4640: break;
- -: 4641: case S_DICT:
- 3: 4642: loop(dictCount) {
+ -: 4713: }
+ 4: 4714: break;
+ -: 4715: case S_DICT:
+ 3: 4716: loop(dictCount) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 2: 4643: char *key = (char*)*data;
- 2: 4644: *data += strlen(key)+1;
- 2: 4645: d = NULL;
- 2: 4646: dictNetDeserial(&d, data, ctx, /*packed=*/true);
+ 2: 4717: char *key = (char*)*data;
+ 2: 4718: *data += strlen(key)+1;
+ 2: 4719: d = NULL;
+ 2: 4720: dictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 2: 4647: sDictPushTiny(dict, key, (smallt *) d);
+ 2: 4721: sDictPushTiny(dict, key, (smallt *) d);
call 0 returned 100%
- -: 4648: }
- 1: 4649: break;
- -: 4650: case S_DOUBLE:
- 4: 4651: loop(dictCount) {
+ -: 4722: }
+ 1: 4723: break;
+ -: 4724: case S_DOUBLE:
+ 4: 4725: loop(dictCount) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 4652: char *key = (char*)*data;
- 3: 4653: *data += strlen(key)+1;
- 3: 4654: D = (double *)(*data);
- 3: 4655: *data += sizeof(double);
- 3: 4656: Do = allocSDouble(*D);
-call 0 returned 100%
- 3: 4657: sDictPushTiny(dict, key, (smallt *) Do);
-call 0 returned 100%
- -: 4658: }
- 1: 4659: break;
- -: 4660: case S_INT:
- 15: 4661: loop(dictCount) {
-branch 0 taken 60%
-branch 1 taken 40% (fallthrough)
- 9: 4662: char *key = (char*)*data;
- 9: 4663: *data += strlen(key)+1;
- 9: 4664: i64 v = varintToUint(data);
-call 0 returned 100%
- 9: 4665: v = (v >> 1) ^ ((v << 63) >> 63);
- 9: 4666: io = allocSInt(v);
-call 0 returned 100%
- 9: 4667: sDictPushTiny(dict, key, (smallt *) io);
-call 0 returned 100%
- -: 4668: }
- 6: 4669: break;
- -: 4670: case S_STRING:
- 16: 4671: loop(dictCount) {
+ 3: 4726: char *key = (char*)*data;
+ 3: 4727: *data += strlen(key)+1;
+ 3: 4728: D = (double *)(*data);
+ 3: 4729: *data += sizeof(double);
+ 3: 4730: Do = allocSDouble(*D);
+call 0 returned 100%
+ 3: 4731: sDictPushTiny(dict, key, (smallt *) Do);
+call 0 returned 100%
+ -: 4732: }
+ 1: 4733: break;
+ -: 4734: case S_INT:
+ 21: 4735: loop(dictCount) {
+branch 0 taken 57%
+branch 1 taken 43% (fallthrough)
+ 12: 4736: char *key = (char*)*data;
+ 12: 4737: *data += strlen(key)+1;
+ 12: 4738: i64 v = varintToUint(data);
+call 0 returned 100%
+ 12: 4739: v = (v >> 1) ^ ((v << 63) >> 63);
+ 12: 4740: io = allocSInt(v);
+call 0 returned 100%
+ 12: 4741: sDictPushTiny(dict, key, (smallt *) io);
+call 0 returned 100%
+ -: 4742: }
+ 9: 4743: break;
+ -: 4744: case S_STRING:
+ 16: 4745: loop(dictCount) {
branch 0 taken 69%
branch 1 taken 31% (fallthrough)
- 11: 4672: char *key = (char*)*data;
- 11: 4673: *data += strlen(key)+1;
- 11: 4674: s = (char *)(*data);
- 11: 4675: *data += strlen(s)+1;
- 11: 4676: so = allocSStringTiny(s);
-call 0 returned 100%
- 11: 4677: sDictPushTiny(dict, key, (smallt *) so);
-call 0 returned 100%
- -: 4678: }
- 5: 4679: break;
- -: 4680: case S_ARRAY:
- 2: 4681: loop(dictCount) {
+ 11: 4746: char *key = (char*)*data;
+ 11: 4747: *data += strlen(key)+1;
+ 11: 4748: s = (char *)(*data);
+ 11: 4749: *data += strlen(s)+1;
+ 11: 4750: so = allocSStringTiny(s);
+call 0 returned 100%
+ 11: 4751: sDictPushTiny(dict, key, (smallt *) so);
+call 0 returned 100%
+ -: 4752: }
+ 5: 4753: break;
+ -: 4754: case S_ARRAY:
+ 2: 4755: loop(dictCount) {
branch 0 taken 50%
branch 1 taken 50% (fallthrough)
- 1: 4682: char *key = (char*)*data;
- 1: 4683: *data += strlen(key)+1;
- 1: 4684: a = NULL;
- 1: 4685: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
+ 1: 4756: char *key = (char*)*data;
+ 1: 4757: *data += strlen(key)+1;
+ 1: 4758: a = NULL;
+ 1: 4759: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
call 0 returned 100%
- 1: 4686: sDictPushTiny(dict, key, (smallt *) a);
+ 1: 4760: sDictPushTiny(dict, key, (smallt *) a);
call 0 returned 100%
- -: 4687: }
- 1: 4688: break;
- -: 4689: case S_BYTES:
- #####: 4690: loop(dictCount) {
+ -: 4761: }
+ 1: 4762: break;
+ -: 4763: case S_BYTES:
+ #####: 4764: loop(dictCount) {
branch 0 never executed
branch 1 never executed
- #####: 4691: char *key = (char*)*data;
- #####: 4692: *data += strlen(key)+1;
- #####: 4693: B = allocSBytes();
+ #####: 4765: char *key = (char*)*data;
+ #####: 4766: *data += strlen(key)+1;
+ #####: 4767: B = allocSBytes();
call 0 never executed
- #####: 4694: count = varintToUint((u8**)data);
+ #####: 4768: count = varintToUint((u8**)data);
call 0 never executed
- #####: 4695: sBytesPushBuffer(&B, data, count);
+ #####: 4769: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 4696: *data += count;
- #####: 4697: sDictPushTiny(dict, key, (smallt *) B);
+ #####: 4770: *data += count;
+ #####: 4771: sDictPushTiny(dict, key, (smallt *) B);
call 0 never executed
- -: 4698: }
- #####: 4699: break;
- -: 4700: case UNIFORM_DICT:
- 3: 4701: loop(dictCount) {
+ -: 4772: }
+ #####: 4773: break;
+ -: 4774: case UNIFORM_DICT:
+ 3: 4775: loop(dictCount) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 2: 4702: char *key = (char*)*data;
- 2: 4703: *data += strlen(key)+1;
- 2: 4704: d = NULL;
- 2: 4705: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
+ 2: 4776: char *key = (char*)*data;
+ 2: 4777: *data += strlen(key)+1;
+ 2: 4778: d = NULL;
+ 2: 4779: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 2: 4706: sDictPushTiny(dict, key, (smallt *) d);
+ 2: 4780: sDictPushTiny(dict, key, (smallt *) d);
call 0 returned 100%
- -: 4707: }
- 1: 4708: break;
- -: 4709: case UNIFORM_ARRAY:
- 2: 4710: loop(dictCount) {
+ -: 4781: }
+ 1: 4782: break;
+ -: 4783: case UNIFORM_ARRAY:
+ 2: 4784: loop(dictCount) {
branch 0 taken 50%
branch 1 taken 50% (fallthrough)
- 1: 4711: char *key = (char*)*data;
- 1: 4712: *data += strlen(key)+1;
- 1: 4713: a = NULL;
- 1: 4714: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
-call 0 returned 100%
- 1: 4715: sDictPushTiny(dict, key, (smallt *) a);
-call 0 returned 100%
- -: 4716: }
- 1: 4717: break;
- -: 4718: }
- -: 4719:}
- -: 4720:
- -: 4721:/**
- -: 4722: * deserialize array from data
- -: 4723: *
- -: 4724: * a new array is allocated
- -: 4725: *
- -: 4726: * \param
- -: 4727: * array holding the elements
- -: 4728: * data serialized dictionary
- -: 4729: */
-function arrayNetDeserial called 48 returned 100% blocks executed 78%
- 48: 4730:internal void arrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
- 48: 4731: sUndefinedt *u = NULL;
- 48: 4732: sBoolt *bo = NULL;
- 48: 4733: double *D = NULL;
- 48: 4734: sDoublet *Do = NULL;
- 48: 4735: sDictt *d = NULL;
- 48: 4736: sIntt *io = NULL;
- 48: 4737: char *s = NULL;
- 48: 4738: sStringt *so = NULL;
- 48: 4739: sArrayt *a = NULL;
- 48: 4740: sBytest *B = NULL;
- -: 4741: uint32_t count;
- -: 4742: uint32_t arrayCount;
- -: 4743:
- 48: 4744: if (packed) {
-branch 0 taken 44% (fallthrough)
-branch 1 taken 56%
- 21: 4745: arrayCount = varintToUint(data);
-call 0 returned 100%
- -: 4746: }
- -: 4747: else {
- 27: 4748: if (ctx->nibble == lowNbl) {
+ 1: 4785: char *key = (char*)*data;
+ 1: 4786: *data += strlen(key)+1;
+ 1: 4787: a = NULL;
+ 1: 4788: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
+call 0 returned 100%
+ 1: 4789: sDictPushTiny(dict, key, (smallt *) a);
+call 0 returned 100%
+ -: 4790: }
+ 1: 4791: break;
+ -: 4792: }
+ -: 4793:}
+ -: 4794:
+ -: 4795:/**
+ -: 4796: * deserialize array from data
+ -: 4797: *
+ -: 4798: * a new array is allocated
+ -: 4799: *
+ -: 4800: * \param
+ -: 4801: * array holding the elements
+ -: 4802: * data serialized dictionary
+ -: 4803: */
+function arrayNetDeserial called 49 returned 100% blocks executed 78%
+ 49: 4804:internal void arrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
+ 49: 4805: sUndefinedt *u = NULL;
+ 49: 4806: sBoolt *bo = NULL;
+ 49: 4807: double *D = NULL;
+ 49: 4808: sDoublet *Do = NULL;
+ 49: 4809: sDictt *d = NULL;
+ 49: 4810: sIntt *io = NULL;
+ 49: 4811: char *s = NULL;
+ 49: 4812: sStringt *so = NULL;
+ 49: 4813: sArrayt *a = NULL;
+ 49: 4814: sBytest *B = NULL;
+ -: 4815: uint32_t count;
+ -: 4816: uint32_t arrayCount;
+ -: 4817:
+ 49: 4818: if (packed) {
+branch 0 taken 45% (fallthrough)
+branch 1 taken 55%
+ 22: 4819: arrayCount = varintToUint(data);
+call 0 returned 100%
+ -: 4820: }
+ -: 4821: else {
+ 27: 4822: if (ctx->nibble == lowNbl) {
branch 0 taken 96% (fallthrough)
branch 1 taken 4%
- 26: 4749: arrayCount = netTypeVarintToUint(data);
+ 26: 4823: arrayCount = netTypeVarintToUint(data);
call 0 returned 100%
- -: 4750: }
- -: 4751: else {
- -: 4752: // high nibble
- 1: 4753: readTypeInHighNbl;
+ -: 4824: }
+ -: 4825: else {
+ -: 4826: // high nibble
+ 1: 4827: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4754: arrayCount = varintToUint(data);
+ 1: 4828: arrayCount = varintToUint(data);
call 0 returned 100%
- -: 4755: }
- -: 4756: }
- -: 4757:
- 48: 4758: if (!arrayCount) {
+ -: 4829: }
+ -: 4830: }
+ -: 4831:
+ 49: 4832: if (!arrayCount) {
branch 0 taken 4% (fallthrough)
branch 1 taken 96%
- 2: 4759: *array = allocSArray();;
-call 0 returned 100%
- 2: 4760: ret;
- -: 4761: }
- -: 4762:
- 46: 4763: bool inPack = false;
- -: 4764: u8 packedType;
- -: 4765: size_t packCount;
- 196: 4766: loop(arrayCount) {
+ 2: 4833: *array = allocSArray();;
+call 0 returned 100%
+ 2: 4834: ret;
+ -: 4835: }
+ -: 4836:
+ 47: 4837: bool inPack = false;
+ -: 4838: u8 packedType;
+ -: 4839: size_t packCount;
+ 201: 4840: loop(arrayCount) {
branch 0 taken 77%
branch 1 taken 23% (fallthrough)
- -: 4767: char type;
- 150: 4768: if (inPack) {
-branch 0 taken 20% (fallthrough)
-branch 1 taken 80%
- 30: 4769: type = packedType;
- -: 4770: }
- -: 4771: else {
- 120: 4772: if (ctx->nibble == lowNbl) {
+ -: 4841: char type;
+ 154: 4842: if (inPack) {
+branch 0 taken 19% (fallthrough)
+branch 1 taken 81%
+ 30: 4843: type = packedType;
+ -: 4844: }
+ -: 4845: else {
+ 124: 4846: if (ctx->nibble == lowNbl) {
branch 0 taken 72% (fallthrough)
branch 1 taken 28%
- 86: 4773: type = (**data) & 0xF;
- -: 4774: }
- -: 4775: else {
- -: 4776: // high nibble
- 34: 4777: type = (*ctx->nblAddr) >> 4;
- -: 4778: }
- -: 4779: }
- -: 4780:
- 150: 4781: switch(type) {
+ 89: 4847: type = (**data) & 0xF;
+ -: 4848: }
+ -: 4849: else {
+ -: 4850: // high nibble
+ 35: 4851: type = (*ctx->nblAddr) >> 4;
+ -: 4852: }
+ -: 4853: }
+ -: 4854:
+ 154: 4855: switch(type) {
branch 0 taken 18%
-branch 1 taken 23%
+branch 1 taken 22%
branch 2 taken 1%
branch 3 taken 1%
-branch 4 taken 15%
-branch 5 taken 9%
+branch 4 taken 14%
+branch 5 taken 8%
branch 6 taken 1%
branch 7 taken 0%
branch 8 taken 5%
@@ -7084,630 +7158,630 @@ branch 10 taken 5%
branch 11 taken 5%
branch 12 taken 5%
branch 13 taken 0%
-branch 14 taken 1%
+branch 14 taken 3%
branch 15 taken 4%
branch 16 taken 0%
- -: 4782: case S_UNDEFINED:
- 27: 4783: if (ctx->nibble == lowNbl) {
+ -: 4856: case S_UNDEFINED:
+ 28: 4857: if (ctx->nibble == lowNbl) {
branch 0 taken 93% (fallthrough)
branch 1 taken 7%
- 25: 4784: readTypeOnly;
- -: 4785: }
- -: 4786: else {
- -: 4787: // high nibble
- 2: 4788: readTypeInHighNbl;
+ 26: 4858: readTypeOnly;
+ -: 4859: }
+ -: 4860: else {
+ -: 4861: // high nibble
+ 2: 4862: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4789: }
- 27: 4790: u = allocSUndefined();
+ -: 4863: }
+ 28: 4864: u = allocSUndefined();
call 0 returned 100%
- 27: 4791: sArrayPushTiny(array, (smallt *) u);
+ 28: 4865: sArrayPushTiny(array, (smallt *) u);
call 0 returned 100%
- 27: 4792: break;
- -: 4793: case S_BOOL:
- 34: 4794: if (!ctx->boolAddr) {
+ 28: 4866: break;
+ -: 4867: case S_BOOL:
+ 34: 4868: if (!ctx->boolAddr) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- -: 4795: // new packed bools
- 6: 4796: if (ctx->nibble == lowNbl) {
+ -: 4869: // new packed bools
+ 6: 4870: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 3: 4797: read4bPackedBool;
- 3: 4798: bo = allocSBool((*ctx->boolAddr) & 0x10);
+ 3: 4871: read4bPackedBool;
+ 3: 4872: bo = allocSBool((*ctx->boolAddr) & 0x10);
call 0 returned 100%
- -: 4799: }
- -: 4800: else {
- -: 4801: // high nibble
- 3: 4802: readTypeInHighNbl;
+ -: 4873: }
+ -: 4874: else {
+ -: 4875: // high nibble
+ 3: 4876: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 3: 4803: read8bPackedBool;
- 3: 4804: bo = allocSBool((*ctx->boolAddr) & 0x1);
-call 0 returned 100%
- -: 4805: }
- -: 4806: }
- -: 4807: else {
- -: 4808: // there was a bool before this one, read bits in nibbles
- 28: 4809: if (ctx->nibble == lowNbl) {
+ 3: 4877: read8bPackedBool;
+ 3: 4878: bo = allocSBool((*ctx->boolAddr) & 0x1);
+call 0 returned 100%
+ -: 4879: }
+ -: 4880: }
+ -: 4881: else {
+ -: 4882: // there was a bool before this one, read bits in nibbles
+ 28: 4883: if (ctx->nibble == lowNbl) {
branch 0 taken 61% (fallthrough)
branch 1 taken 39%
- 17: 4810: if (ctx->boolShift == 8) {
+ 17: 4884: if (ctx->boolShift == 8) {
branch 0 taken 12% (fallthrough)
branch 1 taken 88%
- 2: 4811: read4bPackedBool;
- 2: 4812: bo = allocSBool((*ctx->boolAddr) & 0x10);
-call 0 returned 100%
- -: 4813: }
- -: 4814: else {
- 15: 4815: readTypeOnly;
- 15: 4816: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
-call 0 returned 100%
- -: 4817: }
- -: 4818: }
- -: 4819: else {
- -: 4820: // high nibble
- 11: 4821: readTypeInHighNbl;
+ 2: 4885: read4bPackedBool;
+ 2: 4886: bo = allocSBool((*ctx->boolAddr) & 0x10);
+call 0 returned 100%
+ -: 4887: }
+ -: 4888: else {
+ 15: 4889: readTypeOnly;
+ 15: 4890: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+call 0 returned 100%
+ -: 4891: }
+ -: 4892: }
+ -: 4893: else {
+ -: 4894: // high nibble
+ 11: 4895: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 11: 4822: if (ctx->boolShift == 8) {
+ 11: 4896: if (ctx->boolShift == 8) {
branch 0 taken 18% (fallthrough)
branch 1 taken 82%
- 2: 4823: read8bPackedBool;
- 2: 4824: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ 2: 4897: read8bPackedBool;
+ 2: 4898: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 returned 100%
- -: 4825: }
- -: 4826: else {
- 9: 4827: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 4899: }
+ -: 4900: else {
+ 9: 4901: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 returned 100%
- -: 4828: }
- -: 4829: }
- -: 4830: }
- 34: 4831: sArrayPushTiny(array, (smallt *) bo);
+ -: 4902: }
+ -: 4903: }
+ -: 4904: }
+ 34: 4905: sArrayPushTiny(array, (smallt *) bo);
call 0 returned 100%
- 34: 4832: break;
- -: 4833: case S_DICT:
- 2: 4834: d = NULL;
- 2: 4835: dictNetDeserial(&d, data, ctx, /*packed=*/false);
+ 34: 4906: break;
+ -: 4907: case S_DICT:
+ 2: 4908: d = NULL;
+ 2: 4909: dictNetDeserial(&d, data, ctx, /*packed=*/false);
call 0 returned 100%
- 2: 4836: sArrayPushTiny(array, (smallt *) d);
+ 2: 4910: sArrayPushTiny(array, (smallt *) d);
call 0 returned 100%
- 2: 4837: break;
- -: 4838: case S_DOUBLE:
- 2: 4839: if (ctx->nibble == lowNbl) {
+ 2: 4911: break;
+ -: 4912: case S_DOUBLE:
+ 2: 4913: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4840: readTypeOnly;
- -: 4841: }
- -: 4842: else {
- -: 4843: // high nibble
- 1: 4844: readTypeInHighNbl;
+ 1: 4914: readTypeOnly;
+ -: 4915: }
+ -: 4916: else {
+ -: 4917: // high nibble
+ 1: 4918: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4845: }
- 2: 4846: D = (double *)(*data);
- 2: 4847: *data += sizeof(double);
- 2: 4848: Do = allocSDouble(*D);
+ -: 4919: }
+ 2: 4920: D = (double *)(*data);
+ 2: 4921: *data += sizeof(double);
+ 2: 4922: Do = allocSDouble(*D);
call 0 returned 100%
- 2: 4849: sArrayPushTiny(array, (smallt *) Do);
+ 2: 4923: sArrayPushTiny(array, (smallt *) Do);
call 0 returned 100%
- 2: 4850: break;
- -: 4851: case S_INT: {
- -: 4852: i64 v;
- 22: 4853: if (ctx->nibble == lowNbl) {
+ 2: 4924: break;
+ -: 4925: case S_INT: {
+ -: 4926: i64 v;
+ 22: 4927: if (ctx->nibble == lowNbl) {
branch 0 taken 82% (fallthrough)
branch 1 taken 18%
- 18: 4854: v = netTypeVarintToUint((u8**)data);
+ 18: 4928: v = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4855: }
- -: 4856: else {
- -: 4857: // high nibble
- 4: 4858: readTypeInHighNbl;
+ -: 4929: }
+ -: 4930: else {
+ -: 4931: // high nibble
+ 4: 4932: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 4: 4859: v = varintToUint(data);
+ 4: 4933: v = varintToUint(data);
call 0 returned 100%
- -: 4860: }
- 22: 4861: v = (v >> 1) ^ ((v << 63) >> 63);
- 22: 4862: io = allocSInt(v);
+ -: 4934: }
+ 22: 4935: v = (v >> 1) ^ ((v << 63) >> 63);
+ 22: 4936: io = allocSInt(v);
call 0 returned 100%
- 22: 4863: sArrayPushTiny(array, (smallt *) io);
+ 22: 4937: sArrayPushTiny(array, (smallt *) io);
call 0 returned 100%
- -: 4864: }
- 22: 4865: break;
- -: 4866: case S_STRING:
- 13: 4867: if (ctx->nibble == lowNbl) {
+ -: 4938: }
+ 22: 4939: break;
+ -: 4940: case S_STRING:
+ 13: 4941: if (ctx->nibble == lowNbl) {
branch 0 taken 69% (fallthrough)
branch 1 taken 31%
- 9: 4868: readTypeOnly;
- -: 4869: }
- -: 4870: else {
- -: 4871: // high nibble
- 4: 4872: readTypeInHighNbl;
+ 9: 4942: readTypeOnly;
+ -: 4943: }
+ -: 4944: else {
+ -: 4945: // high nibble
+ 4: 4946: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- -: 4873: }
- 13: 4874: s = (char *)(*data);
- 13: 4875: *data += strlen(s)+1;
- 13: 4876: so = allocSStringTiny(s);
+ -: 4947: }
+ 13: 4948: s = (char *)(*data);
+ 13: 4949: *data += strlen(s)+1;
+ 13: 4950: so = allocSStringTiny(s);
call 0 returned 100%
- 13: 4877: sArrayPushTiny(array, (smallt *) so);
+ 13: 4951: sArrayPushTiny(array, (smallt *) so);
call 0 returned 100%
- 13: 4878: break;
- -: 4879: case S_ARRAY:
- 2: 4880: a = NULL;
- 2: 4881: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
+ 13: 4952: break;
+ -: 4953: case S_ARRAY:
+ 2: 4954: a = NULL;
+ 2: 4955: arrayNetDeserial(&a, data, ctx, /*packed=*/false);
call 0 returned 100%
- 2: 4882: sArrayPushTiny(array, (smallt *) a);
+ 2: 4956: sArrayPushTiny(array, (smallt *) a);
call 0 returned 100%
- 2: 4883: break;
- -: 4884: case S_BYTES:
- #####: 4885: B = allocSBytes();
+ 2: 4957: break;
+ -: 4958: case S_BYTES:
+ #####: 4959: B = allocSBytes();
call 0 never executed
- #####: 4886: if (ctx->nibble == lowNbl) {
+ #####: 4960: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 4887: count = netTypeVarintToUint((u8**)data);
+ #####: 4961: count = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 4888: }
- -: 4889: else {
- -: 4890: // high nibble
- #####: 4891: readTypeInHighNbl;
+ -: 4962: }
+ -: 4963: else {
+ -: 4964: // high nibble
+ #####: 4965: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 4892: count = varintToUint((u8**)data);
+ #####: 4966: count = varintToUint((u8**)data);
call 0 never executed
- -: 4893: }
- #####: 4894: sBytesPushBuffer(&B, data, count);
+ -: 4967: }
+ #####: 4968: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 4895: *data += count;
- #####: 4896: sArrayPushTiny(array, (smallt *) B);
+ #####: 4969: *data += count;
+ #####: 4970: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- #####: 4897: break;
- -: 4898: case PK_DICT:
- 8: 4899: if (!inPack) {
+ #####: 4971: break;
+ -: 4972: case PK_DICT:
+ 8: 4973: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4900: inPack = true;
- 2: 4901: if (ctx->nibble == lowNbl) {
+ 2: 4974: inPack = true;
+ 2: 4975: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4902: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4976: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4903: }
- -: 4904: else {
- -: 4905: // high nibble
- 1: 4906: readTypeInHighNbl;
+ -: 4977: }
+ -: 4978: else {
+ -: 4979: // high nibble
+ 1: 4980: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4907: packCount = varintToUint((u8**)data);
+ 1: 4981: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4908: }
- 2: 4909: packedType = PK_DICT;
- -: 4910: }
- -: 4911:
- 8: 4912: d = NULL;
- 8: 4913: dictNetDeserial(&d, data, ctx, /*packed=*/true);
+ -: 4982: }
+ 2: 4983: packedType = PK_DICT;
+ -: 4984: }
+ -: 4985:
+ 8: 4986: d = NULL;
+ 8: 4987: dictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 8: 4914: sArrayPushTiny(array, (smallt *) d);
+ 8: 4988: sArrayPushTiny(array, (smallt *) d);
call 0 returned 100%
- -: 4915: // stop unpacking when packCount == 0
- 8: 4916: packCount--;
- 8: 4917: if (!packCount) inPack = false;
+ -: 4989: // stop unpacking when packCount == 0
+ 8: 4990: packCount--;
+ 8: 4991: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4918: break;
- -: 4919: case PK_DOUBLE:
- 8: 4920: if (!inPack) {
+ 8: 4992: break;
+ -: 4993: case PK_DOUBLE:
+ 8: 4994: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4921: inPack = true;
- 2: 4922: if (ctx->nibble == lowNbl) {
+ 2: 4995: inPack = true;
+ 2: 4996: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4923: packCount = netTypeVarintToUint((u8**)data);
+ 1: 4997: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4924: }
- -: 4925: else {
- -: 4926: // high nibble
- 1: 4927: readTypeInHighNbl;
+ -: 4998: }
+ -: 4999: else {
+ -: 5000: // high nibble
+ 1: 5001: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4928: packCount = varintToUint((u8**)data);
+ 1: 5002: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4929: }
- 2: 4930: packedType = PK_DOUBLE;
- -: 4931: }
- -: 4932:
- 8: 4933: D = (double *)(*data);
- 8: 4934: *data += sizeof(double);
- 8: 4935: Do = allocSDouble(*D);
-call 0 returned 100%
- 8: 4936: sArrayPushTiny(array, (smallt *) Do);
-call 0 returned 100%
- -: 4937: // stop unpacking when packCount == 0
- 8: 4938: packCount--;
- 8: 4939: if (!packCount) inPack = false;
+ -: 5003: }
+ 2: 5004: packedType = PK_DOUBLE;
+ -: 5005: }
+ -: 5006:
+ 8: 5007: D = (double *)(*data);
+ 8: 5008: *data += sizeof(double);
+ 8: 5009: Do = allocSDouble(*D);
+call 0 returned 100%
+ 8: 5010: sArrayPushTiny(array, (smallt *) Do);
+call 0 returned 100%
+ -: 5011: // stop unpacking when packCount == 0
+ 8: 5012: packCount--;
+ 8: 5013: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4940: break;
- -: 4941: case PK_INT:
- 8: 4942: if (!inPack) {
+ 8: 5014: break;
+ -: 5015: case PK_INT:
+ 8: 5016: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4943: inPack = true;
- 2: 4944: if (ctx->nibble == lowNbl) {
+ 2: 5017: inPack = true;
+ 2: 5018: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4945: packCount = netTypeVarintToUint((u8**)data);
+ 1: 5019: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4946: }
- -: 4947: else {
- -: 4948: // high nibble
- 1: 4949: readTypeInHighNbl;
+ -: 5020: }
+ -: 5021: else {
+ -: 5022: // high nibble
+ 1: 5023: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4950: packCount = varintToUint((u8**)data);
+ 1: 5024: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4951: }
- 2: 4952: packedType = PK_INT;
- -: 4953: }
- -: 4954:
- 8: 4955: i64 v = varintToUint(data);
+ -: 5025: }
+ 2: 5026: packedType = PK_INT;
+ -: 5027: }
+ -: 5028:
+ 8: 5029: i64 v = varintToUint(data);
call 0 returned 100%
- 8: 4956: v = (v >> 1) ^ ((v << 63) >> 63);
- 8: 4957: io = allocSInt(v);
+ 8: 5030: v = (v >> 1) ^ ((v << 63) >> 63);
+ 8: 5031: io = allocSInt(v);
call 0 returned 100%
- 8: 4958: sArrayPushTiny(array, (smallt *) io);
+ 8: 5032: sArrayPushTiny(array, (smallt *) io);
call 0 returned 100%
- -: 4959: // stop unpacking when packCount == 0
- 8: 4960: packCount--;
- 8: 4961: if (!packCount) inPack = false;
+ -: 5033: // stop unpacking when packCount == 0
+ 8: 5034: packCount--;
+ 8: 5035: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4962: break;
- -: 4963: case PK_STRING:
- 8: 4964: if (!inPack) {
+ 8: 5036: break;
+ -: 5037: case PK_STRING:
+ 8: 5038: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4965: inPack = true;
- 2: 4966: if (ctx->nibble == lowNbl) {
+ 2: 5039: inPack = true;
+ 2: 5040: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4967: packCount = netTypeVarintToUint((u8**)data);
+ 1: 5041: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4968: }
- -: 4969: else {
- -: 4970: // high nibble
- 1: 4971: readTypeInHighNbl;
+ -: 5042: }
+ -: 5043: else {
+ -: 5044: // high nibble
+ 1: 5045: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4972: packCount = varintToUint((u8**)data);
+ 1: 5046: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4973: }
- 2: 4974: packedType = PK_STRING;
- -: 4975: }
- -: 4976:
- 8: 4977: s = (char *)(*data);
- 8: 4978: *data += strlen(s)+1;
- 8: 4979: so = allocSStringTiny(s);
+ -: 5047: }
+ 2: 5048: packedType = PK_STRING;
+ -: 5049: }
+ -: 5050:
+ 8: 5051: s = (char *)(*data);
+ 8: 5052: *data += strlen(s)+1;
+ 8: 5053: so = allocSStringTiny(s);
call 0 returned 100%
- 8: 4980: sArrayPushTiny(array, (smallt *) so);
+ 8: 5054: sArrayPushTiny(array, (smallt *) so);
call 0 returned 100%
- -: 4981: // stop unpacking when packCount == 0
- 8: 4982: packCount--;
- 8: 4983: if (!packCount) inPack = false;
+ -: 5055: // stop unpacking when packCount == 0
+ 8: 5056: packCount--;
+ 8: 5057: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 4984: break;
- -: 4985: case PK_ARRAY:
- 8: 4986: if (!inPack) {
+ 8: 5058: break;
+ -: 5059: case PK_ARRAY:
+ 8: 5060: if (!inPack) {
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 2: 4987: inPack = true;
- 2: 4988: if (ctx->nibble == lowNbl) {
+ 2: 5061: inPack = true;
+ 2: 5062: if (ctx->nibble == lowNbl) {
branch 0 taken 50% (fallthrough)
branch 1 taken 50%
- 1: 4989: packCount = netTypeVarintToUint((u8**)data);
+ 1: 5063: packCount = netTypeVarintToUint((u8**)data);
call 0 returned 100%
- -: 4990: }
- -: 4991: else {
- -: 4992: // high nibble
- 1: 4993: readTypeInHighNbl;
+ -: 5064: }
+ -: 5065: else {
+ -: 5066: // high nibble
+ 1: 5067: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 1: 4994: packCount = varintToUint((u8**)data);
+ 1: 5068: packCount = varintToUint((u8**)data);
call 0 returned 100%
- -: 4995: }
- 2: 4996: packedType = PK_ARRAY;
- -: 4997: }
- -: 4998:
- 8: 4999: a = NULL;
- 8: 5000: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
+ -: 5069: }
+ 2: 5070: packedType = PK_ARRAY;
+ -: 5071: }
+ -: 5072:
+ 8: 5073: a = NULL;
+ 8: 5074: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
call 0 returned 100%
- 8: 5001: sArrayPushTiny(array, (smallt *) a);
+ 8: 5075: sArrayPushTiny(array, (smallt *) a);
call 0 returned 100%
- -: 5002: // stop unpacking when packCount == 0
- 8: 5003: packCount--;
- 8: 5004: if (!packCount) inPack = false;
+ -: 5076: // stop unpacking when packCount == 0
+ 8: 5077: packCount--;
+ 8: 5078: if (!packCount) inPack = false;
branch 0 taken 25% (fallthrough)
branch 1 taken 75%
- 8: 5005: break;
- -: 5006: case PK_BYTES:
- #####: 5007: if (!inPack) {
+ 8: 5079: break;
+ -: 5080: case PK_BYTES:
+ #####: 5081: if (!inPack) {
branch 0 never executed
branch 1 never executed
- #####: 5008: inPack = true;
- #####: 5009: if (ctx->nibble == lowNbl) {
+ #####: 5082: inPack = true;
+ #####: 5083: if (ctx->nibble == lowNbl) {
branch 0 never executed
branch 1 never executed
- #####: 5010: packCount = netTypeVarintToUint((u8**)data);
+ #####: 5084: packCount = netTypeVarintToUint((u8**)data);
call 0 never executed
- -: 5011: }
- -: 5012: else {
- -: 5013: // high nibble
- #####: 5014: readTypeInHighNbl;
+ -: 5085: }
+ -: 5086: else {
+ -: 5087: // high nibble
+ #####: 5088: readTypeInHighNbl;
branch 0 never executed
branch 1 never executed
- #####: 5015: packCount = varintToUint((u8**)data);
-call 0 never executed
- -: 5016: }
- #####: 5017: packedType = PK_BYTES;
- -: 5018: }
- -: 5019:
- #####: 5020: B = allocSBytes();
+ #####: 5089: packCount = varintToUint((u8**)data);
call 0 never executed
- #####: 5021: count = varintToUint((u8**)data);
-call 0 never executed
- #####: 5022: sBytesPushBuffer(&B, data, count);
-call 0 never executed
- #####: 5023: *data += count;
- #####: 5024: sArrayPushTiny(array, (smallt *) B);
-call 0 never executed
- -: 5025: // stop unpacking when packCount == 0
- #####: 5026: packCount--;
- #####: 5027: if (!packCount) inPack = false;
-branch 0 never executed
-branch 1 never executed
- #####: 5028: break;
- -: 5029: case UNIFORM_DICT:
- 2: 5030: d = NULL;
- 2: 5031: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
-call 0 returned 100%
- 2: 5032: sArrayPushTiny(array, (smallt *) d);
-call 0 returned 100%
- 2: 5033: break;
- -: 5034: case UNIFORM_ARRAY:
- 6: 5035: a = NULL;
- 6: 5036: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
-call 0 returned 100%
- 6: 5037: sArrayPushTiny(array, (smallt *) a);
-call 0 returned 100%
- 6: 5038: break;
- -: 5039: }
- -: 5040: }
- -: 5041:}
- -: 5042:
-function uniformArrayNetDeserial called 23 returned 100% blocks executed 89%
- 23: 5043:internal void uniformArrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
- 23: 5044: sUndefinedt *u = NULL;
- 23: 5045: sBoolt *bo = NULL;
- 23: 5046: double *D = NULL;
- 23: 5047: sDoublet *Do = NULL;
- 23: 5048: sDictt *d = NULL;
- 23: 5049: sIntt *io = NULL;
- 23: 5050: char *s = NULL;
- 23: 5051: sStringt *so = NULL;
- 23: 5052: sArrayt *a = NULL;
- 23: 5053: sBytest *B = NULL;
- -: 5054: uint32_t count;
- -: 5055: uint32_t arrayCount;
- -: 5056: u8 type;
- -: 5057:
- 23: 5058: if (packed) {
-branch 0 taken 9% (fallthrough)
-branch 1 taken 91%
- 2: 5059: type = (**data) & 0xF;
- 2: 5060: arrayCount = netTypeVarintToUint(data);
+ -: 5090: }
+ #####: 5091: packedType = PK_BYTES;
+ -: 5092: }
+ -: 5093:
+ #####: 5094: B = allocSBytes();
+call 0 never executed
+ #####: 5095: count = varintToUint((u8**)data);
+call 0 never executed
+ #####: 5096: sBytesPushBuffer(&B, data, count);
+call 0 never executed
+ #####: 5097: *data += count;
+ #####: 5098: sArrayPushTiny(array, (smallt *) B);
+call 0 never executed
+ -: 5099: // stop unpacking when packCount == 0
+ #####: 5100: packCount--;
+ #####: 5101: if (!packCount) inPack = false;
+branch 0 never executed
+branch 1 never executed
+ #####: 5102: break;
+ -: 5103: case UNIFORM_DICT:
+ 5: 5104: d = NULL;
+ 5: 5105: uniformDictNetDeserial(&d, data, ctx, /*packed=*/false);
+call 0 returned 100%
+ 5: 5106: sArrayPushTiny(array, (smallt *) d);
+call 0 returned 100%
+ 5: 5107: break;
+ -: 5108: case UNIFORM_ARRAY:
+ 6: 5109: a = NULL;
+ 6: 5110: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/false);
+call 0 returned 100%
+ 6: 5111: sArrayPushTiny(array, (smallt *) a);
+call 0 returned 100%
+ 6: 5112: break;
+ -: 5113: }
+ -: 5114: }
+ -: 5115:}
+ -: 5116:
+function uniformArrayNetDeserial called 24 returned 100% blocks executed 89%
+ 24: 5117:internal void uniformArrayNetDeserial(sArrayt **array, u8 **data, contextt *ctx, bool packed) {
+ 24: 5118: sUndefinedt *u = NULL;
+ 24: 5119: sBoolt *bo = NULL;
+ 24: 5120: double *D = NULL;
+ 24: 5121: sDoublet *Do = NULL;
+ 24: 5122: sDictt *d = NULL;
+ 24: 5123: sIntt *io = NULL;
+ 24: 5124: char *s = NULL;
+ 24: 5125: sStringt *so = NULL;
+ 24: 5126: sArrayt *a = NULL;
+ 24: 5127: sBytest *B = NULL;
+ -: 5128: uint32_t count;
+ -: 5129: uint32_t arrayCount;
+ -: 5130: u8 type;
+ -: 5131:
+ 24: 5132: if (packed) {
+branch 0 taken 8% (fallthrough)
+branch 1 taken 92%
+ 2: 5133: type = (**data) & 0xF;
+ 2: 5134: arrayCount = netTypeVarintToUint(data);
call 0 returned 100%
- -: 5061: }
- -: 5062: else {
- 21: 5063: if (ctx->nibble == lowNbl) {
-branch 0 taken 76% (fallthrough)
-branch 1 taken 24%
- 16: 5064: type = (**data) >> 4;
- 16: 5065: (*data)++;
- 16: 5066: arrayCount = varintToUint(data);
+ -: 5135: }
+ -: 5136: else {
+ 22: 5137: if (ctx->nibble == lowNbl) {
+branch 0 taken 77% (fallthrough)
+branch 1 taken 23%
+ 17: 5138: type = (**data) >> 4;
+ 17: 5139: (*data)++;
+ 17: 5140: arrayCount = varintToUint(data);
call 0 returned 100%
- -: 5067: }
- -: 5068: else {
- 5: 5069: readTypeInHighNbl;
+ -: 5141: }
+ -: 5142: else {
+ 5: 5143: readTypeInHighNbl;
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- 5: 5070: type = (**data) & 0xF;
- 5: 5071: arrayCount = netTypeVarintToUint(data);
+ 5: 5144: type = (**data) & 0xF;
+ 5: 5145: arrayCount = netTypeVarintToUint(data);
call 0 returned 100%
- -: 5072: }
- -: 5073: }
- -: 5074:
- 23: 5075: if (!arrayCount) {
-branch 0 taken 9% (fallthrough)
-branch 1 taken 91%
- 2: 5076: *array = allocSArray();;
+ -: 5146: }
+ -: 5147: }
+ -: 5148:
+ 24: 5149: if (!arrayCount) {
+branch 0 taken 8% (fallthrough)
+branch 1 taken 92%
+ 2: 5150: *array = allocSArray();;
call 0 returned 100%
- 2: 5077: ret;
- -: 5078: }
- -: 5079:
- 21: 5080: switch(type) {
+ 2: 5151: ret;
+ -: 5152: }
+ -: 5153:
+ 22: 5154: switch(type) {
branch 0 taken 5%
-branch 1 taken 10%
+branch 1 taken 9%
branch 2 taken 5%
branch 3 taken 5%
-branch 4 taken 52%
+branch 4 taken 50%
branch 5 taken 5%
-branch 6 taken 10%
+branch 6 taken 14%
branch 7 taken 0%
branch 8 taken 5%
branch 9 taken 5%
branch 10 taken 0%
- -: 5081: case S_UNDEFINED:
- 7: 5082: loop(arrayCount) {
+ -: 5155: case S_UNDEFINED:
+ 7: 5156: loop(arrayCount) {
branch 0 taken 86%
branch 1 taken 14% (fallthrough)
- 6: 5083: u = allocSUndefined();
+ 6: 5157: u = allocSUndefined();
call 0 returned 100%
- 6: 5084: sArrayPushTiny(array, (smallt *) u);
+ 6: 5158: sArrayPushTiny(array, (smallt *) u);
call 0 returned 100%
- -: 5085: }
- 1: 5086: break;
- -: 5087: case S_BOOL:
- 16: 5088: loop(arrayCount) {
+ -: 5159: }
+ 1: 5160: break;
+ -: 5161: case S_BOOL:
+ 16: 5162: loop(arrayCount) {
branch 0 taken 88%
branch 1 taken 13% (fallthrough)
- 14: 5089: if (!ctx->boolAddr) {
+ 14: 5163: if (!ctx->boolAddr) {
branch 0 taken 14% (fallthrough)
branch 1 taken 86%
- 2: 5090: read8bPackedBool;
- 2: 5091: ctx->boolShift = 0;
- -: 5092: }
- 14: 5093: if (ctx->boolShift == 8) {
+ 2: 5164: read8bPackedBool;
+ 2: 5165: ctx->boolShift = 0;
+ -: 5166: }
+ 14: 5167: if (ctx->boolShift == 8) {
branch 0 taken 7% (fallthrough)
branch 1 taken 93%
- 1: 5094: read8bPackedBool;
- 1: 5095: bo = allocSBool((*ctx->boolAddr) & 0x1);
+ 1: 5168: read8bPackedBool;
+ 1: 5169: bo = allocSBool((*ctx->boolAddr) & 0x1);
call 0 returned 100%
- -: 5096: }
- -: 5097: else {
- 13: 5098: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
+ -: 5170: }
+ -: 5171: else {
+ 13: 5172: bo = allocSBool((*ctx->boolAddr) & (0x1 << (ctx->boolShift++)));
call 0 returned 100%
- -: 5099: }
- 14: 5100: sArrayPushTiny(array, (smallt *) bo);
+ -: 5173: }
+ 14: 5174: sArrayPushTiny(array, (smallt *) bo);
call 0 returned 100%
- -: 5101: }
- 2: 5102: break;
- -: 5103: case S_DICT:
- 3: 5104: loop(arrayCount) {
+ -: 5175: }
+ 2: 5176: break;
+ -: 5177: case S_DICT:
+ 3: 5178: loop(arrayCount) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 2: 5105: d = NULL;
- 2: 5106: dictNetDeserial(&d, data, ctx, /*packed=*/true);
+ 2: 5179: d = NULL;
+ 2: 5180: dictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 2: 5107: sArrayPushTiny(array, (smallt *) d);
+ 2: 5181: sArrayPushTiny(array, (smallt *) d);
call 0 returned 100%
- -: 5108: }
- 1: 5109: break;
- -: 5110: case S_DOUBLE:
- 4: 5111: loop(arrayCount) {
+ -: 5182: }
+ 1: 5183: break;
+ -: 5184: case S_DOUBLE:
+ 4: 5185: loop(arrayCount) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 5112: D = (double *)(*data);
- 3: 5113: *data += sizeof(double);
- 3: 5114: Do = allocSDouble(*D);
+ 3: 5186: D = (double *)(*data);
+ 3: 5187: *data += sizeof(double);
+ 3: 5188: Do = allocSDouble(*D);
call 0 returned 100%
- 3: 5115: sArrayPushTiny(array, (smallt *) Do);
+ 3: 5189: sArrayPushTiny(array, (smallt *) Do);
call 0 returned 100%
- -: 5116: }
- 1: 5117: break;
- -: 5118: case S_INT:
- 49: 5119: loop(arrayCount) {
+ -: 5190: }
+ 1: 5191: break;
+ -: 5192: case S_INT:
+ 49: 5193: loop(arrayCount) {
branch 0 taken 78%
branch 1 taken 22% (fallthrough)
- 38: 5120: i64 v = varintToUint(data);
+ 38: 5194: i64 v = varintToUint(data);
call 0 returned 100%
- 38: 5121: v = (v >> 1) ^ ((v << 63) >> 63);
- 38: 5122: io = allocSInt(v);
+ 38: 5195: v = (v >> 1) ^ ((v << 63) >> 63);
+ 38: 5196: io = allocSInt(v);
call 0 returned 100%
- 38: 5123: sArrayPushTiny(array, (smallt *) io);
+ 38: 5197: sArrayPushTiny(array, (smallt *) io);
call 0 returned 100%
- -: 5124: }
- 11: 5125: break;
- -: 5126: case S_STRING:
- 4: 5127: loop(arrayCount) {
+ -: 5198: }
+ 11: 5199: break;
+ -: 5200: case S_STRING:
+ 4: 5201: loop(arrayCount) {
branch 0 taken 75%
branch 1 taken 25% (fallthrough)
- 3: 5128: s = (char *)(*data);
- 3: 5129: *data += strlen(s)+1;
- 3: 5130: so = allocSStringTiny(s);
+ 3: 5202: s = (char *)(*data);
+ 3: 5203: *data += strlen(s)+1;
+ 3: 5204: so = allocSStringTiny(s);
call 0 returned 100%
- 3: 5131: sArrayPushTiny(array, (smallt *) so);
+ 3: 5205: sArrayPushTiny(array, (smallt *) so);
call 0 returned 100%
- -: 5132: }
- 1: 5133: break;
- -: 5134: case S_ARRAY:
- 6: 5135: loop(arrayCount) {
-branch 0 taken 67%
-branch 1 taken 33% (fallthrough)
- 4: 5136: a = NULL;
- 4: 5137: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
+ -: 5206: }
+ 1: 5207: break;
+ -: 5208: case S_ARRAY:
+ 8: 5209: loop(arrayCount) {
+branch 0 taken 63%
+branch 1 taken 38% (fallthrough)
+ 5: 5210: a = NULL;
+ 5: 5211: arrayNetDeserial(&a, data, ctx, /*packed=*/true);
call 0 returned 100%
- 4: 5138: sArrayPushTiny(array, (smallt *) a);
+ 5: 5212: sArrayPushTiny(array, (smallt *) a);
call 0 returned 100%
- -: 5139: }
- 2: 5140: break;
- -: 5141: case S_BYTES:
- #####: 5142: loop(arrayCount) {
+ -: 5213: }
+ 3: 5214: break;
+ -: 5215: case S_BYTES:
+ #####: 5216: loop(arrayCount) {
branch 0 never executed
branch 1 never executed
- #####: 5143: B = allocSBytes();
+ #####: 5217: B = allocSBytes();
call 0 never executed
- #####: 5144: count = varintToUint((u8**)data);
+ #####: 5218: count = varintToUint((u8**)data);
call 0 never executed
- #####: 5145: sBytesPushBuffer(&B, data, count);
+ #####: 5219: sBytesPushBuffer(&B, data, count);
call 0 never executed
- #####: 5146: *data += count;
- #####: 5147: sArrayPushTiny(array, (smallt *) B);
+ #####: 5220: *data += count;
+ #####: 5221: sArrayPushTiny(array, (smallt *) B);
call 0 never executed
- -: 5148: }
- #####: 5149: break;
- -: 5150: case UNIFORM_DICT:
- 3: 5151: loop(arrayCount) {
+ -: 5222: }
+ #####: 5223: break;
+ -: 5224: case UNIFORM_DICT:
+ 3: 5225: loop(arrayCount) {
branch 0 taken 67%
branch 1 taken 33% (fallthrough)
- 2: 5152: d = NULL;
- 2: 5153: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
+ 2: 5226: d = NULL;
+ 2: 5227: uniformDictNetDeserial(&d, data, ctx, /*packed=*/true);
call 0 returned 100%
- 2: 5154: sArrayPushTiny(array, (smallt *) d);
+ 2: 5228: sArrayPushTiny(array, (smallt *) d);
call 0 returned 100%
- -: 5155: }
- 1: 5156: break;
- -: 5157: case UNIFORM_ARRAY:
- 2: 5158: loop(arrayCount) {
+ -: 5229: }
+ 1: 5230: break;
+ -: 5231: case UNIFORM_ARRAY:
+ 2: 5232: loop(arrayCount) {
branch 0 taken 50%
branch 1 taken 50% (fallthrough)
- 1: 5159: a = NULL;
- 1: 5160: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
-call 0 returned 100%
- 1: 5161: sArrayPushTiny(array, (smallt *) a);
-call 0 returned 100%
- -: 5162: }
- 1: 5163: break;
- -: 5164: }
- -: 5165:}
- -: 5166:
-function deserialNetSerial called 76 returned 100% blocks executed 78%
- 76: 5167:internal smallJsont* deserialNetSerial(smallJsont *self, smallBytest *data) {
- -: 5168:
- 76: 5169: if (!data) {
+ 1: 5233: a = NULL;
+ 1: 5234: uniformArrayNetDeserial(&a, data, ctx, /*packed=*/true);
+call 0 returned 100%
+ 1: 5235: sArrayPushTiny(array, (smallt *) a);
+call 0 returned 100%
+ -: 5236: }
+ 1: 5237: break;
+ -: 5238: }
+ -: 5239:}
+ -: 5240:
+function deserialNetSerial called 77 returned 100% blocks executed 78%
+ 77: 5241:internal smallJsont* deserialNetSerial(smallJsont *self, smallBytest *data) {
+ -: 5242:
+ 77: 5243: if (!data) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 5170: ret self;
- -: 5171: }
- -: 5172:
- 76: 5173: smallt *o = netDeserial(data->B);
+ #####: 5244: ret self;
+ -: 5245: }
+ -: 5246:
+ 77: 5247: smallt *o = netDeserial(data->B);
call 0 returned 100%
- -: 5174:
- 76: 5175: if (!o) {
+ -: 5248:
+ 77: 5249: if (!o) {
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
- #####: 5176: ret self;
- -: 5177: }
- -: 5178:
- 76: 5179: freeG(self);
-call 0 returned 100%
- -: 5180:
- 76: 5181: setsoG(self, o);
-call 0 returned 100%
- -: 5182:
- 76: 5183: ret self;
- -: 5184:}
- -: 5185:
- -: 5186:// vim: set expandtab ts=2 sw=2:
+ #####: 5250: ret self;
+ -: 5251: }
+ -: 5252:
+ 77: 5253: freeG(self);
+call 0 returned 100%
+ -: 5254:
+ 77: 5255: setsoG(self, o);
+call 0 returned 100%
+ -: 5256:
+ 77: 5257: ret self;
+ -: 5258:}
+ -: 5259:
+ -: 5260:// vim: set expandtab ts=2 sw=2:
diff --git a/package.yml b/package.yml
@@ -1,6 +1,6 @@
---
name: netSerial
- version: 0.0.2
+ version: 0.0.3
description: "network serializer with binary format more compact than the default serializer in smallJson"
bin: ./netSerial.c
#cflags: -DA -ggdb -std=gnu11 -fPIC -pipe
diff --git a/testNetSerial.c b/testNetSerial.c
@@ -1515,6 +1515,20 @@ START_TEST(variousT)
terminateG(B);
freeManyG(&n, &ds);
+ parseG(&n, "[[{a:1}, null, {a:1}, {a:1}]]");
+ logVarG(&n);
+ B = serialG(&n);
+ logI("len %u", lenG(B));
+ logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
+ s = sToString((smallt *) B->B);
+ ck_assert_str_eq(s, "[111,1,4,78,1,97,0,2,-32,20,97,0,2,78,1,97,0,2]");
+ free(s);
+ deserialG(&ds, B);
+ s = toStringG(&ds);
+ ck_assert_str_eq(s, "[[{\"a\":1},null,{\"a\":1},{\"a\":1}]]");
+ free(s);
+ terminateG(B);
+ freeManyG(&n, &ds);
END_TEST
diff --git a/testNetSerial.sh b/testNetSerial.sh
@@ -1,5 +1,5 @@
spm test
-cd ~/.sheepy/build/home/remy/git/sw/sheepyPackagesGitHub/netSerial/
+cd ~/.sheepy/build/home/$USER/git/sw/sheepyPackagesGitHub/netSerial/
gcov -b netSerial.c
cd -
-cp ~/.sheepy/build/home/remy/git/sw/sheepyPackagesGitHub/netSerial/netSerial.c.gcov .
+cp ~/.sheepy/build/home/$USER/git/sw/sheepyPackagesGitHub/netSerial/netSerial.c.gcov .
