UA_unbase64: 75| 38|UA_unbase64(const unsigned char *src, size_t len, size_t *out_len) { 76| | /* Empty base64 results in an empty byte-string */ 77| 38| if(len == 0) { ------------------ | Branch (77:8): [True: 4, False: 34] ------------------ 78| 4| *out_len = 0; 79| 4| return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 4|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 80| 4| } 81| | 82| | /* Allocate the output string. Append four bytes to allow missing padding */ 83| 34| size_t olen = (len / 4 * 3) + 4; 84| 34| unsigned char *out = (unsigned char*)UA_malloc(olen); ------------------ | | 350| 34|# define UA_malloc(size) UA_mallocSingleton(size) ------------------ 85| 34| if(!out) ------------------ | Branch (85:8): [True: 0, False: 34] ------------------ 86| 0| return NULL; 87| | 88| | /* Iterate over the input */ 89| 34| size_t pad = 0; 90| 34| unsigned char count = 0; 91| 34| unsigned char block[4]; 92| 34| unsigned char *pos = out; 93| 719| for(size_t i = 0; i < len; i++) { ------------------ | Branch (93:23): [True: 702, False: 17] ------------------ 94| 702| if(src[i] & 0x80) ------------------ | Branch (94:12): [True: 6, False: 696] ------------------ 95| 6| goto error; /* Non-ASCII input */ 96| 696| unsigned char tmp = dtable[src[i]]; 97| 696| if(tmp == 0x80) ------------------ | Branch (97:12): [True: 8, False: 688] ------------------ 98| 8| goto error; /* Not an allowed character */ 99| 688| if(tmp == 0x7f) ------------------ | Branch (99:12): [True: 57, False: 631] ------------------ 100| 57| continue; /* Whitespace is ignored to accomodate RFC 2045, used in 101| | * XML for xs:base64Binary. */ 102| 631| block[count++] = tmp; 103| | 104| | /* Padding */ 105| 631| if(src[i] == '=') { ------------------ | Branch (105:12): [True: 57, False: 574] ------------------ 106| 57| if(count < 3) /* Padding can only be the last two bytes of a block */ ------------------ | Branch (106:16): [True: 3, False: 54] ------------------ 107| 3| goto error; 108| 54| block[count-1] = 0; 109| 54| pad++; 110| 574| } else if(pad > 0) { ------------------ | Branch (110:19): [True: 0, False: 574] ------------------ 111| 0| goto error; /* Padding not terminated correctly */ 112| 0| } 113| | 114| | /* Write three output characters for four characters of input */ 115| 628| if(count == 4) { ------------------ | Branch (115:12): [True: 152, False: 476] ------------------ 116| 152| if(pad > 2) ------------------ | Branch (116:16): [True: 0, False: 152] ------------------ 117| 0| goto error; /* Invalid padding */ 118| 152| *pos++ = (block[0] << 2) | (block[1] >> 4); 119| 152| *pos++ = (block[1] << 4) | (block[2] >> 2); 120| 152| *pos++ = (block[2] << 6) | block[3]; 121| 152| count = 0; 122| 152| pos -= pad; 123| 152| pad = 0; 124| 152| } 125| 628| } 126| | 127| | /* Input length not a multiple of four */ 128| 17| if(count > 0) ------------------ | Branch (128:8): [True: 9, False: 8] ------------------ 129| 9| goto error; 130| | 131| 8| *out_len = (size_t)(pos - out); 132| 8| if(*out_len == 0) { ------------------ | Branch (132:8): [True: 1, False: 7] ------------------ 133| 1| UA_free(out); ------------------ | | 351| 1|# define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 134| 1| return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 1|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 135| 1| } 136| 7| return out; 137| | 138| 26| error: 139| 26| UA_free(out); ------------------ | | 351| 26|# define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 140| | return NULL; 141| 8|} musl_tm_to_secs: 149| 436|musl_tm_to_secs(const struct musl_tm *tm) { 150| 436| int is_leap; 151| 436| long long year = tm->tm_year; 152| 436| int month = tm->tm_mon; 153| 436| if (month >= 12 || month < 0) { ------------------ | Branch (153:9): [True: 233, False: 203] | Branch (153:24): [True: 15, False: 188] ------------------ 154| 248| int adj = month / 12; 155| 248| month %= 12; 156| 248| if (month < 0) { ------------------ | Branch (156:13): [True: 15, False: 233] ------------------ 157| 15| adj--; 158| 15| month += 12; 159| 15| } 160| 248| year += adj; 161| 248| } 162| 436| long long t = musl_year_to_secs(year, &is_leap); 163| 436| t += musl_month_to_secs(month, is_leap); 164| 436| t += 86400LL * (tm->tm_mday-1); 165| 436| t += 3600LL * tm->tm_hour; 166| 436| t += 60LL * tm->tm_min; 167| 436| t += tm->tm_sec; 168| 436| return t; 169| 436|} libc_time.c:musl_year_to_secs: 101| 436|musl_year_to_secs(const long long year, int *is_leap) { 102| 436| if (year-2ULL <= 136) { ------------------ | Branch (102:9): [True: 27, False: 409] ------------------ 103| 27| int y = (int)year; 104| 27| int leaps = (y-68)>>2; 105| 27| if (!((y-68)&3)) { ------------------ | Branch (105:13): [True: 7, False: 20] ------------------ 106| 7| leaps--; 107| 7| if (is_leap) *is_leap = 1; ------------------ | Branch (107:17): [True: 7, False: 0] ------------------ 108| 20| } else if (is_leap) *is_leap = 0; ------------------ | Branch (108:20): [True: 20, False: 0] ------------------ 109| 27| return 31536000*(y-70) + 86400*leaps; 110| 27| } 111| | 112| 409| int cycles, centuries, leaps, rem, dummy; 113| | 114| 409| if (!is_leap) is_leap = &dummy; ------------------ | Branch (114:9): [True: 0, False: 409] ------------------ 115| 409| cycles = (int)((year-100) / 400); 116| 409| rem = (int)((year-100) % 400); 117| 409| if (rem < 0) { ------------------ | Branch (117:9): [True: 264, False: 145] ------------------ 118| 264| cycles--; 119| 264| rem += 400; 120| 264| } 121| 409| if (!rem) { ------------------ | Branch (121:9): [True: 28, False: 381] ------------------ 122| 28| *is_leap = 1; 123| 28| centuries = 0; 124| 28| leaps = 0; 125| 381| } else { 126| 381| if (rem >= 200) { ------------------ | Branch (126:13): [True: 130, False: 251] ------------------ 127| 130| if (rem >= 300) centuries = 3, rem -= 300; ------------------ | Branch (127:17): [True: 109, False: 21] ------------------ 128| 21| else centuries = 2, rem -= 200; 129| 251| } else { 130| 251| if (rem >= 100) centuries = 1, rem -= 100; ------------------ | Branch (130:17): [True: 14, False: 237] ------------------ 131| 237| else centuries = 0; 132| 251| } 133| 381| if (!rem) { ------------------ | Branch (133:13): [True: 1, False: 380] ------------------ 134| 1| *is_leap = 0; 135| 1| leaps = 0; 136| 380| } else { 137| 380| leaps = rem / 4; 138| 380| rem %= 4; 139| 380| *is_leap = !rem; 140| 380| } 141| 381| } 142| | 143| 409| leaps += 97*cycles + 24*centuries - *is_leap; 144| | 145| 409| return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400; 146| 436|} libc_time.c:musl_month_to_secs: 93| 436|musl_month_to_secs(int month, int is_leap) { 94| 436| int t = secs_through_month[month]; 95| 436| if (is_leap && month >= 2) ------------------ | Branch (95:9): [True: 181, False: 255] | Branch (95:20): [True: 164, False: 17] ------------------ 96| 164| t+=86400; 97| 436| return t; 98| 436|} parseUInt64: 30| 3.07k|parseUInt64(const char *str, size_t size, uint64_t *result) { 31| 3.07k| size_t i = 0; 32| 3.07k| uint64_t n = 0, prev = 0; 33| | 34| | /* Hex */ 35| 3.07k| if(size > 2 && str[0] == '0' && (str[1] | 32) == 'x') { ------------------ | Branch (35:8): [True: 563, False: 2.51k] | Branch (35:20): [True: 44, False: 519] | Branch (35:37): [True: 20, False: 24] ------------------ 36| 20| i = 2; 37| 46| for(; i < size; i++) { ------------------ | Branch (37:15): [True: 43, False: 3] ------------------ 38| 43| uint8_t c = (uint8_t)str[i] | 32; 39| 43| if(c >= '0' && c <= '9') ------------------ | Branch (39:16): [True: 39, False: 4] | Branch (39:28): [True: 15, False: 24] ------------------ 40| 15| c = (uint8_t)(c - '0'); 41| 28| else if(c >= 'a' && c <='f') ------------------ | Branch (41:21): [True: 23, False: 5] | Branch (41:33): [True: 11, False: 12] ------------------ 42| 11| c = (uint8_t)(c - 'a' + 10); 43| 17| else if(c >= 'A' && c <='F') ------------------ | Branch (43:21): [True: 12, False: 5] | Branch (43:33): [True: 0, False: 12] ------------------ 44| 0| c = (uint8_t)(c - 'A' + 10); 45| 17| else 46| 17| break; 47| 26| n = (n << 4) | (c & 0xF); 48| 26| if(n < prev) /* Check for overflow */ ------------------ | Branch (48:16): [True: 0, False: 26] ------------------ 49| 0| return 0; 50| 26| prev = n; 51| 26| } 52| 20| *result = n; 53| 20| return (i > 2) ? i : 0; /* 2 -> No digit was parsed */ ------------------ | Branch (53:16): [True: 14, False: 6] ------------------ 54| 20| } 55| | 56| | /* Decimal */ 57| 9.14k| for(; i < size; i++) { ------------------ | Branch (57:11): [True: 6.75k, False: 2.38k] ------------------ 58| 6.75k| if(str[i] < '0' || str[i] > '9') ------------------ | Branch (58:12): [True: 596, False: 6.16k] | Branch (58:28): [True: 76, False: 6.08k] ------------------ 59| 672| break; 60| | /* Fast multiplication: n*10 == (n*8) + (n*2) */ 61| 6.08k| n = (n << 3) + (n << 1) + (uint8_t)(str[i] - '0'); 62| 6.08k| if(n < prev) /* Check for overflow */ ------------------ | Branch (62:12): [True: 0, False: 6.08k] ------------------ 63| 0| return 0; 64| 6.08k| prev = n; 65| 6.08k| } 66| 3.05k| *result = n; 67| 3.05k| return i; 68| 3.05k|} parseInt64: 71| 563|parseInt64(const char *str, size_t size, int64_t *result) { 72| | /* Negative value? */ 73| 563| size_t i = 0; 74| 563| bool neg = false; 75| 563| if(*str == '-' || *str == '+') { ------------------ | Branch (75:8): [True: 6, False: 557] | Branch (75:23): [True: 1, False: 556] ------------------ 76| 7| neg = (*str == '-'); 77| 7| i++; 78| 7| } 79| | 80| | /* Parse as unsigned */ 81| 563| uint64_t n = 0; 82| 563| size_t len = parseUInt64(&str[i], size - i, &n); 83| 563| if(len == 0) ------------------ | Branch (83:8): [True: 31, False: 532] ------------------ 84| 31| return 0; 85| | 86| | /* Check for overflow, adjust and return */ 87| 532| if(!neg) { ------------------ | Branch (87:8): [True: 526, False: 6] ------------------ 88| 526| if(n > 9223372036854775807UL) ------------------ | Branch (88:12): [True: 0, False: 526] ------------------ 89| 0| return 0; 90| 526| *result = (int64_t)n; 91| 526| } else { 92| 6| if(n > 9223372036854775808UL) ------------------ | Branch (92:12): [True: 0, False: 6] ------------------ 93| 0| return 0; 94| 6| *result = -(int64_t)n; 95| 6| } 96| 532| return len + i; 97| 532|} UA_STRING: 219| 1|UA_STRING(char *chars) { 220| 1| UA_String s = {0, NULL}; 221| 1| if(!chars) ------------------ | Branch (221:8): [True: 0, False: 1] ------------------ 222| 0| return s; 223| 1| s.length = strlen(chars); 224| 1| s.data = (UA_Byte*)chars; 225| 1| return s; 226| 1|} UA_String_append: 295| 1|UA_String_append(UA_String *s, const UA_String s2) { 296| 1| if(s2.length == 0) ------------------ | Branch (296:8): [True: 0, False: 1] ------------------ 297| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 298| 1| UA_Byte *buf = (UA_Byte*)UA_realloc(s->data, s->length + s2.length); ------------------ | | 353| 1|# define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 299| 1| if(!buf) ------------------ | Branch (299:8): [True: 0, False: 1] ------------------ 300| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 301| 1| memcpy(buf + s->length, s2.data, s2.length); 302| 1| s->data = buf; 303| 1| s->length += s2.length; 304| 1| return UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 305| 1|} UA_DateTime_parse: 531| 594|UA_DateTime_parse(UA_DateTime *dst, const UA_String str) { 532| 594| if(str.length == 0) ------------------ | Branch (532:8): [True: 0, False: 594] ------------------ 533| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 534| | 535| 594| struct musl_tm dts; 536| 594| memset(&dts, 0, sizeof(dts)); 537| | 538| | /* Parse the year. The ISO standard asks for four digits. But we accept up 539| | * to five with an optional plus or minus in front due to the range of the 540| | * DateTime 64bit integer. But in that case we require the year and the 541| | * month to be separated by a '-'. Otherwise we cannot know where the month 542| | * starts. */ 543| 594| size_t pos = 0; 544| 594| if(str.data[0] == '-' || str.data[0] == '+') ------------------ | Branch (544:8): [True: 9, False: 585] | Branch (544:30): [True: 2, False: 583] ------------------ 545| 11| pos++; 546| 594| UA_Int64 year = 0; 547| 594| UA_CHECK(str.length - pos > 5, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 594| do { \ | | 173| 594| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 594|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 31, False: 563] | | | | ------------------ | | ------------------ | | 174| 31| EVAL_ON_ERROR; \ | | 175| 31| } \ | | 176| 594| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 563] | | ------------------ ------------------ 548| 563| size_t len = parseInt64((char*)&str.data[pos], 5, &year); 549| 563| pos += len; 550| 563| UA_CHECK(len > 0 && pos < str.length, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 563| do { \ | | 173| 563| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 1.09k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 31, False: 532] | | | | | Branch (591:43): [True: 532, False: 31] | | | | | Branch (591:43): [True: 532, False: 0] | | | | ------------------ | | ------------------ | | 174| 31| EVAL_ON_ERROR; \ | | 175| 31| } \ | | 176| 563| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 532] | | ------------------ ------------------ 551| 532| UA_CHECK(len == 4 || str.data[pos] == '-', return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 532| do { \ | | 173| 532| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 980|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 53, False: 479] | | | | | Branch (591:43): [True: 84, False: 448] | | | | | Branch (591:43): [True: 395, False: 53] | | | | ------------------ | | ------------------ | | 174| 53| EVAL_ON_ERROR; \ | | 175| 53| } \ | | 176| 532| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 479] | | ------------------ ------------------ 552| 479| if(str.data[0] == '-') ------------------ | Branch (552:8): [True: 3, False: 476] ------------------ 553| 3| year = -year; 554| 479| dts.tm_year = (UA_Int16)year - 1900; 555| 479| if(str.data[pos] == '-') ------------------ | Branch (555:8): [True: 469, False: 10] ------------------ 556| 469| pos++; 557| | 558| | /* Parse the month */ 559| 479| UA_UInt64 month = 0; 560| 479| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 479| do { \ | | 173| 479| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 479|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 14, False: 465] | | | | ------------------ | | ------------------ | | 174| 14| EVAL_ON_ERROR; \ | | 175| 14| } \ | | 176| 479| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 465] | | ------------------ ------------------ 561| 465| len = parseUInt64((char*)&str.data[pos], 2, &month); 562| 465| pos += len; 563| 465| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 465| do { \ | | 173| 465| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 465|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 2, False: 463] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 465| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 463] | | ------------------ ------------------ 564| 463| dts.tm_mon = (UA_UInt16)month - 1; 565| 463| if(str.data[pos] == '-') ------------------ | Branch (565:8): [True: 22, False: 441] ------------------ 566| 22| pos++; 567| | 568| | /* Parse the day and check the T between date and time */ 569| 463| UA_UInt64 day = 0; 570| 463| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 463| do { \ | | 173| 463| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 463|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 2, False: 461] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 463| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 461] | | ------------------ ------------------ 571| 461| len = parseUInt64((char*)&str.data[pos], 2, &day); 572| 461| pos += len; 573| 461| UA_CHECK(len == 2 || str.data[pos] != 'T', ------------------ | | 172| 461| do { \ | | 173| 461| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 770|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 3, False: 458] | | | | | Branch (591:43): [True: 152, False: 309] | | | | | Branch (591:43): [True: 306, False: 3] | | | | ------------------ | | ------------------ | | 174| 3| EVAL_ON_ERROR; \ | | 175| 3| } \ | | 176| 461| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 458] | | ------------------ ------------------ 574| 461| return UA_STATUSCODE_BADDECODINGERROR); 575| 458| dts.tm_mday = (UA_UInt16)day; 576| 458| pos++; 577| | 578| | /* Parse the hour */ 579| 458| UA_UInt64 hour = 0; 580| 458| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 458| do { \ | | 173| 458| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 458|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 4, False: 454] | | | | ------------------ | | ------------------ | | 174| 4| EVAL_ON_ERROR; \ | | 175| 4| } \ | | 176| 458| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 454] | | ------------------ ------------------ 581| 454| len = parseUInt64((char*)&str.data[pos], 2, &hour); 582| 454| pos += len; 583| 454| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 454| do { \ | | 173| 454| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 454|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 2, False: 452] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 454| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 452] | | ------------------ ------------------ 584| 452| dts.tm_hour = (UA_UInt16)hour; 585| 452| if(str.data[pos] == ':') ------------------ | Branch (585:8): [True: 1, False: 451] ------------------ 586| 1| pos++; 587| | 588| | /* Parse the minute */ 589| 452| UA_UInt64 min = 0; 590| 452| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 452| do { \ | | 173| 452| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 452|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 6, False: 446] | | | | ------------------ | | ------------------ | | 174| 6| EVAL_ON_ERROR; \ | | 175| 6| } \ | | 176| 452| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 446] | | ------------------ ------------------ 591| 446| len = parseUInt64((char*)&str.data[pos], 2, &min); 592| 446| pos += len; 593| 446| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 446| do { \ | | 173| 446| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 446|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 1, False: 445] | | | | ------------------ | | ------------------ | | 174| 1| EVAL_ON_ERROR; \ | | 175| 1| } \ | | 176| 446| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 445] | | ------------------ ------------------ 594| 445| dts.tm_min = (UA_UInt16)min; 595| 445| if(str.data[pos] == ':') ------------------ | Branch (595:8): [True: 1, False: 444] ------------------ 596| 1| pos++; 597| | 598| | /* Parse the second */ 599| 445| UA_UInt64 sec = 0; 600| 445| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 445| do { \ | | 173| 445| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 445|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 6, False: 439] | | | | ------------------ | | ------------------ | | 174| 6| EVAL_ON_ERROR; \ | | 175| 6| } \ | | 176| 445| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 439] | | ------------------ ------------------ 601| 439| len = parseUInt64((char*)&str.data[pos], 2, &sec); 602| 439| pos += len; 603| 439| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 439| do { \ | | 173| 439| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 439|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 3, False: 436] | | | | ------------------ | | ------------------ | | 174| 3| EVAL_ON_ERROR; \ | | 175| 3| } \ | | 176| 439| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 436] | | ------------------ ------------------ 604| 436| dts.tm_sec = (UA_UInt16)sec; 605| | 606| | /* Compute the seconds since the Unix epoch */ 607| 436| long long sinceunix = musl_tm_to_secs(&dts); 608| | 609| | /* Are we within the range that can be represented? */ 610| 436| long long sinceunix_min = 611| 436| (long long)(UA_INT64_MIN / UA_DATETIME_SEC) - ------------------ | | 119| 436|#define UA_INT64_MIN ((int64_t)-UA_INT64_MAX-1LL) | | ------------------ | | | | 118| 436|#define UA_INT64_MAX (int64_t)9223372036854775807LL | | ------------------ ------------------ (long long)(UA_INT64_MIN / UA_DATETIME_SEC) - ------------------ | | 285| 436|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 436|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 436|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 612| 436| (long long)(UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC) - ------------------ | | 327| 436|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 436|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 436|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 436|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (long long)(UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC) - ------------------ | | 285| 436|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 436|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 436|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 613| 436| (long long)1; /* manual correction due to rounding */ 614| 436| long long sinceunix_max = (long long) 615| 436| ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 118| 436|#define UA_INT64_MAX (int64_t)9223372036854775807LL ------------------ ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 327| 436|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 436|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 436|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 436|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 285| 436|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 436|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 436|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 616| 436| if(sinceunix < sinceunix_min || sinceunix > sinceunix_max) ------------------ | Branch (616:8): [True: 28, False: 408] | Branch (616:37): [True: 5, False: 403] ------------------ 617| 33| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 33|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 618| | 619| | /* Convert to DateTime. Add or subtract one extra second here to prevent 620| | * underflow/overflow. This is reverted once the fractional part has been 621| | * added. */ 622| 403| sinceunix -= (sinceunix > 0) ? 1 : -1; ------------------ | Branch (622:18): [True: 127, False: 276] ------------------ 623| 403| UA_DateTime dt = (UA_DateTime) 624| 403| (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 327| 403|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 403|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 403|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 403|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 285| 403|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 403|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 403|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 285| 403|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 403|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 403|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 625| | 626| | /* Parse the fraction of the second if defined */ 627| 403| UA_CHECK(pos < str.length, goto finish); ------------------ | | 172| 403| do { \ | | 173| 403| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 403|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 190, False: 213] | | | | ------------------ | | ------------------ | | 174| 190| EVAL_ON_ERROR; \ | | 175| 190| } \ | | 176| 403| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 213] | | ------------------ ------------------ 628| 213| if(str.data[pos] == ',' || str.data[pos] == '.') { ------------------ | Branch (628:8): [True: 76, False: 137] | Branch (628:32): [True: 31, False: 106] ------------------ 629| 107| pos++; 630| 107| double frac = 0.0; 631| 107| double denom = 0.1; 632| 23.6k| while(pos < str.length && str.data[pos] >= '0' && str.data[pos] <= '9') { ------------------ | Branch (632:15): [True: 23.5k, False: 53] | Branch (632:35): [True: 23.5k, False: 46] | Branch (632:59): [True: 23.5k, False: 8] ------------------ 633| 23.5k| frac += denom * (str.data[pos] - '0'); 634| 23.5k| denom *= 0.1; 635| 23.5k| pos++; 636| 23.5k| } 637| 107| frac += 0.00000005; /* Correct rounding when converting to integer */ 638| 107| dt += (UA_DateTime)(frac * UA_DATETIME_SEC); ------------------ | | 285| 107|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 107|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 107|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 639| 107| } 640| | 641| | /* Time zone handling */ 642| 213| UA_CHECK(pos < str.length, goto finish); ------------------ | | 172| 213| do { \ | | 173| 213| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 213|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 53, False: 160] | | | | ------------------ | | ------------------ | | 174| 53| EVAL_ON_ERROR; \ | | 175| 53| } \ | | 176| 213| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 160] | | ------------------ ------------------ 643| 160| if(str.data[pos] == 'Z') { ------------------ | Branch (643:8): [True: 1, False: 159] ------------------ 644| 1| pos++; 645| 159| } else if(str.data[pos] == '+' || str.data[pos] == '-') { ------------------ | Branch (645:15): [True: 78, False: 81] | Branch (645:39): [True: 54, False: 27] ------------------ 646| 132| UA_UInt64 tzHour = 0, tzMin = 0; 647| 132| UA_Int64 offsetSeconds = 0; 648| 132| UA_Byte tzSign = str.data[pos++]; 649| | 650| 132| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 132| do { \ | | 173| 132| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 132|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 2, False: 130] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 132| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 130] | | ------------------ ------------------ 651| 130| len = parseUInt64((char*)&str.data[pos], 2, &tzHour); 652| 130| pos += len; 653| 130| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 130| do { \ | | 173| 130| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 130|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 5, False: 125] | | | | ------------------ | | ------------------ | | 174| 5| EVAL_ON_ERROR; \ | | 175| 5| } \ | | 176| 130| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 125] | | ------------------ ------------------ 654| | 655| 125| UA_CHECK(str.length > pos, goto finish); /* Allow missing tz minutes */ ------------------ | | 172| 125| do { \ | | 173| 125| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 125|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 0, False: 125] | | | | ------------------ | | ------------------ | | 174| 0| EVAL_ON_ERROR; \ | | 175| 0| } \ | | 176| 125| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 125] | | ------------------ ------------------ 656| 125| if(str.data[pos] == ':') ------------------ | Branch (656:12): [True: 1, False: 124] ------------------ 657| 1| pos++; 658| | 659| 125| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 125| do { \ | | 173| 125| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 125|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 7, False: 118] | | | | ------------------ | | ------------------ | | 174| 7| EVAL_ON_ERROR; \ | | 175| 7| } \ | | 176| 125| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 118] | | ------------------ ------------------ 660| 118| len = parseUInt64((char*)&str.data[pos], 2, &tzMin); 661| 118| pos += len; 662| 118| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 118| do { \ | | 173| 118| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 591| 118|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (591:25): [True: 26, False: 92] | | | | ------------------ | | ------------------ | | 174| 26| EVAL_ON_ERROR; \ | | 175| 26| } \ | | 176| 118| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 92] | | ------------------ ------------------ 663| | 664| 92| offsetSeconds = (tzHour * 3600) + (tzMin * 60); 665| 92| if(tzSign == '-') ------------------ | Branch (665:12): [True: 29, False: 63] ------------------ 666| 29| offsetSeconds = -offsetSeconds; 667| 92| dt -= (UA_DateTime)(offsetSeconds * UA_DATETIME_SEC); ------------------ | | 285| 92|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 92|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 92|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 668| 92| } else { 669| 27| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 27|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 670| 27| } 671| | 672| 336| finish: 673| | /* Remove the underflow/overflow protection (see above) */ 674| 336| if(sinceunix > 0) { ------------------ | Branch (674:8): [True: 122, False: 214] ------------------ 675| 122| if(dt > UA_INT64_MAX - UA_DATETIME_SEC) ------------------ | | 118| 122|#define UA_INT64_MAX (int64_t)9223372036854775807LL ------------------ if(dt > UA_INT64_MAX - UA_DATETIME_SEC) ------------------ | | 285| 122|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 122|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 122|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ | Branch (675:12): [True: 3, False: 119] ------------------ 676| 3| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 3|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 677| 119| dt += UA_DATETIME_SEC; ------------------ | | 285| 119|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 119|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 119|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 678| 214| } else { 679| 214| if(dt < UA_INT64_MIN + UA_DATETIME_SEC) ------------------ | | 119| 214|#define UA_INT64_MIN ((int64_t)-UA_INT64_MAX-1LL) | | ------------------ | | | | 118| 214|#define UA_INT64_MAX (int64_t)9223372036854775807LL | | ------------------ ------------------ if(dt < UA_INT64_MIN + UA_DATETIME_SEC) ------------------ | | 285| 214|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 214|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 214|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ | Branch (679:12): [True: 17, False: 197] ------------------ 680| 17| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 17|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 681| 197| dt -= UA_DATETIME_SEC; ------------------ | | 285| 197|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 197|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 197|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 682| 197| } 683| | 684| | /* We must be at the end of the string */ 685| 316| if(pos != str.length) ------------------ | Branch (685:8): [True: 59, False: 257] ------------------ 686| 59| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 59|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 687| | 688| 257| *dst = dt; 689| 257| return UA_STATUSCODE_GOOD; ------------------ | | 16| 257|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 690| 316|} UA_ByteString_allocBuffer: 757| 2.09k|UA_ByteString_allocBuffer(UA_ByteString *bs, size_t length) { 758| 2.09k| UA_ByteString_init(bs); 759| 2.09k| if(length == 0) { ------------------ | Branch (759:8): [True: 0, False: 2.09k] ------------------ 760| 0| bs->data = (u8*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 0|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 761| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 762| 0| } 763| 2.09k| bs->data = (u8*)UA_calloc(1,length); ------------------ | | 352| 2.09k|# define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 764| 2.09k| if(UA_UNLIKELY(!bs->data)) ------------------ | | 591| 2.09k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | ------------------ | | | Branch (591:25): [True: 0, False: 2.09k] | | ------------------ ------------------ 765| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 766| 2.09k| bs->length = length; 767| 2.09k| return UA_STATUSCODE_GOOD; ------------------ | | 16| 2.09k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 768| 2.09k|} UA_NODEID_NUMERIC: 827| 555|UA_NODEID_NUMERIC(UA_UInt16 nsIndex, UA_UInt32 identifier) { 828| 555| UA_NodeId id; 829| 555| memset(&id, 0, sizeof(UA_NodeId)); 830| 555| id.namespaceIndex = nsIndex; 831| 555| id.identifierType = UA_NODEIDTYPE_NUMERIC; 832| 555| id.identifier.numeric = identifier; 833| 555| return id; 834| 555|} UA_copy: 2058| 153|UA_copy(const void *src, void *dst, const UA_DataType *type) { 2059| 153| memset(dst, 0, type->memSize); /* init */ 2060| 153| UA_StatusCode retval = copyJumpTable[type->typeKind](src, dst, type); 2061| 153| if(retval != UA_STATUSCODE_GOOD) ------------------ | | 16| 153|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (2061:8): [True: 0, False: 153] ------------------ 2062| 0| UA_clear(dst, type); 2063| 153| return retval; 2064| 153|} UA_clear: 2161| 4.53k|UA_clear(void *p, const UA_DataType *type) { 2162| 4.53k| clearJumpTable[type->typeKind](p, type); 2163| 4.53k| memset(p, 0, type->memSize); /* init */ 2164| 4.53k|} UA_order: 2615| 19|UA_Order UA_order(const void *p1, const void *p2, const UA_DataType *type) { 2616| 19| return orderJumpTable[type->typeKind](p1, p2, type); 2617| 19|} UA_Array_copy: 2639| 153| void **dst, const UA_DataType *type) { 2640| 153| if(size == 0) { ------------------ | Branch (2640:8): [True: 9, False: 144] ------------------ 2641| 9| if(src == NULL) ------------------ | Branch (2641:12): [True: 0, False: 9] ------------------ 2642| 0| *dst = NULL; 2643| 9| else 2644| 9| *dst= UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 9|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 2645| 9| return UA_STATUSCODE_GOOD; ------------------ | | 16| 9|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2646| 9| } 2647| | 2648| | /* Check the array consistency -- defensive programming in case the user 2649| | * manually created an inconsistent array */ 2650| 144| if(UA_UNLIKELY(!type || !src)) ------------------ | | 591| 288|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | ------------------ | | | Branch (591:25): [True: 0, False: 144] | | | Branch (591:43): [True: 0, False: 144] | | | Branch (591:43): [True: 0, False: 144] | | ------------------ ------------------ 2651| 0| return UA_STATUSCODE_BADINTERNALERROR; ------------------ | | 28| 0|#define UA_STATUSCODE_BADINTERNALERROR ((UA_StatusCode) 0x80020000) ------------------ 2652| | 2653| | /* calloc, so we don't have to check retval in every iteration of copying */ 2654| 144| *dst = UA_calloc(size, type->memSize); ------------------ | | 352| 144|# define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 2655| 144| if(!*dst) ------------------ | Branch (2655:8): [True: 0, False: 144] ------------------ 2656| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 2657| | 2658| 144| if(type->pointerFree) { ------------------ | Branch (2658:8): [True: 144, False: 0] ------------------ 2659| 144| memcpy(*dst, src, type->memSize * size); 2660| 144| return UA_STATUSCODE_GOOD; ------------------ | | 16| 144|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2661| 144| } 2662| | 2663| 0| uintptr_t ptrs = (uintptr_t)src; 2664| 0| uintptr_t ptrd = (uintptr_t)*dst; 2665| 0| UA_StatusCode retval = UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2666| 0| for(size_t i = 0; i < size; ++i) { ------------------ | Branch (2666:23): [True: 0, False: 0] ------------------ 2667| 0| retval |= UA_copy((void*)ptrs, (void*)ptrd, type); 2668| 0| ptrs += type->memSize; 2669| 0| ptrd += type->memSize; 2670| 0| } 2671| 0| if(retval != UA_STATUSCODE_GOOD) { ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (2671:8): [True: 0, False: 0] ------------------ 2672| 0| UA_Array_delete(*dst, size, type); 2673| | *dst = NULL; 2674| 0| } 2675| 0| return retval; 2676| 144|} UA_Array_delete: 2767| 5.08k|UA_Array_delete(void *p, size_t size, const UA_DataType *type) { 2768| 5.08k| if(!type->pointerFree) { ------------------ | Branch (2768:8): [True: 1.04k, False: 4.03k] ------------------ 2769| 1.04k| uintptr_t ptr = (uintptr_t)p; 2770| 1.04k| for(size_t i = 0; i < size; ++i) { ------------------ | Branch (2770:27): [True: 1, False: 1.04k] ------------------ 2771| 1| UA_clear((void*)ptr, type); 2772| 1| ptr += type->memSize; 2773| 1| } 2774| 1.04k| } 2775| 5.08k| UA_free((void*)((uintptr_t)p & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL)); ------------------ | | 351| 5.08k|# define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 2776| 5.08k|} ua_types.c:String_copy: 280| 153|String_copy(UA_String const *src, UA_String *dst, const UA_DataType *_) { 281| 153| UA_StatusCode res = 282| 153| UA_Array_copy(src->data, src->length, (void**)&dst->data, 283| 153| &UA_TYPES[UA_TYPES_BYTE]); ------------------ | | 89| 153|#define UA_TYPES_BYTE 2 ------------------ 284| 153| if(res == UA_STATUSCODE_GOOD) ------------------ | | 16| 153|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (284:8): [True: 153, False: 0] ------------------ 285| 153| dst->length = src->length; 286| 153| return res; 287| 153|} ua_types.c:nopClear: 2123| 679|static void nopClear(void *p, const UA_DataType *type) { } ua_types.c:String_clear: 290| 4.03k|String_clear(UA_String *s, const UA_DataType *_) { 291| 4.03k| UA_Array_delete(s->data, s->length, &UA_TYPES[UA_TYPES_BYTE]); ------------------ | | 89| 4.03k|#define UA_TYPES_BYTE 2 ------------------ 292| 4.03k|} ua_types.c:NodeId_clear: 772| 1.85k|NodeId_clear(UA_NodeId *p, const UA_DataType *_) { 773| 1.85k| switch(p->identifierType) { 774| 4| case UA_NODEIDTYPE_STRING: ------------------ | Branch (774:5): [True: 4, False: 1.85k] ------------------ 775| 42| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (775:5): [True: 38, False: 1.82k] ------------------ 776| 42| String_clear(&p->identifier.string, NULL); 777| 42| break; 778| 1.81k| default: break; ------------------ | Branch (778:5): [True: 1.81k, False: 42] ------------------ 779| 1.85k| } 780| 1.85k|} ua_types.c:ExpandedNodeId_clear: 1070| 675|ExpandedNodeId_clear(UA_ExpandedNodeId *p, const UA_DataType *_) { 1071| 675| NodeId_clear(&p->nodeId, _); 1072| | String_clear(&p->namespaceUri, NULL); 1073| 675|} ua_types.c:QualifiedName_clear: 392| 209|QualifiedName_clear(UA_QualifiedName *p, const UA_DataType *_) { 393| | String_clear(&p->name, NULL); 394| 209|} ua_types.c:clearStructure: 2067| 1.44k|clearStructure(void *p, const UA_DataType *type) { 2068| 1.44k| uintptr_t ptr = (uintptr_t)p; 2069| 5.27k| for(size_t i = 0; i < type->membersSize; ++i) { ------------------ | Branch (2069:23): [True: 3.82k, False: 1.44k] ------------------ 2070| 3.82k| const UA_DataTypeMember *m = &type->members[i]; 2071| 3.82k| const UA_DataType *mt = m->memberType; 2072| 3.82k| ptr += m->padding; 2073| 3.82k| if(!m->isOptional) { ------------------ | Branch (2073:12): [True: 3.82k, False: 0] ------------------ 2074| 3.82k| if(!m->isArray) { ------------------ | Branch (2074:16): [True: 2.77k, False: 1.04k] ------------------ 2075| 2.77k| clearJumpTable[mt->typeKind]((void*)ptr, mt); 2076| 2.77k| ptr += mt->memSize; 2077| 2.77k| } else { 2078| 1.04k| size_t length = *(size_t*)ptr; 2079| 1.04k| ptr += sizeof(size_t); 2080| 1.04k| UA_Array_delete(*(void**)ptr, length, mt); 2081| 1.04k| ptr += sizeof(void*); 2082| 1.04k| } 2083| 3.82k| } else { /* field is optional */ 2084| 0| if(!m->isArray) { ------------------ | Branch (2084:16): [True: 0, False: 0] ------------------ 2085| | /* optional scalar field is contained */ 2086| 0| if((*(void *const *)ptr != NULL)) ------------------ | Branch (2086:20): [True: 0, False: 0] ------------------ 2087| 0| UA_Array_delete(*(void **)ptr, 1, mt); 2088| 0| ptr += sizeof(void *); 2089| 0| } else { 2090| | /* optional array field is contained */ 2091| 0| if((*(void *const *)(ptr + sizeof(size_t)) != NULL)) { ------------------ | Branch (2091:20): [True: 0, False: 0] ------------------ 2092| 0| size_t length = *(size_t *)ptr; 2093| 0| ptr += sizeof(size_t); 2094| 0| UA_Array_delete(*(void **)ptr, length, mt); 2095| 0| ptr += sizeof(void *); 2096| 0| } else { /* optional array field not contained */ 2097| 0| ptr += sizeof(size_t); 2098| 0| ptr += sizeof(void *); 2099| 0| } 2100| 0| } 2101| 0| } 2102| 3.82k| } 2103| 1.44k|} ua_types.c:nodeIdOrder: 2245| 2|nodeIdOrder(const UA_NodeId *p1, const UA_NodeId *p2, const UA_DataType *_) { 2246| | /* Compare namespaceIndex */ 2247| 2| if(p1->namespaceIndex != p2->namespaceIndex) ------------------ | Branch (2247:8): [True: 0, False: 2] ------------------ 2248| 0| return (p1->namespaceIndex < p2->namespaceIndex) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2248:16): [True: 0, False: 0] ------------------ 2249| | 2250| | /* Compare identifierType */ 2251| 2| if(p1->identifierType != p2->identifierType) ------------------ | Branch (2251:8): [True: 0, False: 2] ------------------ 2252| 0| return (p1->identifierType < p2->identifierType) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2252:16): [True: 0, False: 0] ------------------ 2253| | 2254| | /* Compare the identifier */ 2255| 2| switch(p1->identifierType) { 2256| 2| case UA_NODEIDTYPE_NUMERIC: ------------------ | Branch (2256:5): [True: 2, False: 0] ------------------ 2257| 2| default: ------------------ | Branch (2257:5): [True: 0, False: 2] ------------------ 2258| 2| if(p1->identifier.numeric != p2->identifier.numeric) ------------------ | Branch (2258:12): [True: 1, False: 1] ------------------ 2259| 1| return (p1->identifier.numeric < p2->identifier.numeric) ? ------------------ | Branch (2259:20): [True: 1, False: 0] ------------------ 2260| 1| UA_ORDER_LESS : UA_ORDER_MORE; 2261| 1| return UA_ORDER_EQ; 2262| 0| case UA_NODEIDTYPE_GUID: ------------------ | Branch (2262:5): [True: 0, False: 2] ------------------ 2263| 0| return guidOrder(&p1->identifier.guid, &p2->identifier.guid, NULL); 2264| 0| case UA_NODEIDTYPE_STRING: ------------------ | Branch (2264:5): [True: 0, False: 2] ------------------ 2265| 0| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (2265:5): [True: 0, False: 2] ------------------ 2266| | return stringOrder(&p1->identifier.string, &p2->identifier.string, NULL); 2267| 2| } 2268| 2|} ua_types.c:stringOrder: 2230| 17|stringOrder(const UA_String *p1, const UA_String *p2, const UA_DataType *type) { 2231| 17| if(p1->length != p2->length) ------------------ | Branch (2231:8): [True: 17, False: 0] ------------------ 2232| 17| return (p1->length < p2->length) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2232:16): [True: 17, False: 0] ------------------ 2233| | /* For zero-length arrays, every pointer not NULL is considered a 2234| | * UA_EMPTY_ARRAY_SENTINEL. */ 2235| 0| if(p1->data == p2->data) return UA_ORDER_EQ; ------------------ | Branch (2235:8): [True: 0, False: 0] ------------------ 2236| 0| if(p1->data == NULL) return UA_ORDER_LESS; ------------------ | Branch (2236:8): [True: 0, False: 0] ------------------ 2237| 0| if(p2->data == NULL) return UA_ORDER_MORE; ------------------ | Branch (2237:8): [True: 0, False: 0] ------------------ 2238| 0| int cmp = memcmp((const char*)p1->data, (const char*)p2->data, p1->length); 2239| 0| if(cmp != 0) ------------------ | Branch (2239:8): [True: 0, False: 0] ------------------ 2240| 0| return (cmp < 0) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2240:16): [True: 0, False: 0] ------------------ 2241| 0| return UA_ORDER_EQ; 2242| 0|} UA_Guid_parse: 84| 205|UA_Guid_parse(UA_Guid *guid, const UA_String str) { 85| 205| UA_StatusCode res = parse_guid(guid, str.data, str.data + str.length); 86| 205| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 205|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (86:8): [True: 205, False: 0] ------------------ 87| 205| *guid = UA_GUID_NULL; 88| 205| return res; 89| 205|} UA_NodeId_parseEx: 319| 256| const UA_NamespaceMapping *nsMapping) { 320| 256| UA_StatusCode res = 321| 256| parse_nodeid(id, str.data, str.data+str.length, UA_ESCAPING_NONE, nsMapping); 322| 256| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 256|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (322:8): [True: 249, False: 7] ------------------ 323| 249| UA_NodeId_clear(id); 324| 256| return res; 325| 256|} UA_NodeId_parse: 328| 256|UA_NodeId_parse(UA_NodeId *id, const UA_String str) { 329| | return UA_NodeId_parseEx(id, str, NULL); 330| 256|} UA_ExpandedNodeId_parseEx: 667| 339| size_t serverUrisSize, const UA_String *serverUris) { 668| 339| UA_StatusCode res = 669| 339| parse_expandednodeid(id, str.data, str.data + str.length, UA_ESCAPING_NONE, 670| 339| nsMapping, serverUrisSize, serverUris); 671| 339| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 339|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (671:8): [True: 336, False: 3] ------------------ 672| 336| UA_ExpandedNodeId_clear(id); 673| 339| return res; 674| 339|} UA_ExpandedNodeId_parse: 677| 339|UA_ExpandedNodeId_parse(UA_ExpandedNodeId *id, const UA_String str) { 678| 339| return UA_ExpandedNodeId_parseEx(id, str, NULL, 0, NULL); 679| 339|} UA_QualifiedName_parseEx: 823| 145| const UA_NamespaceMapping *nsMapping) { 824| 145| const u8 *pos = str.data; 825| 145| const u8 *end = str.data + str.length; 826| 145| UA_StatusCode res = parse_qn(qn, pos, end, UA_ESCAPING_NONE, nsMapping, 0); 827| 145| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 145|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (827:8): [True: 0, False: 145] ------------------ 828| 0| UA_QualifiedName_clear(qn); 829| 145| return res; 830| 145|} UA_QualifiedName_parse: 833| 145|UA_QualifiedName_parse(UA_QualifiedName *qn, const UA_String str) { 834| | return UA_QualifiedName_parseEx(qn, str, NULL); 835| 145|} UA_RelativePath_parse: 982| 217|UA_RelativePath_parse(UA_RelativePath *rp, const UA_String str) { 983| 217| const u8 *pos = str.data; 984| 217| const u8 *end = pos + str.length; 985| 217| UA_StatusCode res = parse_relativepath(rp, &pos, end, NULL, UA_ESCAPING_AND, 0); 986| 217| if(pos != end) ------------------ | Branch (986:8): [True: 216, False: 1] ------------------ 987| 216| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 216|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 988| 217| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 217|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (988:8): [True: 216, False: 1] ------------------ 989| 216| UA_RelativePath_clear(rp); 990| 217| return res; 991| 217|} sao_parseWithDefaultNsIdx: 1218| 277| const UA_String str, UA_UInt16 defaultNsIndex) { 1219| | /* Parse an AttributeOperand and convert */ 1220| 277| UA_AttributeOperand ao; 1221| 277| const UA_NodeId hierarchRefs = UA_NS0ID(HIERARCHICALREFERENCES); ------------------ | | 457| 277|#define UA_NS0ID(ID) UA_NODEID_NUMERIC(0, UA_NS0ID_##ID) | | ------------------ | | | | 46| 277|#define UA_NS0ID_HIERARCHICALREFERENCES 33 /* ReferenceType */ | | ------------------ ------------------ 1222| 277| UA_StatusCode res = 1223| 277| parseAttributeOperand(&ao, str, UA_NS0ID(BASEEVENTTYPE), defaultNsIndex); ------------------ | | 457| 277|#define UA_NS0ID(ID) UA_NODEID_NUMERIC(0, UA_NS0ID_##ID) | | ------------------ | | | | 771| 277|#define UA_NS0ID_BASEEVENTTYPE 2041 /* ObjectType */ | | ------------------ ------------------ 1224| 277| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 277|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1224:8): [True: 272, False: 5] ------------------ 1225| 272| return res; 1226| | 1227| | /* Initialize the sao and copy over */ 1228| 5| UA_SimpleAttributeOperand_init(sao); 1229| 5| sao->attributeId = ao.attributeId; 1230| 5| sao->indexRange = ao.indexRange; 1231| 5| UA_String_init(&ao.indexRange); 1232| 5| sao->typeDefinitionId = ao.nodeId; 1233| 5| UA_NodeId_init(&ao.nodeId); 1234| | 1235| 5| if(ao.browsePath.elementsSize > 0) { ------------------ | Branch (1235:8): [True: 0, False: 5] ------------------ 1236| 0| sao->browsePath = (UA_QualifiedName *) 1237| 0| UA_calloc(ao.browsePath.elementsSize, sizeof(UA_QualifiedName)); ------------------ | | 352| 0|# define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 1238| 0| if(!sao->browsePath) { ------------------ | Branch (1238:12): [True: 0, False: 0] ------------------ 1239| 0| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1240| 0| goto cleanup; 1241| 0| } 1242| 0| sao->browsePathSize = ao.browsePath.elementsSize; 1243| 0| } 1244| | 1245| 5| for(size_t i = 0; i < ao.browsePath.elementsSize; i++) { ------------------ | Branch (1245:23): [True: 0, False: 5] ------------------ 1246| 0| UA_RelativePathElement *e = &ao.browsePath.elements[i]; 1247| | 1248| | /* Must use hierarchical references (/) */ 1249| 0| if(!UA_NodeId_equal(&e->referenceTypeId, &hierarchRefs)) { ------------------ | Branch (1249:12): [True: 0, False: 0] ------------------ 1250| 0| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1251| 0| goto cleanup; 1252| 0| } 1253| | 1254| | /* Includes subtypes and not inverse */ 1255| 0| if(!e->includeSubtypes || e->isInverse) { ------------------ | Branch (1255:12): [True: 0, False: 0] | Branch (1255:35): [True: 0, False: 0] ------------------ 1256| 0| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1257| 0| goto cleanup; 1258| 0| } 1259| | 1260| 0| sao->browsePath[i] = e->targetName; 1261| 0| UA_QualifiedName_init(&e->targetName); 1262| 0| } 1263| | 1264| 5| cleanup: 1265| 5| UA_AttributeOperand_clear(&ao); 1266| 5| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 5|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1266:8): [True: 0, False: 5] ------------------ 1267| 0| UA_SimpleAttributeOperand_clear(sao); 1268| 5| return res; 1269| 5|} UA_SimpleAttributeOperand_parse: 1273| 277| const UA_String str) { 1274| 277| return sao_parseWithDefaultNsIdx(sao, str, 0); 1275| 277|} UA_ReadValueId_parse: 1278| 62|UA_ReadValueId_parse(UA_ReadValueId *rvi, const UA_String str) { 1279| | /* Parse an AttributeOperand and convert */ 1280| 62| UA_AttributeOperand ao; 1281| 62| UA_StatusCode res = parseAttributeOperand(&ao, str, UA_NODEID_NULL, 0); 1282| 62| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 62|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1282:8): [True: 61, False: 1] ------------------ 1283| 61| return res; 1284| | 1285| 1| if(ao.browsePath.elementsSize > 0) { ------------------ | Branch (1285:8): [True: 0, False: 1] ------------------ 1286| 0| UA_AttributeOperand_clear(&ao); 1287| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1288| 0| } 1289| | 1290| 1| UA_ReadValueId_init(rvi); 1291| 1| rvi->nodeId = ao.nodeId; 1292| 1| rvi->attributeId = ao.attributeId; 1293| 1| rvi->indexRange = ao.indexRange; 1294| 1| return UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1295| 1|} ua_types_lex.c:parse_guid: 48| 208|parse_guid(UA_Guid *guid, const UA_Byte *s, const UA_Byte *e) { 49| 208| size_t len = (size_t)(e - s); 50| 208| if(len != 36 || s[8] != '-' || s[13] != '-' || s[23] != '-') ------------------ | Branch (50:8): [True: 197, False: 11] | Branch (50:21): [True: 9, False: 2] | Branch (50:36): [True: 0, False: 2] | Branch (50:52): [True: 0, False: 2] ------------------ 51| 206| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 206|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 52| | 53| 2| UA_UInt32 tmp; 54| 2| if(UA_readNumberWithBase(s, 8, &tmp, 16) != 8) ------------------ | Branch (54:8): [True: 0, False: 2] ------------------ 55| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 56| 2| guid->data1 = tmp; 57| | 58| 2| if(UA_readNumberWithBase(&s[9], 4, &tmp, 16) != 4) ------------------ | Branch (58:8): [True: 0, False: 2] ------------------ 59| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 60| 2| guid->data2 = (UA_UInt16)tmp; 61| | 62| 2| if(UA_readNumberWithBase(&s[14], 4, &tmp, 16) != 4) ------------------ | Branch (62:8): [True: 0, False: 2] ------------------ 63| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 64| 2| guid->data3 = (UA_UInt16)tmp; 65| | 66| 2| if(UA_readNumberWithBase(&s[19], 2, &tmp, 16) != 2) ------------------ | Branch (66:8): [True: 0, False: 2] ------------------ 67| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 68| 2| guid->data4[0] = (UA_Byte)tmp; 69| | 70| 2| if(UA_readNumberWithBase(&s[21], 2, &tmp, 16) != 2) ------------------ | Branch (70:8): [True: 1, False: 1] ------------------ 71| 1| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 1|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 72| 1| guid->data4[1] = (UA_Byte)tmp; 73| | 74| 1| for(size_t pos = 2, spos = 24; pos < 8; pos++, spos += 2) { ------------------ | Branch (74:36): [True: 1, False: 0] ------------------ 75| 1| if(UA_readNumberWithBase(&s[spos], 2, &tmp, 16) != 2) ------------------ | Branch (75:12): [True: 1, False: 0] ------------------ 76| 1| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 1|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 77| 0| guid->data4[pos] = (UA_Byte)tmp; 78| 0| } 79| | 80| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 81| 1|} ua_types_lex.c:parse_nodeid: 144| 287| UA_Escaping idEsc, const UA_NamespaceMapping *nsMapping) { 145| 287| *id = UA_NODEID_NULL; /* Reset the NodeId */ 146| 287| LexContext context; 147| 287| memset(&context, 0, sizeof(LexContext)); 148| 287| UA_Byte *begin = (UA_Byte*)(uintptr_t)pos; 149| 287| const u8 *ns = NULL, *nsu = NULL, *body = NULL; 150| | 151| | 152| 287|{ 153| 287| u8 yych; 154| 287| yych = YYPEEK(); ------------------ | | 31| 287|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 287|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 287|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 287, False: 0] | | ------------------ ------------------ 155| 287| switch (yych) { 156| 39| case 'b': ------------------ | Branch (156:3): [True: 39, False: 248] ------------------ 157| 43| case 'g': ------------------ | Branch (157:3): [True: 4, False: 283] ------------------ 158| 70| case 'i': ------------------ | Branch (158:3): [True: 27, False: 260] ------------------ 159| 205| case 's': ------------------ | Branch (159:3): [True: 135, False: 152] ------------------ 160| 205| YYSTAGN(context.yyt1); ------------------ | | 37| 205|#define YYSTAGN(t) t = NULL ------------------ 161| 205| YYSTAGN(context.yyt2); ------------------ | | 37| 205|#define YYSTAGN(t) t = NULL ------------------ 162| 205| goto yy3; 163| 45| case 'n': goto yy4; ------------------ | Branch (163:3): [True: 45, False: 242] ------------------ 164| 37| default: goto yy1; ------------------ | Branch (164:3): [True: 37, False: 250] ------------------ 165| 287| } 166| 37|yy1: 167| 37| YYSKIP(); ------------------ | | 33| 37|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 37|#define YYCURSOR pos | | ------------------ ------------------ 168| 222|yy2: 169| 222| { (void)pos; return UA_STATUSCODE_BADDECODINGERROR; } ------------------ | | 43| 222|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 170| 205|yy3: 171| 205| YYSKIP(); ------------------ | | 33| 205|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 205|#define YYCURSOR pos | | ------------------ ------------------ 172| 205| yych = YYPEEK(); ------------------ | | 31| 205|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 205|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 204|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 204, False: 1] | | ------------------ ------------------ 173| 205| switch (yych) { 174| 63| case '=': goto yy5; ------------------ | Branch (174:3): [True: 63, False: 142] ------------------ 175| 142| default: goto yy2; ------------------ | Branch (175:3): [True: 142, False: 63] ------------------ 176| 205| } 177| 45|yy4: 178| 45| YYSKIP(); ------------------ | | 33| 45|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 45|#define YYCURSOR pos | | ------------------ ------------------ 179| 45| YYBACKUP(); ------------------ | | 34| 45|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 45|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 45|#define YYCURSOR pos | | ------------------ ------------------ 180| 45| yych = YYPEEK(); ------------------ | | 31| 45|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 45|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 44|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 44, False: 1] | | ------------------ ------------------ 181| 45| switch (yych) { 182| 38| case 's': goto yy6; ------------------ | Branch (182:3): [True: 38, False: 7] ------------------ 183| 7| default: goto yy2; ------------------ | Branch (183:3): [True: 7, False: 38] ------------------ 184| 45| } 185| 65|yy5: 186| 65| YYSKIP(); ------------------ | | 33| 65|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 65|#define YYCURSOR pos | | ------------------ ------------------ 187| 65| nsu = context.yyt2; 188| 65| ns = context.yyt1; 189| 65| YYSTAGP(body); ------------------ | | 36| 65|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 65|#define YYCURSOR pos | | ------------------ ------------------ 190| 65| YYSHIFTSTAG(body, -2); ------------------ | | 38| 65|#define YYSHIFTSTAG(t, shift) t += shift ------------------ 191| 65| { goto match; } 192| 38|yy6: 193| 38| YYSKIP(); ------------------ | | 33| 38|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 38|#define YYCURSOR pos | | ------------------ ------------------ 194| 38| yych = YYPEEK(); ------------------ | | 31| 38|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 38|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 37|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 37, False: 1] | | ------------------ ------------------ 195| 38| switch (yych) { 196| 18| case '=': goto yy8; ------------------ | Branch (196:3): [True: 18, False: 20] ------------------ 197| 19| case 'u': goto yy9; ------------------ | Branch (197:3): [True: 19, False: 19] ------------------ 198| 1| default: goto yy7; ------------------ | Branch (198:3): [True: 1, False: 37] ------------------ 199| 38| } 200| 36|yy7: 201| 36| YYRESTORE(); ------------------ | | 35| 36|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 30| 36|#define YYMARKER context.marker | | ------------------ ------------------ 202| 36| goto yy2; 203| 18|yy8: 204| 18| YYSKIP(); ------------------ | | 33| 18|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 18|#define YYCURSOR pos | | ------------------ ------------------ 205| 18| yych = YYPEEK(); ------------------ | | 31| 18|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 18|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 18|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 18, False: 0] | | ------------------ ------------------ 206| 18| switch (yych) { 207| 3| case '0': ------------------ | Branch (207:3): [True: 3, False: 15] ------------------ 208| 5| case '1': ------------------ | Branch (208:3): [True: 2, False: 16] ------------------ 209| 6| case '2': ------------------ | Branch (209:3): [True: 1, False: 17] ------------------ 210| 8| case '3': ------------------ | Branch (210:3): [True: 2, False: 16] ------------------ 211| 10| case '4': ------------------ | Branch (211:3): [True: 2, False: 16] ------------------ 212| 13| case '5': ------------------ | Branch (212:3): [True: 3, False: 15] ------------------ 213| 13| case '6': ------------------ | Branch (213:3): [True: 0, False: 18] ------------------ 214| 13| case '7': ------------------ | Branch (214:3): [True: 0, False: 18] ------------------ 215| 15| case '8': ------------------ | Branch (215:3): [True: 2, False: 16] ------------------ 216| 17| case '9': ------------------ | Branch (216:3): [True: 2, False: 16] ------------------ 217| 17| YYSTAGP(context.yyt1); ------------------ | | 36| 17|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 17|#define YYCURSOR pos | | ------------------ ------------------ 218| 17| goto yy10; 219| 1| default: goto yy7; ------------------ | Branch (219:3): [True: 1, False: 17] ------------------ 220| 18| } 221| 19|yy9: 222| 19| YYSKIP(); ------------------ | | 33| 19|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 19|#define YYCURSOR pos | | ------------------ ------------------ 223| 19| yych = YYPEEK(); ------------------ | | 31| 19|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 19|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 19|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 19, False: 0] | | ------------------ ------------------ 224| 19| switch (yych) { 225| 14| case '=': goto yy11; ------------------ | Branch (225:3): [True: 14, False: 5] ------------------ 226| 5| default: goto yy7; ------------------ | Branch (226:3): [True: 5, False: 14] ------------------ 227| 19| } 228| 429|yy10: 229| 429| YYSKIP(); ------------------ | | 33| 429|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 429|#define YYCURSOR pos | | ------------------ ------------------ 230| 429| yych = YYPEEK(); ------------------ | | 31| 429|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 429|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 416|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 416, False: 13] | | ------------------ ------------------ 231| 429| switch (yych) { 232| 128| case '0': ------------------ | Branch (232:3): [True: 128, False: 301] ------------------ 233| 159| case '1': ------------------ | Branch (233:3): [True: 31, False: 398] ------------------ 234| 208| case '2': ------------------ | Branch (234:3): [True: 49, False: 380] ------------------ 235| 209| case '3': ------------------ | Branch (235:3): [True: 1, False: 428] ------------------ 236| 229| case '4': ------------------ | Branch (236:3): [True: 20, False: 409] ------------------ 237| 229| case '5': ------------------ | Branch (237:3): [True: 0, False: 429] ------------------ 238| 229| case '6': ------------------ | Branch (238:3): [True: 0, False: 429] ------------------ 239| 357| case '7': ------------------ | Branch (239:3): [True: 128, False: 301] ------------------ 240| 364| case '8': ------------------ | Branch (240:3): [True: 7, False: 422] ------------------ 241| 412| case '9': goto yy10; ------------------ | Branch (241:3): [True: 48, False: 381] ------------------ 242| 2| case ';': ------------------ | Branch (242:3): [True: 2, False: 427] ------------------ 243| 2| YYSTAGN(context.yyt2); ------------------ | | 37| 2|#define YYSTAGN(t) t = NULL ------------------ 244| 2| goto yy12; 245| 15| default: goto yy7; ------------------ | Branch (245:3): [True: 15, False: 414] ------------------ 246| 429| } 247| 14|yy11: 248| 14| YYSKIP(); ------------------ | | 33| 14|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 14|#define YYCURSOR pos | | ------------------ ------------------ 249| 14| yych = YYPEEK(); ------------------ | | 31| 14|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 14|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 14|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 14, False: 0] | | ------------------ ------------------ 250| 14| switch (yych) { 251| 0| case 0x00: goto yy7; ------------------ | Branch (251:3): [True: 0, False: 14] ------------------ 252| 6| case ';': ------------------ | Branch (252:3): [True: 6, False: 8] ------------------ 253| 6| YYSTAGN(context.yyt1); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 254| 6| YYSTAGP(context.yyt2); ------------------ | | 36| 6|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 255| 6| goto yy12; 256| 8| default: ------------------ | Branch (256:3): [True: 8, False: 6] ------------------ 257| 8| YYSTAGP(context.yyt2); ------------------ | | 36| 8|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 8|#define YYCURSOR pos | | ------------------ ------------------ 258| 8| goto yy13; 259| 14| } 260| 9|yy12: 261| 9| YYSKIP(); ------------------ | | 33| 9|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 9|#define YYCURSOR pos | | ------------------ ------------------ 262| 9| yych = YYPEEK(); ------------------ | | 31| 9|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 9|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 8|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 8, False: 1] | | ------------------ ------------------ 263| 9| switch (yych) { 264| 0| case 'b': ------------------ | Branch (264:3): [True: 0, False: 9] ------------------ 265| 1| case 'g': ------------------ | Branch (265:3): [True: 1, False: 8] ------------------ 266| 3| case 'i': ------------------ | Branch (266:3): [True: 2, False: 7] ------------------ 267| 8| case 's': goto yy14; ------------------ | Branch (267:3): [True: 5, False: 4] ------------------ 268| 1| default: goto yy7; ------------------ | Branch (268:3): [True: 1, False: 8] ------------------ 269| 9| } 270| 27|yy13: 271| 27| YYSKIP(); ------------------ | | 33| 27|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 27|#define YYCURSOR pos | | ------------------ ------------------ 272| 27| yych = YYPEEK(); ------------------ | | 31| 27|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 27|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 21|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 21, False: 6] | | ------------------ ------------------ 273| 27| switch (yych) { 274| 7| case 0x00: goto yy7; ------------------ | Branch (274:3): [True: 7, False: 20] ------------------ 275| 1| case ';': ------------------ | Branch (275:3): [True: 1, False: 26] ------------------ 276| 1| YYSTAGN(context.yyt1); ------------------ | | 37| 1|#define YYSTAGN(t) t = NULL ------------------ 277| 1| goto yy12; 278| 19| default: goto yy13; ------------------ | Branch (278:3): [True: 19, False: 8] ------------------ 279| 27| } 280| 8|yy14: 281| 8| YYSKIP(); ------------------ | | 33| 8|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 8|#define YYCURSOR pos | | ------------------ ------------------ 282| 8| yych = YYPEEK(); ------------------ | | 31| 8|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 8|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 6, False: 2] | | ------------------ ------------------ 283| 8| switch (yych) { 284| 2| case '=': goto yy5; ------------------ | Branch (284:3): [True: 2, False: 6] ------------------ 285| 6| default: goto yy7; ------------------ | Branch (285:3): [True: 6, False: 2] ------------------ 286| 8| } 287| 8|} 288| | 289| | 290| 65| match: 291| 65| if(nsu) { ------------------ | Branch (291:8): [True: 1, False: 64] ------------------ 292| | /* NamespaceUri */ 293| 1| UA_String nsUri = {(size_t)(body - 1 - nsu), (UA_Byte*)(uintptr_t)nsu}; 294| 1| UA_StatusCode res = escapedUri2Index(nsUri, &id->namespaceIndex, nsMapping); 295| 1| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (295:12): [True: 1, False: 0] ------------------ 296| | /* Return the entire NodeId string s=... */ 297| 1| UA_String total = {(size_t)((const UA_Byte*)end - begin), begin}; 298| 1| id->identifierType = UA_NODEIDTYPE_STRING; 299| 1| return UA_String_copy(&total, &id->identifier.string); 300| 1| } 301| 64| } else if(ns) { ------------------ | Branch (301:15): [True: 1, False: 63] ------------------ 302| | /* NamespaceIndex */ 303| 1| UA_UInt32 tmp; 304| 1| size_t len = (size_t)(body - 1 - ns); 305| 1| if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) ------------------ | Branch (305:12): [True: 0, False: 1] ------------------ 306| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 307| 1| id->namespaceIndex = (UA_UInt16)tmp; 308| 1| if(nsMapping) ------------------ | Branch (308:12): [True: 0, False: 1] ------------------ 309| 0| id->namespaceIndex = 310| 0| UA_NamespaceMapping_remote2Local(nsMapping, id->namespaceIndex); 311| 1| } 312| | 313| | /* From the current position until the end */ 314| 64| return parse_nodeid_body(id, body, end, idEsc); 315| 65|} ua_types_lex.c:escapedUri2Index: 93| 10| const UA_NamespaceMapping *nsMapping) { 94| 10| if(!nsMapping) ------------------ | Branch (94:8): [True: 10, False: 0] ------------------ 95| 10| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 10|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 96| 0| UA_String tmp = uri; 97| 0| status res = UA_String_unescape(&uri, true, UA_ESCAPING_PERCENT); 98| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (98:8): [True: 0, False: 0] ------------------ 99| 0| return res; 100| 0| res = UA_NamespaceMapping_uri2Index(nsMapping, uri, nsIndex); 101| 0| if(tmp.data != uri.data) ------------------ | Branch (101:8): [True: 0, False: 0] ------------------ 102| 0| UA_String_clear(&uri); 103| 0| return res; 104| 0|} ua_types_lex.c:parse_nodeid_body: 107| 79|parse_nodeid_body(UA_NodeId *id, const u8 *body, const u8 *end, UA_Escaping esc) { 108| 79| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 16| 79|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 109| 79| UA_String str = {(size_t)(end - (body+2)), (UA_Byte*)(uintptr_t)body + 2}; 110| 79| switch(*body) { 111| 35| case 'i': ------------------ | Branch (111:5): [True: 35, False: 44] ------------------ 112| 35| id->identifierType = UA_NODEIDTYPE_NUMERIC; 113| 35| if(UA_readNumber(str.data, str.length, &id->identifier.numeric) != str.length) ------------------ | Branch (113:12): [True: 29, False: 6] ------------------ 114| 29| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 29|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 115| 35| break; 116| 3| case 's': ------------------ | Branch (116:5): [True: 3, False: 76] ------------------ 117| 3| id->identifierType = UA_NODEIDTYPE_STRING; 118| 3| res |= UA_String_copy(&str, &id->identifier.string); 119| 3| res |= UA_String_unescape(&id->identifier.string, false, esc); 120| 3| break; 121| 3| case 'g': ------------------ | Branch (121:5): [True: 3, False: 76] ------------------ 122| 3| id->identifierType = UA_NODEIDTYPE_GUID; 123| 3| res = parse_guid(&id->identifier.guid, str.data, end); 124| 3| break; 125| 38| case 'b': ------------------ | Branch (125:5): [True: 38, False: 41] ------------------ 126| | /* For percent-escaping, base64url bytestring encoding is used. That 127| | * doesn't need to be escaped here. The and-escaping is not applied to 128| | * the NodeId identifier part. */ 129| 38| id->identifierType = UA_NODEIDTYPE_BYTESTRING; 130| 38| id->identifier.byteString.data = 131| 38| UA_unbase64(str.data, str.length, &id->identifier.byteString.length); 132| 38| if(!id->identifier.byteString.data && str.length > 0) ------------------ | Branch (132:12): [True: 26, False: 12] | Branch (132:47): [True: 26, False: 0] ------------------ 133| 26| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 26|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 134| 38| break; 135| 0| default: ------------------ | Branch (135:5): [True: 0, False: 79] ------------------ 136| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 137| 0| break; 138| 79| } 139| 79| return res; 140| 79|} ua_types_lex.c:parse_expandednodeid: 335| 339| size_t serverUrisSize, const UA_String *serverUris) { 336| 339| *id = UA_EXPANDEDNODEID_NULL; /* Reset the NodeId */ 337| 339| LexContext context; 338| 339| memset(&context, 0, sizeof(LexContext)); 339| 339| const u8 *svr = NULL, *sve = NULL, *svu = NULL, 340| 339| *nsu = NULL, *ns = NULL, *body = NULL, *begin = pos; 341| | 342| | 343| 339|{ 344| 339| u8 yych; 345| 339| yych = YYPEEK(); ------------------ | | 31| 339|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 339|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 339|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 339, False: 0] | | ------------------ ------------------ 346| 339| switch (yych) { 347| 6| case 'b': ------------------ | Branch (347:3): [True: 6, False: 333] ------------------ 348| 7| case 'g': ------------------ | Branch (348:3): [True: 1, False: 338] ------------------ 349| 17| case 'i': ------------------ | Branch (349:3): [True: 10, False: 329] ------------------ 350| 17| YYSTAGN(context.yyt1); ------------------ | | 37| 17|#define YYSTAGN(t) t = NULL ------------------ 351| 17| YYSTAGN(context.yyt2); ------------------ | | 37| 17|#define YYSTAGN(t) t = NULL ------------------ 352| 17| YYSTAGN(context.yyt3); ------------------ | | 37| 17|#define YYSTAGN(t) t = NULL ------------------ 353| 17| YYSTAGN(context.yyt4); ------------------ | | 37| 17|#define YYSTAGN(t) t = NULL ------------------ 354| 17| YYSTAGN(context.yyt5); ------------------ | | 37| 17|#define YYSTAGN(t) t = NULL ------------------ 355| 17| goto yy18; 356| 36| case 'n': ------------------ | Branch (356:3): [True: 36, False: 303] ------------------ 357| 36| YYSTAGN(context.yyt1); ------------------ | | 37| 36|#define YYSTAGN(t) t = NULL ------------------ 358| 36| YYSTAGN(context.yyt2); ------------------ | | 37| 36|#define YYSTAGN(t) t = NULL ------------------ 359| 36| YYSTAGN(context.yyt5); ------------------ | | 37| 36|#define YYSTAGN(t) t = NULL ------------------ 360| 36| goto yy19; 361| 6| case 's': ------------------ | Branch (361:3): [True: 6, False: 333] ------------------ 362| 6| YYSTAGN(context.yyt1); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 363| 6| YYSTAGN(context.yyt2); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 364| 6| YYSTAGN(context.yyt3); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 365| 6| YYSTAGN(context.yyt4); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 366| 6| YYSTAGN(context.yyt5); ------------------ | | 37| 6|#define YYSTAGN(t) t = NULL ------------------ 367| 6| goto yy20; 368| 280| default: goto yy16; ------------------ | Branch (368:3): [True: 280, False: 59] ------------------ 369| 339| } 370| 280|yy16: 371| 280| YYSKIP(); ------------------ | | 33| 280|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 280|#define YYCURSOR pos | | ------------------ ------------------ 372| 324|yy17: 373| 324| { (void)pos; return UA_STATUSCODE_BADDECODINGERROR; } ------------------ | | 43| 324|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 374| 17|yy18: 375| 17| YYSKIP(); ------------------ | | 33| 17|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 17|#define YYCURSOR pos | | ------------------ ------------------ 376| 17| yych = YYPEEK(); ------------------ | | 31| 17|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 17|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 16|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 16, False: 1] | | ------------------ ------------------ 377| 17| switch (yych) { 378| 13| case '=': goto yy21; ------------------ | Branch (378:3): [True: 13, False: 4] ------------------ 379| 4| default: goto yy17; ------------------ | Branch (379:3): [True: 4, False: 13] ------------------ 380| 17| } 381| 36|yy19: 382| 36| YYSKIP(); ------------------ | | 33| 36|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ ------------------ 383| 36| YYBACKUP(); ------------------ | | 34| 36|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 36|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ ------------------ 384| 36| yych = YYPEEK(); ------------------ | | 31| 36|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 36, False: 0] | | ------------------ ------------------ 385| 36| switch (yych) { 386| 34| case 's': goto yy22; ------------------ | Branch (386:3): [True: 34, False: 2] ------------------ 387| 2| default: goto yy17; ------------------ | Branch (387:3): [True: 2, False: 34] ------------------ 388| 36| } 389| 6|yy20: 390| 6| YYSKIP(); ------------------ | | 33| 6|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 391| 6| YYBACKUP(); ------------------ | | 34| 6|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 6|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 392| 6| yych = YYPEEK(); ------------------ | | 31| 6|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 6, False: 0] | | ------------------ ------------------ 393| 6| switch (yych) { 394| 0| case '=': goto yy21; ------------------ | Branch (394:3): [True: 0, False: 6] ------------------ 395| 5| case 'v': goto yy24; ------------------ | Branch (395:3): [True: 5, False: 1] ------------------ 396| 1| default: goto yy17; ------------------ | Branch (396:3): [True: 1, False: 5] ------------------ 397| 6| } 398| 15|yy21: 399| 15| YYSKIP(); ------------------ | | 33| 15|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 15|#define YYCURSOR pos | | ------------------ ------------------ 400| 15| svr = context.yyt5; 401| 15| svu = context.yyt1; 402| 15| sve = context.yyt2; 403| 15| ns = context.yyt3; 404| 15| nsu = context.yyt4; 405| 15| YYSTAGP(body); ------------------ | | 36| 15|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 15|#define YYCURSOR pos | | ------------------ ------------------ 406| 15| YYSHIFTSTAG(body, -2); ------------------ | | 38| 15|#define YYSHIFTSTAG(t, shift) t += shift ------------------ 407| 15| { goto match; } 408| 34|yy22: 409| 34| YYSKIP(); ------------------ | | 33| 34|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 34|#define YYCURSOR pos | | ------------------ ------------------ 410| 34| yych = YYPEEK(); ------------------ | | 31| 34|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 34|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 34|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 34, False: 0] | | ------------------ ------------------ 411| 34| switch (yych) { 412| 25| case '=': goto yy25; ------------------ | Branch (412:3): [True: 25, False: 9] ------------------ 413| 9| case 'u': goto yy26; ------------------ | Branch (413:3): [True: 9, False: 25] ------------------ 414| 0| default: goto yy23; ------------------ | Branch (414:3): [True: 0, False: 34] ------------------ 415| 34| } 416| 37|yy23: 417| 37| YYRESTORE(); ------------------ | | 35| 37|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 29| 37|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 30| 37|#define YYMARKER context.marker | | ------------------ ------------------ 418| 37| goto yy17; 419| 5|yy24: 420| 5| YYSKIP(); ------------------ | | 33| 5|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 5|#define YYCURSOR pos | | ------------------ ------------------ 421| 5| yych = YYPEEK(); ------------------ | | 31| 5|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 5|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 5|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 5, False: 0] | | ------------------ ------------------ 422| 5| switch (yych) { 423| 2| case 'r': goto yy27; ------------------ | Branch (423:3): [True: 2, False: 3] ------------------ 424| 3| case 'u': goto yy28; ------------------ | Branch (424:3): [True: 3, False: 2] ------------------ 425| 0| default: goto yy23; ------------------ | Branch (425:3): [True: 0, False: 5] ------------------ 426| 5| } 427| 25|yy25: 428| 25| YYSKIP(); ------------------ | | 33| 25|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 25|#define YYCURSOR pos | | ------------------ ------------------ 429| 25| yych = YYPEEK(); ------------------ | | 31| 25|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 25|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 24|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 24, False: 1] | | ------------------ ------------------ 430| 25| switch (yych) { 431| 0| case '0': ------------------ | Branch (431:3): [True: 0, False: 25] ------------------ 432| 9| case '1': ------------------ | Branch (432:3): [True: 9, False: 16] ------------------ 433| 13| case '2': ------------------ | Branch (433:3): [True: 4, False: 21] ------------------ 434| 14| case '3': ------------------ | Branch (434:3): [True: 1, False: 24] ------------------ 435| 15| case '4': ------------------ | Branch (435:3): [True: 1, False: 24] ------------------ 436| 17| case '5': ------------------ | Branch (436:3): [True: 2, False: 23] ------------------ 437| 19| case '6': ------------------ | Branch (437:3): [True: 2, False: 23] ------------------ 438| 20| case '7': ------------------ | Branch (438:3): [True: 1, False: 24] ------------------ 439| 23| case '8': ------------------ | Branch (439:3): [True: 3, False: 22] ------------------ 440| 23| case '9': ------------------ | Branch (440:3): [True: 0, False: 25] ------------------ 441| 23| YYSTAGP(context.yyt3); ------------------ | | 36| 23|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 23|#define YYCURSOR pos | | ------------------ ------------------ 442| 23| goto yy29; 443| 2| default: goto yy23; ------------------ | Branch (443:3): [True: 2, False: 23] ------------------ 444| 25| } 445| 9|yy26: 446| 9| YYSKIP(); ------------------ | | 33| 9|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 9|#define YYCURSOR pos | | ------------------ ------------------ 447| 9| yych = YYPEEK(); ------------------ | | 31| 9|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 9|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 8|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 8, False: 1] | | ------------------ ------------------ 448| 9| switch (yych) { 449| 6| case '=': goto yy30; ------------------ | Branch (449:3): [True: 6, False: 3] ------------------ 450| 3| default: goto yy23; ------------------ | Branch (450:3): [True: 3, False: 6] ------------------ 451| 9| } 452| 2|yy27: 453| 2| YYSKIP(); ------------------ | | 33| 2|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 454| 2| yych = YYPEEK(); ------------------ | | 31| 2|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 2, False: 0] | | ------------------ ------------------ 455| 2| switch (yych) { 456| 2| case '=': goto yy31; ------------------ | Branch (456:3): [True: 2, False: 0] ------------------ 457| 0| default: goto yy23; ------------------ | Branch (457:3): [True: 0, False: 2] ------------------ 458| 2| } 459| 3|yy28: 460| 3| YYSKIP(); ------------------ | | 33| 3|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ ------------------ 461| 3| yych = YYPEEK(); ------------------ | | 31| 3|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 3, False: 0] | | ------------------ ------------------ 462| 3| switch (yych) { 463| 3| case '=': goto yy32; ------------------ | Branch (463:3): [True: 3, False: 0] ------------------ 464| 0| default: goto yy23; ------------------ | Branch (464:3): [True: 0, False: 3] ------------------ 465| 3| } 466| 431|yy29: 467| 431| YYSKIP(); ------------------ | | 33| 431|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 431|#define YYCURSOR pos | | ------------------ ------------------ 468| 431| yych = YYPEEK(); ------------------ | | 31| 431|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 431|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 409|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 409, False: 22] | | ------------------ ------------------ 469| 431| switch (yych) { 470| 1| case '0': ------------------ | Branch (470:3): [True: 1, False: 430] ------------------ 471| 4| case '1': ------------------ | Branch (471:3): [True: 3, False: 428] ------------------ 472| 56| case '2': ------------------ | Branch (472:3): [True: 52, False: 379] ------------------ 473| 201| case '3': ------------------ | Branch (473:3): [True: 145, False: 286] ------------------ 474| 203| case '4': ------------------ | Branch (474:3): [True: 2, False: 429] ------------------ 475| 358| case '5': ------------------ | Branch (475:3): [True: 155, False: 276] ------------------ 476| 369| case '6': ------------------ | Branch (476:3): [True: 11, False: 420] ------------------ 477| 388| case '7': ------------------ | Branch (477:3): [True: 19, False: 412] ------------------ 478| 392| case '8': ------------------ | Branch (478:3): [True: 4, False: 427] ------------------ 479| 408| case '9': goto yy29; ------------------ | Branch (479:3): [True: 16, False: 415] ------------------ 480| 0| case ';': ------------------ | Branch (480:3): [True: 0, False: 431] ------------------ 481| 0| YYSTAGN(context.yyt4); ------------------ | | 37| 0|#define YYSTAGN(t) t = NULL ------------------ 482| 0| goto yy33; 483| 23| default: goto yy23; ------------------ | Branch (483:3): [True: 23, False: 408] ------------------ 484| 431| } 485| 6|yy30: 486| 6| YYSKIP(); ------------------ | | 33| 6|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 487| 6| yych = YYPEEK(); ------------------ | | 31| 6|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 5|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 5, False: 1] | | ------------------ ------------------ 488| 6| switch (yych) { 489| 1| case 0x00: goto yy23; ------------------ | Branch (489:3): [True: 1, False: 5] ------------------ 490| 2| case ';': ------------------ | Branch (490:3): [True: 2, False: 4] ------------------ 491| 2| YYSTAGN(context.yyt3); ------------------ | | 37| 2|#define YYSTAGN(t) t = NULL ------------------ 492| 2| YYSTAGP(context.yyt4); ------------------ | | 36| 2|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 493| 2| goto yy33; 494| 3| default: ------------------ | Branch (494:3): [True: 3, False: 3] ------------------ 495| 3| YYSTAGP(context.yyt4); ------------------ | | 36| 3|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ ------------------ 496| 3| goto yy34; 497| 6| } 498| 2|yy31: 499| 2| YYSKIP(); ------------------ | | 33| 2|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 500| 2| yych = YYPEEK(); ------------------ | | 31| 2|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 2, False: 0] | | ------------------ ------------------ 501| 2| switch (yych) { 502| 2| case '0': ------------------ | Branch (502:3): [True: 2, False: 0] ------------------ 503| 2| case '1': ------------------ | Branch (503:3): [True: 0, False: 2] ------------------ 504| 2| case '2': ------------------ | Branch (504:3): [True: 0, False: 2] ------------------ 505| 2| case '3': ------------------ | Branch (505:3): [True: 0, False: 2] ------------------ 506| 2| case '4': ------------------ | Branch (506:3): [True: 0, False: 2] ------------------ 507| 2| case '5': ------------------ | Branch (507:3): [True: 0, False: 2] ------------------ 508| 2| case '6': ------------------ | Branch (508:3): [True: 0, False: 2] ------------------ 509| 2| case '7': ------------------ | Branch (509:3): [True: 0, False: 2] ------------------ 510| 2| case '8': ------------------ | Branch (510:3): [True: 0, False: 2] ------------------ 511| 2| case '9': ------------------ | Branch (511:3): [True: 0, False: 2] ------------------ 512| 2| YYSTAGP(context.yyt5); ------------------ | | 36| 2|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 513| 2| goto yy35; 514| 0| default: goto yy23; ------------------ | Branch (514:3): [True: 0, False: 2] ------------------ 515| 2| } 516| 3|yy32: 517| 3| YYSKIP(); ------------------ | | 33| 3|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ ------------------ 518| 3| yych = YYPEEK(); ------------------ | | 31| 3|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 3, False: 0] | | ------------------ ------------------ 519| 3| switch (yych) { 520| 0| case 0x00: goto yy23; ------------------ | Branch (520:3): [True: 0, False: 3] ------------------ 521| 1| case ';': ------------------ | Branch (521:3): [True: 1, False: 2] ------------------ 522| 1| YYSTAGP(context.yyt1); ------------------ | | 36| 1|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ ------------------ 523| 1| YYSTAGP(context.yyt2); ------------------ | | 36| 1|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ ------------------ 524| 1| YYSTAGN(context.yyt5); ------------------ | | 37| 1|#define YYSTAGN(t) t = NULL ------------------ 525| 1| goto yy37; 526| 2| default: ------------------ | Branch (526:3): [True: 2, False: 1] ------------------ 527| 2| YYSTAGP(context.yyt1); ------------------ | | 36| 2|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 528| 2| goto yy36; 529| 3| } 530| 3|yy33: 531| 3| YYSKIP(); ------------------ | | 33| 3|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ ------------------ 532| 3| yych = YYPEEK(); ------------------ | | 31| 3|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 2, False: 1] | | ------------------ ------------------ 533| 3| switch (yych) { 534| 0| case 'b': ------------------ | Branch (534:3): [True: 0, False: 3] ------------------ 535| 0| case 'g': ------------------ | Branch (535:3): [True: 0, False: 3] ------------------ 536| 0| case 'i': ------------------ | Branch (536:3): [True: 0, False: 3] ------------------ 537| 2| case 's': goto yy38; ------------------ | Branch (537:3): [True: 2, False: 1] ------------------ 538| 1| default: goto yy23; ------------------ | Branch (538:3): [True: 1, False: 2] ------------------ 539| 3| } 540| 36|yy34: 541| 36| YYSKIP(); ------------------ | | 33| 36|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ ------------------ 542| 36| yych = YYPEEK(); ------------------ | | 31| 36|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 36|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 34|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 34, False: 2] | | ------------------ ------------------ 543| 36| switch (yych) { 544| 2| case 0x00: goto yy23; ------------------ | Branch (544:3): [True: 2, False: 34] ------------------ 545| 1| case ';': ------------------ | Branch (545:3): [True: 1, False: 35] ------------------ 546| 1| YYSTAGN(context.yyt3); ------------------ | | 37| 1|#define YYSTAGN(t) t = NULL ------------------ 547| 1| goto yy33; 548| 33| default: goto yy34; ------------------ | Branch (548:3): [True: 33, False: 3] ------------------ 549| 36| } 550| 33|yy35: 551| 33| YYSKIP(); ------------------ | | 33| 33|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 33|#define YYCURSOR pos | | ------------------ ------------------ 552| 33| yych = YYPEEK(); ------------------ | | 31| 33|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 33|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 33|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 33, False: 0] | | ------------------ ------------------ 553| 33| switch (yych) { 554| 9| case '0': ------------------ | Branch (554:3): [True: 9, False: 24] ------------------ 555| 14| case '1': ------------------ | Branch (555:3): [True: 5, False: 28] ------------------ 556| 22| case '2': ------------------ | Branch (556:3): [True: 8, False: 25] ------------------ 557| 22| case '3': ------------------ | Branch (557:3): [True: 0, False: 33] ------------------ 558| 22| case '4': ------------------ | Branch (558:3): [True: 0, False: 33] ------------------ 559| 22| case '5': ------------------ | Branch (559:3): [True: 0, False: 33] ------------------ 560| 22| case '6': ------------------ | Branch (560:3): [True: 0, False: 33] ------------------ 561| 27| case '7': ------------------ | Branch (561:3): [True: 5, False: 28] ------------------ 562| 31| case '8': ------------------ | Branch (562:3): [True: 4, False: 29] ------------------ 563| 31| case '9': goto yy35; ------------------ | Branch (563:3): [True: 0, False: 33] ------------------ 564| 0| case ';': ------------------ | Branch (564:3): [True: 0, False: 33] ------------------ 565| 0| YYSTAGN(context.yyt1); ------------------ | | 37| 0|#define YYSTAGN(t) t = NULL ------------------ 566| 0| YYSTAGP(context.yyt2); ------------------ | | 36| 0|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 0|#define YYCURSOR pos | | ------------------ ------------------ 567| 0| goto yy37; 568| 2| default: goto yy23; ------------------ | Branch (568:3): [True: 2, False: 31] ------------------ 569| 33| } 570| 4|yy36: 571| 4| YYSKIP(); ------------------ | | 33| 4|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 4|#define YYCURSOR pos | | ------------------ ------------------ 572| 4| yych = YYPEEK(); ------------------ | | 31| 4|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 4|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 4|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 4, False: 0] | | ------------------ ------------------ 573| 4| switch (yych) { 574| 2| case 0x00: goto yy23; ------------------ | Branch (574:3): [True: 2, False: 2] ------------------ 575| 0| case ';': ------------------ | Branch (575:3): [True: 0, False: 4] ------------------ 576| 0| YYSTAGP(context.yyt2); ------------------ | | 36| 0|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 29| 0|#define YYCURSOR pos | | ------------------ ------------------ 577| 0| YYSTAGN(context.yyt5); ------------------ | | 37| 0|#define YYSTAGN(t) t = NULL ------------------ 578| 0| goto yy37; 579| 2| default: goto yy36; ------------------ | Branch (579:3): [True: 2, False: 2] ------------------ 580| 4| } 581| 1|yy37: 582| 1| YYSKIP(); ------------------ | | 33| 1|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ ------------------ 583| 1| yych = YYPEEK(); ------------------ | | 31| 1|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 1, False: 0] | | ------------------ ------------------ 584| 1| switch (yych) { 585| 0| case 'b': ------------------ | Branch (585:3): [True: 0, False: 1] ------------------ 586| 0| case 'g': ------------------ | Branch (586:3): [True: 0, False: 1] ------------------ 587| 0| case 'i': ------------------ | Branch (587:3): [True: 0, False: 1] ------------------ 588| 1| case 's': ------------------ | Branch (588:3): [True: 1, False: 0] ------------------ 589| 1| YYSTAGN(context.yyt3); ------------------ | | 37| 1|#define YYSTAGN(t) t = NULL ------------------ 590| 1| YYSTAGN(context.yyt4); ------------------ | | 37| 1|#define YYSTAGN(t) t = NULL ------------------ 591| 1| goto yy38; 592| 0| case 'n': goto yy39; ------------------ | Branch (592:3): [True: 0, False: 1] ------------------ 593| 0| default: goto yy23; ------------------ | Branch (593:3): [True: 0, False: 1] ------------------ 594| 1| } 595| 3|yy38: 596| 3| YYSKIP(); ------------------ | | 33| 3|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ ------------------ 597| 3| yych = YYPEEK(); ------------------ | | 31| 3|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 3|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 2, False: 1] | | ------------------ ------------------ 598| 3| switch (yych) { 599| 2| case '=': goto yy21; ------------------ | Branch (599:3): [True: 2, False: 1] ------------------ 600| 1| default: goto yy23; ------------------ | Branch (600:3): [True: 1, False: 2] ------------------ 601| 3| } 602| 0|yy39: 603| 0| YYSKIP(); ------------------ | | 33| 0|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 0|#define YYCURSOR pos | | ------------------ ------------------ 604| 0| yych = YYPEEK(); ------------------ | | 31| 0|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 0|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 0|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 0, False: 0] | | ------------------ ------------------ 605| 0| switch (yych) { 606| 0| case 's': goto yy22; ------------------ | Branch (606:3): [True: 0, False: 0] ------------------ 607| 0| default: goto yy23; ------------------ | Branch (607:3): [True: 0, False: 0] ------------------ 608| 0| } 609| 0|} 610| | 611| | 612| 15| match: 613| 15| if(svu) { ------------------ | Branch (613:8): [True: 0, False: 15] ------------------ 614| | /* ServerUri */ 615| 0| UA_String serverUri = {(size_t)(sve - svu), (UA_Byte*)(uintptr_t)svu}; 616| 0| size_t i = 0; 617| 0| for(; i < serverUrisSize; i++) { ------------------ | Branch (617:15): [True: 0, False: 0] ------------------ 618| 0| if(UA_String_equal(&serverUri, &serverUris[i])) ------------------ | Branch (618:16): [True: 0, False: 0] ------------------ 619| 0| break; 620| 0| } 621| 0| if(i == serverUrisSize) { ------------------ | Branch (621:12): [True: 0, False: 0] ------------------ 622| | /* The ServerUri cannot be mapped. Return the entire input as a 623| | * string NodeId. */ 624| 0| UA_String total = {(size_t)(end - begin), (UA_Byte*)(uintptr_t)begin}; 625| 0| id->nodeId.identifierType = UA_NODEIDTYPE_STRING; 626| 0| return UA_String_copy(&total, &id->nodeId.identifier.string); 627| 0| } 628| 0| id->serverIndex = (UA_UInt32)i; 629| 15| } else if(svr) { ------------------ | Branch (629:15): [True: 0, False: 15] ------------------ 630| | /* ServerIndex */ 631| 0| size_t len = (size_t)(sve - svr); 632| 0| if(UA_readNumber((const UA_Byte*)svr, len, &id->serverIndex) != len) ------------------ | Branch (632:12): [True: 0, False: 0] ------------------ 633| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 634| 0| } 635| | 636| 15| if(nsu) { ------------------ | Branch (636:8): [True: 2, False: 13] ------------------ 637| | /* NamespaceUri */ 638| 2| UA_String nsuri = {(size_t)(body - 1 - nsu), (UA_Byte*)(uintptr_t)nsu}; 639| 2| UA_StatusCode res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 2|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 640| | /* Try to map the NamespaceUri to its NamespaceIndex for ServerIndex == 0. 641| | * If this fails, keep the full NamespaceUri. */ 642| 2| if(id->serverIndex == 0) ------------------ | Branch (642:12): [True: 2, False: 0] ------------------ 643| 2| res = escapedUri2Index(nsuri, &id->nodeId.namespaceIndex, nsMapping); 644| 2| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 2|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (644:12): [True: 2, False: 0] ------------------ 645| 2| res = UA_String_copy(&nsuri, &id->namespaceUri); /* Keep the Uri without mapping */ 646| 2| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 2|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (646:12): [True: 0, False: 2] ------------------ 647| 0| return res; 648| 13| } else if(ns) { ------------------ | Branch (648:15): [True: 0, False: 13] ------------------ 649| | /* NamespaceIndex */ 650| 0| UA_UInt32 tmp; 651| 0| size_t len = (size_t)(body - 1 - ns); 652| 0| if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) ------------------ | Branch (652:12): [True: 0, False: 0] ------------------ 653| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 654| 0| id->nodeId.namespaceIndex = (UA_UInt16)tmp; 655| 0| if(nsMapping) ------------------ | Branch (655:12): [True: 0, False: 0] ------------------ 656| 0| id->nodeId.namespaceIndex = 657| 0| UA_NamespaceMapping_remote2Local(nsMapping, id->nodeId.namespaceIndex); 658| 0| } 659| | 660| | /* From the current position until the end */ 661| 15| return parse_nodeid_body(&id->nodeId, body, end, idEsc); 662| 15|} ua_types_lex.c:parse_qn: 699| 147| UA_UInt16 defaultNamespaceIndex) { 700| 147| size_t len; 701| 147| UA_UInt32 tmp; 702| 147| UA_String str; 703| 147| UA_StatusCode res; 704| | 705| 147| LexContext context; 706| 147| memset(&context, 0, sizeof(LexContext)); 707| | 708| 147| const u8 *begin = pos; 709| 147| UA_QualifiedName_init(qn); 710| 147| qn->namespaceIndex = defaultNamespaceIndex; 711| | 712| | 713| 147|{ 714| 147| u8 yych; 715| 147| yych = YYPEEK(); ------------------ | | 31| 147|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 147|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 147|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 147, False: 0] | | ------------------ ------------------ 716| 147| switch (yych) { 717| 0| case 0x00: ------------------ | Branch (717:3): [True: 0, False: 147] ------------------ 718| 1| case ';': goto yy41; ------------------ | Branch (718:3): [True: 1, False: 146] ------------------ 719| 9| case '0': ------------------ | Branch (719:3): [True: 9, False: 138] ------------------ 720| 11| case '1': ------------------ | Branch (720:3): [True: 2, False: 145] ------------------ 721| 13| case '2': ------------------ | Branch (721:3): [True: 2, False: 145] ------------------ 722| 15| case '3': ------------------ | Branch (722:3): [True: 2, False: 145] ------------------ 723| 17| case '4': ------------------ | Branch (723:3): [True: 2, False: 145] ------------------ 724| 20| case '5': ------------------ | Branch (724:3): [True: 3, False: 144] ------------------ 725| 22| case '6': ------------------ | Branch (725:3): [True: 2, False: 145] ------------------ 726| 25| case '7': ------------------ | Branch (726:3): [True: 3, False: 144] ------------------ 727| 28| case '8': ------------------ | Branch (727:3): [True: 3, False: 144] ------------------ 728| 30| case '9': goto yy44; ------------------ | Branch (728:3): [True: 2, False: 145] ------------------ 729| 116| default: goto yy43; ------------------ | Branch (729:3): [True: 116, False: 31] ------------------ 730| 147| } 731| 1|yy41: 732| 1| YYSKIP(); ------------------ | | 33| 1|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ ------------------ 733| 134|yy42: 734| 134| { pos = begin; goto match_name; } 735| 116|yy43: 736| 116| YYSKIP(); ------------------ | | 33| 116|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 116|#define YYCURSOR pos | | ------------------ ------------------ 737| 116| YYBACKUP(); ------------------ | | 34| 116|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 116|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 116|#define YYCURSOR pos | | ------------------ ------------------ 738| 116| yych = YYPEEK(); ------------------ | | 31| 116|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 116|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 115|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 115, False: 1] | | ------------------ ------------------ 739| 116| if (yych <= 0x00) goto yy42; ------------------ | Branch (739:6): [True: 1, False: 115] ------------------ 740| 115| goto yy46; 741| 115|yy44: 742| 30| YYSKIP(); ------------------ | | 33| 30|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 30|#define YYCURSOR pos | | ------------------ ------------------ 743| 30| YYBACKUP(); ------------------ | | 34| 30|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 30|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 30|#define YYCURSOR pos | | ------------------ ------------------ 744| 30| yych = YYPEEK(); ------------------ | | 31| 30|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 30|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 28|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 28, False: 2] | | ------------------ ------------------ 745| 30| switch (yych) { 746| 8| case '0': ------------------ | Branch (746:3): [True: 8, False: 22] ------------------ 747| 9| case '1': ------------------ | Branch (747:3): [True: 1, False: 29] ------------------ 748| 9| case '2': ------------------ | Branch (748:3): [True: 0, False: 30] ------------------ 749| 10| case '3': ------------------ | Branch (749:3): [True: 1, False: 29] ------------------ 750| 10| case '4': ------------------ | Branch (750:3): [True: 0, False: 30] ------------------ 751| 12| case '5': ------------------ | Branch (751:3): [True: 2, False: 28] ------------------ 752| 13| case '6': ------------------ | Branch (752:3): [True: 1, False: 29] ------------------ 753| 17| case '7': ------------------ | Branch (753:3): [True: 4, False: 26] ------------------ 754| 19| case '8': ------------------ | Branch (754:3): [True: 2, False: 28] ------------------ 755| 22| case '9': ------------------ | Branch (755:3): [True: 3, False: 27] ------------------ 756| 23| case ':': goto yy50; ------------------ | Branch (756:3): [True: 1, False: 29] ------------------ 757| 7| default: goto yy42; ------------------ | Branch (757:3): [True: 7, False: 23] ------------------ 758| 30| } 759| 10.3k|yy45: 760| 10.3k| YYSKIP(); ------------------ | | 33| 10.3k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 10.3k|#define YYCURSOR pos | | ------------------ ------------------ 761| 10.3k| yych = YYPEEK(); ------------------ | | 31| 10.3k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 10.3k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 10.2k|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 10.2k, False: 93] | | ------------------ ------------------ 762| 10.4k|yy46: 763| 10.4k| switch (yych) { 764| 108| case 0x00: goto yy47; ------------------ | Branch (764:3): [True: 108, False: 10.3k] ------------------ 765| 7| case ';': goto yy48; ------------------ | Branch (765:3): [True: 7, False: 10.4k] ------------------ 766| 10.3k| default: goto yy45; ------------------ | Branch (766:3): [True: 10.3k, False: 115] ------------------ 767| 10.4k| } 768| 125|yy47: 769| 125| YYRESTORE(); ------------------ | | 35| 125|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 29| 125|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 30| 125|#define YYMARKER context.marker | | ------------------ ------------------ 770| 125| goto yy42; 771| 7|yy48: 772| 7| YYSKIP(); ------------------ | | 33| 7|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 7|#define YYCURSOR pos | | ------------------ ------------------ 773| 7| { goto match_uri; } 774| 15.0k|yy49: 775| 15.0k| YYSKIP(); ------------------ | | 33| 15.0k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 15.0k|#define YYCURSOR pos | | ------------------ ------------------ 776| 15.0k| yych = YYPEEK(); ------------------ | | 31| 15.0k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 15.0k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 14.9k|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 14.9k, False: 12] | | ------------------ ------------------ 777| 15.0k|yy50: 778| 15.0k| switch (yych) { 779| 8.74k| case '0': ------------------ | Branch (779:3): [True: 8.74k, False: 6.27k] ------------------ 780| 14.4k| case '1': ------------------ | Branch (780:3): [True: 5.66k, False: 9.36k] ------------------ 781| 14.4k| case '2': ------------------ | Branch (781:3): [True: 62, False: 14.9k] ------------------ 782| 14.5k| case '3': ------------------ | Branch (782:3): [True: 64, False: 14.9k] ------------------ 783| 14.5k| case '4': ------------------ | Branch (783:3): [True: 43, False: 14.9k] ------------------ 784| 14.6k| case '5': ------------------ | Branch (784:3): [True: 77, False: 14.9k] ------------------ 785| 14.6k| case '6': ------------------ | Branch (785:3): [True: 28, False: 14.9k] ------------------ 786| 14.8k| case '7': ------------------ | Branch (786:3): [True: 128, False: 14.8k] ------------------ 787| 14.9k| case '8': ------------------ | Branch (787:3): [True: 124, False: 14.9k] ------------------ 788| 15.0k| case '9': goto yy49; ------------------ | Branch (788:3): [True: 69, False: 14.9k] ------------------ 789| 6| case ':': goto yy51; ------------------ | Branch (789:3): [True: 6, False: 15.0k] ------------------ 790| 17| default: goto yy47; ------------------ | Branch (790:3): [True: 17, False: 15.0k] ------------------ 791| 15.0k| } 792| 6|yy51: 793| 6| YYSKIP(); ------------------ | | 33| 6|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 794| 6| { goto match_index; } 795| 15.0k|} 796| | 797| | 798| 6| match_index: 799| 6| len = (size_t)(pos - 1 - begin); 800| 6| if(UA_readNumber((const UA_Byte*)begin, len, &tmp) != len) ------------------ | Branch (800:8): [True: 0, False: 6] ------------------ 801| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 802| 6| qn->namespaceIndex = (UA_UInt16)tmp; 803| 6| goto match_name; 804| | 805| 7| match_uri: 806| 7| str.length = (size_t)(pos - 1 - begin); 807| 7| str.data = (UA_Byte*)(uintptr_t)begin; 808| 7| res = escapedUri2Index(str, &qn->namespaceIndex, nsMapping); 809| 7| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 7|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (809:8): [True: 7, False: 0] ------------------ 810| 7| pos = begin; /* Use the entire string for the name */ 811| | 812| 147| match_name: 813| 147| str.length = (size_t)(end - pos); 814| 147| str.data = (UA_Byte*)(uintptr_t)pos; 815| 147| res = UA_String_copy(&str, &qn->name); 816| 147| if(UA_LIKELY(res == UA_STATUSCODE_GOOD)) ------------------ | | 590| 147|# define UA_LIKELY(x) __builtin_expect((x), 1) | | ------------------ | | | Branch (590:23): [True: 147, False: 0] | | ------------------ ------------------ 817| 147| res = UA_String_unescape(&qn->name, false, escName); 818| 147| return res; 819| 7|} ua_types_lex.c:parse_relativepath: 970| 538| UA_UInt16 defaultNamespaceIndex) { 971| 538| UA_RelativePath_init(rp); 972| 538| UA_Boolean done = false; 973| 538| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 16| 538|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 974| 539| do { 975| 539| res = parse_relativepathElement(rp, ppos, end, server, esc, 976| 539| defaultNamespaceIndex, &done); 977| 539| } while(!done); ------------------ | Branch (977:13): [True: 1, False: 538] ------------------ 978| 538| return res; 979| 538|} ua_types_lex.c:parse_relativepathElement: 841| 539| UA_UInt16 defaultTargetNamespaceIndex, UA_Boolean *done) { 842| 539| const u8 *pos = *ppos; 843| 539| if(pos == end) { ------------------ | Branch (843:8): [True: 7, False: 532] ------------------ 844| 7| *done = true; 845| 7| return UA_STATUSCODE_GOOD; ------------------ | | 16| 7|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 846| 7| } 847| | 848| | /* Create the element on the stack. 849| | * Moved into the rp upon successful parsing. */ 850| 532| UA_RelativePathElement current; 851| 532| UA_RelativePathElement_init(¤t); 852| 532| current.includeSubtypes = true; /* Follow subtypes by default */ 853| | 854| | /* Which ReferenceType? */ 855| 532| const u8 *begin; 856| 532| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 16| 532|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 857| 532| switch(*pos) { 858| 0| case '/': ------------------ | Branch (858:5): [True: 0, False: 532] ------------------ 859| 0| current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); ------------------ | | 46| 0|#define UA_NS0ID_HIERARCHICALREFERENCES 33 /* ReferenceType */ ------------------ 860| 0| goto reftype_target; 861| 1| case '.': ------------------ | Branch (861:5): [True: 1, False: 531] ------------------ 862| | /* Recognize the dot only for the and-escaping. The dot is not escaped 863| | * for percent-escaping and commonly used as part of the browse-name. */ 864| 1| if(esc != UA_ESCAPING_AND) { ------------------ | Branch (864:12): [True: 0, False: 1] ------------------ 865| 0| *done = true; 866| 0| goto out; 867| 0| } 868| 1| current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); ------------------ | | 55| 1|#define UA_NS0ID_AGGREGATES 44 /* ReferenceType */ ------------------ 869| 1| goto reftype_target; 870| 1| case '<': ------------------ | Branch (870:5): [True: 1, False: 531] ------------------ 871| 1| break; 872| 530| default: ------------------ | Branch (872:5): [True: 530, False: 2] ------------------ 873| 530| *done = true; 874| 530| goto out; 875| 532| } 876| | 877| | /* ReferenceType with modifiers wrapped in angle brackets */ 878| 1| begin = ++pos; 879| 3| for(; pos < end; pos++) { ------------------ | Branch (879:11): [True: 3, False: 0] ------------------ 880| 3| if((esc == UA_ESCAPING_AND || esc == UA_ESCAPING_AND_EXTENDED) && *pos == '&') { ------------------ | Branch (880:13): [True: 0, False: 3] | Branch (880:39): [True: 0, False: 3] | Branch (880:75): [True: 0, False: 0] ------------------ 881| 0| pos++; 882| 0| continue; 883| 0| } 884| 3| if((esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) && *pos == '%') { ------------------ | Branch (884:13): [True: 0, False: 3] | Branch (884:43): [True: 3, False: 0] | Branch (884:83): [True: 0, False: 3] ------------------ 885| 0| pos += 2; 886| 0| continue; 887| 0| } 888| 3| if(*pos == '>') ------------------ | Branch (888:12): [True: 1, False: 2] ------------------ 889| 1| break; 890| 3| } 891| 1| if(pos > end) { ------------------ | Branch (891:8): [True: 0, False: 1] ------------------ 892| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 893| 0| goto out; 894| 0| } 895| | 896| | /* Process modifiers */ 897| 1| for(; begin < pos; begin++) { ------------------ | Branch (897:11): [True: 1, False: 0] ------------------ 898| 1| if(*begin == '#') ------------------ | Branch (898:12): [True: 0, False: 1] ------------------ 899| 0| current.includeSubtypes = false; 900| 1| else if(*begin == '!') ------------------ | Branch (900:17): [True: 0, False: 1] ------------------ 901| 0| current.isInverse = true; 902| 1| else 903| 1| break; 904| 1| } 905| | 906| | /* Try to parse a NodeId for the ReferenceType (non-standard!) */ 907| 1| res = parse_nodeid(¤t.referenceTypeId, begin, pos, esc, NULL); 908| 1| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (908:8): [True: 1, False: 0] ------------------ 909| | /* Parse the the ReferenceType from its BrowseName (default) */ 910| 1| UA_QualifiedName refqn; 911| 1| res = parse_qn(&refqn, begin, pos, esc, NULL, defaultTargetNamespaceIndex); 912| 1| res |= lookupRefType(server, &refqn, ¤t.referenceTypeId); 913| 1| UA_QualifiedName_clear(&refqn); 914| 1| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (914:12): [True: 1, False: 0] ------------------ 915| 1| goto out; 916| 1| } 917| | 918| 1| reftype_target: 919| | /* Move pos to the end of the TargetName based on the escaping */ 920| 1| begin = ++pos; 921| 1| while(pos < end && *pos >= '0' && *pos <= '9') ------------------ | Branch (921:11): [True: 1, False: 0] | Branch (921:24): [True: 1, False: 0] | Branch (921:39): [True: 0, False: 1] ------------------ 922| 0| pos++; 923| 1| if(pos < end && *pos == ':') ------------------ | Branch (923:8): [True: 1, False: 0] | Branch (923:21): [True: 0, False: 1] ------------------ 924| 0| pos++; 925| 6| for(; pos < end; pos++) { ------------------ | Branch (925:11): [True: 5, False: 1] ------------------ 926| 5| if((esc == UA_ESCAPING_AND || esc == UA_ESCAPING_AND_EXTENDED) && *pos == '&') { ------------------ | Branch (926:13): [True: 5, False: 0] | Branch (926:39): [True: 0, False: 0] | Branch (926:75): [True: 0, False: 5] ------------------ 927| 0| pos++; 928| 0| continue; 929| 0| } 930| 5| if((esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) && *pos == '%') { ------------------ | Branch (930:13): [True: 0, False: 5] | Branch (930:43): [True: 0, False: 5] | Branch (930:83): [True: 0, False: 0] ------------------ 931| 0| pos += 2; 932| 0| continue; 933| 0| } 934| 5| if(esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (934:12): [True: 0, False: 5] | Branch (934:42): [True: 0, False: 5] ------------------ 935| 0| if(isReservedPercentExtended(*pos)) ------------------ | Branch (935:16): [True: 0, False: 0] ------------------ 936| 0| break; 937| 5| } else { 938| 5| if(isReservedAnd(*pos)) ------------------ | Branch (938:16): [True: 0, False: 5] ------------------ 939| 0| break; 940| 5| } 941| 5| } 942| 1| if(pos > end) { ------------------ | Branch (942:8): [True: 0, False: 1] ------------------ 943| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 944| 0| goto out; 945| 0| } 946| | 947| | /* Parse the TargetName */ 948| 1| res = parse_qn(¤t.targetName, begin, pos, esc, 949| 1| NULL, defaultTargetNamespaceIndex); 950| 1| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (950:8): [True: 0, False: 1] ------------------ 951| 0| UA_RelativePathElement_clear(¤t); 952| 0| goto out; 953| 0| } 954| | 955| | /* Add current to the rp */ 956| 1| res |= relativepath_addelem(rp, ¤t); 957| 1| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (957:8): [True: 0, False: 1] ------------------ 958| 0| UA_RelativePathElement_clear(¤t); 959| | 960| 532| out: 961| | /* Return the status */ 962| 532| *ppos = pos; 963| 532| *done |= (res != UA_STATUSCODE_GOOD); ------------------ | | 16| 532|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 964| 532| return res; 965| 1|} ua_types_lex.c:relativepath_addelem: 682| 1|relativepath_addelem(UA_RelativePath *rp, UA_RelativePathElement *el) { 683| | /* Allocate memory */ 684| 1| UA_RelativePathElement *newArray = (UA_RelativePathElement*) 685| 1| UA_realloc(rp->elements, sizeof(UA_RelativePathElement) * (rp->elementsSize + 1)); ------------------ | | 353| 1|# define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 686| 1| if(!newArray) ------------------ | Branch (686:8): [True: 0, False: 1] ------------------ 687| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 688| 1| rp->elements = newArray; 689| | 690| | /* Move to the target */ 691| 1| rp->elements[rp->elementsSize] = *el; 692| 1| rp->elementsSize++; 693| 1| return UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 694| 1|} ua_types_lex.c:parseAttributeOperand: 1013| 339| UA_NodeId defaultId, UA_UInt16 defaultNamespaceIndex) { 1014| | /* Initialize and set the default values */ 1015| 339| UA_AttributeOperand_init(ao); 1016| 339| ao->nodeId = defaultId; 1017| 339| ao->attributeId = UA_ATTRIBUTEID_VALUE; 1018| | 1019| | /* Nothing to parse */ 1020| 339| if(str.length == 0) ------------------ | Branch (1020:8): [True: 0, False: 339] ------------------ 1021| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1022| | 1023| 339| const u8 *pos = str.data; 1024| 339| const u8 *end = pos + str.length; 1025| 339| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 16| 339|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1026| | 1027| | /* Initial NodeId before the BrowsePath */ 1028| 339| LexContext context; 1029| 339| memset(&context, 0, sizeof(LexContext)); 1030| | 1031| 339|{ 1032| 339| u8 yych; 1033| 339| yych = YYPEEK(); ------------------ | | 31| 339|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 339|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 339|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 339, False: 0] | | ------------------ ------------------ 1034| 339| switch (yych) { 1035| 16| case 'b': ------------------ | Branch (1035:3): [True: 16, False: 323] ------------------ 1036| 17| case 'g': ------------------ | Branch (1036:3): [True: 1, False: 338] ------------------ 1037| 33| case 'i': ------------------ | Branch (1037:3): [True: 16, False: 323] ------------------ 1038| 99| case 's': goto yy55; ------------------ | Branch (1038:3): [True: 66, False: 273] ------------------ 1039| 31| case 'n': goto yy56; ------------------ | Branch (1039:3): [True: 31, False: 308] ------------------ 1040| 209| default: goto yy53; ------------------ | Branch (1040:3): [True: 209, False: 130] ------------------ 1041| 339| } 1042| 209|yy53: 1043| 209| YYSKIP(); ------------------ | | 33| 209|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 209|#define YYCURSOR pos | | ------------------ ------------------ 1044| 309|yy54: 1045| 309| { pos = str.data; goto parse_path; } 1046| 99|yy55: 1047| 99| YYSKIP(); ------------------ | | 33| 99|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 99|#define YYCURSOR pos | | ------------------ ------------------ 1048| 99| yych = YYPEEK(); ------------------ | | 31| 99|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 99|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 95|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 95, False: 4] | | ------------------ ------------------ 1049| 99| switch (yych) { 1050| 30| case '=': goto yy57; ------------------ | Branch (1050:3): [True: 30, False: 69] ------------------ 1051| 69| default: goto yy54; ------------------ | Branch (1051:3): [True: 69, False: 30] ------------------ 1052| 99| } 1053| 31|yy56: 1054| 31| YYSKIP(); ------------------ | | 33| 31|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 31|#define YYCURSOR pos | | ------------------ ------------------ 1055| 31| YYBACKUP(); ------------------ | | 34| 31|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 30| 31|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 29| 31|#define YYCURSOR pos | | ------------------ ------------------ 1056| 31| yych = YYPEEK(); ------------------ | | 31| 31|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 31|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 31|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 31, False: 0] | | ------------------ ------------------ 1057| 31| switch (yych) { 1058| 28| case 's': goto yy58; ------------------ | Branch (1058:3): [True: 28, False: 3] ------------------ 1059| 3| default: goto yy54; ------------------ | Branch (1059:3): [True: 3, False: 28] ------------------ 1060| 31| } 1061| 30|yy57: 1062| 30| YYSKIP(); ------------------ | | 33| 30|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 30|#define YYCURSOR pos | | ------------------ ------------------ 1063| 30| { 1064| | // Find the end position of the NodeId body and parse 1065| 686| for(; pos < end; pos++) { ------------------ | Branch (1065:15): [True: 662, False: 24] ------------------ 1066| 662| if(*pos == '%') { ------------------ | Branch (1066:16): [True: 0, False: 662] ------------------ 1067| 0| pos += 2; 1068| 0| continue; 1069| 0| } 1070| 662| if(isReservedPercentExtended(*pos)) ------------------ | Branch (1070:16): [True: 6, False: 656] ------------------ 1071| 6| break; 1072| 662| } 1073| 30| if(pos > end) { ------------------ | Branch (1073:12): [True: 0, False: 30] ------------------ 1074| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1075| 0| goto cleanup; 1076| 0| } 1077| 30| res = parse_nodeid(&ao->nodeId, str.data, pos, UA_ESCAPING_PERCENT, NULL); 1078| 30| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 30|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1078:12): [True: 18, False: 12] ------------------ 1079| 18| goto cleanup; 1080| 12| goto parse_path; 1081| 30| } 1082| 28|yy58: 1083| 28| YYSKIP(); ------------------ | | 33| 28|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 28|#define YYCURSOR pos | | ------------------ ------------------ 1084| 28| yych = YYPEEK(); ------------------ | | 31| 28|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 28|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 28|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 28, False: 0] | | ------------------ ------------------ 1085| 28| switch (yych) { 1086| 22| case '=': goto yy60; ------------------ | Branch (1086:3): [True: 22, False: 6] ------------------ 1087| 6| case 'u': goto yy61; ------------------ | Branch (1087:3): [True: 6, False: 22] ------------------ 1088| 0| default: goto yy59; ------------------ | Branch (1088:3): [True: 0, False: 28] ------------------ 1089| 28| } 1090| 28|yy59: 1091| 28| YYRESTORE(); ------------------ | | 35| 28|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 29| 28|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 30| 28|#define YYMARKER context.marker | | ------------------ ------------------ 1092| 28| goto yy54; 1093| 22|yy60: 1094| 22| YYSKIP(); ------------------ | | 33| 22|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 22|#define YYCURSOR pos | | ------------------ ------------------ 1095| 22| yych = YYPEEK(); ------------------ | | 31| 22|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 22|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 22|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 22, False: 0] | | ------------------ ------------------ 1096| 22| switch (yych) { 1097| 6| case '0': ------------------ | Branch (1097:3): [True: 6, False: 16] ------------------ 1098| 8| case '1': ------------------ | Branch (1098:3): [True: 2, False: 20] ------------------ 1099| 9| case '2': ------------------ | Branch (1099:3): [True: 1, False: 21] ------------------ 1100| 11| case '3': ------------------ | Branch (1100:3): [True: 2, False: 20] ------------------ 1101| 12| case '4': ------------------ | Branch (1101:3): [True: 1, False: 21] ------------------ 1102| 13| case '5': ------------------ | Branch (1102:3): [True: 1, False: 21] ------------------ 1103| 18| case '6': ------------------ | Branch (1103:3): [True: 5, False: 17] ------------------ 1104| 18| case '7': ------------------ | Branch (1104:3): [True: 0, False: 22] ------------------ 1105| 18| case '8': ------------------ | Branch (1105:3): [True: 0, False: 22] ------------------ 1106| 20| case '9': goto yy62; ------------------ | Branch (1106:3): [True: 2, False: 20] ------------------ 1107| 2| default: goto yy59; ------------------ | Branch (1107:3): [True: 2, False: 20] ------------------ 1108| 22| } 1109| 6|yy61: 1110| 6| YYSKIP(); ------------------ | | 33| 6|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ ------------------ 1111| 6| yych = YYPEEK(); ------------------ | | 31| 6|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 6|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 6, False: 0] | | ------------------ ------------------ 1112| 6| switch (yych) { 1113| 1| case '=': goto yy63; ------------------ | Branch (1113:3): [True: 1, False: 5] ------------------ 1114| 5| default: goto yy59; ------------------ | Branch (1114:3): [True: 5, False: 1] ------------------ 1115| 6| } 1116| 1.15k|yy62: 1117| 1.15k| YYSKIP(); ------------------ | | 33| 1.15k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 1.15k|#define YYCURSOR pos | | ------------------ ------------------ 1118| 1.15k| yych = YYPEEK(); ------------------ | | 31| 1.15k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1.15k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1.14k|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 1.14k, False: 15] | | ------------------ ------------------ 1119| 1.15k| switch (yych) { 1120| 9| case '0': ------------------ | Branch (1120:3): [True: 9, False: 1.14k] ------------------ 1121| 21| case '1': ------------------ | Branch (1121:3): [True: 12, False: 1.14k] ------------------ 1122| 28| case '2': ------------------ | Branch (1122:3): [True: 7, False: 1.14k] ------------------ 1123| 811| case '3': ------------------ | Branch (1123:3): [True: 783, False: 372] ------------------ 1124| 817| case '4': ------------------ | Branch (1124:3): [True: 6, False: 1.14k] ------------------ 1125| 835| case '5': ------------------ | Branch (1125:3): [True: 18, False: 1.13k] ------------------ 1126| 844| case '6': ------------------ | Branch (1126:3): [True: 9, False: 1.14k] ------------------ 1127| 979| case '7': ------------------ | Branch (1127:3): [True: 135, False: 1.02k] ------------------ 1128| 993| case '8': ------------------ | Branch (1128:3): [True: 14, False: 1.14k] ------------------ 1129| 1.13k| case '9': goto yy62; ------------------ | Branch (1129:3): [True: 142, False: 1.01k] ------------------ 1130| 2| case ';': goto yy64; ------------------ | Branch (1130:3): [True: 2, False: 1.15k] ------------------ 1131| 18| default: goto yy59; ------------------ | Branch (1131:3): [True: 18, False: 1.13k] ------------------ 1132| 1.15k| } 1133| 2|yy63: 1134| 2| YYSKIP(); ------------------ | | 33| 2|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 1135| 2| yych = YYPEEK(); ------------------ | | 31| 2|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 1, False: 1] | | ------------------ ------------------ 1136| 2| switch (yych) { 1137| 1| case 0x00: goto yy59; ------------------ | Branch (1137:3): [True: 1, False: 1] ------------------ 1138| 0| case ';': goto yy64; ------------------ | Branch (1138:3): [True: 0, False: 2] ------------------ 1139| 1| default: goto yy63; ------------------ | Branch (1139:3): [True: 1, False: 1] ------------------ 1140| 2| } 1141| 2|yy64: 1142| 2| YYSKIP(); ------------------ | | 33| 2|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ ------------------ 1143| 2| yych = YYPEEK(); ------------------ | | 31| 2|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 2|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 1, False: 1] | | ------------------ ------------------ 1144| 2| switch (yych) { 1145| 0| case 'b': ------------------ | Branch (1145:3): [True: 0, False: 2] ------------------ 1146| 0| case 'g': ------------------ | Branch (1146:3): [True: 0, False: 2] ------------------ 1147| 0| case 'i': ------------------ | Branch (1147:3): [True: 0, False: 2] ------------------ 1148| 1| case 's': goto yy65; ------------------ | Branch (1148:3): [True: 1, False: 1] ------------------ 1149| 1| default: goto yy59; ------------------ | Branch (1149:3): [True: 1, False: 1] ------------------ 1150| 2| } 1151| 1|yy65: 1152| 1| YYSKIP(); ------------------ | | 33| 1|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ ------------------ 1153| 1| yych = YYPEEK(); ------------------ | | 31| 1|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 29| 1|#define YYCURSOR pos | | ------------------ | | | Branch (31:18): [True: 1, False: 0] | | ------------------ ------------------ 1154| 1| switch (yych) { 1155| 0| case '=': goto yy57; ------------------ | Branch (1155:3): [True: 0, False: 1] ------------------ 1156| 1| default: goto yy59; ------------------ | Branch (1156:3): [True: 1, False: 0] ------------------ 1157| 1| } 1158| 1|} 1159| | 1160| | 1161| | /* Parse the BrowsePath */ 1162| 321| parse_path: 1163| 321| res = parse_relativepath(&ao->browsePath, &pos, end, NULL, 1164| 321| UA_ESCAPING_PERCENT_EXTENDED, defaultNamespaceIndex); 1165| 321| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 321|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1165:8): [True: 1, False: 320] ------------------ 1166| 1| goto cleanup; 1167| | 1168| | /* Parse the AttributeId */ 1169| 320| if(pos < end && *pos == '#') { ------------------ | Branch (1169:8): [True: 314, False: 6] | Branch (1169:21): [True: 0, False: 314] ------------------ 1170| 0| const u8 *attr_pos = ++pos; 1171| 0| while(pos < end && ((*pos >= 'a' && *pos <= 'z') || ------------------ | Branch (1171:15): [True: 0, False: 0] | Branch (1171:30): [True: 0, False: 0] | Branch (1171:45): [True: 0, False: 0] ------------------ 1172| 0| (*pos >= 'A' && *pos <= 'Z'))) { ------------------ | Branch (1172:30): [True: 0, False: 0] | Branch (1172:45): [True: 0, False: 0] ------------------ 1173| 0| pos++; 1174| 0| } 1175| 0| UA_String attrString = {(size_t)(pos - attr_pos), (UA_Byte*)(uintptr_t)attr_pos}; 1176| 0| ao->attributeId = UA_AttributeId_fromName(attrString); 1177| 0| if(ao->attributeId == UA_ATTRIBUTEID_INVALID) { ------------------ | Branch (1177:12): [True: 0, False: 0] ------------------ 1178| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1179| 0| goto cleanup; 1180| 0| } 1181| 0| } 1182| | 1183| | /* Parse the IndexRange */ 1184| 320| if(pos < end && *pos == '[') { ------------------ | Branch (1184:8): [True: 314, False: 6] | Branch (1184:21): [True: 0, False: 314] ------------------ 1185| 0| const u8 *range_pos = ++pos; 1186| 0| while(pos < end && *pos != ']') { ------------------ | Branch (1186:15): [True: 0, False: 0] | Branch (1186:28): [True: 0, False: 0] ------------------ 1187| 0| pos++; 1188| 0| } 1189| 0| if(pos == end) { ------------------ | Branch (1189:12): [True: 0, False: 0] ------------------ 1190| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1191| 0| goto cleanup; 1192| 0| } 1193| 0| UA_String rangeString = {(size_t)(pos - range_pos), (UA_Byte*)(uintptr_t)range_pos}; 1194| 0| if(rangeString.length > 0) ------------------ | Branch (1194:12): [True: 0, False: 0] ------------------ 1195| 0| res = UA_String_copy(&rangeString, &ao->indexRange); 1196| 0| pos++; 1197| 0| } 1198| | 1199| | /* Check that we have parsed the entire string */ 1200| 320| if(pos != end) ------------------ | Branch (1200:8): [True: 314, False: 6] ------------------ 1201| 314| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 314|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1202| | 1203| | 1204| 339| cleanup: 1205| 339| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 339|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1205:8): [True: 333, False: 6] ------------------ 1206| 333| UA_AttributeOperand_clear(ao); 1207| 339| return res; 1208| 320|} UA_readNumberWithBase: 110| 53|UA_readNumberWithBase(const UA_Byte *buf, size_t buflen, UA_UInt32 *number, UA_Byte base) { 111| 53| UA_assert(buf); ------------------ | | 411| 53|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (111:5): [True: 53, False: 0] ------------------ 112| 53| UA_assert(number); ------------------ | | 411| 53|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (112:5): [True: 53, False: 0] ------------------ 113| 53| u32 n = 0; 114| 53| size_t progress = 0; 115| | /* read numbers until the end or a non-number character appears */ 116| 17.4k| while(progress < buflen) { ------------------ | Branch (116:11): [True: 17.4k, False: 22] ------------------ 117| 17.4k| u8 c = buf[progress]; 118| 17.4k| if(c >= '0' && c <= '9' && c <= '0' + (base-1)) ------------------ | Branch (118:12): [True: 17.4k, False: 9] | Branch (118:24): [True: 17.4k, False: 32] | Branch (118:36): [True: 17.4k, False: 0] ------------------ 119| 17.4k| n = (n * base) + c - '0'; 120| 41| else if(base > 9 && c >= 'a' && c <= 'z' && c <= 'a' + (base-11)) ------------------ | Branch (120:17): [True: 41, False: 0] | Branch (120:29): [True: 24, False: 17] | Branch (120:41): [True: 14, False: 10] | Branch (120:53): [True: 7, False: 7] ------------------ 121| 7| n = (n * base) + c-'a' + 10; 122| 34| else if(base > 9 && c >= 'A' && c <= 'Z' && c <= 'A' + (base-11)) ------------------ | Branch (122:17): [True: 34, False: 0] | Branch (122:29): [True: 23, False: 11] | Branch (122:41): [True: 5, False: 18] | Branch (122:53): [True: 3, False: 2] ------------------ 123| 3| n = (n * base) + c-'A' + 10; 124| 31| else 125| 31| break; 126| 17.4k| ++progress; 127| 17.4k| } 128| 53| *number = n; 129| 53| return progress; 130| 53|} UA_readNumber: 133| 42|UA_readNumber(const UA_Byte *buf, size_t buflen, UA_UInt32 *number) { 134| 42| return UA_readNumberWithBase(buf, buflen, number, 10); 135| 42|} lookupRefType: 734| 1|lookupRefType(UA_Server *server, UA_QualifiedName *qn, UA_NodeId *outRefTypeId) { 735| | /* Check well-known ReferenceTypes first */ 736| 1| if(qn->namespaceIndex == 0) { ------------------ | Branch (736:8): [True: 1, False: 0] ------------------ 737| 18| for(size_t i = 0; i < KNOWNREFTYPES; i++) { ------------------ | | 712| 18|#define KNOWNREFTYPES 17 ------------------ | Branch (737:27): [True: 17, False: 1] ------------------ 738| 17| if(UA_String_equal(&qn->name, &knownRefTypes[i].browseName)) { ------------------ | Branch (738:16): [True: 0, False: 17] ------------------ 739| 0| *outRefTypeId = UA_NODEID_NUMERIC(0, knownRefTypes[i].identifier); 740| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 741| 0| } 742| 17| } 743| 1| } 744| | 745| | /* Browse the information model. Return the first results if the browse name 746| | * in the hierarchy is ambiguous. */ 747| 1| if(server) { ------------------ | Branch (747:8): [True: 0, False: 1] ------------------ 748| 0| UA_BrowseDescription bd; 749| 0| UA_BrowseDescription_init(&bd); 750| 0| bd.nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_REFERENCES); ------------------ | | 44| 0|#define UA_NS0ID_REFERENCES 31 /* ReferenceType */ ------------------ 751| 0| bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; 752| 0| bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE); ------------------ | | 56| 0|#define UA_NS0ID_HASSUBTYPE 45 /* ReferenceType */ ------------------ 753| 0| bd.nodeClassMask = UA_NODECLASS_REFERENCETYPE; 754| | 755| 0| size_t resultsSize = 0; 756| 0| UA_ExpandedNodeId *results = NULL; 757| 0| UA_StatusCode res = 758| 0| UA_Server_browseRecursive(server, &bd, &resultsSize, &results); 759| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (759:12): [True: 0, False: 0] ------------------ 760| 0| return res; 761| 0| for(size_t i = 0; i < resultsSize; i++) { ------------------ | Branch (761:27): [True: 0, False: 0] ------------------ 762| 0| UA_QualifiedName bn; 763| 0| UA_Server_readBrowseName(server, results[i].nodeId, &bn); 764| 0| if(UA_QualifiedName_equal(qn, &bn)) { ------------------ | Branch (764:16): [True: 0, False: 0] ------------------ 765| 0| UA_QualifiedName_clear(&bn); 766| 0| *outRefTypeId = results[i].nodeId; 767| 0| UA_NodeId_clear(&results[i].nodeId); 768| 0| UA_Array_delete(results, resultsSize, &UA_TYPES[UA_TYPES_NODEID]); ------------------ | | 565| 0|#define UA_TYPES_NODEID 16 ------------------ 769| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 770| 0| } 771| 0| UA_QualifiedName_clear(&bn); 772| 0| } 773| | 774| 0| UA_Array_delete(results, resultsSize, &UA_TYPES[UA_TYPES_NODEID]); ------------------ | | 565| 0|#define UA_TYPES_NODEID 16 ------------------ 775| 0| } 776| | 777| 1| return UA_STATUSCODE_BADNOTFOUND; ------------------ | | 232| 1|#define UA_STATUSCODE_BADNOTFOUND ((UA_StatusCode) 0x803E0000) ------------------ 778| 1|} UA_String_unescape: 810| 150|UA_String_unescape(UA_String *str, UA_Boolean copyEscape, UA_Escaping esc) { 811| 150| if(esc == UA_ESCAPING_NONE) ------------------ | Branch (811:8): [True: 147, False: 3] ------------------ 812| 147| return UA_STATUSCODE_GOOD; ------------------ | | 16| 147|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 813| | 814| | /* Does the string need escaping? */ 815| 3| UA_String tmp; 816| 3| status res = UA_STATUSCODE_GOOD; ------------------ | | 16| 3|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 817| 3| u8 *pos = str->data; 818| 3| u8 *end = str->data + str->length; 819| 3| u8 escape_char = (esc == UA_ESCAPING_PERCENT || ------------------ | Branch (819:23): [True: 1, False: 2] ------------------ 820| 2| esc == UA_ESCAPING_PERCENT_EXTENDED) ? '%' : '&'; ------------------ | Branch (820:23): [True: 1, False: 1] ------------------ 821| 10| for(; pos < end; pos++) { ------------------ | Branch (821:11): [True: 7, False: 3] ------------------ 822| 7| if(*pos == escape_char) ------------------ | Branch (822:12): [True: 0, False: 7] ------------------ 823| 0| goto escape; 824| 7| } 825| | 826| 3| return UA_STATUSCODE_GOOD; ------------------ | | 16| 3|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 827| | 828| 0| escape: 829| 0| if(copyEscape) { ------------------ | Branch (829:8): [True: 0, False: 0] ------------------ 830| 0| res = UA_String_copy(str, &tmp); 831| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (831:12): [True: 0, False: 0] ------------------ 832| 0| return res; 833| 0| pos = tmp.data; 834| 0| end = tmp.data + tmp.length; 835| 0| } 836| | 837| 0| u8 byte = 0; 838| 0| u8 *writepos = pos; 839| | 840| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 43| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 841| 0| if(esc == UA_ESCAPING_PERCENT || ------------------ | Branch (841:8): [True: 0, False: 0] ------------------ 842| 0| esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (842:8): [True: 0, False: 0] ------------------ 843| | /* Percent-Escaping */ 844| 0| for(; pos < end; pos++) { ------------------ | Branch (844:15): [True: 0, False: 0] ------------------ 845| 0| if(*pos == '%') { ------------------ | Branch (845:16): [True: 0, False: 0] ------------------ 846| 0| if(pos + 2 >= end || !isHex(pos[1]) || !isHex(pos[2])) ------------------ | Branch (846:20): [True: 0, False: 0] | Branch (846:38): [True: 0, False: 0] | Branch (846:56): [True: 0, False: 0] ------------------ 847| 0| goto out; 848| 0| if(pos[1] >= 'a') ------------------ | Branch (848:20): [True: 0, False: 0] ------------------ 849| 0| byte = pos[1] - ('a' - 10); 850| 0| else if(pos[1] >= 'A') ------------------ | Branch (850:25): [True: 0, False: 0] ------------------ 851| 0| byte = pos[1] - ('A' - 10); 852| 0| else 853| 0| byte = pos[1] - '0'; 854| 0| byte <<= 4; 855| | 856| 0| if(pos[2] >= 'a') ------------------ | Branch (856:20): [True: 0, False: 0] ------------------ 857| 0| byte += (u8)(pos[2] - ('a' - 10)); 858| 0| else if(pos[2] >= 'A') ------------------ | Branch (858:25): [True: 0, False: 0] ------------------ 859| 0| byte += (u8)(pos[2] - ('A' - 10)); 860| 0| else 861| 0| byte += (u8)(pos[2] - '0'); 862| | 863| 0| pos += 2; 864| 0| *writepos++ = byte; 865| 0| continue; 866| 0| } 867| 0| *writepos++ = *pos; 868| 0| } 869| 0| } else { 870| | /* And-Escaping */ 871| 0| for(; pos < end; pos++) { ------------------ | Branch (871:15): [True: 0, False: 0] ------------------ 872| 0| if(*pos == '&') { ------------------ | Branch (872:16): [True: 0, False: 0] ------------------ 873| 0| pos++; 874| 0| if(pos == end) ------------------ | Branch (874:20): [True: 0, False: 0] ------------------ 875| 0| goto out; 876| 0| } 877| 0| *writepos++ = *pos; 878| 0| } 879| 0| } 880| 0| res = UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 881| | 882| 0| out: 883| 0| if(copyEscape) { ------------------ | Branch (883:8): [True: 0, False: 0] ------------------ 884| 0| tmp.length = (size_t)(writepos - tmp.data); 885| 0| if(tmp.length == 0) ------------------ | Branch (885:12): [True: 0, False: 0] ------------------ 886| 0| UA_String_clear(&tmp); 887| 0| if(res == UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (887:12): [True: 0, False: 0] ------------------ 888| 0| *str = tmp; 889| 0| else 890| 0| UA_String_clear(&tmp); 891| 0| } else if(res == UA_STATUSCODE_GOOD) { ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (891:15): [True: 0, False: 0] ------------------ 892| 0| str->length = (size_t)(writepos - str->data); 893| 0| } 894| 0| return res; 895| 0|} UA_String_escapedSize: 901| 1|UA_String_escapedSize(const UA_String s, UA_Escaping esc) { 902| | /* Find out the overhead from escaping */ 903| 1| size_t overhead = 0; 904| 6| for(size_t j = 0; j < s.length; j++) { ------------------ | Branch (904:23): [True: 5, False: 1] ------------------ 905| 5| if(esc == UA_ESCAPING_AND_EXTENDED) ------------------ | Branch (905:12): [True: 0, False: 5] ------------------ 906| 0| overhead += isReservedAndExtended(s.data[j]); 907| 5| else if(esc == UA_ESCAPING_AND) ------------------ | Branch (907:17): [True: 5, False: 0] ------------------ 908| 5| overhead += isReservedAnd(s.data[j]); 909| 0| else if(esc == UA_ESCAPING_PERCENT) ------------------ | Branch (909:17): [True: 0, False: 0] ------------------ 910| 0| overhead += (isReservedPercent(s.data[j]) ? 2 : 0); ------------------ | Branch (910:26): [True: 0, False: 0] ------------------ 911| 0| else /* if(esc == UA_ESCAPING_PERCENT_EXTENDED) */ 912| 0| overhead += (isReservedPercentExtended(s.data[j]) ? 2 : 0); ------------------ | Branch (912:26): [True: 0, False: 0] ------------------ 913| 5| } 914| | 915| 1| return s.length + overhead; 916| 1|} UA_String_escapeInsert: 919| 1|UA_String_escapeInsert(u8 *pos, const UA_String s2, UA_Escaping esc) { 920| 1| u8 *begin = pos; 921| | 922| 1| if(esc == UA_ESCAPING_NONE) { ------------------ | Branch (922:8): [True: 0, False: 1] ------------------ 923| 0| for(size_t j = 0; j < s2.length; j++) ------------------ | Branch (923:27): [True: 0, False: 0] ------------------ 924| 0| *pos++ = s2.data[j]; 925| 1| } else if(esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (925:15): [True: 0, False: 1] | Branch (925:45): [True: 0, False: 1] ------------------ 926| 0| for(size_t j = 0; j < s2.length; j++) { ------------------ | Branch (926:27): [True: 0, False: 0] ------------------ 927| 0| UA_Boolean reserved = (esc == UA_ESCAPING_PERCENT_EXTENDED) ? ------------------ | Branch (927:35): [True: 0, False: 0] ------------------ 928| 0| isReservedPercentExtended(s2.data[j]) : isReservedPercent(s2.data[j]); 929| 0| if(UA_LIKELY(!reserved)) { ------------------ | | 590| 0|# define UA_LIKELY(x) __builtin_expect((x), 1) | | ------------------ | | | Branch (590:23): [True: 0, False: 0] | | ------------------ ------------------ 930| 0| *pos++ = s2.data[j]; 931| 0| } else { 932| 0| *pos++ = '%'; 933| 0| *pos++ = hexchars[s2.data[j] >> 4]; 934| 0| *pos++ = hexchars[s2.data[j] & 0x0f]; 935| 0| } 936| 0| } 937| 1| } else { 938| 6| for(size_t j = 0; j < s2.length; j++) { ------------------ | Branch (938:27): [True: 5, False: 1] ------------------ 939| 5| UA_Boolean reserved = (esc == UA_ESCAPING_AND_EXTENDED) ? ------------------ | Branch (939:35): [True: 0, False: 5] ------------------ 940| 5| isReservedAndExtended(s2.data[j]) : isReservedAnd(s2.data[j]); 941| 5| if(reserved) ------------------ | Branch (941:16): [True: 0, False: 5] ------------------ 942| 0| *pos++ = '&'; 943| 5| *pos++ = s2.data[j]; 944| 5| } 945| 1| } 946| | 947| 1| return (size_t)(pos - begin); 948| 1|} UA_String_escapeAppend: 951| 1|UA_String_escapeAppend(UA_String *s, const UA_String s2, UA_Escaping esc) { 952| 1| if(esc == UA_ESCAPING_NONE) ------------------ | Branch (952:8): [True: 0, False: 1] ------------------ 953| 0| return UA_String_append(s, s2); 954| | 955| | /* Allocate memory for the additional escaped string */ 956| 1| size_t escapedLength = UA_String_escapedSize(s2, esc); 957| 1| UA_Byte *buf = (UA_Byte*) 958| 1| UA_realloc(s->data, s->length + s2.length + escapedLength); ------------------ | | 353| 1|# define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 959| 1| if(!buf) ------------------ | Branch (959:8): [True: 0, False: 1] ------------------ 960| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 31| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 961| | 962| | /* Escape and insert at the end */ 963| 1| s->data = buf; 964| 1| UA_String_escapeInsert(s->data + s->length, s2, esc); 965| 1| s->length += escapedLength; 966| 1| return UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 967| 1|} UA_RelativePath_print: 1065| 1|UA_RelativePath_print(const UA_RelativePath *rp, UA_String *out) { 1066| 1| return printRelativePath(rp, out, UA_ESCAPING_AND); 1067| 1|} ua_util.c:printRelativePath: 1007| 1|printRelativePath(const UA_RelativePath *rp, UA_String *out, UA_Escaping esc) { 1008| 1| UA_String tmp = UA_STRING_NULL; 1009| 1| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1010| 2| for(size_t i = 0; i < rp->elementsSize && res == UA_STATUSCODE_GOOD; i++) { ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1010:23): [True: 1, False: 1] | Branch (1010:47): [True: 1, False: 0] ------------------ 1011| | /* Print the reference type */ 1012| 1| UA_RelativePathElement *elm = &rp->elements[i]; 1013| 1| if(UA_NodeId_equal(&hierarchicalRefs, &elm->referenceTypeId) && ------------------ | Branch (1013:12): [True: 0, False: 1] ------------------ 1014| 0| !elm->isInverse && elm->includeSubtypes) { ------------------ | Branch (1014:12): [True: 0, False: 0] | Branch (1014:31): [True: 0, False: 0] ------------------ 1015| 0| res |= UA_String_append(&tmp, UA_STRING("/")); 1016| 1| } else if(esc == UA_ESCAPING_AND && ------------------ | Branch (1016:19): [True: 1, False: 0] ------------------ 1017| 1| UA_NodeId_equal(&aggregatesRefs, &elm->referenceTypeId) && ------------------ | Branch (1017:19): [True: 1, False: 0] ------------------ 1018| 1| !elm->isInverse && elm->includeSubtypes) { ------------------ | Branch (1018:19): [True: 1, False: 0] | Branch (1018:38): [True: 1, False: 0] ------------------ 1019| 1| res |= UA_String_append(&tmp, UA_STRING(".")); 1020| 1| } else { 1021| 0| res |= UA_String_append(&tmp, UA_STRING("<")); 1022| 0| if(!elm->includeSubtypes) ------------------ | Branch (1022:16): [True: 0, False: 0] ------------------ 1023| 0| res |= UA_String_append(&tmp, UA_STRING("#")); 1024| 0| if(elm->isInverse) ------------------ | Branch (1024:16): [True: 0, False: 0] ------------------ 1025| 0| res |= UA_String_append(&tmp, UA_STRING("!")); 1026| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1026:16): [True: 0, False: 0] ------------------ 1027| 0| break; 1028| | 1029| 0| UA_Byte bnBuf[512]; 1030| 0| UA_String bnBufStr = {512, bnBuf}; 1031| 0| res = getRefTypeBrowseName(&elm->referenceTypeId, &bnBufStr); 1032| 0| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1032:16): [True: 0, False: 0] ------------------ 1033| 0| UA_String_init(&bnBufStr); 1034| 0| res = getRefTypeBrowseName(&elm->referenceTypeId, &bnBufStr); 1035| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1035:20): [True: 0, False: 0] ------------------ 1036| 0| break; 1037| 0| } 1038| 0| res |= UA_String_escapeAppend(&tmp, bnBufStr, esc); 1039| 0| res |= UA_String_append(&tmp, UA_STRING(">")); 1040| 0| if(bnBufStr.data != bnBuf) ------------------ | Branch (1040:16): [True: 0, False: 0] ------------------ 1041| 0| UA_String_clear(&bnBufStr); 1042| 0| } 1043| | 1044| | /* Print the qualified name */ 1045| 1| UA_QualifiedName *qn = &elm->targetName; 1046| 1| if(qn->namespaceIndex > 0) { ------------------ | Branch (1046:12): [True: 0, False: 1] ------------------ 1047| 0| char nsStr[8]; /* Enough for a uint16 */ 1048| 0| itoaUnsigned(qn->namespaceIndex, nsStr, 10); 1049| 0| res |= UA_String_append(&tmp, UA_STRING(nsStr)); 1050| 0| res |= UA_String_append(&tmp, UA_STRING(":")); 1051| 0| } 1052| 1| res |= UA_String_escapeAppend(&tmp, qn->name, esc); 1053| 1| } 1054| | 1055| | /* Encoding failed, clean up */ 1056| 1| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1056:8): [True: 0, False: 1] ------------------ 1057| 0| UA_String_clear(&tmp); 1058| 0| return res; 1059| 0| } 1060| | 1061| 1| return moveTmpToOut(&tmp, out); 1062| 1|} ua_util.c:moveTmpToOut: 970| 1|moveTmpToOut(UA_String *tmp, UA_String *out) { 971| | /* Output has zero length */ 972| 1| if(tmp->length == 0) { ------------------ | Branch (972:8): [True: 0, False: 1] ------------------ 973| 0| UA_assert(tmp->data == NULL); ------------------ | | 411| 0|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (973:9): [True: 0, False: 0] ------------------ 974| 0| if(out->data == NULL) ------------------ | Branch (974:12): [True: 0, False: 0] ------------------ 975| 0| out->data = (UA_Byte*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 0|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 976| 0| out->length = 0; 977| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 978| 0| } 979| | 980| | /* No output buffer provided, return the tmp buffer */ 981| 1| if(out->length == 0) { ------------------ | Branch (981:8): [True: 1, False: 0] ------------------ 982| 1| *out = *tmp; 983| 1| return UA_STATUSCODE_GOOD; ------------------ | | 16| 1|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 984| 1| } 985| | 986| | /* The provided buffer is too short */ 987| 0| if(out->length < tmp->length) { ------------------ | Branch (987:8): [True: 0, False: 0] ------------------ 988| 0| UA_String_clear(tmp); 989| 0| return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED; ------------------ | | 46| 0|#define UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED ((UA_StatusCode) 0x80080000) ------------------ 990| 0| } 991| | 992| | /* Copy output to the provided buffer */ 993| 0| memcpy(out->data, tmp->data, tmp->length); 994| 0| out->length = tmp->length; 995| 0| UA_String_clear(tmp); 996| 0| return UA_STATUSCODE_GOOD; ------------------ | | 16| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 997| 0|} ua_types.c:isTrue: 167| 7.49k|isTrue(uint8_t expr) { 168| 7.49k| return expr; 169| 7.49k|} ua_util.c:isReservedAnd: 83| 10|isReservedAnd(u8 c) { 84| 10| return (c == '/' || c == '.' || c == '<' || c == '>' || ------------------ | Branch (84:13): [True: 0, False: 10] | Branch (84:25): [True: 0, False: 10] | Branch (84:37): [True: 0, False: 10] | Branch (84:49): [True: 0, False: 10] ------------------ 85| 10| c == ':' || c == '#' || c == '!' || c == '&'); ------------------ | Branch (85:13): [True: 0, False: 10] | Branch (85:25): [True: 0, False: 10] | Branch (85:37): [True: 0, False: 10] | Branch (85:49): [True: 0, False: 10] ------------------ 86| 10|} ua_types_lex.c:isReservedPercentExtended: 100| 662|isReservedPercentExtended(u8 c) { 101| 662| return (isReservedPercent(c) || c == ':' || c == '#' || c == '[' || c == ']' || ------------------ | Branch (101:13): [True: 3, False: 659] | Branch (101:37): [True: 0, False: 659] | Branch (101:49): [True: 0, False: 659] | Branch (101:61): [True: 0, False: 659] | Branch (101:73): [True: 0, False: 659] ------------------ 102| 659| c == '&' || c == '(' || c == ')' || c == ',' || c == '<' || c == '>' || ------------------ | Branch (102:13): [True: 1, False: 658] | Branch (102:25): [True: 1, False: 657] | Branch (102:37): [True: 0, False: 657] | Branch (102:49): [True: 0, False: 657] | Branch (102:61): [True: 1, False: 656] | Branch (102:73): [True: 0, False: 656] ------------------ 103| 656| c == '`' || c == '/' || c == '\\' || c == '"' || c == '\'' ); ------------------ | Branch (103:13): [True: 0, False: 656] | Branch (103:25): [True: 0, False: 656] | Branch (103:37): [True: 0, False: 656] | Branch (103:50): [True: 0, False: 656] | Branch (103:62): [True: 0, False: 656] ------------------ 104| 662|} ua_types_lex.c:isReservedPercent: 95| 662|isReservedPercent(u8 c) { 96| 662| return (c == ';' || c == '%' || c <= ' ' || c == 127); ------------------ | Branch (96:13): [True: 0, False: 662] | Branch (96:26): [True: 0, False: 662] | Branch (96:38): [True: 3, False: 659] | Branch (96:50): [True: 0, False: 659] ------------------ 97| 662|} ua_types_lex.c:isReservedAnd: 83| 5|isReservedAnd(u8 c) { 84| 5| return (c == '/' || c == '.' || c == '<' || c == '>' || ------------------ | Branch (84:13): [True: 0, False: 5] | Branch (84:25): [True: 0, False: 5] | Branch (84:37): [True: 0, False: 5] | Branch (84:49): [True: 0, False: 5] ------------------ 85| 5| c == ':' || c == '#' || c == '!' || c == '&'); ------------------ | Branch (85:13): [True: 0, False: 5] | Branch (85:25): [True: 0, False: 5] | Branch (85:37): [True: 0, False: 5] | Branch (85:49): [True: 0, False: 5] ------------------ 86| 5|} LLVMFuzzerTestOneInput: 14| 2.09k|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 15| 2.09k| if(size <= 1) ------------------ | Branch (15:8): [True: 1, False: 2.09k] ------------------ 16| 1| return 0; 17| | 18| | /* Use the first byte as a selector to choose which parsing function to fuzz */ 19| 2.09k| uint8_t selector = data[0]; 20| 2.09k| const uint8_t *payload = data + 1; 21| 2.09k| size_t payload_size = size - 1; 22| | 23| 2.09k| UA_String str; 24| 2.09k| UA_StatusCode retval = UA_ByteString_allocBuffer(&str, payload_size); 25| 2.09k| if(retval != UA_STATUSCODE_GOOD) ------------------ | | 16| 2.09k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (25:8): [True: 0, False: 2.09k] ------------------ 26| 0| return 0; 27| 2.09k| memcpy(str.data, payload, payload_size); 28| | 29| 2.09k| switch(selector % 8) { 30| 256| case 0: { ------------------ | Branch (30:5): [True: 256, False: 1.83k] ------------------ 31| 256| UA_NodeId id; 32| 256| UA_NodeId_init(&id); 33| 256| UA_NodeId_parse(&id, str); 34| 256| UA_NodeId_clear(&id); 35| 256| break; 36| 0| } 37| 594| case 1: { ------------------ | Branch (37:5): [True: 594, False: 1.50k] ------------------ 38| 594| UA_DateTime dt; 39| 594| UA_DateTime_parse(&dt, str); 40| 594| break; 41| 0| } 42| 205| case 2: { ------------------ | Branch (42:5): [True: 205, False: 1.89k] ------------------ 43| 205| UA_Guid guid; 44| 205| UA_Guid_init(&guid); 45| 205| UA_Guid_parse(&guid, str); 46| 205| break; 47| 0| } 48| 339| case 3: { ------------------ | Branch (48:5): [True: 339, False: 1.75k] ------------------ 49| 339| UA_ExpandedNodeId enid; 50| 339| UA_ExpandedNodeId_init(&enid); 51| 339| UA_ExpandedNodeId_parse(&enid, str); 52| 339| UA_ExpandedNodeId_clear(&enid); 53| 339| break; 54| 0| } 55| 145| case 4: { ------------------ | Branch (55:5): [True: 145, False: 1.95k] ------------------ 56| 145| UA_QualifiedName qn; 57| 145| UA_QualifiedName_init(&qn); 58| 145| UA_QualifiedName_parse(&qn, str); 59| 145| UA_QualifiedName_clear(&qn); 60| 145| break; 61| 0| } 62| 217| case 5: { ------------------ | Branch (62:5): [True: 217, False: 1.87k] ------------------ 63| 217| UA_RelativePath rp; 64| 217| UA_RelativePath_init(&rp); 65| 217| UA_StatusCode ret = UA_RelativePath_parse(&rp, str); 66| 217| if(ret == UA_STATUSCODE_GOOD) { ------------------ | | 16| 217|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (66:12): [True: 1, False: 216] ------------------ 67| 1| UA_String printed = UA_STRING_NULL; 68| 1| UA_RelativePath_print(&rp, &printed); 69| 1| UA_String_clear(&printed); 70| 1| } 71| 217| UA_RelativePath_clear(&rp); 72| 217| break; 73| 0| } 74| 277| case 6: { ------------------ | Branch (74:5): [True: 277, False: 1.81k] ------------------ 75| 277| UA_SimpleAttributeOperand sao; 76| 277| UA_SimpleAttributeOperand_init(&sao); 77| 277| UA_SimpleAttributeOperand_parse(&sao, str); 78| 277| UA_SimpleAttributeOperand_clear(&sao); 79| 277| break; 80| 0| } 81| 62| case 7: { ------------------ | Branch (81:5): [True: 62, False: 2.03k] ------------------ 82| 62| UA_ReadValueId rvi; 83| 62| UA_ReadValueId_init(&rvi); 84| 62| UA_ReadValueId_parse(&rvi, str); 85| 62| UA_ReadValueId_clear(&rvi); 86| 62| break; 87| 0| } 88| 0| default: break; ------------------ | Branch (88:5): [True: 0, False: 2.09k] ------------------ 89| 2.09k| } 90| | 91| 2.09k| UA_String_clear(&str); 92| 2.09k| return 0; 93| 2.09k|} fuzz_parse_string.cc:_ZL14UA_NodeId_initP9UA_NodeId: 222| 256|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL15UA_NodeId_clearP9UA_NodeId: 222| 256|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL12UA_Guid_initP7UA_Guid: 222| 205|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL22UA_ExpandedNodeId_initP17UA_ExpandedNodeId: 222| 339|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL23UA_ExpandedNodeId_clearP17UA_ExpandedNodeId: 222| 339|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL21UA_QualifiedName_initP16UA_QualifiedName: 222| 145|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL22UA_QualifiedName_clearP16UA_QualifiedName: 222| 145|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL20UA_RelativePath_initP15UA_RelativePath: 222| 217|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL15UA_String_clearP9UA_String: 222| 2.09k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL21UA_RelativePath_clearP15UA_RelativePath: 222| 217|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL30UA_SimpleAttributeOperand_initP25UA_SimpleAttributeOperand: 222| 277|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL31UA_SimpleAttributeOperand_clearP25UA_SimpleAttributeOperand: 222| 277|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL19UA_ReadValueId_initP14UA_ReadValueId: 222| 62|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL20UA_ReadValueId_clearP14UA_ReadValueId: 222| 62|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types.c:UA_ByteString_init: 222| 2.09k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_String_equal: 222| 17|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_NodeId_equal: 222| 2|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_String_copy: 222| 153|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_NodeId_clear: 222| 249|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_ExpandedNodeId_clear: 222| 336|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_QualifiedName_clear: 222| 1|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePath_init: 222| 538|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePathElement_init: 222| 532|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePath_clear: 222| 216|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_AttributeOperand_init: 222| 339|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_SimpleAttributeOperand_init: 222| 5|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_String_init: 222| 5|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_NodeId_init: 222| 5|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_QualifiedName_init: 222| 147|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_AttributeOperand_clear: 222| 338|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_ReadValueId_init: 222| 1|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl