UA_base64_buf: 36| 846|UA_base64_buf(const unsigned char *src, size_t len, unsigned char *out) { 37| 846| const unsigned char *end = src + len; 38| 846| const unsigned char *in = src; 39| 846| unsigned char *pos = out; 40| 16.2k| while(end - in >= 3) { ------------------ | Branch (40:11): [True: 15.4k, False: 846] ------------------ 41| 15.4k| *pos++ = base64_table[in[0] >> 2]; 42| 15.4k| *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; 43| 15.4k| *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)]; 44| 15.4k| *pos++ = base64_table[in[2] & 0x3f]; 45| 15.4k| in += 3; 46| 15.4k| } 47| | 48| 846| if(end - in) { ------------------ | Branch (48:8): [True: 393, False: 453] ------------------ 49| 393| *pos++ = base64_table[in[0] >> 2]; 50| 393| if(end - in == 1) { ------------------ | Branch (50:12): [True: 195, False: 198] ------------------ 51| 195| *pos++ = base64_table[(in[0] & 0x03) << 4]; 52| 195| *pos++ = '='; 53| 198| } else { 54| 198| *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; 55| 198| *pos++ = base64_table[(in[1] & 0x0f) << 2]; 56| 198| } 57| 393| *pos++ = '='; 58| 393| } 59| | 60| 846| return (size_t)(pos - out); 61| 846|} UA_unbase64: 75| 1.53k|UA_unbase64(const unsigned char *src, size_t len, size_t *out_len) { 76| | /* Empty base64 results in an empty byte-string */ 77| 1.53k| if(len == 0) { ------------------ | Branch (77:8): [True: 754, False: 778] ------------------ 78| 754| *out_len = 0; 79| 754| return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 754|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 80| 754| } 81| | 82| | /* Allocate the output string. Append four bytes to allow missing padding */ 83| 778| size_t olen = (len / 4 * 3) + 4; 84| 778| unsigned char *out = (unsigned char*)UA_malloc(olen); ------------------ | | 18| 778|#define UA_malloc(size) UA_mallocSingleton(size) ------------------ 85| 778| if(!out) ------------------ | Branch (85:8): [True: 0, False: 778] ------------------ 86| 0| return NULL; 87| | 88| | /* Iterate over the input */ 89| 778| size_t pad = 0; 90| 778| unsigned char count = 0; 91| 778| unsigned char block[4]; 92| 778| unsigned char *pos = out; 93| 66.6k| for(size_t i = 0; i < len; i++) { ------------------ | Branch (93:23): [True: 65.8k, False: 746] ------------------ 94| 65.8k| if(src[i] & 0x80) ------------------ | Branch (94:12): [True: 17, False: 65.8k] ------------------ 95| 17| goto error; /* Non-ASCII input */ 96| 65.8k| unsigned char tmp = dtable[src[i]]; 97| 65.8k| if(tmp == 0x80) ------------------ | Branch (97:12): [True: 11, False: 65.8k] ------------------ 98| 11| goto error; /* Not an allowed character */ 99| 65.8k| if(tmp == 0x7f) ------------------ | Branch (99:12): [True: 603, False: 65.2k] ------------------ 100| 603| continue; /* Whitespace is ignored to accomodate RFC 2045, used in 101| | * XML for xs:base64Binary. */ 102| 65.2k| block[count++] = tmp; 103| | 104| | /* Padding */ 105| 65.2k| if(src[i] == '=') { ------------------ | Branch (105:12): [True: 845, False: 64.3k] ------------------ 106| 845| if(count < 3) /* Padding can only be the last two bytes of a block */ ------------------ | Branch (106:16): [True: 3, False: 842] ------------------ 107| 3| goto error; 108| 842| block[count-1] = 0; 109| 842| pad++; 110| 64.3k| } else if(pad > 0) { ------------------ | Branch (110:19): [True: 1, False: 64.3k] ------------------ 111| 1| goto error; /* Padding not terminated correctly */ 112| 1| } 113| | 114| | /* Write three output characters for four characters of input */ 115| 65.2k| if(count == 4) { ------------------ | Branch (115:12): [True: 16.2k, False: 48.9k] ------------------ 116| 16.2k| if(pad > 2) ------------------ | Branch (116:16): [True: 0, False: 16.2k] ------------------ 117| 0| goto error; /* Invalid padding */ 118| 16.2k| *pos++ = (block[0] << 2) | (block[1] >> 4); 119| 16.2k| *pos++ = (block[1] << 4) | (block[2] >> 2); 120| 16.2k| *pos++ = (block[2] << 6) | block[3]; 121| 16.2k| count = 0; 122| 16.2k| pos -= pad; 123| 16.2k| pad = 0; 124| 16.2k| } 125| 65.2k| } 126| | 127| | /* Input length not a multiple of four */ 128| 746| if(count > 0) ------------------ | Branch (128:8): [True: 24, False: 722] ------------------ 129| 24| goto error; 130| | 131| 722| *out_len = (size_t)(pos - out); 132| 722| if(*out_len == 0) { ------------------ | Branch (132:8): [True: 201, False: 521] ------------------ 133| 201| UA_free(out); ------------------ | | 19| 201|#define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 134| 201| return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 201|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 135| 201| } 136| 521| return out; 137| | 138| 56| error: 139| 56| UA_free(out); ------------------ | | 19| 56|#define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 140| | return NULL; 141| 722|} itoaUnsigned: 42| 1.77k|UA_UInt16 itoaUnsigned(UA_UInt64 value, char* buffer, UA_Byte base) { 43| | /* consider absolute value of number */ 44| 1.77k| UA_UInt64 n = value; 45| | 46| 1.77k| UA_UInt16 i = 0; 47| 5.01k| while (n) { ------------------ | Branch (47:12): [True: 3.23k, False: 1.77k] ------------------ 48| 3.23k| UA_UInt64 r = n % base; 49| | 50| 3.23k| if (r >= 10) ------------------ | Branch (50:13): [True: 0, False: 3.23k] ------------------ 51| 0| buffer[i++] = (char)(65 + (r - 10)); 52| 3.23k| else 53| 3.23k| buffer[i++] = (char)(48 + r); 54| | 55| 3.23k| n = n / base; 56| 3.23k| } 57| | /* if number is 0 */ 58| 1.77k| if (i == 0) ------------------ | Branch (58:9): [True: 399, False: 1.37k] ------------------ 59| 399| buffer[i++] = '0'; 60| | 61| 1.77k| buffer[i] = '\0'; /* null terminate string */ 62| 1.77k| i--; 63| | /* reverse the string */ 64| 1.77k| reverse(buffer, 0, i); 65| 1.77k| i++; 66| 1.77k| return i; 67| 1.77k|} itoa.c:reverse: 34| 1.77k|static char* reverse(char *buffer, UA_UInt16 i, UA_UInt16 j) { 35| 2.83k| while (i < j) ------------------ | Branch (35:12): [True: 1.05k, False: 1.77k] ------------------ 36| 1.05k| swap(&buffer[i++], &buffer[j--]); 37| | 38| 1.77k| return buffer; 39| 1.77k|} itoa.c:swap: 27| 1.05k|static void swap(char *x, char *y) { 28| 1.05k| char t = *x; 29| 1.05k| *x = *y; 30| 1.05k| *y = t; 31| 1.05k|} musl_tm_to_secs: 149| 652|musl_tm_to_secs(const struct musl_tm *tm) { 150| 652| int is_leap; 151| 652| long long year = tm->tm_year; 152| 652| int month = tm->tm_mon; 153| 652| if (month >= 12 || month < 0) { ------------------ | Branch (153:9): [True: 497, False: 155] | Branch (153:24): [True: 19, False: 136] ------------------ 154| 516| int adj = month / 12; 155| 516| month %= 12; 156| 516| if (month < 0) { ------------------ | Branch (156:13): [True: 19, False: 497] ------------------ 157| 19| adj--; 158| 19| month += 12; 159| 19| } 160| 516| year += adj; 161| 516| } 162| 652| long long t = musl_year_to_secs(year, &is_leap); 163| 652| t += musl_month_to_secs(month, is_leap); 164| 652| t += 86400LL * (tm->tm_mday-1); 165| 652| t += 3600LL * tm->tm_hour; 166| 652| t += 60LL * tm->tm_min; 167| 652| t += tm->tm_sec; 168| 652| return t; 169| 652|} libc_time.c:musl_year_to_secs: 101| 652|musl_year_to_secs(const long long year, int *is_leap) { 102| 652| if (year-2ULL <= 136) { ------------------ | Branch (102:9): [True: 57, False: 595] ------------------ 103| 57| int y = (int)year; 104| 57| int leaps = (y-68)>>2; 105| 57| if (!((y-68)&3)) { ------------------ | Branch (105:13): [True: 6, False: 51] ------------------ 106| 6| leaps--; 107| 6| if (is_leap) *is_leap = 1; ------------------ | Branch (107:17): [True: 6, False: 0] ------------------ 108| 51| } else if (is_leap) *is_leap = 0; ------------------ | Branch (108:20): [True: 51, False: 0] ------------------ 109| 57| return 31536000*(y-70) + 86400*leaps; 110| 57| } 111| | 112| 595| int cycles, centuries, leaps, rem, dummy; 113| | 114| 595| if (!is_leap) is_leap = &dummy; ------------------ | Branch (114:9): [True: 0, False: 595] ------------------ 115| 595| cycles = (int)((year-100) / 400); 116| 595| rem = (int)((year-100) % 400); 117| 595| if (rem < 0) { ------------------ | Branch (117:9): [True: 404, False: 191] ------------------ 118| 404| cycles--; 119| 404| rem += 400; 120| 404| } 121| 595| if (!rem) { ------------------ | Branch (121:9): [True: 23, False: 572] ------------------ 122| 23| *is_leap = 1; 123| 23| centuries = 0; 124| 23| leaps = 0; 125| 572| } else { 126| 572| if (rem >= 200) { ------------------ | Branch (126:13): [True: 198, False: 374] ------------------ 127| 198| if (rem >= 300) centuries = 3, rem -= 300; ------------------ | Branch (127:17): [True: 160, False: 38] ------------------ 128| 38| else centuries = 2, rem -= 200; 129| 374| } else { 130| 374| if (rem >= 100) centuries = 1, rem -= 100; ------------------ | Branch (130:17): [True: 24, False: 350] ------------------ 131| 350| else centuries = 0; 132| 374| } 133| 572| if (!rem) { ------------------ | Branch (133:13): [True: 4, False: 568] ------------------ 134| 4| *is_leap = 0; 135| 4| leaps = 0; 136| 568| } else { 137| 568| leaps = rem / 4; 138| 568| rem %= 4; 139| 568| *is_leap = !rem; 140| 568| } 141| 572| } 142| | 143| 595| leaps += 97*cycles + 24*centuries - *is_leap; 144| | 145| 595| return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400; 146| 652|} libc_time.c:musl_month_to_secs: 93| 652|musl_month_to_secs(int month, int is_leap) { 94| 652| int t = secs_through_month[month]; 95| 652| if (is_leap && month >= 2) ------------------ | Branch (95:9): [True: 236, False: 416] | Branch (95:20): [True: 202, False: 34] ------------------ 96| 202| t+=86400; 97| 652| return t; 98| 652|} parseUInt64: 30| 4.55k|parseUInt64(const char *str, size_t size, uint64_t *result) { 31| 4.55k| size_t i = 0; 32| 4.55k| uint64_t n = 0, prev = 0; 33| | 34| | /* Hex */ 35| 4.55k| if(size > 2 && str[0] == '0' && (str[1] | 32) == 'x') { ------------------ | Branch (35:8): [True: 797, False: 3.75k] | Branch (35:20): [True: 97, False: 700] | Branch (35:37): [True: 32, False: 65] ------------------ 36| 32| i = 2; 37| 86| for(; i < size; i++) { ------------------ | Branch (37:15): [True: 75, False: 11] ------------------ 38| 75| uint8_t c = (uint8_t)str[i] | 32; 39| 75| if(c >= '0' && c <= '9') ------------------ | Branch (39:16): [True: 71, False: 4] | Branch (39:28): [True: 36, False: 35] ------------------ 40| 36| c = (uint8_t)(c - '0'); 41| 39| else if(c >= 'a' && c <='f') ------------------ | Branch (41:21): [True: 31, False: 8] | Branch (41:33): [True: 18, False: 13] ------------------ 42| 18| c = (uint8_t)(c - 'a' + 10); 43| 21| else if(c >= 'A' && c <='F') ------------------ | Branch (43:21): [True: 14, False: 7] | Branch (43:33): [True: 0, False: 14] ------------------ 44| 0| c = (uint8_t)(c - 'A' + 10); 45| 21| else 46| 21| break; 47| 54| n = (n << 4) | (c & 0xF); 48| 54| if(n < prev) /* Check for overflow */ ------------------ | Branch (48:16): [True: 0, False: 54] ------------------ 49| 0| return 0; 50| 54| prev = n; 51| 54| } 52| 32| *result = n; 53| 32| return (i > 2) ? i : 0; /* 2 -> No digit was parsed */ ------------------ | Branch (53:16): [True: 27, False: 5] ------------------ 54| 32| } 55| | 56| | /* Decimal */ 57| 13.2k| for(; i < size; i++) { ------------------ | Branch (57:11): [True: 9.82k, False: 3.44k] ------------------ 58| 9.82k| if(str[i] < '0' || str[i] > '9') ------------------ | Branch (58:12): [True: 883, False: 8.94k] | Branch (58:28): [True: 193, False: 8.74k] ------------------ 59| 1.07k| break; 60| | /* Fast multiplication: n*10 == (n*8) + (n*2) */ 61| 8.74k| n = (n << 3) + (n << 1) + (uint8_t)(str[i] - '0'); 62| 8.74k| if(n < prev) /* Check for overflow */ ------------------ | Branch (62:12): [True: 0, False: 8.74k] ------------------ 63| 0| return 0; 64| 8.74k| prev = n; 65| 8.74k| } 66| 4.52k| *result = n; 67| 4.52k| return i; 68| 4.52k|} parseInt64: 71| 797|parseInt64(const char *str, size_t size, int64_t *result) { 72| | /* Negative value? */ 73| 797| size_t i = 0; 74| 797| bool neg = false; 75| 797| if(*str == '-' || *str == '+') { ------------------ | Branch (75:8): [True: 15, False: 782] | Branch (75:23): [True: 1, False: 781] ------------------ 76| 16| neg = (*str == '-'); 77| 16| i++; 78| 16| } 79| | 80| | /* Parse as unsigned */ 81| 797| uint64_t n = 0; 82| 797| size_t len = parseUInt64(&str[i], size - i, &n); 83| 797| if(len == 0) ------------------ | Branch (83:8): [True: 19, False: 778] ------------------ 84| 19| return 0; 85| | 86| | /* Check for overflow, adjust and return */ 87| 778| if(!neg) { ------------------ | Branch (87:8): [True: 763, False: 15] ------------------ 88| 763| if(n > 9223372036854775807UL) ------------------ | Branch (88:12): [True: 0, False: 763] ------------------ 89| 0| return 0; 90| 763| *result = (int64_t)n; 91| 763| } else { 92| | /* n is unsigned, so 9223372036854775808UL == 2^63 fits without 93| | * overflow. (int64_t)n would also fit for n in [0, 2^63], but 94| | * the negation -(int64_t)(2^63) is undefined because the result 95| | * (which is +2^63) cannot be represented. Use the unsigned 96| | * representation and reinterpret as int64_t instead. */ 97| 15| if(n > 9223372036854775808UL) ------------------ | Branch (97:12): [True: 0, False: 15] ------------------ 98| 0| return 0; 99| 15| *result = (n == 9223372036854775808UL) ------------------ | Branch (99:19): [True: 0, False: 15] ------------------ 100| 15| ? (int64_t)(-9223372036854775807LL - 1) 101| 15| : -(int64_t)n; 102| 15| } 103| 778| return len + i; 104| 778|} UA_STRING: 219| 14.8k|UA_STRING(char *chars) { 220| 14.8k| UA_String s = {0, NULL}; 221| 14.8k| if(!chars) ------------------ | Branch (221:8): [True: 0, False: 14.8k] ------------------ 222| 0| return s; 223| 14.8k| s.length = strlen(chars); 224| 14.8k| s.data = (UA_Byte*)chars; 225| 14.8k| return s; 226| 14.8k|} UA_String_append: 298| 14.8k|UA_String_append(UA_String *s, const UA_String s2) { 299| 14.8k| if(s2.length == 0) ------------------ | Branch (299:8): [True: 0, False: 14.8k] ------------------ 300| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 301| 14.8k| UA_Byte *buf = (UA_Byte*)UA_realloc(s->data, s->length + s2.length); ------------------ | | 21| 14.8k|#define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 302| 14.8k| if(!buf) ------------------ | Branch (302:8): [True: 0, False: 14.8k] ------------------ 303| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 304| 14.8k| memcpy(buf + s->length, s2.data, s2.length); 305| 14.8k| s->data = buf; 306| 14.8k| s->length += s2.length; 307| 14.8k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 14.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 308| 14.8k|} UA_DateTime_parse: 530| 817|UA_DateTime_parse(UA_DateTime *dst, const UA_String str) { 531| 817| if(str.length == 0) ------------------ | Branch (531:8): [True: 0, False: 817] ------------------ 532| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 533| | 534| 817| struct musl_tm dts; 535| 817| memset(&dts, 0, sizeof(dts)); 536| | 537| | /* Parse the year. The ISO standard asks for four digits. But we accept up 538| | * to five with an optional plus or minus in front due to the range of the 539| | * DateTime 64bit integer. But in that case we require the year and the 540| | * month to be separated by a '-'. Otherwise we cannot know where the month 541| | * starts. */ 542| 817| size_t pos = 0; 543| 817| if(str.data[0] == '-' || str.data[0] == '+') ------------------ | Branch (543:8): [True: 17, False: 800] | Branch (543:30): [True: 7, False: 793] ------------------ 544| 24| pos++; 545| 817| UA_Int64 year = 0; 546| 817| UA_CHECK(str.length - pos > 5, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 817| do { \ | | 173| 817| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 817|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 20, False: 797] | | | | ------------------ | | ------------------ | | 174| 20| EVAL_ON_ERROR; \ | | 175| 20| } \ | | 176| 817| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 797] | | ------------------ ------------------ 547| 797| size_t len = parseInt64((char*)&str.data[pos], 5, &year); 548| 797| pos += len; 549| 797| UA_CHECK(len > 0 && pos < str.length, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 797| do { \ | | 173| 797| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 1.57k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 19, False: 778] | | | | | Branch (579:43): [True: 778, False: 19] | | | | | Branch (579:43): [True: 778, False: 0] | | | | ------------------ | | ------------------ | | 174| 19| EVAL_ON_ERROR; \ | | 175| 19| } \ | | 176| 797| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 778] | | ------------------ ------------------ 550| 778| UA_CHECK(len == 4 || str.data[pos] == '-', return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 778| do { \ | | 173| 778| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 1.40k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 58, False: 720] | | | | | Branch (579:43): [True: 154, False: 624] | | | | | Branch (579:43): [True: 566, False: 58] | | | | ------------------ | | ------------------ | | 174| 58| EVAL_ON_ERROR; \ | | 175| 58| } \ | | 176| 778| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 720] | | ------------------ ------------------ 551| 720| if(str.data[0] == '-') ------------------ | Branch (551:8): [True: 6, False: 714] ------------------ 552| 6| year = -year; 553| 720| dts.tm_year = (UA_Int16)year - 1900; 554| 720| if(str.data[pos] == '-') ------------------ | Branch (554:8): [True: 699, False: 21] ------------------ 555| 699| pos++; 556| | 557| | /* Parse the month */ 558| 720| UA_UInt64 month = 0; 559| 720| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 720| do { \ | | 173| 720| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 720|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 23, False: 697] | | | | ------------------ | | ------------------ | | 174| 23| EVAL_ON_ERROR; \ | | 175| 23| } \ | | 176| 720| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 697] | | ------------------ ------------------ 560| 697| len = parseUInt64((char*)&str.data[pos], 2, &month); 561| 697| pos += len; 562| 697| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 697| do { \ | | 173| 697| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 697|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 4, False: 693] | | | | ------------------ | | ------------------ | | 174| 4| EVAL_ON_ERROR; \ | | 175| 4| } \ | | 176| 697| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 693] | | ------------------ ------------------ 563| 693| dts.tm_mon = (UA_UInt16)month - 1; 564| 693| if(str.data[pos] == '-') ------------------ | Branch (564:8): [True: 5, False: 688] ------------------ 565| 5| pos++; 566| | 567| | /* Parse the day and check the T between date and time */ 568| 693| UA_UInt64 day = 0; 569| 693| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 693| do { \ | | 173| 693| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 693|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 3, False: 690] | | | | ------------------ | | ------------------ | | 174| 3| EVAL_ON_ERROR; \ | | 175| 3| } \ | | 176| 693| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 690] | | ------------------ ------------------ 570| 690| len = parseUInt64((char*)&str.data[pos], 2, &day); 571| 690| pos += len; 572| 690| UA_CHECK(len == 2 || str.data[pos] != 'T', ------------------ | | 172| 690| do { \ | | 173| 690| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 1.20k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 1, False: 689] | | | | | Branch (579:43): [True: 172, False: 518] | | | | | Branch (579:43): [True: 517, False: 1] | | | | ------------------ | | ------------------ | | 174| 1| EVAL_ON_ERROR; \ | | 175| 1| } \ | | 176| 690| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 689] | | ------------------ ------------------ 573| 690| return UA_STATUSCODE_BADDECODINGERROR); 574| 689| dts.tm_mday = (UA_UInt16)day; 575| 689| pos++; 576| | 577| | /* Parse the hour */ 578| 689| UA_UInt64 hour = 0; 579| 689| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 689| do { \ | | 173| 689| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 689|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 5, False: 684] | | | | ------------------ | | ------------------ | | 174| 5| EVAL_ON_ERROR; \ | | 175| 5| } \ | | 176| 689| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 684] | | ------------------ ------------------ 580| 684| len = parseUInt64((char*)&str.data[pos], 2, &hour); 581| 684| pos += len; 582| 684| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 684| do { \ | | 173| 684| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 684|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 6, False: 678] | | | | ------------------ | | ------------------ | | 174| 6| EVAL_ON_ERROR; \ | | 175| 6| } \ | | 176| 684| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 678] | | ------------------ ------------------ 583| 678| dts.tm_hour = (UA_UInt16)hour; 584| 678| if(str.data[pos] == ':') ------------------ | Branch (584:8): [True: 1, False: 677] ------------------ 585| 1| pos++; 586| | 587| | /* Parse the minute */ 588| 678| UA_UInt64 min = 0; 589| 678| UA_CHECK(str.length - pos > 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 678| do { \ | | 173| 678| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 678|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 12, False: 666] | | | | ------------------ | | ------------------ | | 174| 12| EVAL_ON_ERROR; \ | | 175| 12| } \ | | 176| 678| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 666] | | ------------------ ------------------ 590| 666| len = parseUInt64((char*)&str.data[pos], 2, &min); 591| 666| pos += len; 592| 666| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 666| do { \ | | 173| 666| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 666|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 8, False: 658] | | | | ------------------ | | ------------------ | | 174| 8| EVAL_ON_ERROR; \ | | 175| 8| } \ | | 176| 666| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 658] | | ------------------ ------------------ 593| 658| dts.tm_min = (UA_UInt16)min; 594| 658| if(str.data[pos] == ':') ------------------ | Branch (594:8): [True: 1, False: 657] ------------------ 595| 1| pos++; 596| | 597| | /* Parse the second */ 598| 658| UA_UInt64 sec = 0; 599| 658| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 658| do { \ | | 173| 658| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 658|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 2, False: 656] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 658| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 656] | | ------------------ ------------------ 600| 656| len = parseUInt64((char*)&str.data[pos], 2, &sec); 601| 656| pos += len; 602| 656| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 656| do { \ | | 173| 656| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 656|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 4, False: 652] | | | | ------------------ | | ------------------ | | 174| 4| EVAL_ON_ERROR; \ | | 175| 4| } \ | | 176| 656| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 652] | | ------------------ ------------------ 603| 652| dts.tm_sec = (UA_UInt16)sec; 604| | 605| | /* Compute the seconds since the Unix epoch */ 606| 652| long long sinceunix = musl_tm_to_secs(&dts); 607| | 608| | /* Are we within the range that can be represented? */ 609| 652| long long sinceunix_min = 610| 652| (long long)(UA_INT64_MIN / UA_DATETIME_SEC) - ------------------ | | 119| 652|#define UA_INT64_MIN ((int64_t)-UA_INT64_MAX-1LL) | | ------------------ | | | | 118| 652|#define UA_INT64_MAX (int64_t)9223372036854775807LL | | ------------------ ------------------ (long long)(UA_INT64_MIN / UA_DATETIME_SEC) - ------------------ | | 285| 652|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 652|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 652|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 611| 652| (long long)(UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC) - ------------------ | | 327| 652|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 652|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 652|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 652|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (long long)(UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC) - ------------------ | | 285| 652|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 652|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 652|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 612| 652| (long long)1; /* manual correction due to rounding */ 613| 652| long long sinceunix_max = (long long) 614| 652| ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 118| 652|#define UA_INT64_MAX (int64_t)9223372036854775807LL ------------------ ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 327| 652|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 652|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 652|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 652|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ ((UA_INT64_MAX - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC); ------------------ | | 285| 652|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 652|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 652|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 615| 652| if(sinceunix < sinceunix_min || sinceunix > sinceunix_max) ------------------ | Branch (615:8): [True: 38, False: 614] | Branch (615:37): [True: 4, False: 610] ------------------ 616| 42| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 42|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 617| | 618| | /* Convert to DateTime. Add or subtract one extra second here to prevent 619| | * underflow/overflow. This is reverted once the fractional part has been 620| | * added. */ 621| 610| sinceunix -= (sinceunix > 0) ? 1 : -1; ------------------ | Branch (621:18): [True: 184, False: 426] ------------------ 622| 610| UA_DateTime dt = (UA_DateTime) 623| 610| (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 327| 610|#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) | | ------------------ | | | | 285| 610|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | | | ------------------ | | | | | | 284| 610|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | | | ------------------ | | | | | | | | 283| 610|#define UA_DATETIME_USEC 10LL | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 285| 610|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 610|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 610|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ (sinceunix + (UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC)) * UA_DATETIME_SEC; ------------------ | | 285| 610|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 610|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 610|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 624| | 625| | /* Parse the fraction of the second if defined */ 626| 610| UA_CHECK(pos < str.length, goto finish); ------------------ | | 172| 610| do { \ | | 173| 610| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 610|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 293, False: 317] | | | | ------------------ | | ------------------ | | 174| 293| EVAL_ON_ERROR; \ | | 175| 293| } \ | | 176| 610| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 317] | | ------------------ ------------------ 627| 317| if(str.data[pos] == ',' || str.data[pos] == '.') { ------------------ | Branch (627:8): [True: 67, False: 250] | Branch (627:32): [True: 75, False: 175] ------------------ 628| 142| pos++; 629| 142| double frac = 0.0; 630| 142| double denom = 0.1; 631| 643k| while(pos < str.length && str.data[pos] >= '0' && str.data[pos] <= '9') { ------------------ | Branch (631:15): [True: 643k, False: 69] | Branch (631:35): [True: 643k, False: 61] | Branch (631:59): [True: 643k, False: 12] ------------------ 632| 643k| frac += denom * (str.data[pos] - '0'); 633| 643k| denom *= 0.1; 634| 643k| pos++; 635| 643k| } 636| 142| frac += 0.00000005; /* Correct rounding when converting to integer */ 637| 142| dt += (UA_DateTime)(frac * UA_DATETIME_SEC); ------------------ | | 285| 142|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 142|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 142|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 638| 142| } 639| | 640| | /* Time zone handling */ 641| 317| UA_CHECK(pos < str.length, goto finish); ------------------ | | 172| 317| do { \ | | 173| 317| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 317|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 69, False: 248] | | | | ------------------ | | ------------------ | | 174| 69| EVAL_ON_ERROR; \ | | 175| 69| } \ | | 176| 317| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 248] | | ------------------ ------------------ 642| 248| if(str.data[pos] == 'Z') { ------------------ | Branch (642:8): [True: 2, False: 246] ------------------ 643| 2| pos++; 644| 246| } else if(str.data[pos] == '+' || str.data[pos] == '-') { ------------------ | Branch (644:15): [True: 66, False: 180] | Branch (644:39): [True: 127, False: 53] ------------------ 645| 193| UA_UInt64 tzHour = 0, tzMin = 0; 646| 193| UA_Int64 offsetSeconds = 0; 647| 193| UA_Byte tzSign = str.data[pos++]; 648| | 649| 193| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 193| do { \ | | 173| 193| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 193|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 2, False: 191] | | | | ------------------ | | ------------------ | | 174| 2| EVAL_ON_ERROR; \ | | 175| 2| } \ | | 176| 193| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 191] | | ------------------ ------------------ 650| 191| len = parseUInt64((char*)&str.data[pos], 2, &tzHour); 651| 191| pos += len; 652| 191| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 191| do { \ | | 173| 191| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 191|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 5, False: 186] | | | | ------------------ | | ------------------ | | 174| 5| EVAL_ON_ERROR; \ | | 175| 5| } \ | | 176| 191| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 186] | | ------------------ ------------------ 653| | 654| 186| UA_CHECK(str.length > pos, goto finish); /* Allow missing tz minutes */ ------------------ | | 172| 186| do { \ | | 173| 186| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 186|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 1, False: 185] | | | | ------------------ | | ------------------ | | 174| 1| EVAL_ON_ERROR; \ | | 175| 1| } \ | | 176| 186| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 185] | | ------------------ ------------------ 655| 185| if(str.data[pos] == ':') ------------------ | Branch (655:12): [True: 1, False: 184] ------------------ 656| 1| pos++; 657| | 658| 185| UA_CHECK(str.length - pos >= 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 185| do { \ | | 173| 185| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 185|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 14, False: 171] | | | | ------------------ | | ------------------ | | 174| 14| EVAL_ON_ERROR; \ | | 175| 14| } \ | | 176| 185| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 171] | | ------------------ ------------------ 659| 171| len = parseUInt64((char*)&str.data[pos], 2, &tzMin); 660| 171| pos += len; 661| 171| UA_CHECK(len == 2, return UA_STATUSCODE_BADDECODINGERROR); ------------------ | | 172| 171| do { \ | | 173| 171| if(UA_UNLIKELY(!isTrue(A))) { \ | | ------------------ | | | | 579| 171|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (579:25): [True: 37, False: 134] | | | | ------------------ | | ------------------ | | 174| 37| EVAL_ON_ERROR; \ | | 175| 37| } \ | | 176| 171| } while(0) | | ------------------ | | | Branch (176:13): [Folded, False: 134] | | ------------------ ------------------ 662| | 663| 134| offsetSeconds = (tzHour * 3600) + (tzMin * 60); 664| 134| if(tzSign == '-') ------------------ | Branch (664:12): [True: 79, False: 55] ------------------ 665| 79| offsetSeconds = -offsetSeconds; 666| 134| dt -= (UA_DateTime)(offsetSeconds * UA_DATETIME_SEC); ------------------ | | 285| 134|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 134|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 134|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 667| 134| } else { 668| 53| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 53|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 669| 53| } 670| | 671| 499| finish: 672| | /* Remove the underflow/overflow protection (see above) */ 673| 499| if(sinceunix > 0) { ------------------ | Branch (673:8): [True: 173, False: 326] ------------------ 674| 173| if(dt > UA_INT64_MAX - UA_DATETIME_SEC) ------------------ | | 118| 173|#define UA_INT64_MAX (int64_t)9223372036854775807LL ------------------ if(dt > UA_INT64_MAX - UA_DATETIME_SEC) ------------------ | | 285| 173|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 173|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 173|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ | Branch (674:12): [True: 1, False: 172] ------------------ 675| 1| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 1|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 676| 172| dt += UA_DATETIME_SEC; ------------------ | | 285| 172|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 172|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 172|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 677| 326| } else { 678| 326| if(dt < UA_INT64_MIN + UA_DATETIME_SEC) ------------------ | | 119| 326|#define UA_INT64_MIN ((int64_t)-UA_INT64_MAX-1LL) | | ------------------ | | | | 118| 326|#define UA_INT64_MAX (int64_t)9223372036854775807LL | | ------------------ ------------------ if(dt < UA_INT64_MIN + UA_DATETIME_SEC) ------------------ | | 285| 326|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 326|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 326|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ | Branch (678:12): [True: 26, False: 300] ------------------ 679| 26| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 26|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 680| 300| dt -= UA_DATETIME_SEC; ------------------ | | 285| 300|#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) | | ------------------ | | | | 284| 300|#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) | | | | ------------------ | | | | | | 283| 300|#define UA_DATETIME_USEC 10LL | | | | ------------------ | | ------------------ ------------------ 681| 300| } 682| | 683| | /* We must be at the end of the string */ 684| 472| if(pos != str.length) ------------------ | Branch (684:8): [True: 101, False: 371] ------------------ 685| 101| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 101|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 686| | 687| 371| *dst = dt; 688| 371| return UA_STATUSCODE_GOOD; ------------------ | | 17| 371|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 689| 472|} UA_Guid_to_hex: 708| 647|UA_Guid_to_hex(const UA_Guid *guid, u8* out, UA_Boolean lower) { 709| 647| const u8 *hexmap = (lower) ? hexmapLower : hexmapUpper; ------------------ | Branch (709:24): [True: 647, False: 0] ------------------ 710| 647| size_t i = 0, j = 28; 711| 5.82k| for(; i<8;i++,j-=4) /* pos 0-7, 4byte, (a) */ ------------------ | Branch (711:11): [True: 5.17k, False: 647] ------------------ 712| 5.17k| out[i] = hexmap[(guid->data1 >> j) & 0x0Fu]; 713| 647| out[i++] = '-'; /* pos 8 */ 714| 3.23k| for(j=12; i<13;i++,j-=4) /* pos 9-12, 2byte, (b) */ ------------------ | Branch (714:15): [True: 2.58k, False: 647] ------------------ 715| 2.58k| out[i] = hexmap[(uint16_t)(guid->data2 >> j) & 0x0Fu]; 716| 647| out[i++] = '-'; /* pos 13 */ 717| 3.23k| for(j=12; i<18;i++,j-=4) /* pos 14-17, 2byte (c) */ ------------------ | Branch (717:15): [True: 2.58k, False: 647] ------------------ 718| 2.58k| out[i] = hexmap[(uint16_t)(guid->data3 >> j) & 0x0Fu]; 719| 647| out[i++] = '-'; /* pos 18 */ 720| 1.94k| for(j=0;i<23;i+=2,j++) { /* pos 19-22, 2byte (d) */ ------------------ | Branch (720:13): [True: 1.29k, False: 647] ------------------ 721| 1.29k| out[i] = hexmap[(guid->data4[j] & 0xF0u) >> 4u]; 722| 1.29k| out[i+1] = hexmap[guid->data4[j] & 0x0Fu]; 723| 1.29k| } 724| 647| out[i++] = '-'; /* pos 23 */ 725| 4.52k| for(j=2; i<36;i+=2,j++) { /* pos 24-35, 6byte (e) */ ------------------ | Branch (725:14): [True: 3.88k, False: 647] ------------------ 726| 3.88k| out[i] = hexmap[(guid->data4[j] & 0xF0u) >> 4u]; 727| 3.88k| out[i+1] = hexmap[guid->data4[j] & 0x0Fu]; 728| 3.88k| } 729| 647|} UA_ByteString_allocBuffer: 756| 4.38k|UA_ByteString_allocBuffer(UA_ByteString *bs, size_t length) { 757| 4.38k| UA_ByteString_init(bs); 758| 4.38k| if(length == 0) { ------------------ | Branch (758:8): [True: 0, False: 4.38k] ------------------ 759| 0| bs->data = (u8*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 0|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 760| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 761| 0| } 762| 4.38k| bs->data = (u8*)UA_calloc(1,length); ------------------ | | 20| 4.38k|#define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 763| 4.38k| if(UA_UNLIKELY(!bs->data)) ------------------ | | 579| 4.38k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | ------------------ | | | Branch (579:25): [True: 0, False: 4.38k] | | ------------------ ------------------ 764| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 765| 4.38k| bs->length = length; 766| 4.38k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 4.38k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 767| 4.38k|} UA_NODEID_NUMERIC: 829| 8.84k|UA_NODEID_NUMERIC(UA_UInt16 nsIndex, UA_UInt32 identifier) { 830| 8.84k| UA_NodeId id; 831| 8.84k| memset(&id, 0, sizeof(UA_NodeId)); 832| 8.84k| id.namespaceIndex = nsIndex; 833| 8.84k| id.identifierType = UA_NODEIDTYPE_NUMERIC; 834| 8.84k| id.identifier.numeric = identifier; 835| 8.84k| return id; 836| 8.84k|} nodeId_printEscape: 1023| 4.41k| const UA_NamespaceMapping *nsMapping, UA_Escaping idEsc) { 1024| | /* Try to map the NamespaceIndex to the Uri */ 1025| 4.41k| UA_String nsUri = UA_STRING_NULL; 1026| 4.41k| if(id->namespaceIndex > 0 && nsMapping) ------------------ | Branch (1026:8): [True: 788, False: 3.62k] | Branch (1026:34): [True: 0, False: 788] ------------------ 1027| 0| UA_NamespaceMapping_index2Uri(nsMapping, id->namespaceIndex, &nsUri); 1028| | 1029| | /* Compute the string length and print numerical identifiers. */ 1030| 4.41k| u8 nsStr[7]; 1031| 4.41k| u8 numIdStr[12]; 1032| 4.41k| size_t idLen = nodeIdSize(id, nsStr, numIdStr, nsUri, idEsc); 1033| 4.41k| if(idLen == 0) ------------------ | Branch (1033:8): [True: 0, False: 4.41k] ------------------ 1034| 0| return UA_STATUSCODE_BADINTERNALERROR; ------------------ | | 29| 0|#define UA_STATUSCODE_BADINTERNALERROR ((UA_StatusCode) 0x80020000) ------------------ 1035| | 1036| | /* Allocate memory if required */ 1037| 4.41k| if(output->length == 0) { ------------------ | Branch (1037:8): [True: 690, False: 3.72k] ------------------ 1038| 690| UA_StatusCode res = UA_ByteString_allocBuffer((UA_ByteString*)output, idLen); 1039| 690| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 690|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1039:12): [True: 0, False: 690] ------------------ 1040| 0| return res; 1041| 3.72k| } else { 1042| 3.72k| if(output->length < idLen) ------------------ | Branch (1042:12): [True: 690, False: 3.03k] ------------------ 1043| 690| return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED; ------------------ | | 47| 690|#define UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED ((UA_StatusCode) 0x80080000) ------------------ 1044| 3.03k| output->length = idLen; 1045| 3.03k| } 1046| | 1047| | /* Print the NodeId */ 1048| 3.72k| u8 *pos = printNodeIdBody(id, nsUri, nsStr, numIdStr, output->data, nsMapping, idEsc); 1049| 3.72k| output->length = (size_t)(pos - output->data); 1050| 3.72k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 3.72k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1051| 4.41k|} UA_NodeId_printEx: 1055| 4.41k| const UA_NamespaceMapping *nsMapping) { 1056| 4.41k| return nodeId_printEscape(id, output, nsMapping, UA_ESCAPING_NONE); 1057| 4.41k|} UA_NodeId_print: 1060| 4.41k|UA_NodeId_print(const UA_NodeId *id, UA_String *output) { 1061| | return UA_NodeId_printEx(id, output, NULL); 1062| 4.41k|} UA_copy: 2094| 18.0k|UA_copy(const void *src, void *dst, const UA_DataType *type) { 2095| 18.0k| memset(dst, 0, type->memSize); /* init */ 2096| 18.0k| UA_StatusCode retval = copyJumpTable[type->typeKind](src, dst, type); 2097| 18.0k| if(retval != UA_STATUSCODE_GOOD) ------------------ | | 17| 18.0k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (2097:8): [True: 0, False: 18.0k] ------------------ 2098| 0| UA_clear(dst, type); 2099| 18.0k| return retval; 2100| 18.0k|} UA_clear: 2197| 26.9k|UA_clear(void *p, const UA_DataType *type) { 2198| 26.9k| clearJumpTable[type->typeKind](p, type); 2199| 26.9k| memset(p, 0, type->memSize); /* init */ 2200| 26.9k|} UA_order: 2670| 27.8k|UA_Order UA_order(const void *p1, const void *p2, const UA_DataType *type) { 2671| 27.8k| return orderJumpTable[type->typeKind](p1, p2, type); 2672| 27.8k|} UA_Array_copy: 2694| 18.0k| void **dst, const UA_DataType *type) { 2695| 18.0k| if(size == 0) { ------------------ | Branch (2695:8): [True: 10.2k, False: 7.78k] ------------------ 2696| 10.2k| if(src == NULL) ------------------ | Branch (2696:12): [True: 0, False: 10.2k] ------------------ 2697| 0| *dst = NULL; 2698| 10.2k| else 2699| 10.2k| *dst= UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 10.2k|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 2700| 10.2k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 10.2k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2701| 10.2k| } 2702| | 2703| | /* Check the array consistency -- defensive programming in case the user 2704| | * manually created an inconsistent array */ 2705| 7.78k| if(UA_UNLIKELY(!type || !src)) ------------------ | | 579| 15.5k|# define UA_UNLIKELY(x) __builtin_expect((x), 0) | | ------------------ | | | Branch (579:25): [True: 0, False: 7.78k] | | | Branch (579:43): [True: 0, False: 7.78k] | | | Branch (579:43): [True: 0, False: 7.78k] | | ------------------ ------------------ 2706| 0| return UA_STATUSCODE_BADINTERNALERROR; ------------------ | | 29| 0|#define UA_STATUSCODE_BADINTERNALERROR ((UA_StatusCode) 0x80020000) ------------------ 2707| | 2708| | /* calloc, so we don't have to check retval in every iteration of copying */ 2709| 7.78k| *dst = UA_calloc(size, type->memSize); ------------------ | | 20| 7.78k|#define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 2710| 7.78k| if(!*dst) ------------------ | Branch (2710:8): [True: 0, False: 7.78k] ------------------ 2711| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 2712| | 2713| 7.78k| if(type->pointerFree) { ------------------ | Branch (2713:8): [True: 7.78k, False: 0] ------------------ 2714| 7.78k| memcpy(*dst, src, type->memSize * size); 2715| 7.78k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 7.78k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2716| 7.78k| } 2717| | 2718| 0| uintptr_t ptrs = (uintptr_t)src; 2719| 0| uintptr_t ptrd = (uintptr_t)*dst; 2720| 0| UA_StatusCode retval = UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 2721| 0| for(size_t i = 0; i < size; ++i) { ------------------ | Branch (2721:23): [True: 0, False: 0] ------------------ 2722| 0| retval |= UA_copy((void*)ptrs, (void*)ptrd, type); 2723| 0| ptrs += type->memSize; 2724| 0| ptrd += type->memSize; 2725| 0| } 2726| 0| if(retval != UA_STATUSCODE_GOOD) { ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (2726:8): [True: 0, False: 0] ------------------ 2727| 0| UA_Array_delete(*dst, size, type); 2728| | *dst = NULL; 2729| 0| } 2730| 0| return retval; 2731| 7.78k|} UA_Array_delete: 2822| 33.9k|UA_Array_delete(void *p, size_t size, const UA_DataType *type) { 2823| 33.9k| if(!type->pointerFree) { ------------------ | Branch (2823:8): [True: 2.88k, False: 31.0k] ------------------ 2824| 2.88k| uintptr_t ptr = (uintptr_t)p; 2825| 18.2k| for(size_t i = 0; i < size; ++i) { ------------------ | Branch (2825:27): [True: 15.3k, False: 2.88k] ------------------ 2826| 15.3k| UA_clear((void*)ptr, type); 2827| 15.3k| ptr += type->memSize; 2828| 15.3k| } 2829| 2.88k| } 2830| 33.9k| UA_free((void*)((uintptr_t)p & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL)); ------------------ | | 19| 33.9k|#define UA_free(ptr) UA_freeSingleton(ptr) ------------------ 2831| 33.9k|} ua_types.c:nodeIdSize: 922| 4.41k| UA_Escaping idEsc) { 923| | /* Namespace length */ 924| 4.41k| size_t len = 0; 925| 4.41k| if(nsUri.data != NULL) { ------------------ | Branch (925:8): [True: 0, False: 4.41k] ------------------ 926| 0| len += 5; /* nsu=; */ 927| 0| len += UA_String_escapedSize(nsUri, UA_ESCAPING_PERCENT); 928| 4.41k| } else if(id->namespaceIndex > 0) { ------------------ | Branch (928:15): [True: 788, False: 3.62k] ------------------ 929| 788| len += 4; /* ns=; */ 930| 788| size_t nsStrSize = itoaUnsigned(id->namespaceIndex, (char*)nsStr, 10); 931| 788| nsStr[nsStrSize] = 0; 932| 788| len += nsStrSize; 933| 788| } 934| | 935| 4.41k| len += 2; /* ?= */ 936| | 937| 4.41k| switch (id->identifierType) { 938| 569| case UA_NODEIDTYPE_NUMERIC: { ------------------ | Branch (938:5): [True: 569, False: 3.84k] ------------------ 939| 569| size_t numIdStrSize = itoaUnsigned(id->identifier.numeric, (char*)numIdStr, 10); 940| 569| numIdStr[numIdStrSize] = 0; 941| 569| len += numIdStrSize; 942| 569| break; 943| 0| } 944| 2.34k| case UA_NODEIDTYPE_STRING: ------------------ | Branch (944:5): [True: 2.34k, False: 2.06k] ------------------ 945| 2.34k| len += UA_String_escapedSize(id->identifier.string, idEsc); 946| 2.34k| break; 947| 647| case UA_NODEIDTYPE_GUID: ------------------ | Branch (947:5): [True: 647, False: 3.76k] ------------------ 948| 647| len += 36; 949| 647| break; 950| 853| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (950:5): [True: 853, False: 3.56k] ------------------ 951| 853| len += 4 * ((id->identifier.byteString.length + 2) / 3); 952| 853| break; 953| 0| default: ------------------ | Branch (953:5): [True: 0, False: 4.41k] ------------------ 954| 0| len = 0; 955| 4.41k| } 956| 4.41k| return len; 957| 4.41k|} ua_types.c:printNodeIdBody: 961| 3.72k| const UA_NamespaceMapping *nsMapping, UA_Escaping idEsc) { 962| 3.72k| size_t len; 963| | 964| | /* Encode the namespace */ 965| 3.72k| if(nsUri.data != NULL) { ------------------ | Branch (965:8): [True: 0, False: 3.72k] ------------------ 966| 0| memcpy(pos, "nsu=", 4); 967| 0| pos += 4; 968| 0| pos += UA_String_escapeInsert(pos, nsUri, UA_ESCAPING_PERCENT); 969| 0| *pos++ = ';'; 970| 3.72k| } else if(id->namespaceIndex > 0) { ------------------ | Branch (970:15): [True: 546, False: 3.18k] ------------------ 971| 546| memcpy(pos, "ns=", 3); 972| 546| pos += 3; 973| 546| len = strlen((char*)nsStr); 974| 546| memcpy(pos, nsStr, len); 975| 546| pos += len; 976| 546| *pos++ = ';'; 977| 546| } 978| | 979| | /* Encode the identifier */ 980| 3.72k| switch(id->identifierType) { ------------------ | Branch (980:12): [True: 3.72k, False: 0] ------------------ 981| 569| case UA_NODEIDTYPE_NUMERIC: ------------------ | Branch (981:5): [True: 569, False: 3.15k] ------------------ 982| 569| memcpy(pos, "i=", 2); 983| 569| pos += 2; 984| 569| len = strlen((char*)numIdStr); 985| 569| memcpy(pos, numIdStr, len); 986| 569| pos += len; 987| 569| break; 988| 1.66k| case UA_NODEIDTYPE_STRING: ------------------ | Branch (988:5): [True: 1.66k, False: 2.06k] ------------------ 989| 1.66k| memcpy(pos, "s=", 2); 990| 1.66k| pos += 2; 991| 1.66k| pos += UA_String_escapeInsert(pos, id->identifier.string, idEsc); 992| 1.66k| break; 993| 647| case UA_NODEIDTYPE_GUID: ------------------ | Branch (993:5): [True: 647, False: 3.07k] ------------------ 994| 647| memcpy(pos, "g=", 2); 995| 647| pos += 2; 996| 647| UA_Guid_to_hex(&id->identifier.guid, pos, true); 997| 647| pos += 36; 998| 647| break; 999| 846| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (999:5): [True: 846, False: 2.88k] ------------------ 1000| 846| memcpy(pos, "b=", 2); 1001| 846| pos += 2; 1002| | /* Use base64url encoding for percent-escaping. 1003| | * Replace +/ with -_ and remove the padding. */ 1004| 846| u8 *bpos = pos; 1005| 846| pos += UA_base64_buf(id->identifier.byteString.data, 1006| 846| id->identifier.byteString.length, pos); 1007| 846| if(idEsc == UA_ESCAPING_PERCENT || ------------------ | Branch (1007:12): [True: 0, False: 846] ------------------ 1008| 846| idEsc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (1008:12): [True: 0, False: 846] ------------------ 1009| 0| while(pos > bpos && pos[-1] == '=') ------------------ | Branch (1009:19): [True: 0, False: 0] | Branch (1009:33): [True: 0, False: 0] ------------------ 1010| 0| pos--; 1011| 0| for(; bpos < pos; bpos++) { ------------------ | Branch (1011:19): [True: 0, False: 0] ------------------ 1012| 0| if(*bpos == '+') *bpos = '-'; ------------------ | Branch (1012:20): [True: 0, False: 0] ------------------ 1013| 0| else if(*bpos == '/') *bpos = '_'; ------------------ | Branch (1013:25): [True: 0, False: 0] ------------------ 1014| 0| } 1015| 0| } 1016| 846| break; 1017| 3.72k| } 1018| 3.72k| return pos; 1019| 3.72k|} ua_types.c:String_copy: 280| 18.0k|String_copy(const void *src, void *dst, const UA_DataType *_) { 281| 18.0k| const UA_String *srcS = (const UA_String*)src; 282| 18.0k| UA_String *dstS = (UA_String *)dst; 283| 18.0k| UA_StatusCode res = 284| 18.0k| UA_Array_copy(srcS->data, srcS->length, (void**)&dstS->data, 285| 18.0k| &UA_TYPES[UA_TYPES_BYTE]); ------------------ | | 89| 18.0k|#define UA_TYPES_BYTE 2 ------------------ 286| 18.0k| if(res == UA_STATUSCODE_GOOD) ------------------ | | 17| 18.0k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (286:8): [True: 18.0k, False: 0] ------------------ 287| 18.0k| dstS->length = srcS->length; 288| 18.0k| return res; 289| 18.0k|} ua_types.c:nopClear: 2159| 30.9k|static void nopClear(void *p, const UA_DataType *type) { } ua_types.c:String_clear: 292| 31.0k|String_clear(void *p, const UA_DataType *_) { 293| 31.0k| UA_String *s = (UA_String*)p; 294| 31.0k| UA_Array_delete(s->data, s->length, &UA_TYPES[UA_TYPES_BYTE]); ------------------ | | 89| 31.0k|#define UA_TYPES_BYTE 2 ------------------ 295| 31.0k|} ua_types.c:NodeId_clear: 771| 17.7k|NodeId_clear(void *p, const UA_DataType *_) { 772| 17.7k| UA_NodeId *id = (UA_NodeId*)p; 773| 17.7k| switch(id->identifierType) { 774| 2.75k| case UA_NODEIDTYPE_STRING: ------------------ | Branch (774:5): [True: 2.75k, False: 14.9k] ------------------ 775| 4.29k| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (775:5): [True: 1.53k, False: 16.2k] ------------------ 776| 4.29k| String_clear(&id->identifier.string, NULL); 777| 4.29k| break; 778| 13.4k| default: break; ------------------ | Branch (778:5): [True: 13.4k, False: 4.29k] ------------------ 779| 17.7k| } 780| 17.7k|} ua_types.c:ExpandedNodeId_clear: 1072| 879|ExpandedNodeId_clear(void *p, const UA_DataType *_) { 1073| 879| UA_ExpandedNodeId *id = (UA_ExpandedNodeId*)p; 1074| 879| NodeId_clear(&id->nodeId, NULL); 1075| | String_clear(&id->namespaceUri, NULL); 1076| 879|} ua_types.c:QualifiedName_clear: 396| 17.7k|QualifiedName_clear(void *p, const UA_DataType *_) { 397| 17.7k| UA_QualifiedName *qn = (UA_QualifiedName*)p; 398| | String_clear(&qn->name, NULL); 399| 17.7k|} ua_types.c:clearStructure: 2103| 18.7k|clearStructure(void *p, const UA_DataType *type) { 2104| 18.7k| uintptr_t ptr = (uintptr_t)p; 2105| 88.1k| for(size_t i = 0; i < type->membersSize; ++i) { ------------------ | Branch (2105:23): [True: 69.3k, False: 18.7k] ------------------ 2106| 69.3k| const UA_DataTypeMember *m = &type->members[i]; 2107| 69.3k| const UA_DataType *mt = m->memberType; 2108| 69.3k| ptr += m->padding; 2109| 69.3k| if(!m->isOptional) { ------------------ | Branch (2109:12): [True: 69.3k, False: 0] ------------------ 2110| 69.3k| if(!m->isArray) { ------------------ | Branch (2110:16): [True: 66.4k, False: 2.88k] ------------------ 2111| 66.4k| clearJumpTable[mt->typeKind]((void*)ptr, mt); 2112| 66.4k| ptr += mt->memSize; 2113| 66.4k| } else { 2114| 2.88k| size_t length = *(size_t*)ptr; 2115| 2.88k| ptr += sizeof(size_t); 2116| 2.88k| UA_Array_delete(*(void**)ptr, length, mt); 2117| 2.88k| ptr += sizeof(void*); 2118| 2.88k| } 2119| 69.3k| } else { /* field is optional */ 2120| 0| if(!m->isArray) { ------------------ | Branch (2120:16): [True: 0, False: 0] ------------------ 2121| | /* optional scalar field is contained */ 2122| 0| if((*(void *const *)ptr != NULL)) ------------------ | Branch (2122:20): [True: 0, False: 0] ------------------ 2123| 0| UA_Array_delete(*(void **)ptr, 1, mt); 2124| 0| ptr += sizeof(void *); 2125| 0| } else { 2126| | /* optional array field is contained */ 2127| 0| if((*(void *const *)(ptr + sizeof(size_t)) != NULL)) { ------------------ | Branch (2127:20): [True: 0, False: 0] ------------------ 2128| 0| size_t length = *(size_t *)ptr; 2129| 0| ptr += sizeof(size_t); 2130| 0| UA_Array_delete(*(void **)ptr, length, mt); 2131| 0| ptr += sizeof(void *); 2132| 0| } else { /* optional array field not contained */ 2133| 0| ptr += sizeof(size_t); 2134| 0| ptr += sizeof(void *); 2135| 0| } 2136| 0| } 2137| 0| } 2138| 69.3k| } 2139| 18.7k|} ua_types.c:nodeIdOrder: 2289| 16.1k|nodeIdOrder(const void *p1_, const void *p2_, const UA_DataType *_) { 2290| 16.1k| const UA_NodeId *p1 = (const UA_NodeId*)p1_; 2291| 16.1k| const UA_NodeId *p2 = (const UA_NodeId*)p2_; 2292| | /* Compare namespaceIndex */ 2293| 16.1k| if(p1->namespaceIndex != p2->namespaceIndex) ------------------ | Branch (2293:8): [True: 1.10k, False: 15.0k] ------------------ 2294| 1.10k| return (p1->namespaceIndex < p2->namespaceIndex) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2294:16): [True: 1.09k, False: 11] ------------------ 2295| | 2296| | /* Compare identifierType */ 2297| 15.0k| if(p1->identifierType != p2->identifierType) ------------------ | Branch (2297:8): [True: 5.22k, False: 9.86k] ------------------ 2298| 5.22k| return (p1->identifierType < p2->identifierType) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2298:16): [True: 5.22k, False: 3] ------------------ 2299| | 2300| | /* Compare the identifier */ 2301| 9.86k| switch(p1->identifierType) { 2302| 9.86k| case UA_NODEIDTYPE_NUMERIC: ------------------ | Branch (2302:5): [True: 9.86k, False: 0] ------------------ 2303| 9.86k| default: ------------------ | Branch (2303:5): [True: 0, False: 9.86k] ------------------ 2304| 9.86k| if(p1->identifier.numeric != p2->identifier.numeric) ------------------ | Branch (2304:12): [True: 3.80k, False: 6.06k] ------------------ 2305| 3.80k| return (p1->identifier.numeric < p2->identifier.numeric) ? ------------------ | Branch (2305:20): [True: 2.42k, False: 1.37k] ------------------ 2306| 2.42k| UA_ORDER_LESS : UA_ORDER_MORE; 2307| 6.06k| return UA_ORDER_EQ; 2308| 0| case UA_NODEIDTYPE_GUID: ------------------ | Branch (2308:5): [True: 0, False: 9.86k] ------------------ 2309| 0| return guidOrder(&p1->identifier.guid, &p2->identifier.guid, NULL); 2310| 0| case UA_NODEIDTYPE_STRING: ------------------ | Branch (2310:5): [True: 0, False: 9.86k] ------------------ 2311| 0| case UA_NODEIDTYPE_BYTESTRING: ------------------ | Branch (2311:5): [True: 0, False: 9.86k] ------------------ 2312| | return stringOrder(&p1->identifier.string, &p2->identifier.string, NULL); 2313| 9.86k| } 2314| 9.86k|} ua_types.c:stringOrder: 2272| 11.6k|stringOrder(const void *p1_, const void *p2_, const UA_DataType *type) { 2273| 11.6k| const UA_String *p1 = (const UA_String*)p1_; 2274| 11.6k| const UA_String *p2 = (const UA_String*)p2_; 2275| 11.6k| if(p1->length != p2->length) ------------------ | Branch (2275:8): [True: 10.5k, False: 1.10k] ------------------ 2276| 10.5k| return (p1->length < p2->length) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2276:16): [True: 7.98k, False: 2.54k] ------------------ 2277| | /* For zero-length arrays, every pointer not NULL is considered a 2278| | * UA_EMPTY_ARRAY_SENTINEL. */ 2279| 1.10k| if(p1->data == p2->data) return UA_ORDER_EQ; ------------------ | Branch (2279:8): [True: 0, False: 1.10k] ------------------ 2280| 1.10k| if(p1->data == NULL) return UA_ORDER_LESS; ------------------ | Branch (2280:8): [True: 0, False: 1.10k] ------------------ 2281| 1.10k| if(p2->data == NULL) return UA_ORDER_MORE; ------------------ | Branch (2281:8): [True: 0, False: 1.10k] ------------------ 2282| 1.10k| int cmp = memcmp((const char*)p1->data, (const char*)p2->data, p1->length); 2283| 1.10k| if(cmp != 0) ------------------ | Branch (2283:8): [True: 447, False: 662] ------------------ 2284| 447| return (cmp < 0) ? UA_ORDER_LESS : UA_ORDER_MORE; ------------------ | Branch (2284:16): [True: 200, False: 247] ------------------ 2285| 662| return UA_ORDER_EQ; 2286| 1.10k|} UA_Guid_parse: 86| 58|UA_Guid_parse(UA_Guid *guid, const UA_String str) { 87| 58| UA_StatusCode res = parse_guid(guid, str.data, str.data + str.length); 88| 58| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 58|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (88:8): [True: 54, False: 4] ------------------ 89| 54| *guid = UA_GUID_NULL; 90| 58| return res; 91| 58|} UA_NodeId_parseEx: 323| 170| const UA_NamespaceMapping *nsMapping) { 324| 170| UA_StatusCode res = 325| 170| parse_nodeid(id, str.data, str.data+str.length, UA_ESCAPING_NONE, nsMapping); 326| 170| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 170|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (326:8): [True: 163, False: 7] ------------------ 327| 163| UA_NodeId_clear(id); 328| 170| return res; 329| 170|} UA_NodeId_parse: 332| 170|UA_NodeId_parse(UA_NodeId *id, const UA_String str) { 333| | return UA_NodeId_parseEx(id, str, NULL); 334| 170|} UA_ExpandedNodeId_parseEx: 671| 476| size_t serverUrisSize, const UA_String *serverUris) { 672| 476| UA_StatusCode res = 673| 476| parse_expandednodeid(id, str.data, str.data + str.length, UA_ESCAPING_NONE, 674| 476| nsMapping, serverUrisSize, serverUris); 675| 476| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 476|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (675:8): [True: 403, False: 73] ------------------ 676| 403| UA_ExpandedNodeId_clear(id); 677| 476| return res; 678| 476|} UA_ExpandedNodeId_parse: 681| 476|UA_ExpandedNodeId_parse(UA_ExpandedNodeId *id, const UA_String str) { 682| 476| return UA_ExpandedNodeId_parseEx(id, str, NULL, 0, NULL); 683| 476|} UA_QualifiedName_parseEx: 831| 152| const UA_NamespaceMapping *nsMapping) { 832| 152| const u8 *pos = str.data; 833| 152| const u8 *end = str.data + str.length; 834| 152| UA_StatusCode res = parse_qn(qn, pos, end, UA_ESCAPING_NONE, nsMapping, 0); 835| 152| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 152|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (835:8): [True: 0, False: 152] ------------------ 836| 0| UA_QualifiedName_clear(qn); 837| 152| return res; 838| 152|} UA_QualifiedName_parse: 841| 152|UA_QualifiedName_parse(UA_QualifiedName *qn, const UA_String str) { 842| | return UA_QualifiedName_parseEx(qn, str, NULL); 843| 152|} UA_RelativePath_parse: 991| 1.00k|UA_RelativePath_parse(UA_RelativePath *rp, const UA_String str) { 992| 1.00k| const u8 *pos = str.data; 993| 1.00k| const u8 *end = pos + str.length; 994| 1.00k| UA_StatusCode res = parse_relativepath(rp, &pos, end, NULL, UA_ESCAPING_AND, 0); 995| 1.00k| if(pos != end) ------------------ | Branch (995:8): [True: 69, False: 939] ------------------ 996| 69| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 69|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 997| 1.00k| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 1.00k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (997:8): [True: 247, False: 761] ------------------ 998| 247| UA_RelativePath_clear(rp); 999| 1.00k| return res; 1000| 1.00k|} sao_parseWithDefaultNsIdx: 1227| 585| const UA_String str, UA_UInt16 defaultNsIndex) { 1228| | /* Parse an AttributeOperand and convert */ 1229| 585| UA_AttributeOperand ao; 1230| 585| const UA_NodeId hierarchRefs = UA_NS0ID(HIERARCHICALREFERENCES); ------------------ | | 457| 585|#define UA_NS0ID(ID) UA_NODEID_NUMERIC(0, UA_NS0ID_##ID) | | ------------------ | | | | 46| 585|#define UA_NS0ID_HIERARCHICALREFERENCES 33 /* ReferenceType */ | | ------------------ ------------------ 1231| 585| UA_StatusCode res = 1232| 585| parseAttributeOperand(&ao, str, UA_NS0ID(BASEEVENTTYPE), defaultNsIndex); ------------------ | | 457| 585|#define UA_NS0ID(ID) UA_NODEID_NUMERIC(0, UA_NS0ID_##ID) | | ------------------ | | | | 771| 585|#define UA_NS0ID_BASEEVENTTYPE 2041 /* ObjectType */ | | ------------------ ------------------ 1233| 585| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 585|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1233:8): [True: 458, False: 127] ------------------ 1234| 458| return res; 1235| | 1236| | /* Initialize the sao and copy over */ 1237| 127| UA_SimpleAttributeOperand_init(sao); 1238| 127| sao->attributeId = ao.attributeId; 1239| 127| sao->indexRange = ao.indexRange; 1240| 127| UA_String_init(&ao.indexRange); 1241| 127| sao->typeDefinitionId = ao.nodeId; 1242| 127| UA_NodeId_init(&ao.nodeId); 1243| | 1244| 127| if(ao.browsePath.elementsSize > 0) { ------------------ | Branch (1244:8): [True: 105, False: 22] ------------------ 1245| 105| sao->browsePath = (UA_QualifiedName *) 1246| 105| UA_calloc(ao.browsePath.elementsSize, sizeof(UA_QualifiedName)); ------------------ | | 20| 105|#define UA_calloc(num, size) UA_callocSingleton(num, size) ------------------ 1247| 105| if(!sao->browsePath) { ------------------ | Branch (1247:12): [True: 0, False: 105] ------------------ 1248| 0| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1249| 0| goto cleanup; 1250| 0| } 1251| 105| sao->browsePathSize = ao.browsePath.elementsSize; 1252| 105| } 1253| | 1254| 1.59k| for(size_t i = 0; i < ao.browsePath.elementsSize; i++) { ------------------ | Branch (1254:23): [True: 1.51k, False: 82] ------------------ 1255| 1.51k| UA_RelativePathElement *e = &ao.browsePath.elements[i]; 1256| | 1257| | /* Must use hierarchical references (/) */ 1258| 1.51k| if(!UA_NodeId_equal(&e->referenceTypeId, &hierarchRefs)) { ------------------ | Branch (1258:12): [True: 43, False: 1.46k] ------------------ 1259| 43| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 43|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1260| 43| goto cleanup; 1261| 43| } 1262| | 1263| | /* Includes subtypes and not inverse */ 1264| 1.46k| if(!e->includeSubtypes || e->isInverse) { ------------------ | Branch (1264:12): [True: 1, False: 1.46k] | Branch (1264:35): [True: 1, False: 1.46k] ------------------ 1265| 2| res = UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 2|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 1266| 2| goto cleanup; 1267| 2| } 1268| | 1269| 1.46k| sao->browsePath[i] = e->targetName; 1270| 1.46k| UA_QualifiedName_init(&e->targetName); 1271| 1.46k| } 1272| | 1273| 127| cleanup: 1274| 127| UA_AttributeOperand_clear(&ao); 1275| 127| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 127|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1275:8): [True: 45, False: 82] ------------------ 1276| 45| UA_SimpleAttributeOperand_clear(sao); 1277| 127| return res; 1278| 127|} UA_SimpleAttributeOperand_parse: 1282| 585| const UA_String str) { 1283| 585| return sao_parseWithDefaultNsIdx(sao, str, 0); 1284| 585|} UA_ReadValueId_parse: 1287| 426|UA_ReadValueId_parse(UA_ReadValueId *rvi, const UA_String str) { 1288| | /* Parse an AttributeOperand and convert */ 1289| 426| UA_AttributeOperand ao; 1290| 426| UA_StatusCode res = parseAttributeOperand(&ao, str, UA_NODEID_NULL, 0); 1291| 426| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 426|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1291:8): [True: 363, False: 63] ------------------ 1292| 363| return res; 1293| | 1294| 63| if(ao.browsePath.elementsSize > 0) { ------------------ | Branch (1294:8): [True: 51, False: 12] ------------------ 1295| 51| UA_AttributeOperand_clear(&ao); 1296| 51| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 51|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1297| 51| } 1298| | 1299| 12| UA_ReadValueId_init(rvi); 1300| 12| rvi->nodeId = ao.nodeId; 1301| 12| rvi->attributeId = ao.attributeId; 1302| 12| rvi->indexRange = ao.indexRange; 1303| 12| return UA_STATUSCODE_GOOD; ------------------ | | 17| 12|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1304| 63|} ua_types_lex.c:parse_guid: 50| 806|parse_guid(UA_Guid *guid, const UA_Byte *s, const UA_Byte *e) { 51| 806| size_t len = (size_t)(e - s); 52| 806| if(len != 36 || s[8] != '-' || s[13] != '-' || s[23] != '-') ------------------ | Branch (52:8): [True: 34, False: 772] | Branch (52:21): [True: 10, False: 762] | Branch (52:36): [True: 1, False: 761] | Branch (52:52): [True: 1, False: 760] ------------------ 53| 46| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 46|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 54| | 55| 760| UA_UInt32 tmp; 56| 760| if(UA_readNumberWithBase(s, 8, &tmp, 16) != 8) ------------------ | Branch (56:8): [True: 6, False: 754] ------------------ 57| 6| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 6|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 58| 754| guid->data1 = tmp; 59| | 60| 754| if(UA_readNumberWithBase(&s[9], 4, &tmp, 16) != 4) ------------------ | Branch (60:8): [True: 1, False: 753] ------------------ 61| 1| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 1|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 62| 753| guid->data2 = (UA_UInt16)tmp; 63| | 64| 753| if(UA_readNumberWithBase(&s[14], 4, &tmp, 16) != 4) ------------------ | Branch (64:8): [True: 1, False: 752] ------------------ 65| 1| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 1|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 66| 752| guid->data3 = (UA_UInt16)tmp; 67| | 68| 752| if(UA_readNumberWithBase(&s[19], 2, &tmp, 16) != 2) ------------------ | Branch (68:8): [True: 2, False: 750] ------------------ 69| 2| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 2|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 70| 750| guid->data4[0] = (UA_Byte)tmp; 71| | 72| 750| if(UA_readNumberWithBase(&s[21], 2, &tmp, 16) != 2) ------------------ | Branch (72:8): [True: 2, False: 748] ------------------ 73| 2| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 2|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 74| 748| guid->data4[1] = (UA_Byte)tmp; 75| | 76| 5.21k| for(size_t pos = 2, spos = 24; pos < 8; pos++, spos += 2) { ------------------ | Branch (76:36): [True: 4.47k, False: 740] ------------------ 77| 4.47k| if(UA_readNumberWithBase(&s[spos], 2, &tmp, 16) != 2) ------------------ | Branch (77:12): [True: 8, False: 4.46k] ------------------ 78| 8| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 8|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 79| 4.46k| guid->data4[pos] = (UA_Byte)tmp; 80| 4.46k| } 81| | 82| 740| return UA_STATUSCODE_GOOD; ------------------ | | 17| 740|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 83| 748|} ua_types_lex.c:parse_nodeid: 148| 7.79k| UA_Escaping idEsc, const UA_NamespaceMapping *nsMapping) { 149| 7.79k| *id = UA_NODEID_NULL; /* Reset the NodeId */ 150| 7.79k| LexContext context; 151| 7.79k| memset(&context, 0, sizeof(LexContext)); 152| 7.79k| UA_Byte *begin = (UA_Byte*)(uintptr_t)pos; 153| 7.79k| const u8 *ns = NULL, *nsu = NULL, *body = NULL; 154| | 155| | 156| 7.79k|{ 157| 7.79k| u8 yych; 158| 7.79k| yych = YYPEEK(); ------------------ | | 33| 7.79k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 7.79k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 7.72k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 7.72k, False: 61] | | ------------------ ------------------ 159| 7.79k| switch (yych) { 160| 1.36k| case 'b': ------------------ | Branch (160:3): [True: 1.36k, False: 6.42k] ------------------ 161| 2.11k| case 'g': ------------------ | Branch (161:3): [True: 750, False: 7.04k] ------------------ 162| 3.67k| case 'i': ------------------ | Branch (162:3): [True: 1.56k, False: 6.22k] ------------------ 163| 5.00k| case 's': ------------------ | Branch (163:3): [True: 1.33k, False: 6.45k] ------------------ 164| 5.00k| YYSTAGN(context.yyt1); ------------------ | | 39| 5.00k|#define YYSTAGN(t) t = NULL ------------------ 165| 5.00k| YYSTAGN(context.yyt2); ------------------ | | 39| 5.00k|#define YYSTAGN(t) t = NULL ------------------ 166| 5.00k| goto yy3; 167| 1.77k| case 'n': goto yy4; ------------------ | Branch (167:3): [True: 1.77k, False: 6.01k] ------------------ 168| 1.00k| default: goto yy1; ------------------ | Branch (168:3): [True: 1.00k, False: 6.78k] ------------------ 169| 7.79k| } 170| 1.00k|yy1: 171| 1.00k| YYSKIP(); ------------------ | | 35| 1.00k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 1.00k|#define YYCURSOR pos | | ------------------ ------------------ 172| 1.22k|yy2: 173| 1.22k| { (void)pos; return UA_STATUSCODE_BADDECODINGERROR; } ------------------ | | 44| 1.22k|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 174| 5.00k|yy3: 175| 5.00k| YYSKIP(); ------------------ | | 35| 5.00k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 5.00k|#define YYCURSOR pos | | ------------------ ------------------ 176| 5.00k| yych = YYPEEK(); ------------------ | | 33| 5.00k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 5.00k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 4.99k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 4.99k, False: 19] | | ------------------ ------------------ 177| 5.00k| switch (yych) { 178| 4.97k| case '=': goto yy5; ------------------ | Branch (178:3): [True: 4.97k, False: 34] ------------------ 179| 34| default: goto yy2; ------------------ | Branch (179:3): [True: 34, False: 4.97k] ------------------ 180| 5.00k| } 181| 1.77k|yy4: 182| 1.77k| YYSKIP(); ------------------ | | 35| 1.77k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ ------------------ 183| 1.77k| YYBACKUP(); ------------------ | | 36| 1.77k|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 1.77k|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ ------------------ 184| 1.77k| yych = YYPEEK(); ------------------ | | 33| 1.77k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 1.77k, False: 1] | | ------------------ ------------------ 185| 1.77k| switch (yych) { 186| 1.77k| case 's': goto yy6; ------------------ | Branch (186:3): [True: 1.77k, False: 5] ------------------ 187| 5| default: goto yy2; ------------------ | Branch (187:3): [True: 5, False: 1.77k] ------------------ 188| 1.77k| } 189| 6.56k|yy5: 190| 6.56k| YYSKIP(); ------------------ | | 35| 6.56k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 6.56k|#define YYCURSOR pos | | ------------------ ------------------ 191| 6.56k| nsu = context.yyt2; 192| 6.56k| ns = context.yyt1; 193| 6.56k| YYSTAGP(body); ------------------ | | 38| 6.56k|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 6.56k|#define YYCURSOR pos | | ------------------ ------------------ 194| 6.56k| YYSHIFTSTAG(body, -2); ------------------ | | 40| 6.56k|#define YYSHIFTSTAG(t, shift) t += shift ------------------ 195| 6.56k| { goto match; } 196| 1.77k|yy6: 197| 1.77k| YYSKIP(); ------------------ | | 35| 1.77k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ ------------------ 198| 1.77k| yych = YYPEEK(); ------------------ | | 33| 1.77k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.77k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 1.77k, False: 2] | | ------------------ ------------------ 199| 1.77k| switch (yych) { 200| 798| case '=': goto yy8; ------------------ | Branch (200:3): [True: 798, False: 974] ------------------ 201| 971| case 'u': goto yy9; ------------------ | Branch (201:3): [True: 971, False: 801] ------------------ 202| 3| default: goto yy7; ------------------ | Branch (202:3): [True: 3, False: 1.76k] ------------------ 203| 1.77k| } 204| 184|yy7: 205| 184| YYRESTORE(); ------------------ | | 37| 184|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 31| 184|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 32| 184|#define YYMARKER context.marker | | ------------------ ------------------ 206| 184| goto yy2; 207| 798|yy8: 208| 798| YYSKIP(); ------------------ | | 35| 798|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 798|#define YYCURSOR pos | | ------------------ ------------------ 209| 798| yych = YYPEEK(); ------------------ | | 33| 798|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 798|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 797|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 797, False: 1] | | ------------------ ------------------ 210| 798| switch (yych) { 211| 85| case '0': ------------------ | Branch (211:3): [True: 85, False: 713] ------------------ 212| 342| case '1': ------------------ | Branch (212:3): [True: 257, False: 541] ------------------ 213| 417| case '2': ------------------ | Branch (213:3): [True: 75, False: 723] ------------------ 214| 502| case '3': ------------------ | Branch (214:3): [True: 85, False: 713] ------------------ 215| 563| case '4': ------------------ | Branch (215:3): [True: 61, False: 737] ------------------ 216| 577| case '5': ------------------ | Branch (216:3): [True: 14, False: 784] ------------------ 217| 596| case '6': ------------------ | Branch (217:3): [True: 19, False: 779] ------------------ 218| 610| case '7': ------------------ | Branch (218:3): [True: 14, False: 784] ------------------ 219| 739| case '8': ------------------ | Branch (219:3): [True: 129, False: 669] ------------------ 220| 789| case '9': ------------------ | Branch (220:3): [True: 50, False: 748] ------------------ 221| 789| YYSTAGP(context.yyt1); ------------------ | | 38| 789|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 789|#define YYCURSOR pos | | ------------------ ------------------ 222| 789| goto yy10; 223| 9| default: goto yy7; ------------------ | Branch (223:3): [True: 9, False: 789] ------------------ 224| 798| } 225| 971|yy9: 226| 971| YYSKIP(); ------------------ | | 35| 971|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 971|#define YYCURSOR pos | | ------------------ ------------------ 227| 971| yych = YYPEEK(); ------------------ | | 33| 971|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 971|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 969|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 969, False: 2] | | ------------------ ------------------ 228| 971| switch (yych) { 229| 958| case '=': goto yy11; ------------------ | Branch (229:3): [True: 958, False: 13] ------------------ 230| 13| default: goto yy7; ------------------ | Branch (230:3): [True: 13, False: 958] ------------------ 231| 971| } 232| 17.3k|yy10: 233| 17.3k| YYSKIP(); ------------------ | | 35| 17.3k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 17.3k|#define YYCURSOR pos | | ------------------ ------------------ 234| 17.3k| yych = YYPEEK(); ------------------ | | 33| 17.3k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 17.3k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 17.2k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 17.2k, False: 87] | | ------------------ ------------------ 235| 17.3k| switch (yych) { 236| 4.50k| case '0': ------------------ | Branch (236:3): [True: 4.50k, False: 12.8k] ------------------ 237| 14.0k| case '1': ------------------ | Branch (237:3): [True: 9.56k, False: 7.80k] ------------------ 238| 14.3k| case '2': ------------------ | Branch (238:3): [True: 305, False: 17.0k] ------------------ 239| 14.6k| case '3': ------------------ | Branch (239:3): [True: 285, False: 17.0k] ------------------ 240| 14.9k| case '4': ------------------ | Branch (240:3): [True: 254, False: 17.1k] ------------------ 241| 15.2k| case '5': ------------------ | Branch (241:3): [True: 324, False: 17.0k] ------------------ 242| 15.6k| case '6': ------------------ | Branch (242:3): [True: 363, False: 17.0k] ------------------ 243| 15.9k| case '7': ------------------ | Branch (243:3): [True: 300, False: 17.0k] ------------------ 244| 16.2k| case '8': ------------------ | Branch (244:3): [True: 371, False: 16.9k] ------------------ 245| 16.5k| case '9': goto yy10; ------------------ | Branch (245:3): [True: 307, False: 17.0k] ------------------ 246| 697| case ';': ------------------ | Branch (246:3): [True: 697, False: 16.6k] ------------------ 247| 697| YYSTAGN(context.yyt2); ------------------ | | 39| 697|#define YYSTAGN(t) t = NULL ------------------ 248| 697| goto yy12; 249| 92| default: goto yy7; ------------------ | Branch (249:3): [True: 92, False: 17.2k] ------------------ 250| 17.3k| } 251| 958|yy11: 252| 958| YYSKIP(); ------------------ | | 35| 958|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 958|#define YYCURSOR pos | | ------------------ ------------------ 253| 958| yych = YYPEEK(); ------------------ | | 33| 958|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 958|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 956|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 956, False: 2] | | ------------------ ------------------ 254| 958| switch (yych) { 255| 2| case 0x00: goto yy7; ------------------ | Branch (255:3): [True: 2, False: 956] ------------------ 256| 597| case ';': ------------------ | Branch (256:3): [True: 597, False: 361] ------------------ 257| 597| YYSTAGN(context.yyt1); ------------------ | | 39| 597|#define YYSTAGN(t) t = NULL ------------------ 258| 597| YYSTAGP(context.yyt2); ------------------ | | 38| 597|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 597|#define YYCURSOR pos | | ------------------ ------------------ 259| 597| goto yy12; 260| 359| default: ------------------ | Branch (260:3): [True: 359, False: 599] ------------------ 261| 359| YYSTAGP(context.yyt2); ------------------ | | 38| 359|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 359|#define YYCURSOR pos | | ------------------ ------------------ 262| 359| goto yy13; 263| 958| } 264| 1.64k|yy12: 265| 1.64k| YYSKIP(); ------------------ | | 35| 1.64k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 1.64k|#define YYCURSOR pos | | ------------------ ------------------ 266| 1.64k| yych = YYPEEK(); ------------------ | | 33| 1.64k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.64k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.62k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 1.62k, False: 15] | | ------------------ ------------------ 267| 1.64k| switch (yych) { 268| 642| case 'b': ------------------ | Branch (268:3): [True: 642, False: 1.00k] ------------------ 269| 847| case 'g': ------------------ | Branch (269:3): [True: 205, False: 1.43k] ------------------ 270| 1.11k| case 'i': ------------------ | Branch (270:3): [True: 263, False: 1.37k] ------------------ 271| 1.62k| case 's': goto yy14; ------------------ | Branch (271:3): [True: 515, False: 1.12k] ------------------ 272| 17| default: goto yy7; ------------------ | Branch (272:3): [True: 17, False: 1.62k] ------------------ 273| 1.64k| } 274| 6.64k|yy13: 275| 6.64k| YYSKIP(); ------------------ | | 35| 6.64k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 6.64k|#define YYCURSOR pos | | ------------------ ------------------ 276| 6.64k| yych = YYPEEK(); ------------------ | | 33| 6.64k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 6.64k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 6.63k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 6.63k, False: 9] | | ------------------ ------------------ 277| 6.64k| switch (yych) { 278| 11| case 0x00: goto yy7; ------------------ | Branch (278:3): [True: 11, False: 6.63k] ------------------ 279| 348| case ';': ------------------ | Branch (279:3): [True: 348, False: 6.29k] ------------------ 280| 348| YYSTAGN(context.yyt1); ------------------ | | 39| 348|#define YYSTAGN(t) t = NULL ------------------ 281| 348| goto yy12; 282| 6.28k| default: goto yy13; ------------------ | Branch (282:3): [True: 6.28k, False: 359] ------------------ 283| 6.64k| } 284| 1.62k|yy14: 285| 1.62k| YYSKIP(); ------------------ | | 35| 1.62k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 1.62k|#define YYCURSOR pos | | ------------------ ------------------ 286| 1.62k| yych = YYPEEK(); ------------------ | | 33| 1.62k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.62k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.59k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 1.59k, False: 27] | | ------------------ ------------------ 287| 1.62k| switch (yych) { 288| 1.58k| case '=': goto yy5; ------------------ | Branch (288:3): [True: 1.58k, False: 37] ------------------ 289| 37| default: goto yy7; ------------------ | Branch (289:3): [True: 37, False: 1.58k] ------------------ 290| 1.62k| } 291| 1.62k|} 292| | 293| | 294| 6.56k| match: 295| 6.56k| if(nsu) { ------------------ | Branch (295:8): [True: 908, False: 5.65k] ------------------ 296| | /* NamespaceUri */ 297| 908| UA_String nsUri = {(size_t)(body - 1 - nsu), (UA_Byte*)(uintptr_t)nsu}; 298| 908| UA_StatusCode res = escapedUri2Index(nsUri, &id->namespaceIndex, nsMapping); 299| 908| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 17| 908|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (299:12): [True: 908, False: 0] ------------------ 300| | /* Return the entire NodeId string s=... */ 301| 908| UA_String total = {(size_t)((const UA_Byte*)end - begin), begin}; 302| 908| id->identifierType = UA_NODEIDTYPE_STRING; 303| 908| return UA_String_copy(&total, &id->identifier.string); 304| 908| } 305| 5.65k| } else if(ns) { ------------------ | Branch (305:15): [True: 680, False: 4.97k] ------------------ 306| | /* NamespaceIndex */ 307| 680| UA_UInt32 tmp; 308| 680| size_t len = (size_t)(body - 1 - ns); 309| 680| if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) ------------------ | Branch (309:12): [True: 0, False: 680] ------------------ 310| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 311| 680| id->namespaceIndex = (UA_UInt16)tmp; 312| 680| if(nsMapping) ------------------ | Branch (312:12): [True: 0, False: 680] ------------------ 313| 0| id->namespaceIndex = 314| 0| UA_NamespaceMapping_remote2Local(nsMapping, id->namespaceIndex); 315| 680| } 316| | 317| | /* From the current position until the end */ 318| 5.65k| return parse_nodeid_body(id, body, end, idEsc); 319| 6.56k|} ua_types_lex.c:escapedUri2Index: 95| 1.16k| const UA_NamespaceMapping *nsMapping) { 96| 1.16k| if(!nsMapping) ------------------ | Branch (96:8): [True: 1.16k, False: 0] ------------------ 97| 1.16k| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 1.16k|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 98| 0| UA_String tmp = uri; 99| 0| status res = UA_String_unescape(&uri, true, UA_ESCAPING_PERCENT); 100| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (100:8): [True: 0, False: 0] ------------------ 101| 0| return res; 102| 0| res = UA_NamespaceMapping_uri2Index(nsMapping, uri, nsIndex); 103| 0| if(tmp.data != uri.data) ------------------ | Branch (103:8): [True: 0, False: 0] ------------------ 104| 0| UA_String_clear(&uri); 105| 0| return res; 106| 0|} ua_types_lex.c:parse_nodeid_body: 109| 5.75k|parse_nodeid_body(UA_NodeId *id, const u8 *body, const u8 *end, UA_Escaping esc) { 110| 5.75k| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 17| 5.75k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 111| 5.75k| UA_String str = {(size_t)(end - (body+2)), (UA_Byte*)(uintptr_t)body + 2}; 112| 5.75k| switch(*body) { 113| 1.62k| case 'i': ------------------ | Branch (113:5): [True: 1.62k, False: 4.12k] ------------------ 114| 1.62k| id->identifierType = UA_NODEIDTYPE_NUMERIC; 115| 1.62k| if(UA_readNumber(str.data, str.length, &id->identifier.numeric) != str.length) ------------------ | Branch (115:12): [True: 56, False: 1.56k] ------------------ 116| 56| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 56|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 117| 1.62k| break; 118| 1.84k| case 's': ------------------ | Branch (118:5): [True: 1.84k, False: 3.90k] ------------------ 119| 1.84k| id->identifierType = UA_NODEIDTYPE_STRING; 120| 1.84k| res |= UA_String_copy(&str, &id->identifier.string); 121| 1.84k| res |= UA_String_unescape(&id->identifier.string, false, esc); 122| 1.84k| break; 123| 748| case 'g': ------------------ | Branch (123:5): [True: 748, False: 5.00k] ------------------ 124| 748| id->identifierType = UA_NODEIDTYPE_GUID; 125| 748| res = parse_guid(&id->identifier.guid, str.data, end); 126| 748| break; 127| 1.53k| case 'b': ------------------ | Branch (127:5): [True: 1.53k, False: 4.22k] ------------------ 128| | /* For percent-escaping, base64url bytestring encoding is used. That 129| | * doesn't need to be escaped here. The and-escaping is not applied to 130| | * the NodeId identifier part. */ 131| 1.53k| id->identifierType = UA_NODEIDTYPE_BYTESTRING; 132| 1.53k| id->identifier.byteString.data = 133| 1.53k| UA_unbase64(str.data, str.length, &id->identifier.byteString.length); 134| 1.53k| if(!id->identifier.byteString.data) { ------------------ | Branch (134:12): [True: 56, False: 1.47k] ------------------ 135| 56| UA_assert(id->identifier.byteString.length == 0); ------------------ | | 399| 56|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (135:13): [True: 56, False: 0] ------------------ 136| 56| res = UA_STATUSCODE_BADDECODINGERROR; /* Returned on error by UA_unbase64 */ ------------------ | | 44| 56|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 137| 56| } 138| 1.53k| break; 139| 1.53k| default: ------------------ | Branch (139:5): [True: 0, False: 5.75k] ------------------ 140| 0| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 141| 0| break; 142| 5.75k| } 143| 5.75k| return res; 144| 5.75k|} ua_types_lex.c:parse_expandednodeid: 339| 476| size_t serverUrisSize, const UA_String *serverUris) { 340| 476| *id = UA_EXPANDEDNODEID_NULL; /* Reset the NodeId */ 341| 476| LexContext context; 342| 476| memset(&context, 0, sizeof(LexContext)); 343| 476| const u8 *svr = NULL, *sve = NULL, *svu = NULL, 344| 476| *nsu = NULL, *ns = NULL, *body = NULL, *begin = pos; 345| | 346| | 347| 476|{ 348| 476| u8 yych; 349| 476| yych = YYPEEK(); ------------------ | | 33| 476|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 476|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 476|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 476, False: 0] | | ------------------ ------------------ 350| 476| switch (yych) { 351| 25| case 'b': ------------------ | Branch (351:3): [True: 25, False: 451] ------------------ 352| 33| case 'g': ------------------ | Branch (352:3): [True: 8, False: 468] ------------------ 353| 59| case 'i': ------------------ | Branch (353:3): [True: 26, False: 450] ------------------ 354| 59| YYSTAGN(context.yyt1); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 355| 59| YYSTAGN(context.yyt2); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 356| 59| YYSTAGN(context.yyt3); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 357| 59| YYSTAGN(context.yyt4); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 358| 59| YYSTAGN(context.yyt5); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 359| 59| goto yy18; 360| 154| case 'n': ------------------ | Branch (360:3): [True: 154, False: 322] ------------------ 361| 154| YYSTAGN(context.yyt1); ------------------ | | 39| 154|#define YYSTAGN(t) t = NULL ------------------ 362| 154| YYSTAGN(context.yyt2); ------------------ | | 39| 154|#define YYSTAGN(t) t = NULL ------------------ 363| 154| YYSTAGN(context.yyt5); ------------------ | | 39| 154|#define YYSTAGN(t) t = NULL ------------------ 364| 154| goto yy19; 365| 259| case 's': ------------------ | Branch (365:3): [True: 259, False: 217] ------------------ 366| 259| YYSTAGN(context.yyt1); ------------------ | | 39| 259|#define YYSTAGN(t) t = NULL ------------------ 367| 259| YYSTAGN(context.yyt2); ------------------ | | 39| 259|#define YYSTAGN(t) t = NULL ------------------ 368| 259| YYSTAGN(context.yyt3); ------------------ | | 39| 259|#define YYSTAGN(t) t = NULL ------------------ 369| 259| YYSTAGN(context.yyt4); ------------------ | | 39| 259|#define YYSTAGN(t) t = NULL ------------------ 370| 259| YYSTAGN(context.yyt5); ------------------ | | 39| 259|#define YYSTAGN(t) t = NULL ------------------ 371| 259| goto yy20; 372| 4| default: goto yy16; ------------------ | Branch (372:3): [True: 4, False: 472] ------------------ 373| 476| } 374| 4|yy16: 375| 4| YYSKIP(); ------------------ | | 35| 4|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 4|#define YYCURSOR pos | | ------------------ ------------------ 376| 376|yy17: 377| 376| { (void)pos; return UA_STATUSCODE_BADDECODINGERROR; } ------------------ | | 44| 376|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 378| 59|yy18: 379| 59| YYSKIP(); ------------------ | | 35| 59|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 59|#define YYCURSOR pos | | ------------------ ------------------ 380| 59| yych = YYPEEK(); ------------------ | | 33| 59|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 59|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 56|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 56, False: 3] | | ------------------ ------------------ 381| 59| switch (yych) { 382| 36| case '=': goto yy21; ------------------ | Branch (382:3): [True: 36, False: 23] ------------------ 383| 23| default: goto yy17; ------------------ | Branch (383:3): [True: 23, False: 36] ------------------ 384| 59| } 385| 154|yy19: 386| 154| YYSKIP(); ------------------ | | 35| 154|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 154|#define YYCURSOR pos | | ------------------ ------------------ 387| 154| YYBACKUP(); ------------------ | | 36| 154|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 154|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 154|#define YYCURSOR pos | | ------------------ ------------------ 388| 154| yych = YYPEEK(); ------------------ | | 33| 154|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 154|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 153|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 153, False: 1] | | ------------------ ------------------ 389| 154| switch (yych) { 390| 144| case 's': goto yy22; ------------------ | Branch (390:3): [True: 144, False: 10] ------------------ 391| 10| default: goto yy17; ------------------ | Branch (391:3): [True: 10, False: 144] ------------------ 392| 154| } 393| 259|yy20: 394| 259| YYSKIP(); ------------------ | | 35| 259|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 259|#define YYCURSOR pos | | ------------------ ------------------ 395| 259| YYBACKUP(); ------------------ | | 36| 259|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 259|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 259|#define YYCURSOR pos | | ------------------ ------------------ 396| 259| yych = YYPEEK(); ------------------ | | 33| 259|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 259|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 258|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 258, False: 1] | | ------------------ ------------------ 397| 259| switch (yych) { 398| 1| case '=': goto yy21; ------------------ | Branch (398:3): [True: 1, False: 258] ------------------ 399| 257| case 'v': goto yy24; ------------------ | Branch (399:3): [True: 257, False: 2] ------------------ 400| 1| default: goto yy17; ------------------ | Branch (400:3): [True: 1, False: 258] ------------------ 401| 259| } 402| 100|yy21: 403| 100| YYSKIP(); ------------------ | | 35| 100|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 100|#define YYCURSOR pos | | ------------------ ------------------ 404| 100| svr = context.yyt5; 405| 100| svu = context.yyt1; 406| 100| sve = context.yyt2; 407| 100| ns = context.yyt3; 408| 100| nsu = context.yyt4; 409| 100| YYSTAGP(body); ------------------ | | 38| 100|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 100|#define YYCURSOR pos | | ------------------ ------------------ 410| 100| YYSHIFTSTAG(body, -2); ------------------ | | 40| 100|#define YYSHIFTSTAG(t, shift) t += shift ------------------ 411| 100| { goto match; } 412| 201|yy22: 413| 201| YYSKIP(); ------------------ | | 35| 201|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 201|#define YYCURSOR pos | | ------------------ ------------------ 414| 201| yych = YYPEEK(); ------------------ | | 33| 201|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 201|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 199|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 199, False: 2] | | ------------------ ------------------ 415| 201| switch (yych) { 416| 105| case '=': goto yy25; ------------------ | Branch (416:3): [True: 105, False: 96] ------------------ 417| 92| case 'u': goto yy26; ------------------ | Branch (417:3): [True: 92, False: 109] ------------------ 418| 4| default: goto yy23; ------------------ | Branch (418:3): [True: 4, False: 197] ------------------ 419| 201| } 420| 338|yy23: 421| 338| YYRESTORE(); ------------------ | | 37| 338|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 31| 338|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 32| 338|#define YYMARKER context.marker | | ------------------ ------------------ 422| 338| goto yy17; 423| 257|yy24: 424| 257| YYSKIP(); ------------------ | | 35| 257|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 257|#define YYCURSOR pos | | ------------------ ------------------ 425| 257| yych = YYPEEK(); ------------------ | | 33| 257|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 257|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 256|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 256, False: 1] | | ------------------ ------------------ 426| 257| switch (yych) { 427| 195| case 'r': goto yy27; ------------------ | Branch (427:3): [True: 195, False: 62] ------------------ 428| 61| case 'u': goto yy28; ------------------ | Branch (428:3): [True: 61, False: 196] ------------------ 429| 1| default: goto yy23; ------------------ | Branch (429:3): [True: 1, False: 256] ------------------ 430| 257| } 431| 105|yy25: 432| 105| YYSKIP(); ------------------ | | 35| 105|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 105|#define YYCURSOR pos | | ------------------ ------------------ 433| 105| yych = YYPEEK(); ------------------ | | 33| 105|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 105|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 104|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 104, False: 1] | | ------------------ ------------------ 434| 105| switch (yych) { 435| 19| case '0': ------------------ | Branch (435:3): [True: 19, False: 86] ------------------ 436| 34| case '1': ------------------ | Branch (436:3): [True: 15, False: 90] ------------------ 437| 40| case '2': ------------------ | Branch (437:3): [True: 6, False: 99] ------------------ 438| 51| case '3': ------------------ | Branch (438:3): [True: 11, False: 94] ------------------ 439| 58| case '4': ------------------ | Branch (439:3): [True: 7, False: 98] ------------------ 440| 64| case '5': ------------------ | Branch (440:3): [True: 6, False: 99] ------------------ 441| 73| case '6': ------------------ | Branch (441:3): [True: 9, False: 96] ------------------ 442| 82| case '7': ------------------ | Branch (442:3): [True: 9, False: 96] ------------------ 443| 89| case '8': ------------------ | Branch (443:3): [True: 7, False: 98] ------------------ 444| 97| case '9': ------------------ | Branch (444:3): [True: 8, False: 97] ------------------ 445| 97| YYSTAGP(context.yyt3); ------------------ | | 38| 97|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 97|#define YYCURSOR pos | | ------------------ ------------------ 446| 97| goto yy29; 447| 8| default: goto yy23; ------------------ | Branch (447:3): [True: 8, False: 97] ------------------ 448| 105| } 449| 92|yy26: 450| 92| YYSKIP(); ------------------ | | 35| 92|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 92|#define YYCURSOR pos | | ------------------ ------------------ 451| 92| yych = YYPEEK(); ------------------ | | 33| 92|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 92|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 91|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 91, False: 1] | | ------------------ ------------------ 452| 92| switch (yych) { 453| 74| case '=': goto yy30; ------------------ | Branch (453:3): [True: 74, False: 18] ------------------ 454| 18| default: goto yy23; ------------------ | Branch (454:3): [True: 18, False: 74] ------------------ 455| 92| } 456| 195|yy27: 457| 195| YYSKIP(); ------------------ | | 35| 195|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 195|#define YYCURSOR pos | | ------------------ ------------------ 458| 195| yych = YYPEEK(); ------------------ | | 33| 195|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 195|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 194|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 194, False: 1] | | ------------------ ------------------ 459| 195| switch (yych) { 460| 182| case '=': goto yy31; ------------------ | Branch (460:3): [True: 182, False: 13] ------------------ 461| 13| default: goto yy23; ------------------ | Branch (461:3): [True: 13, False: 182] ------------------ 462| 195| } 463| 61|yy28: 464| 61| YYSKIP(); ------------------ | | 35| 61|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 61|#define YYCURSOR pos | | ------------------ ------------------ 465| 61| yych = YYPEEK(); ------------------ | | 33| 61|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 61|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 60|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 60, False: 1] | | ------------------ ------------------ 466| 61| switch (yych) { 467| 60| case '=': goto yy32; ------------------ | Branch (467:3): [True: 60, False: 1] ------------------ 468| 1| default: goto yy23; ------------------ | Branch (468:3): [True: 1, False: 60] ------------------ 469| 61| } 470| 2.10k|yy29: 471| 2.10k| YYSKIP(); ------------------ | | 35| 2.10k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 2.10k|#define YYCURSOR pos | | ------------------ ------------------ 472| 2.10k| yych = YYPEEK(); ------------------ | | 33| 2.10k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.10k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.01k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 2.01k, False: 85] | | ------------------ ------------------ 473| 2.10k| switch (yych) { 474| 209| case '0': ------------------ | Branch (474:3): [True: 209, False: 1.89k] ------------------ 475| 407| case '1': ------------------ | Branch (475:3): [True: 198, False: 1.90k] ------------------ 476| 602| case '2': ------------------ | Branch (476:3): [True: 195, False: 1.90k] ------------------ 477| 796| case '3': ------------------ | Branch (477:3): [True: 194, False: 1.90k] ------------------ 478| 1.00k| case '4': ------------------ | Branch (478:3): [True: 205, False: 1.89k] ------------------ 479| 1.19k| case '5': ------------------ | Branch (479:3): [True: 195, False: 1.90k] ------------------ 480| 1.39k| case '6': ------------------ | Branch (480:3): [True: 195, False: 1.90k] ------------------ 481| 1.58k| case '7': ------------------ | Branch (481:3): [True: 194, False: 1.90k] ------------------ 482| 1.81k| case '8': ------------------ | Branch (482:3): [True: 225, False: 1.87k] ------------------ 483| 2.00k| case '9': goto yy29; ------------------ | Branch (483:3): [True: 194, False: 1.90k] ------------------ 484| 6| case ';': ------------------ | Branch (484:3): [True: 6, False: 2.09k] ------------------ 485| 6| YYSTAGN(context.yyt4); ------------------ | | 39| 6|#define YYSTAGN(t) t = NULL ------------------ 486| 6| goto yy33; 487| 91| default: goto yy23; ------------------ | Branch (487:3): [True: 91, False: 2.01k] ------------------ 488| 2.10k| } 489| 74|yy30: 490| 74| YYSKIP(); ------------------ | | 35| 74|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 74|#define YYCURSOR pos | | ------------------ ------------------ 491| 74| yych = YYPEEK(); ------------------ | | 33| 74|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 74|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 73|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 73, False: 1] | | ------------------ ------------------ 492| 74| switch (yych) { 493| 1| case 0x00: goto yy23; ------------------ | Branch (493:3): [True: 1, False: 73] ------------------ 494| 63| case ';': ------------------ | Branch (494:3): [True: 63, False: 11] ------------------ 495| 63| YYSTAGN(context.yyt3); ------------------ | | 39| 63|#define YYSTAGN(t) t = NULL ------------------ 496| 63| YYSTAGP(context.yyt4); ------------------ | | 38| 63|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 63|#define YYCURSOR pos | | ------------------ ------------------ 497| 63| goto yy33; 498| 10| default: ------------------ | Branch (498:3): [True: 10, False: 64] ------------------ 499| 10| YYSTAGP(context.yyt4); ------------------ | | 38| 10|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 10|#define YYCURSOR pos | | ------------------ ------------------ 500| 10| goto yy34; 501| 74| } 502| 182|yy31: 503| 182| YYSKIP(); ------------------ | | 35| 182|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 182|#define YYCURSOR pos | | ------------------ ------------------ 504| 182| yych = YYPEEK(); ------------------ | | 33| 182|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 182|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 181|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 181, False: 1] | | ------------------ ------------------ 505| 182| switch (yych) { 506| 22| case '0': ------------------ | Branch (506:3): [True: 22, False: 160] ------------------ 507| 39| case '1': ------------------ | Branch (507:3): [True: 17, False: 165] ------------------ 508| 51| case '2': ------------------ | Branch (508:3): [True: 12, False: 170] ------------------ 509| 64| case '3': ------------------ | Branch (509:3): [True: 13, False: 169] ------------------ 510| 107| case '4': ------------------ | Branch (510:3): [True: 43, False: 139] ------------------ 511| 113| case '5': ------------------ | Branch (511:3): [True: 6, False: 176] ------------------ 512| 123| case '6': ------------------ | Branch (512:3): [True: 10, False: 172] ------------------ 513| 135| case '7': ------------------ | Branch (513:3): [True: 12, False: 170] ------------------ 514| 158| case '8': ------------------ | Branch (514:3): [True: 23, False: 159] ------------------ 515| 169| case '9': ------------------ | Branch (515:3): [True: 11, False: 171] ------------------ 516| 169| YYSTAGP(context.yyt5); ------------------ | | 38| 169|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 169|#define YYCURSOR pos | | ------------------ ------------------ 517| 169| goto yy35; 518| 13| default: goto yy23; ------------------ | Branch (518:3): [True: 13, False: 169] ------------------ 519| 182| } 520| 60|yy32: 521| 60| YYSKIP(); ------------------ | | 35| 60|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 60|#define YYCURSOR pos | | ------------------ ------------------ 522| 60| yych = YYPEEK(); ------------------ | | 33| 60|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 60|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 59|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 59, False: 1] | | ------------------ ------------------ 523| 60| switch (yych) { 524| 1| case 0x00: goto yy23; ------------------ | Branch (524:3): [True: 1, False: 59] ------------------ 525| 26| case ';': ------------------ | Branch (525:3): [True: 26, False: 34] ------------------ 526| 26| YYSTAGP(context.yyt1); ------------------ | | 38| 26|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 26|#define YYCURSOR pos | | ------------------ ------------------ 527| 26| YYSTAGP(context.yyt2); ------------------ | | 38| 26|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 26|#define YYCURSOR pos | | ------------------ ------------------ 528| 26| YYSTAGN(context.yyt5); ------------------ | | 39| 26|#define YYSTAGN(t) t = NULL ------------------ 529| 26| goto yy37; 530| 33| default: ------------------ | Branch (530:3): [True: 33, False: 27] ------------------ 531| 33| YYSTAGP(context.yyt1); ------------------ | | 38| 33|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 33|#define YYCURSOR pos | | ------------------ ------------------ 532| 33| goto yy36; 533| 60| } 534| 70|yy33: 535| 70| YYSKIP(); ------------------ | | 35| 70|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 70|#define YYCURSOR pos | | ------------------ ------------------ 536| 70| yych = YYPEEK(); ------------------ | | 33| 70|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 70|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 67|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 67, False: 3] | | ------------------ ------------------ 537| 70| switch (yych) { 538| 4| case 'b': ------------------ | Branch (538:3): [True: 4, False: 66] ------------------ 539| 6| case 'g': ------------------ | Branch (539:3): [True: 2, False: 68] ------------------ 540| 10| case 'i': ------------------ | Branch (540:3): [True: 4, False: 66] ------------------ 541| 67| case 's': goto yy38; ------------------ | Branch (541:3): [True: 57, False: 13] ------------------ 542| 3| default: goto yy23; ------------------ | Branch (542:3): [True: 3, False: 67] ------------------ 543| 70| } 544| 204|yy34: 545| 204| YYSKIP(); ------------------ | | 35| 204|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 204|#define YYCURSOR pos | | ------------------ ------------------ 546| 204| yych = YYPEEK(); ------------------ | | 33| 204|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 204|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 195|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 195, False: 9] | | ------------------ ------------------ 547| 204| switch (yych) { 548| 9| case 0x00: goto yy23; ------------------ | Branch (548:3): [True: 9, False: 195] ------------------ 549| 1| case ';': ------------------ | Branch (549:3): [True: 1, False: 203] ------------------ 550| 1| YYSTAGN(context.yyt3); ------------------ | | 39| 1|#define YYSTAGN(t) t = NULL ------------------ 551| 1| goto yy33; 552| 194| default: goto yy34; ------------------ | Branch (552:3): [True: 194, False: 10] ------------------ 553| 204| } 554| 3.04k|yy35: 555| 3.04k| YYSKIP(); ------------------ | | 35| 3.04k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 3.04k|#define YYCURSOR pos | | ------------------ ------------------ 556| 3.04k| yych = YYPEEK(); ------------------ | | 33| 3.04k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 3.04k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.96k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 2.96k, False: 85] | | ------------------ ------------------ 557| 3.04k| switch (yych) { 558| 536| case '0': ------------------ | Branch (558:3): [True: 536, False: 2.50k] ------------------ 559| 785| case '1': ------------------ | Branch (559:3): [True: 249, False: 2.79k] ------------------ 560| 1.08k| case '2': ------------------ | Branch (560:3): [True: 297, False: 2.74k] ------------------ 561| 1.30k| case '3': ------------------ | Branch (561:3): [True: 223, False: 2.82k] ------------------ 562| 1.58k| case '4': ------------------ | Branch (562:3): [True: 280, False: 2.76k] ------------------ 563| 1.84k| case '5': ------------------ | Branch (563:3): [True: 255, False: 2.79k] ------------------ 564| 2.10k| case '6': ------------------ | Branch (564:3): [True: 269, False: 2.77k] ------------------ 565| 2.35k| case '7': ------------------ | Branch (565:3): [True: 248, False: 2.79k] ------------------ 566| 2.60k| case '8': ------------------ | Branch (566:3): [True: 244, False: 2.80k] ------------------ 567| 2.87k| case '9': goto yy35; ------------------ | Branch (567:3): [True: 275, False: 2.77k] ------------------ 568| 59| case ';': ------------------ | Branch (568:3): [True: 59, False: 2.98k] ------------------ 569| 59| YYSTAGN(context.yyt1); ------------------ | | 39| 59|#define YYSTAGN(t) t = NULL ------------------ 570| 59| YYSTAGP(context.yyt2); ------------------ | | 38| 59|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 59|#define YYCURSOR pos | | ------------------ ------------------ 571| 59| goto yy37; 572| 110| default: goto yy23; ------------------ | Branch (572:3): [True: 110, False: 2.93k] ------------------ 573| 3.04k| } 574| 520|yy36: 575| 520| YYSKIP(); ------------------ | | 35| 520|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 520|#define YYCURSOR pos | | ------------------ ------------------ 576| 520| yych = YYPEEK(); ------------------ | | 33| 520|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 520|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 511|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 511, False: 9] | | ------------------ ------------------ 577| 520| switch (yych) { 578| 30| case 0x00: goto yy23; ------------------ | Branch (578:3): [True: 30, False: 490] ------------------ 579| 3| case ';': ------------------ | Branch (579:3): [True: 3, False: 517] ------------------ 580| 3| YYSTAGP(context.yyt2); ------------------ | | 38| 3|#define YYSTAGP(t) t = YYCURSOR | | ------------------ | | | | 31| 3|#define YYCURSOR pos | | ------------------ ------------------ 581| 3| YYSTAGN(context.yyt5); ------------------ | | 39| 3|#define YYSTAGN(t) t = NULL ------------------ 582| 3| goto yy37; 583| 487| default: goto yy36; ------------------ | Branch (583:3): [True: 487, False: 33] ------------------ 584| 520| } 585| 88|yy37: 586| 88| YYSKIP(); ------------------ | | 35| 88|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 88|#define YYCURSOR pos | | ------------------ ------------------ 587| 88| yych = YYPEEK(); ------------------ | | 33| 88|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 88|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 85|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 85, False: 3] | | ------------------ ------------------ 588| 88| switch (yych) { 589| 5| case 'b': ------------------ | Branch (589:3): [True: 5, False: 83] ------------------ 590| 7| case 'g': ------------------ | Branch (590:3): [True: 2, False: 86] ------------------ 591| 10| case 'i': ------------------ | Branch (591:3): [True: 3, False: 85] ------------------ 592| 15| case 's': ------------------ | Branch (592:3): [True: 5, False: 83] ------------------ 593| 15| YYSTAGN(context.yyt3); ------------------ | | 39| 15|#define YYSTAGN(t) t = NULL ------------------ 594| 15| YYSTAGN(context.yyt4); ------------------ | | 39| 15|#define YYSTAGN(t) t = NULL ------------------ 595| 15| goto yy38; 596| 67| case 'n': goto yy39; ------------------ | Branch (596:3): [True: 67, False: 21] ------------------ 597| 6| default: goto yy23; ------------------ | Branch (597:3): [True: 6, False: 82] ------------------ 598| 88| } 599| 82|yy38: 600| 82| YYSKIP(); ------------------ | | 35| 82|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 82|#define YYCURSOR pos | | ------------------ ------------------ 601| 82| yych = YYPEEK(); ------------------ | | 33| 82|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 82|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 74|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 74, False: 8] | | ------------------ ------------------ 602| 82| switch (yych) { 603| 63| case '=': goto yy21; ------------------ | Branch (603:3): [True: 63, False: 19] ------------------ 604| 19| default: goto yy23; ------------------ | Branch (604:3): [True: 19, False: 63] ------------------ 605| 82| } 606| 67|yy39: 607| 67| YYSKIP(); ------------------ | | 35| 67|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 67|#define YYCURSOR pos | | ------------------ ------------------ 608| 67| yych = YYPEEK(); ------------------ | | 33| 67|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 67|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 66|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 66, False: 1] | | ------------------ ------------------ 609| 67| switch (yych) { 610| 57| case 's': goto yy22; ------------------ | Branch (610:3): [True: 57, False: 10] ------------------ 611| 10| default: goto yy23; ------------------ | Branch (611:3): [True: 10, False: 57] ------------------ 612| 67| } 613| 67|} 614| | 615| | 616| 100| match: 617| 100| if(svu) { ------------------ | Branch (617:8): [True: 3, False: 97] ------------------ 618| | /* ServerUri */ 619| 3| UA_String serverUri = {(size_t)(sve - svu), (UA_Byte*)(uintptr_t)svu}; 620| 3| size_t i = 0; 621| 3| for(; i < serverUrisSize; i++) { ------------------ | Branch (621:15): [True: 0, False: 3] ------------------ 622| 0| if(UA_String_equal(&serverUri, &serverUris[i])) ------------------ | Branch (622:16): [True: 0, False: 0] ------------------ 623| 0| break; 624| 0| } 625| 3| if(i == serverUrisSize) { ------------------ | Branch (625:12): [True: 3, False: 0] ------------------ 626| | /* The ServerUri cannot be mapped. Return the entire input as a 627| | * string NodeId. */ 628| 3| UA_String total = {(size_t)(end - begin), (UA_Byte*)(uintptr_t)begin}; 629| 3| id->nodeId.identifierType = UA_NODEIDTYPE_STRING; 630| 3| return UA_String_copy(&total, &id->nodeId.identifier.string); 631| 3| } 632| 0| id->serverIndex = (UA_UInt32)i; 633| 97| } else if(svr) { ------------------ | Branch (633:15): [True: 57, False: 40] ------------------ 634| | /* ServerIndex */ 635| 57| size_t len = (size_t)(sve - svr); 636| 57| if(UA_readNumber((const UA_Byte*)svr, len, &id->serverIndex) != len) ------------------ | Branch (636:12): [True: 0, False: 57] ------------------ 637| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 638| 57| } 639| | 640| 97| if(nsu) { ------------------ | Branch (640:8): [True: 57, False: 40] ------------------ 641| | /* NamespaceUri */ 642| 57| UA_String nsuri = {(size_t)(body - 1 - nsu), (UA_Byte*)(uintptr_t)nsu}; 643| 57| UA_StatusCode res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 57|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 644| | /* Try to map the NamespaceUri to its NamespaceIndex for ServerIndex == 0. 645| | * If this fails, keep the full NamespaceUri. */ 646| 57| if(id->serverIndex == 0) ------------------ | Branch (646:12): [True: 1, False: 56] ------------------ 647| 1| res = escapedUri2Index(nsuri, &id->nodeId.namespaceIndex, nsMapping); 648| 57| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 57|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (648:12): [True: 57, False: 0] ------------------ 649| 57| res = UA_String_copy(&nsuri, &id->namespaceUri); /* Keep the Uri without mapping */ 650| 57| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 57|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (650:12): [True: 0, False: 57] ------------------ 651| 0| return res; 652| 57| } else if(ns) { ------------------ | Branch (652:15): [True: 2, False: 38] ------------------ 653| | /* NamespaceIndex */ 654| 2| UA_UInt32 tmp; 655| 2| size_t len = (size_t)(body - 1 - ns); 656| 2| if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) ------------------ | Branch (656:12): [True: 0, False: 2] ------------------ 657| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 658| 2| id->nodeId.namespaceIndex = (UA_UInt16)tmp; 659| 2| if(nsMapping) ------------------ | Branch (659:12): [True: 0, False: 2] ------------------ 660| 0| id->nodeId.namespaceIndex = 661| 0| UA_NamespaceMapping_remote2Local(nsMapping, id->nodeId.namespaceIndex); 662| 2| } 663| | 664| | /* From the current position until the end */ 665| 97| return parse_nodeid_body(&id->nodeId, body, end, idEsc); 666| 97|} ua_types_lex.c:parse_qn: 707| 15.1k| UA_UInt16 defaultNamespaceIndex) { 708| 15.1k| size_t len; 709| 15.1k| UA_UInt32 tmp; 710| 15.1k| UA_String str; 711| 15.1k| UA_StatusCode res; 712| | 713| 15.1k| LexContext context; 714| 15.1k| memset(&context, 0, sizeof(LexContext)); 715| | 716| 15.1k| const u8 *begin = pos; 717| 15.1k| UA_QualifiedName_init(qn); 718| 15.1k| qn->namespaceIndex = defaultNamespaceIndex; 719| | 720| | 721| 15.1k|{ 722| 15.1k| u8 yych; 723| 15.1k| yych = YYPEEK(); ------------------ | | 33| 15.1k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 15.1k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 6.22k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 6.22k, False: 8.95k] | | ------------------ ------------------ 724| 15.1k| switch (yych) { 725| 8.99k| case 0x00: ------------------ | Branch (725:3): [True: 8.99k, False: 6.18k] ------------------ 726| 9.18k| case ';': goto yy41; ------------------ | Branch (726:3): [True: 197, False: 14.9k] ------------------ 727| 234| case '0': ------------------ | Branch (727:3): [True: 234, False: 14.9k] ------------------ 728| 478| case '1': ------------------ | Branch (728:3): [True: 244, False: 14.9k] ------------------ 729| 756| case '2': ------------------ | Branch (729:3): [True: 278, False: 14.8k] ------------------ 730| 1.19k| case '3': ------------------ | Branch (730:3): [True: 437, False: 14.7k] ------------------ 731| 1.64k| case '4': ------------------ | Branch (731:3): [True: 452, False: 14.7k] ------------------ 732| 1.88k| case '5': ------------------ | Branch (732:3): [True: 238, False: 14.9k] ------------------ 733| 2.15k| case '6': ------------------ | Branch (733:3): [True: 272, False: 14.9k] ------------------ 734| 2.40k| case '7': ------------------ | Branch (734:3): [True: 245, False: 14.9k] ------------------ 735| 2.67k| case '8': ------------------ | Branch (735:3): [True: 278, False: 14.8k] ------------------ 736| 2.91k| case '9': goto yy44; ------------------ | Branch (736:3): [True: 235, False: 14.9k] ------------------ 737| 3.07k| default: goto yy43; ------------------ | Branch (737:3): [True: 3.07k, False: 12.1k] ------------------ 738| 15.1k| } 739| 9.18k|yy41: 740| 9.18k| YYSKIP(); ------------------ | | 35| 9.18k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 9.18k|#define YYCURSOR pos | | ------------------ ------------------ 741| 14.4k|yy42: 742| 14.4k| { pos = begin; goto match_name; } 743| 3.07k|yy43: 744| 3.07k| YYSKIP(); ------------------ | | 35| 3.07k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 3.07k|#define YYCURSOR pos | | ------------------ ------------------ 745| 3.07k| YYBACKUP(); ------------------ | | 36| 3.07k|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 3.07k|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 3.07k|#define YYCURSOR pos | | ------------------ ------------------ 746| 3.07k| yych = YYPEEK(); ------------------ | | 33| 3.07k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 3.07k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.24k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 2.24k, False: 833] | | ------------------ ------------------ 747| 3.07k| if (yych <= 0x00) goto yy42; ------------------ | Branch (747:6): [True: 976, False: 2.09k] ------------------ 748| 2.09k| goto yy46; 749| 2.91k|yy44: 750| 2.91k| YYSKIP(); ------------------ | | 35| 2.91k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 2.91k|#define YYCURSOR pos | | ------------------ ------------------ 751| 2.91k| YYBACKUP(); ------------------ | | 36| 2.91k|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 2.91k|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 2.91k|#define YYCURSOR pos | | ------------------ ------------------ 752| 2.91k| yych = YYPEEK(); ------------------ | | 33| 2.91k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.91k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 852|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 852, False: 2.06k] | | ------------------ ------------------ 753| 2.91k| switch (yych) { 754| 44| case '0': ------------------ | Branch (754:3): [True: 44, False: 2.86k] ------------------ 755| 80| case '1': ------------------ | Branch (755:3): [True: 36, False: 2.87k] ------------------ 756| 192| case '2': ------------------ | Branch (756:3): [True: 112, False: 2.80k] ------------------ 757| 249| case '3': ------------------ | Branch (757:3): [True: 57, False: 2.85k] ------------------ 758| 383| case '4': ------------------ | Branch (758:3): [True: 134, False: 2.77k] ------------------ 759| 418| case '5': ------------------ | Branch (759:3): [True: 35, False: 2.87k] ------------------ 760| 485| case '6': ------------------ | Branch (760:3): [True: 67, False: 2.84k] ------------------ 761| 546| case '7': ------------------ | Branch (761:3): [True: 61, False: 2.85k] ------------------ 762| 591| case '8': ------------------ | Branch (762:3): [True: 45, False: 2.86k] ------------------ 763| 614| case '9': ------------------ | Branch (763:3): [True: 23, False: 2.89k] ------------------ 764| 826| case ':': goto yy50; ------------------ | Branch (764:3): [True: 212, False: 2.70k] ------------------ 765| 2.08k| default: goto yy42; ------------------ | Branch (765:3): [True: 2.08k, False: 826] ------------------ 766| 2.91k| } 767| 253k|yy45: 768| 253k| YYSKIP(); ------------------ | | 35| 253k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 253k|#define YYCURSOR pos | | ------------------ ------------------ 769| 253k| yych = YYPEEK(); ------------------ | | 33| 253k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 253k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 251k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 251k, False: 1.68k] | | ------------------ ------------------ 770| 255k|yy46: 771| 255k| switch (yych) { 772| 1.84k| case 0x00: goto yy47; ------------------ | Branch (772:3): [True: 1.84k, False: 253k] ------------------ 773| 253| case ';': goto yy48; ------------------ | Branch (773:3): [True: 253, False: 254k] ------------------ 774| 253k| default: goto yy45; ------------------ | Branch (774:3): [True: 253k, False: 2.09k] ------------------ 775| 255k| } 776| 2.21k|yy47: 777| 2.21k| YYRESTORE(); ------------------ | | 37| 2.21k|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 31| 2.21k|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 32| 2.21k|#define YYMARKER context.marker | | ------------------ ------------------ 778| 2.21k| goto yy42; 779| 253|yy48: 780| 253| YYSKIP(); ------------------ | | 35| 253|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 253|#define YYCURSOR pos | | ------------------ ------------------ 781| 253| { goto match_uri; } 782| 526k|yy49: 783| 526k| YYSKIP(); ------------------ | | 35| 526k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 526k|#define YYCURSOR pos | | ------------------ ------------------ 784| 526k| yych = YYPEEK(); ------------------ | | 33| 526k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 526k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 526k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 526k, False: 329] | | ------------------ ------------------ 785| 527k|yy50: 786| 527k| switch (yych) { 787| 418k| case '0': ------------------ | Branch (787:3): [True: 418k, False: 108k] ------------------ 788| 515k| case '1': ------------------ | Branch (788:3): [True: 97.0k, False: 430k] ------------------ 789| 517k| case '2': ------------------ | Branch (789:3): [True: 1.54k, False: 525k] ------------------ 790| 518k| case '3': ------------------ | Branch (790:3): [True: 1.36k, False: 525k] ------------------ 791| 519k| case '4': ------------------ | Branch (791:3): [True: 1.05k, False: 526k] ------------------ 792| 520k| case '5': ------------------ | Branch (792:3): [True: 1.48k, False: 525k] ------------------ 793| 521k| case '6': ------------------ | Branch (793:3): [True: 661, False: 526k] ------------------ 794| 523k| case '7': ------------------ | Branch (794:3): [True: 1.51k, False: 525k] ------------------ 795| 525k| case '8': ------------------ | Branch (795:3): [True: 2.27k, False: 524k] ------------------ 796| 526k| case '9': goto yy49; ------------------ | Branch (796:3): [True: 1.00k, False: 526k] ------------------ 797| 455| case ':': goto yy51; ------------------ | Branch (797:3): [True: 455, False: 526k] ------------------ 798| 371| default: goto yy47; ------------------ | Branch (798:3): [True: 371, False: 526k] ------------------ 799| 527k| } 800| 455|yy51: 801| 455| YYSKIP(); ------------------ | | 35| 455|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 455|#define YYCURSOR pos | | ------------------ ------------------ 802| 455| { goto match_index; } 803| 527k|} 804| | 805| | 806| 455| match_index: 807| 455| len = (size_t)(pos - 1 - begin); 808| 455| if(UA_readNumber((const UA_Byte*)begin, len, &tmp) != len) ------------------ | Branch (808:8): [True: 0, False: 455] ------------------ 809| 0| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 0|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 810| 455| qn->namespaceIndex = (UA_UInt16)tmp; 811| 455| goto match_name; 812| | 813| 253| match_uri: 814| 253| str.length = (size_t)(pos - 1 - begin); 815| 253| str.data = (UA_Byte*)(uintptr_t)begin; 816| 253| res = escapedUri2Index(str, &qn->namespaceIndex, nsMapping); 817| 253| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 253|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (817:8): [True: 253, False: 0] ------------------ 818| 253| pos = begin; /* Use the entire string for the name */ 819| | 820| 15.1k| match_name: 821| 15.1k| str.length = (size_t)(end - pos); 822| 15.1k| str.data = (UA_Byte*)(uintptr_t)pos; 823| 15.1k| res = UA_String_copy(&str, &qn->name); 824| 15.1k| if(UA_LIKELY(res == UA_STATUSCODE_GOOD)) ------------------ | | 578| 15.1k|# define UA_LIKELY(x) __builtin_expect((x), 1) | | ------------------ | | | Branch (578:23): [True: 15.1k, False: 0] | | ------------------ ------------------ 825| 15.1k| res = UA_String_unescape(&qn->name, false, escName); 826| 15.1k| return res; 827| 253|} ua_types_lex.c:parse_relativepath: 979| 1.94k| UA_UInt16 defaultNamespaceIndex) { 980| 1.94k| UA_RelativePath_init(rp); 981| 1.94k| UA_Boolean done = false; 982| 1.94k| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 17| 1.94k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 983| 15.7k| do { 984| 15.7k| res = parse_relativepathElement(rp, ppos, end, server, esc, 985| 15.7k| defaultNamespaceIndex, &done); 986| 15.7k| } while(!done); ------------------ | Branch (986:13): [True: 13.8k, False: 1.94k] ------------------ 987| 1.94k| return res; 988| 1.94k|} ua_types_lex.c:parse_relativepathElement: 849| 15.7k| UA_UInt16 defaultTargetNamespaceIndex, UA_Boolean *done) { 850| 15.7k| const u8 *pos = *ppos; 851| 15.7k| if(pos == end) { ------------------ | Branch (851:8): [True: 937, False: 14.8k] ------------------ 852| 937| *done = true; 853| 937| return UA_STATUSCODE_GOOD; ------------------ | | 17| 937|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 854| 937| } 855| | 856| | /* Create the element on the stack. 857| | * Moved into the rp upon successful parsing. */ 858| 14.8k| UA_RelativePathElement current; 859| 14.8k| UA_RelativePathElement_init(¤t); 860| 14.8k| current.includeSubtypes = true; /* Follow subtypes by default */ 861| | 862| | /* Which ReferenceType? */ 863| 14.8k| const u8 *begin; 864| 14.8k| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 17| 14.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 865| 14.8k| switch(*pos) { 866| 5.21k| case '/': ------------------ | Branch (866:5): [True: 5.21k, False: 9.63k] ------------------ 867| 5.21k| current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); ------------------ | | 46| 5.21k|#define UA_NS0ID_HIERARCHICALREFERENCES 33 /* ReferenceType */ ------------------ 868| 5.21k| goto reftype_target; 869| 1.79k| case '.': ------------------ | Branch (869:5): [True: 1.79k, False: 13.0k] ------------------ 870| | /* Recognize the dot only for the and-escaping. The dot is not escaped 871| | * for percent-escaping and commonly used as part of the browse-name. */ 872| 1.79k| if(esc != UA_ESCAPING_AND) { ------------------ | Branch (872:12): [True: 1, False: 1.79k] ------------------ 873| 1| *done = true; 874| 1| goto out; 875| 1| } 876| 1.79k| current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); ------------------ | | 55| 1.79k|#define UA_NS0ID_AGGREGATES 44 /* ReferenceType */ ------------------ 877| 1.79k| goto reftype_target; 878| 7.44k| case '<': ------------------ | Branch (878:5): [True: 7.44k, False: 7.40k] ------------------ 879| 7.44k| break; 880| 398| default: ------------------ | Branch (880:5): [True: 398, False: 14.4k] ------------------ 881| 398| *done = true; 882| 398| goto out; 883| 14.8k| } 884| | 885| | /* ReferenceType with modifiers wrapped in angle brackets */ 886| 7.44k| begin = ++pos; 887| 12.6M| for(; pos < end; pos++) { ------------------ | Branch (887:11): [True: 12.6M, False: 564] ------------------ 888| 12.6M| if((esc == UA_ESCAPING_AND || esc == UA_ESCAPING_AND_EXTENDED) && *pos == '&') { ------------------ | Branch (888:13): [True: 6.90M, False: 5.73M] | Branch (888:39): [True: 0, False: 5.73M] | Branch (888:75): [True: 4.20k, False: 6.89M] ------------------ 889| 4.20k| pos++; 890| 4.20k| continue; 891| 4.20k| } 892| 12.6M| if((esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) && *pos == '%') { ------------------ | Branch (892:13): [True: 0, False: 12.6M] | Branch (892:43): [True: 5.73M, False: 6.89M] | Branch (892:83): [True: 3.09k, False: 5.73M] ------------------ 893| 3.09k| pos += 2; 894| 3.09k| continue; 895| 3.09k| } 896| 12.6M| if(*pos == '>') ------------------ | Branch (896:12): [True: 6.88k, False: 12.6M] ------------------ 897| 6.88k| break; 898| 12.6M| } 899| 7.44k| if(pos > end) { ------------------ | Branch (899:8): [True: 16, False: 7.43k] ------------------ 900| 16| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 16|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 901| 16| goto out; 902| 16| } 903| | 904| | /* Process modifiers */ 905| 9.10k| for(; begin < pos; begin++) { ------------------ | Branch (905:11): [True: 9.04k, False: 61] ------------------ 906| 9.04k| if(*begin == '#') ------------------ | Branch (906:12): [True: 812, False: 8.23k] ------------------ 907| 812| current.includeSubtypes = false; 908| 8.23k| else if(*begin == '!') ------------------ | Branch (908:17): [True: 863, False: 7.37k] ------------------ 909| 863| current.isInverse = true; 910| 7.37k| else 911| 7.37k| break; 912| 9.04k| } 913| | 914| | /* Try to parse a NodeId for the ReferenceType (non-standard!) */ 915| 7.43k| res = parse_nodeid(¤t.referenceTypeId, begin, pos, esc, NULL); 916| 7.43k| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 17| 7.43k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (916:8): [True: 1.16k, False: 6.26k] ------------------ 917| | /* Parse the the ReferenceType from its BrowseName (default) */ 918| 1.16k| UA_QualifiedName refqn; 919| 1.16k| res = parse_qn(&refqn, begin, pos, esc, NULL, defaultTargetNamespaceIndex); 920| 1.16k| res |= lookupRefType(server, &refqn, ¤t.referenceTypeId); 921| 1.16k| UA_QualifiedName_clear(&refqn); 922| 1.16k| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 1.16k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (922:12): [True: 501, False: 662] ------------------ 923| 501| goto out; 924| 1.16k| } 925| | 926| 13.9k| reftype_target: 927| | /* Move pos to the end of the TargetName based on the escaping */ 928| 13.9k| begin = ++pos; 929| 18.1k| while(pos < end && *pos >= '0' && *pos <= '9') ------------------ | Branch (929:11): [True: 17.3k, False: 763] | Branch (929:24): [True: 11.3k, False: 5.97k] | Branch (929:39): [True: 4.18k, False: 7.20k] ------------------ 930| 4.18k| pos++; 931| 13.9k| if(pos < end && *pos == ':') ------------------ | Branch (931:8): [True: 13.1k, False: 763] | Branch (931:21): [True: 614, False: 12.5k] ------------------ 932| 614| pos++; 933| 87.9k| for(; pos < end; pos++) { ------------------ | Branch (933:11): [True: 86.9k, False: 1.00k] ------------------ 934| 86.9k| if((esc == UA_ESCAPING_AND || esc == UA_ESCAPING_AND_EXTENDED) && *pos == '&') { ------------------ | Branch (934:13): [True: 82.6k, False: 4.38k] | Branch (934:39): [True: 0, False: 4.38k] | Branch (934:75): [True: 1.22k, False: 81.3k] ------------------ 935| 1.22k| pos++; 936| 1.22k| continue; 937| 1.22k| } 938| 85.7k| if((esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) && *pos == '%') { ------------------ | Branch (938:13): [True: 0, False: 85.7k] | Branch (938:43): [True: 4.38k, False: 81.3k] | Branch (938:83): [True: 407, False: 3.97k] ------------------ 939| 407| pos += 2; 940| 407| continue; 941| 407| } 942| 85.3k| if(esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (942:12): [True: 0, False: 85.3k] | Branch (942:42): [True: 3.97k, False: 81.3k] ------------------ 943| 3.97k| if(isReservedPercentExtended(*pos)) ------------------ | Branch (943:16): [True: 3.01k, False: 957] ------------------ 944| 3.01k| break; 945| 81.3k| } else { 946| 81.3k| if(isReservedAnd(*pos)) ------------------ | Branch (946:16): [True: 9.91k, False: 71.4k] ------------------ 947| 9.91k| break; 948| 81.3k| } 949| 85.3k| } 950| 13.9k| if(pos > end) { ------------------ | Branch (950:8): [True: 78, False: 13.8k] ------------------ 951| 78| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 78|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 952| 78| goto out; 953| 78| } 954| | 955| | /* Parse the TargetName */ 956| 13.8k| res = parse_qn(¤t.targetName, begin, pos, esc, 957| 13.8k| NULL, defaultTargetNamespaceIndex); 958| 13.8k| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 17| 13.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (958:8): [True: 10, False: 13.8k] ------------------ 959| 10| UA_RelativePathElement_clear(¤t); 960| 10| goto out; 961| 10| } 962| | 963| | /* Add current to the rp */ 964| 13.8k| res |= relativepath_addelem(rp, ¤t); 965| | 966| 14.8k| out: 967| 14.8k| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 14.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (967:8): [True: 610, False: 14.2k] ------------------ 968| 610| UA_RelativePathElement_clear(¤t); 969| | 970| | /* Return the status */ 971| 14.8k| *ppos = pos; 972| 14.8k| *done |= (res != UA_STATUSCODE_GOOD); ------------------ | | 17| 14.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 973| 14.8k| return res; 974| 13.8k|} ua_types_lex.c:relativepath_addelem: 686| 13.8k|relativepath_addelem(UA_RelativePath *rp, UA_RelativePathElement *el) { 687| | /* Check for unrealistic path lengths */ 688| 13.8k| if(rp->elementsSize >= UA_MAXPATHLENGTH) ------------------ | | 29| 13.8k|#define UA_MAXPATHLENGTH 128 /* Maximum relative path depth */ ------------------ | Branch (688:8): [True: 5, False: 13.8k] ------------------ 689| 5| return UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 5|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 690| | 691| | /* Allocate memory */ 692| 13.8k| UA_RelativePathElement *newArray = (UA_RelativePathElement*) 693| 13.8k| UA_realloc(rp->elements, sizeof(UA_RelativePathElement) * (rp->elementsSize + 1)); ------------------ | | 21| 13.8k|#define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 694| 13.8k| if(!newArray) ------------------ | Branch (694:8): [True: 0, False: 13.8k] ------------------ 695| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 696| 13.8k| rp->elements = newArray; 697| | 698| | /* Move to the target */ 699| 13.8k| rp->elements[rp->elementsSize] = *el; 700| 13.8k| rp->elementsSize++; 701| 13.8k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 13.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 702| 13.8k|} ua_types_lex.c:parseAttributeOperand: 1022| 1.01k| UA_NodeId defaultId, UA_UInt16 defaultNamespaceIndex) { 1023| | /* Initialize and set the default values */ 1024| 1.01k| UA_AttributeOperand_init(ao); 1025| 1.01k| ao->nodeId = defaultId; 1026| 1.01k| ao->attributeId = UA_ATTRIBUTEID_VALUE; 1027| | 1028| | /* Nothing to parse */ 1029| 1.01k| if(str.length == 0) ------------------ | Branch (1029:8): [True: 0, False: 1.01k] ------------------ 1030| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1031| | 1032| 1.01k| const u8 *pos = str.data; 1033| 1.01k| const u8 *end = pos + str.length; 1034| 1.01k| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 17| 1.01k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1035| | 1036| | /* Initial NodeId before the BrowsePath */ 1037| 1.01k| LexContext context; 1038| 1.01k| memset(&context, 0, sizeof(LexContext)); 1039| | 1040| 1.01k|{ 1041| 1.01k| u8 yych; 1042| 1.01k| yych = YYPEEK(); ------------------ | | 33| 1.01k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.01k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 1.01k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 1.01k, False: 0] | | ------------------ ------------------ 1043| 1.01k| switch (yych) { 1044| 63| case 'b': ------------------ | Branch (1044:3): [True: 63, False: 948] ------------------ 1045| 66| case 'g': ------------------ | Branch (1045:3): [True: 3, False: 1.00k] ------------------ 1046| 106| case 'i': ------------------ | Branch (1046:3): [True: 40, False: 971] ------------------ 1047| 159| case 's': goto yy55; ------------------ | Branch (1047:3): [True: 53, False: 958] ------------------ 1048| 233| case 'n': goto yy56; ------------------ | Branch (1048:3): [True: 233, False: 778] ------------------ 1049| 619| default: goto yy53; ------------------ | Branch (1049:3): [True: 619, False: 392] ------------------ 1050| 1.01k| } 1051| 619|yy53: 1052| 619| YYSKIP(); ------------------ | | 35| 619|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 619|#define YYCURSOR pos | | ------------------ ------------------ 1053| 814|yy54: 1054| 814| { pos = str.data; goto parse_path; } 1055| 159|yy55: 1056| 159| YYSKIP(); ------------------ | | 35| 159|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 159|#define YYCURSOR pos | | ------------------ ------------------ 1057| 159| yych = YYPEEK(); ------------------ | | 33| 159|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 159|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 155|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 155, False: 4] | | ------------------ ------------------ 1058| 159| switch (yych) { 1059| 150| case '=': goto yy57; ------------------ | Branch (1059:3): [True: 150, False: 9] ------------------ 1060| 9| default: goto yy54; ------------------ | Branch (1060:3): [True: 9, False: 150] ------------------ 1061| 159| } 1062| 233|yy56: 1063| 233| YYSKIP(); ------------------ | | 35| 233|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 233|#define YYCURSOR pos | | ------------------ ------------------ 1064| 233| YYBACKUP(); ------------------ | | 36| 233|#define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 32| 233|#define YYMARKER context.marker | | ------------------ | | #define YYBACKUP() YYMARKER = YYCURSOR | | ------------------ | | | | 31| 233|#define YYCURSOR pos | | ------------------ ------------------ 1065| 233| yych = YYPEEK(); ------------------ | | 33| 233|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 233|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 232|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 232, False: 1] | | ------------------ ------------------ 1066| 233| switch (yych) { 1067| 224| case 's': goto yy58; ------------------ | Branch (1067:3): [True: 224, False: 9] ------------------ 1068| 9| default: goto yy54; ------------------ | Branch (1068:3): [True: 9, False: 224] ------------------ 1069| 233| } 1070| 197|yy57: 1071| 197| YYSKIP(); ------------------ | | 35| 197|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 197|#define YYCURSOR pos | | ------------------ ------------------ 1072| 197| { 1073| | // Find the end position of the NodeId body and parse 1074| 2.77k| for(; pos < end; pos++) { ------------------ | Branch (1074:15): [True: 2.68k, False: 89] ------------------ 1075| 2.68k| if(*pos == '%') { ------------------ | Branch (1075:16): [True: 203, False: 2.48k] ------------------ 1076| 203| pos += 2; 1077| 203| continue; 1078| 203| } 1079| 2.48k| if(isReservedPercentExtended(*pos)) ------------------ | Branch (1079:16): [True: 108, False: 2.37k] ------------------ 1080| 108| break; 1081| 2.48k| } 1082| 197| if(pos > end) { ------------------ | Branch (1082:12): [True: 8, False: 189] ------------------ 1083| 8| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 8|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1084| 8| goto cleanup; 1085| 8| } 1086| 189| res = parse_nodeid(&ao->nodeId, str.data, pos, UA_ESCAPING_PERCENT, NULL); 1087| 189| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 189|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1087:12): [True: 65, False: 124] ------------------ 1088| 65| goto cleanup; 1089| 124| goto parse_path; 1090| 189| } 1091| 224|yy58: 1092| 224| YYSKIP(); ------------------ | | 35| 224|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 224|#define YYCURSOR pos | | ------------------ ------------------ 1093| 224| yych = YYPEEK(); ------------------ | | 33| 224|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 224|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 223|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 223, False: 1] | | ------------------ ------------------ 1094| 224| switch (yych) { 1095| 141| case '=': goto yy60; ------------------ | Branch (1095:3): [True: 141, False: 83] ------------------ 1096| 81| case 'u': goto yy61; ------------------ | Branch (1096:3): [True: 81, False: 143] ------------------ 1097| 2| default: goto yy59; ------------------ | Branch (1097:3): [True: 2, False: 222] ------------------ 1098| 224| } 1099| 177|yy59: 1100| 177| YYRESTORE(); ------------------ | | 37| 177|#define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 31| 177|#define YYCURSOR pos | | ------------------ | | #define YYRESTORE() YYCURSOR = YYMARKER | | ------------------ | | | | 32| 177|#define YYMARKER context.marker | | ------------------ ------------------ 1101| 177| goto yy54; 1102| 141|yy60: 1103| 141| YYSKIP(); ------------------ | | 35| 141|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 141|#define YYCURSOR pos | | ------------------ ------------------ 1104| 141| yych = YYPEEK(); ------------------ | | 33| 141|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 141|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 140|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 140, False: 1] | | ------------------ ------------------ 1105| 141| switch (yych) { 1106| 29| case '0': ------------------ | Branch (1106:3): [True: 29, False: 112] ------------------ 1107| 49| case '1': ------------------ | Branch (1107:3): [True: 20, False: 121] ------------------ 1108| 57| case '2': ------------------ | Branch (1108:3): [True: 8, False: 133] ------------------ 1109| 75| case '3': ------------------ | Branch (1109:3): [True: 18, False: 123] ------------------ 1110| 84| case '4': ------------------ | Branch (1110:3): [True: 9, False: 132] ------------------ 1111| 95| case '5': ------------------ | Branch (1111:3): [True: 11, False: 130] ------------------ 1112| 105| case '6': ------------------ | Branch (1112:3): [True: 10, False: 131] ------------------ 1113| 110| case '7': ------------------ | Branch (1113:3): [True: 5, False: 136] ------------------ 1114| 121| case '8': ------------------ | Branch (1114:3): [True: 11, False: 130] ------------------ 1115| 130| case '9': goto yy62; ------------------ | Branch (1115:3): [True: 9, False: 132] ------------------ 1116| 11| default: goto yy59; ------------------ | Branch (1116:3): [True: 11, False: 130] ------------------ 1117| 141| } 1118| 81|yy61: 1119| 81| YYSKIP(); ------------------ | | 35| 81|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 81|#define YYCURSOR pos | | ------------------ ------------------ 1120| 81| yych = YYPEEK(); ------------------ | | 33| 81|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 81|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 80|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 80, False: 1] | | ------------------ ------------------ 1121| 81| switch (yych) { 1122| 70| case '=': goto yy63; ------------------ | Branch (1122:3): [True: 70, False: 11] ------------------ 1123| 11| default: goto yy59; ------------------ | Branch (1123:3): [True: 11, False: 70] ------------------ 1124| 81| } 1125| 2.72k|yy62: 1126| 2.72k| YYSKIP(); ------------------ | | 35| 2.72k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 2.72k|#define YYCURSOR pos | | ------------------ ------------------ 1127| 2.72k| yych = YYPEEK(); ------------------ | | 33| 2.72k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.72k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.64k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 2.64k, False: 86] | | ------------------ ------------------ 1128| 2.72k| switch (yych) { 1129| 407| case '0': ------------------ | Branch (1129:3): [True: 407, False: 2.31k] ------------------ 1130| 773| case '1': ------------------ | Branch (1130:3): [True: 366, False: 2.36k] ------------------ 1131| 1.01k| case '2': ------------------ | Branch (1131:3): [True: 244, False: 2.48k] ------------------ 1132| 1.23k| case '3': ------------------ | Branch (1132:3): [True: 220, False: 2.50k] ------------------ 1133| 1.46k| case '4': ------------------ | Branch (1133:3): [True: 227, False: 2.49k] ------------------ 1134| 1.72k| case '5': ------------------ | Branch (1134:3): [True: 262, False: 2.46k] ------------------ 1135| 1.95k| case '6': ------------------ | Branch (1135:3): [True: 226, False: 2.50k] ------------------ 1136| 2.17k| case '7': ------------------ | Branch (1136:3): [True: 221, False: 2.50k] ------------------ 1137| 2.39k| case '8': ------------------ | Branch (1137:3): [True: 217, False: 2.50k] ------------------ 1138| 2.59k| case '9': goto yy62; ------------------ | Branch (1138:3): [True: 206, False: 2.52k] ------------------ 1139| 17| case ';': goto yy64; ------------------ | Branch (1139:3): [True: 17, False: 2.70k] ------------------ 1140| 113| default: goto yy59; ------------------ | Branch (1140:3): [True: 113, False: 2.61k] ------------------ 1141| 2.72k| } 1142| 2.58k|yy63: 1143| 2.58k| YYSKIP(); ------------------ | | 35| 2.58k|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 2.58k|#define YYCURSOR pos | | ------------------ ------------------ 1144| 2.58k| yych = YYPEEK(); ------------------ | | 33| 2.58k|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.58k|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 2.57k|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 2.57k, False: 10] | | ------------------ ------------------ 1145| 2.58k| switch (yych) { 1146| 17| case 0x00: goto yy59; ------------------ | Branch (1146:3): [True: 17, False: 2.56k] ------------------ 1147| 53| case ';': goto yy64; ------------------ | Branch (1147:3): [True: 53, False: 2.53k] ------------------ 1148| 2.51k| default: goto yy63; ------------------ | Branch (1148:3): [True: 2.51k, False: 70] ------------------ 1149| 2.58k| } 1150| 70|yy64: 1151| 70| YYSKIP(); ------------------ | | 35| 70|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 70|#define YYCURSOR pos | | ------------------ ------------------ 1152| 70| yych = YYPEEK(); ------------------ | | 33| 70|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 70|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 68|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 68, False: 2] | | ------------------ ------------------ 1153| 70| switch (yych) { 1154| 14| case 'b': ------------------ | Branch (1154:3): [True: 14, False: 56] ------------------ 1155| 20| case 'g': ------------------ | Branch (1155:3): [True: 6, False: 64] ------------------ 1156| 47| case 'i': ------------------ | Branch (1156:3): [True: 27, False: 43] ------------------ 1157| 65| case 's': goto yy65; ------------------ | Branch (1157:3): [True: 18, False: 52] ------------------ 1158| 5| default: goto yy59; ------------------ | Branch (1158:3): [True: 5, False: 65] ------------------ 1159| 70| } 1160| 65|yy65: 1161| 65| YYSKIP(); ------------------ | | 35| 65|#define YYSKIP() ++YYCURSOR; | | ------------------ | | | | 31| 65|#define YYCURSOR pos | | ------------------ ------------------ 1162| 65| yych = YYPEEK(); ------------------ | | 33| 65|#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 65|#define YYCURSOR pos | | ------------------ | | #define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of | | ------------------ | | | | 31| 61|#define YYCURSOR pos | | ------------------ | | | Branch (33:18): [True: 61, False: 4] | | ------------------ ------------------ 1163| 65| switch (yych) { 1164| 47| case '=': goto yy57; ------------------ | Branch (1164:3): [True: 47, False: 18] ------------------ 1165| 18| default: goto yy59; ------------------ | Branch (1165:3): [True: 18, False: 47] ------------------ 1166| 65| } 1167| 65|} 1168| | 1169| | 1170| | /* Parse the BrowsePath */ 1171| 938| parse_path: 1172| 938| res = parse_relativepath(&ao->browsePath, &pos, end, NULL, 1173| 938| UA_ESCAPING_PERCENT_EXTENDED, defaultNamespaceIndex); 1174| 938| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 938|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1174:8): [True: 369, False: 569] ------------------ 1175| 369| goto cleanup; 1176| | 1177| | /* Parse the AttributeId */ 1178| 569| if(pos < end && *pos == '#') { ------------------ | Branch (1178:8): [True: 393, False: 176] | Branch (1178:21): [True: 87, False: 306] ------------------ 1179| 87| const u8 *attr_pos = ++pos; 1180| 639k| while(pos < end && ((*pos >= 'a' && *pos <= 'z') || ------------------ | Branch (1180:15): [True: 639k, False: 61] | Branch (1180:30): [True: 57.2k, False: 582k] | Branch (1180:45): [True: 57.2k, False: 10] ------------------ 1181| 639k| (*pos >= 'A' && *pos <= 'Z'))) { ------------------ | Branch (1181:30): [True: 582k, False: 13] | Branch (1181:45): [True: 582k, False: 13] ------------------ 1182| 639k| pos++; 1183| 639k| } 1184| 87| UA_String attrString = {(size_t)(pos - attr_pos), (UA_Byte*)(uintptr_t)attr_pos}; 1185| 87| ao->attributeId = UA_AttributeId_fromName(attrString); 1186| 87| if(ao->attributeId == UA_ATTRIBUTEID_INVALID) { ------------------ | Branch (1186:12): [True: 85, False: 2] ------------------ 1187| 85| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 85|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1188| 85| goto cleanup; 1189| 85| } 1190| 87| } 1191| | 1192| | /* Parse the IndexRange */ 1193| 484| if(pos < end && *pos == '[') { ------------------ | Branch (1193:8): [True: 306, False: 178] | Branch (1193:21): [True: 35, False: 271] ------------------ 1194| 35| const u8 *range_pos = ++pos; 1195| 2.36M| while(pos < end && *pos != ']') { ------------------ | Branch (1195:15): [True: 2.36M, False: 15] | Branch (1195:28): [True: 2.36M, False: 20] ------------------ 1196| 2.36M| pos++; 1197| 2.36M| } 1198| 35| if(pos == end) { ------------------ | Branch (1198:12): [True: 15, False: 20] ------------------ 1199| 15| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 15|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1200| 15| goto cleanup; 1201| 15| } 1202| 20| UA_String rangeString = {(size_t)(pos - range_pos), (UA_Byte*)(uintptr_t)range_pos}; 1203| 20| if(rangeString.length > 0) ------------------ | Branch (1203:12): [True: 19, False: 1] ------------------ 1204| 19| res = UA_String_copy(&rangeString, &ao->indexRange); 1205| 20| pos++; 1206| 20| } 1207| | 1208| | /* Check that we have parsed the entire string */ 1209| 469| if(pos != end) ------------------ | Branch (1209:8): [True: 279, False: 190] ------------------ 1210| 279| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 279|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 1211| | 1212| | 1213| 1.01k| cleanup: 1214| 1.01k| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 1.01k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1214:8): [True: 821, False: 190] ------------------ 1215| 821| UA_AttributeOperand_clear(ao); 1216| 1.01k| return res; 1217| 469|} UA_AttributeId_fromName: 55| 87|UA_AttributeId_fromName(const UA_String name) { 56| 2.48k| for(size_t i = 0; i < 28; i++) { ------------------ | Branch (56:23): [True: 2.39k, False: 85] ------------------ 57| 2.39k| if(strlen(attributeIdNames[i]) != name.length) ------------------ | Branch (57:12): [True: 2.36k, False: 30] ------------------ 58| 2.36k| continue; 59| 48| for(size_t j = 0; j < name.length; j++) { ------------------ | Branch (59:27): [True: 46, False: 2] ------------------ 60| 46| if((attributeIdNames[i][j] | 32) != (name.data[j] | 32)) ------------------ | Branch (60:16): [True: 28, False: 18] ------------------ 61| 28| goto next; 62| 46| } 63| 2| return (UA_AttributeId)i; 64| 28| next: 65| 28| continue; 66| 30| } 67| 85| return UA_ATTRIBUTEID_INVALID; 68| 87|} UA_readNumberWithBase: 110| 11.0k|UA_readNumberWithBase(const UA_Byte *buf, size_t buflen, UA_UInt32 *number, UA_Byte base) { 111| 11.0k| UA_assert(buf); ------------------ | | 399| 11.0k|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (111:5): [True: 11.0k, False: 0] ------------------ 112| 11.0k| UA_assert(number); ------------------ | | 399| 11.0k|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (112:5): [True: 11.0k, False: 0] ------------------ 113| 11.0k| u32 n = 0; 114| 11.0k| size_t progress = 0; 115| | /* read numbers until the end or a non-number character appears */ 116| 573k| while(progress < buflen) { ------------------ | Branch (116:11): [True: 562k, False: 10.9k] ------------------ 117| 562k| u8 c = buf[progress]; 118| 562k| if(c >= '0' && c <= '9' && c <= '0' + (base-1)) ------------------ | Branch (118:12): [True: 562k, False: 20] | Branch (118:24): [True: 547k, False: 14.3k] | Branch (118:36): [True: 547k, False: 0] ------------------ 119| 547k| n = (n * base) + c - '0'; 120| 14.3k| else if(base > 9 && c >= 'a' && c <= 'z' && c <= 'a' + (base-11)) ------------------ | Branch (120:17): [True: 14.3k, False: 0] | Branch (120:29): [True: 2.45k, False: 11.9k] | Branch (120:41): [True: 2.42k, False: 31] | Branch (120:53): [True: 2.41k, False: 11] ------------------ 121| 2.41k| n = (n * base) + c-'a' + 10; 122| 11.9k| else if(base > 9 && c >= 'A' && c <= 'Z' && c <= 'A' + (base-11)) ------------------ | Branch (122:17): [True: 11.9k, False: 0] | Branch (122:29): [True: 11.9k, False: 25] | Branch (122:41): [True: 11.8k, False: 44] | Branch (122:53): [True: 11.8k, False: 7] ------------------ 123| 11.8k| n = (n * base) + c-'A' + 10; 124| 76| else 125| 76| break; 126| 562k| ++progress; 127| 562k| } 128| 11.0k| *number = n; 129| 11.0k| return progress; 130| 11.0k|} UA_readNumber: 133| 2.81k|UA_readNumber(const UA_Byte *buf, size_t buflen, UA_UInt32 *number) { 134| 2.81k| return UA_readNumberWithBase(buf, buflen, number, 10); 135| 2.81k|} lookupRefType: 724| 1.16k|lookupRefType(UA_Server *server, UA_QualifiedName *qn, UA_NodeId *outRefTypeId) { 725| | /* Check well-known ReferenceTypes first */ 726| 1.16k| if(qn->namespaceIndex == 0) { ------------------ | Branch (726:8): [True: 1.15k, False: 13] ------------------ 727| 12.1k| for(size_t i = 0; i < KNOWNREFTYPES; i++) { ------------------ | | 702| 12.1k|#define KNOWNREFTYPES 17 ------------------ | Branch (727:27): [True: 11.6k, False: 488] ------------------ 728| 11.6k| if(UA_String_equal(&qn->name, &knownRefTypes[i].browseName)) { ------------------ | Branch (728:16): [True: 662, False: 10.9k] ------------------ 729| 662| *outRefTypeId = UA_NODEID_NUMERIC(0, knownRefTypes[i].identifier); 730| 662| return UA_STATUSCODE_GOOD; ------------------ | | 17| 662|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 731| 662| } 732| 11.6k| } 733| 1.15k| } 734| | 735| | /* Browse the information model. Return the first results if the browse name 736| | * in the hierarchy is ambiguous. */ 737| 501| if(server) { ------------------ | Branch (737:8): [True: 0, False: 501] ------------------ 738| 0| UA_BrowseDescription bd; 739| 0| UA_BrowseDescription_init(&bd); 740| 0| bd.nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_REFERENCES); ------------------ | | 44| 0|#define UA_NS0ID_REFERENCES 31 /* ReferenceType */ ------------------ 741| 0| bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; 742| 0| bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE); ------------------ | | 56| 0|#define UA_NS0ID_HASSUBTYPE 45 /* ReferenceType */ ------------------ 743| 0| bd.nodeClassMask = UA_NODECLASS_REFERENCETYPE; 744| | 745| 0| size_t resultsSize = 0; 746| 0| UA_ExpandedNodeId *results = NULL; 747| 0| UA_StatusCode res = 748| 0| UA_Server_browseRecursive(server, &bd, &resultsSize, &results); 749| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (749:12): [True: 0, False: 0] ------------------ 750| 0| return res; 751| 0| for(size_t i = 0; i < resultsSize; i++) { ------------------ | Branch (751:27): [True: 0, False: 0] ------------------ 752| 0| UA_QualifiedName bn; 753| 0| UA_Server_readBrowseName(server, results[i].nodeId, &bn); 754| 0| if(UA_QualifiedName_equal(qn, &bn)) { ------------------ | Branch (754:16): [True: 0, False: 0] ------------------ 755| 0| UA_QualifiedName_clear(&bn); 756| 0| *outRefTypeId = results[i].nodeId; 757| 0| UA_NodeId_clear(&results[i].nodeId); 758| 0| UA_Array_delete(results, resultsSize, &UA_TYPES[UA_TYPES_NODEID]); ------------------ | | 565| 0|#define UA_TYPES_NODEID 16 ------------------ 759| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 760| 0| } 761| 0| UA_QualifiedName_clear(&bn); 762| 0| } 763| | 764| 0| UA_Array_delete(results, resultsSize, &UA_TYPES[UA_TYPES_NODEID]); ------------------ | | 565| 0|#define UA_TYPES_NODEID 16 ------------------ 765| 0| } 766| | 767| 501| return UA_STATUSCODE_BADNOTFOUND; ------------------ | | 233| 501|#define UA_STATUSCODE_BADNOTFOUND ((UA_StatusCode) 0x803E0000) ------------------ 768| 501|} getRefTypeBrowseName: 771| 5.17k|getRefTypeBrowseName(const UA_NodeId *refTypeId, UA_String *outBN) { 772| | /* Canonical name known? */ 773| 5.17k| if(refTypeId->namespaceIndex == 0 && ------------------ | Branch (773:8): [True: 4.38k, False: 788] ------------------ 774| 4.38k| refTypeId->identifierType == UA_NODEIDTYPE_NUMERIC) { ------------------ | Branch (774:8): [True: 1.32k, False: 3.06k] ------------------ 775| 13.2k| for(size_t i = 0; i < KNOWNREFTYPES; i++) { ------------------ | | 702| 13.2k|#define KNOWNREFTYPES 17 ------------------ | Branch (775:27): [True: 12.6k, False: 568] ------------------ 776| 12.6k| if(refTypeId->identifier.numeric != knownRefTypes[i].identifier) ------------------ | Branch (776:16): [True: 11.8k, False: 754] ------------------ 777| 11.8k| continue; 778| 754| memcpy(outBN->data, knownRefTypes[i].browseName.data, knownRefTypes[i].browseName.length); 779| 754| outBN->length = knownRefTypes[i].browseName.length; 780| 754| return UA_STATUSCODE_GOOD; ------------------ | | 17| 754|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 781| 12.6k| } 782| 1.32k| } 783| | 784| | /* Print the NodeId */ 785| 4.41k| return UA_NodeId_print(refTypeId, outBN); 786| 5.17k|} UA_String_unescape: 800| 17.0k|UA_String_unescape(UA_String *str, UA_Boolean copyEscape, UA_Escaping esc) { 801| 17.0k| if(esc == UA_ESCAPING_NONE) ------------------ | Branch (801:8): [True: 210, False: 16.8k] ------------------ 802| 210| return UA_STATUSCODE_GOOD; ------------------ | | 17| 210|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 803| | 804| | /* Does the string need escaping? */ 805| 16.8k| UA_String tmp; 806| 16.8k| status res = UA_STATUSCODE_GOOD; ------------------ | | 17| 16.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 807| 16.8k| u8 *pos = str->data; 808| 16.8k| u8 *end = str->data + str->length; 809| 16.8k| u8 escape_char = (esc == UA_ESCAPING_PERCENT || ------------------ | Branch (809:23): [True: 44, False: 16.7k] ------------------ 810| 16.7k| esc == UA_ESCAPING_PERCENT_EXTENDED) ? '%' : '&'; ------------------ | Branch (810:23): [True: 3.60k, False: 13.1k] ------------------ 811| 3.56M| for(; pos < end; pos++) { ------------------ | Branch (811:11): [True: 3.55M, False: 15.8k] ------------------ 812| 3.55M| if(*pos == escape_char) ------------------ | Branch (812:12): [True: 988, False: 3.55M] ------------------ 813| 988| goto escape; 814| 3.55M| } 815| | 816| 15.8k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 15.8k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 817| | 818| 988| escape: 819| 988| if(copyEscape) { ------------------ | Branch (819:8): [True: 0, False: 988] ------------------ 820| 0| res = UA_String_copy(str, &tmp); 821| 0| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (821:12): [True: 0, False: 0] ------------------ 822| 0| return res; 823| 0| pos = tmp.data; 824| 0| end = tmp.data + tmp.length; 825| 0| } 826| | 827| 988| u8 byte = 0; 828| 988| u8 *writepos = pos; 829| | 830| 988| res = UA_STATUSCODE_BADDECODINGERROR; ------------------ | | 44| 988|#define UA_STATUSCODE_BADDECODINGERROR ((UA_StatusCode) 0x80070000) ------------------ 831| 988| if(esc == UA_ESCAPING_PERCENT || ------------------ | Branch (831:8): [True: 3, False: 985] ------------------ 832| 985| esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (832:8): [True: 442, False: 543] ------------------ 833| | /* Percent-Escaping */ 834| 476k| for(; pos < end; pos++) { ------------------ | Branch (834:15): [True: 476k, False: 234] ------------------ 835| 476k| if(*pos == '%') { ------------------ | Branch (835:16): [True: 2.29k, False: 473k] ------------------ 836| 2.29k| if(pos + 2 >= end || !isHex(pos[1]) || !isHex(pos[2])) ------------------ | Branch (836:20): [True: 0, False: 2.29k] | Branch (836:38): [True: 109, False: 2.18k] | Branch (836:56): [True: 102, False: 2.08k] ------------------ 837| 211| goto out; 838| 2.08k| if(pos[1] >= 'a') ------------------ | Branch (838:20): [True: 576, False: 1.50k] ------------------ 839| 576| byte = pos[1] - ('a' - 10); 840| 1.50k| else if(pos[1] >= 'A') ------------------ | Branch (840:25): [True: 898, False: 611] ------------------ 841| 898| byte = pos[1] - ('A' - 10); 842| 611| else 843| 611| byte = pos[1] - '0'; 844| 2.08k| byte <<= 4; 845| | 846| 2.08k| if(pos[2] >= 'a') ------------------ | Branch (846:20): [True: 692, False: 1.39k] ------------------ 847| 692| byte += (u8)(pos[2] - ('a' - 10)); 848| 1.39k| else if(pos[2] >= 'A') ------------------ | Branch (848:25): [True: 880, False: 513] ------------------ 849| 880| byte += (u8)(pos[2] - ('A' - 10)); 850| 513| else 851| 513| byte += (u8)(pos[2] - '0'); 852| | 853| 2.08k| pos += 2; 854| 2.08k| *writepos++ = byte; 855| 2.08k| continue; 856| 2.29k| } 857| 473k| *writepos++ = *pos; 858| 473k| } 859| 543| } else { 860| | /* And-Escaping */ 861| 4.41M| for(; pos < end; pos++) { ------------------ | Branch (861:15): [True: 4.41M, False: 543] ------------------ 862| 4.41M| if(*pos == '&') { ------------------ | Branch (862:16): [True: 2.43k, False: 4.40M] ------------------ 863| 2.43k| pos++; 864| 2.43k| if(pos == end) ------------------ | Branch (864:20): [True: 0, False: 2.43k] ------------------ 865| 0| goto out; 866| 2.43k| } 867| 4.41M| *writepos++ = *pos; 868| 4.41M| } 869| 543| } 870| 777| res = UA_STATUSCODE_GOOD; ------------------ | | 17| 777|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 871| | 872| 988| out: 873| 988| if(copyEscape) { ------------------ | Branch (873:8): [True: 0, False: 988] ------------------ 874| 0| tmp.length = (size_t)(writepos - tmp.data); 875| 0| if(tmp.length == 0) ------------------ | Branch (875:12): [True: 0, False: 0] ------------------ 876| 0| UA_String_clear(&tmp); 877| 0| if(res == UA_STATUSCODE_GOOD) ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (877:12): [True: 0, False: 0] ------------------ 878| 0| *str = tmp; 879| 0| else 880| 0| UA_String_clear(&tmp); 881| 988| } else if(res == UA_STATUSCODE_GOOD) { ------------------ | | 17| 988|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (881:15): [True: 777, False: 211] ------------------ 882| 777| str->length = (size_t)(writepos - str->data); 883| 777| } 884| 988| return res; 885| 777|} UA_String_escapedSize: 891| 15.3k|UA_String_escapedSize(const UA_String s, UA_Escaping esc) { 892| | /* Find out the overhead from escaping */ 893| 15.3k| size_t overhead = 0; 894| 16.8M| for(size_t j = 0; j < s.length; j++) { ------------------ | Branch (894:23): [True: 16.8M, False: 15.3k] ------------------ 895| 16.8M| if(esc == UA_ESCAPING_AND_EXTENDED) ------------------ | Branch (895:12): [True: 0, False: 16.8M] ------------------ 896| 0| overhead += isReservedAndExtended(s.data[j]); 897| 16.8M| else if(esc == UA_ESCAPING_AND) ------------------ | Branch (897:17): [True: 5.73M, False: 11.1M] ------------------ 898| 5.73M| overhead += isReservedAnd(s.data[j]); 899| 11.1M| else if(esc == UA_ESCAPING_PERCENT) ------------------ | Branch (899:17): [True: 0, False: 11.1M] ------------------ 900| 0| overhead += (isReservedPercent(s.data[j]) ? 2 : 0); ------------------ | Branch (900:26): [True: 0, False: 0] ------------------ 901| 11.1M| else /* if(esc == UA_ESCAPING_PERCENT_EXTENDED) */ 902| 11.1M| overhead += (isReservedPercentExtended(s.data[j]) ? 2 : 0); ------------------ | Branch (902:26): [True: 9.05M, False: 2.06M] ------------------ 903| 16.8M| } 904| | 905| 15.3k| return s.length + overhead; 906| 15.3k|} UA_String_escapeInsert: 909| 14.7k|UA_String_escapeInsert(u8 *pos, const UA_String s2, UA_Escaping esc) { 910| 14.7k| u8 *begin = pos; 911| | 912| 14.7k| if(esc == UA_ESCAPING_NONE) { ------------------ | Branch (912:8): [True: 1.66k, False: 13.0k] ------------------ 913| 5.56M| for(size_t j = 0; j < s2.length; j++) ------------------ | Branch (913:27): [True: 5.56M, False: 1.66k] ------------------ 914| 5.56M| *pos++ = s2.data[j]; 915| 13.0k| } else if(esc == UA_ESCAPING_PERCENT || esc == UA_ESCAPING_PERCENT_EXTENDED) { ------------------ | Branch (915:15): [True: 0, False: 13.0k] | Branch (915:45): [True: 0, False: 13.0k] ------------------ 916| 0| for(size_t j = 0; j < s2.length; j++) { ------------------ | Branch (916:27): [True: 0, False: 0] ------------------ 917| 0| UA_Boolean reserved = (esc == UA_ESCAPING_PERCENT_EXTENDED) ? ------------------ | Branch (917:35): [True: 0, False: 0] ------------------ 918| 0| isReservedPercentExtended(s2.data[j]) : isReservedPercent(s2.data[j]); 919| 0| if(UA_LIKELY(!reserved)) { ------------------ | | 578| 0|# define UA_LIKELY(x) __builtin_expect((x), 1) | | ------------------ | | | Branch (578:23): [True: 0, False: 0] | | ------------------ ------------------ 920| 0| *pos++ = s2.data[j]; 921| 0| } else { 922| 0| *pos++ = '%'; 923| 0| *pos++ = hexchars[s2.data[j] >> 4]; 924| 0| *pos++ = hexchars[s2.data[j] & 0x0f]; 925| 0| } 926| 0| } 927| 13.0k| } else { 928| 5.74M| for(size_t j = 0; j < s2.length; j++) { ------------------ | Branch (928:27): [True: 5.73M, False: 13.0k] ------------------ 929| 5.73M| UA_Boolean reserved = (esc == UA_ESCAPING_AND_EXTENDED) ? ------------------ | Branch (929:35): [True: 0, False: 5.73M] ------------------ 930| 5.73M| isReservedAndExtended(s2.data[j]) : isReservedAnd(s2.data[j]); 931| 5.73M| if(reserved) ------------------ | Branch (931:16): [True: 160k, False: 5.56M] ------------------ 932| 160k| *pos++ = '&'; 933| 5.73M| *pos++ = s2.data[j]; 934| 5.73M| } 935| 13.0k| } 936| | 937| 14.7k| return (size_t)(pos - begin); 938| 14.7k|} UA_String_escapeAppend: 941| 13.0k|UA_String_escapeAppend(UA_String *s, const UA_String s2, UA_Escaping esc) { 942| 13.0k| if(esc == UA_ESCAPING_NONE) ------------------ | Branch (942:8): [True: 0, False: 13.0k] ------------------ 943| 0| return UA_String_append(s, s2); 944| | 945| | /* Allocate memory for the additional escaped string */ 946| 13.0k| size_t escapedLength = UA_String_escapedSize(s2, esc); 947| 13.0k| UA_Byte *buf = (UA_Byte*) 948| 13.0k| UA_realloc(s->data, s->length + s2.length + escapedLength); ------------------ | | 21| 13.0k|#define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) ------------------ 949| 13.0k| if(!buf) ------------------ | Branch (949:8): [True: 0, False: 13.0k] ------------------ 950| 0| return UA_STATUSCODE_BADOUTOFMEMORY; ------------------ | | 32| 0|#define UA_STATUSCODE_BADOUTOFMEMORY ((UA_StatusCode) 0x80030000) ------------------ 951| | 952| | /* Escape and insert at the end */ 953| 13.0k| s->data = buf; 954| 13.0k| UA_String_escapeInsert(s->data + s->length, s2, esc); 955| 13.0k| s->length += escapedLength; 956| 13.0k| return UA_STATUSCODE_GOOD; ------------------ | | 17| 13.0k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 957| 13.0k|} UA_RelativePath_print: 1055| 761|UA_RelativePath_print(const UA_RelativePath *rp, UA_String *out) { 1056| 761| return printRelativePath(rp, out, UA_ESCAPING_AND); 1057| 761|} ua_util.c:isHex: 793| 4.48k|isHex(u8 c) { 794| 4.48k| return ((c >= 'a' && c <= 'f') || ------------------ | Branch (794:14): [True: 1.37k, False: 3.10k] | Branch (794:26): [True: 1.29k, False: 77] ------------------ 795| 3.18k| (c >= 'A' && c <= 'F') || ------------------ | Branch (795:14): [True: 1.90k, False: 1.28k] | Branch (795:26): [True: 1.80k, False: 102] ------------------ 796| 1.38k| (c >= '0' && c <= '9')); ------------------ | Branch (796:14): [True: 1.30k, False: 81] | Branch (796:26): [True: 1.17k, False: 130] ------------------ 797| 4.48k|} ua_util.c:printRelativePath: 997| 761|printRelativePath(const UA_RelativePath *rp, UA_String *out, UA_Escaping esc) { 998| 761| UA_String tmp = UA_STRING_NULL; 999| 761| UA_StatusCode res = UA_STATUSCODE_GOOD; ------------------ | | 17| 761|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 1000| 9.31k| for(size_t i = 0; i < rp->elementsSize && res == UA_STATUSCODE_GOOD; i++) { ------------------ | | 17| 8.55k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1000:23): [True: 8.55k, False: 761] | Branch (1000:47): [True: 8.55k, False: 0] ------------------ 1001| | /* Print the reference type */ 1002| 8.55k| UA_RelativePathElement *elm = &rp->elements[i]; 1003| 8.55k| if(UA_NodeId_equal(&hierarchicalRefs, &elm->referenceTypeId) && ------------------ | Branch (1003:12): [True: 2.68k, False: 5.86k] ------------------ 1004| 2.68k| !elm->isInverse && elm->includeSubtypes) { ------------------ | Branch (1004:12): [True: 2.62k, False: 66] | Branch (1004:31): [True: 2.43k, False: 191] ------------------ 1005| 2.43k| res |= UA_String_append(&tmp, UA_STRING("/")); 1006| 6.12k| } else if(esc == UA_ESCAPING_AND && ------------------ | Branch (1006:19): [True: 6.12k, False: 0] ------------------ 1007| 6.12k| UA_NodeId_equal(&aggregatesRefs, &elm->referenceTypeId) && ------------------ | Branch (1007:19): [True: 1.90k, False: 4.22k] ------------------ 1008| 1.90k| !elm->isInverse && elm->includeSubtypes) { ------------------ | Branch (1008:19): [True: 1.71k, False: 194] | Branch (1008:38): [True: 1.64k, False: 66] ------------------ 1009| 1.64k| res |= UA_String_append(&tmp, UA_STRING(".")); 1010| 4.48k| } else { 1011| 4.48k| res |= UA_String_append(&tmp, UA_STRING("<")); 1012| 4.48k| if(!elm->includeSubtypes) ------------------ | Branch (1012:16): [True: 553, False: 3.92k] ------------------ 1013| 553| res |= UA_String_append(&tmp, UA_STRING("#")); 1014| 4.48k| if(elm->isInverse) ------------------ | Branch (1014:16): [True: 454, False: 4.02k] ------------------ 1015| 454| res |= UA_String_append(&tmp, UA_STRING("!")); 1016| 4.48k| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 4.48k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1016:16): [True: 0, False: 4.48k] ------------------ 1017| 0| break; 1018| | 1019| 4.48k| UA_Byte bnBuf[512]; 1020| 4.48k| UA_String bnBufStr = {512, bnBuf}; 1021| 4.48k| res = getRefTypeBrowseName(&elm->referenceTypeId, &bnBufStr); 1022| 4.48k| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 17| 4.48k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1022:16): [True: 690, False: 3.79k] ------------------ 1023| 690| UA_String_init(&bnBufStr); 1024| 690| res = getRefTypeBrowseName(&elm->referenceTypeId, &bnBufStr); 1025| 690| if(res != UA_STATUSCODE_GOOD) ------------------ | | 17| 690|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1025:20): [True: 0, False: 690] ------------------ 1026| 0| break; 1027| 690| } 1028| 4.48k| res |= UA_String_escapeAppend(&tmp, bnBufStr, esc); 1029| 4.48k| res |= UA_String_append(&tmp, UA_STRING(">")); 1030| 4.48k| if(bnBufStr.data != bnBuf) ------------------ | Branch (1030:16): [True: 690, False: 3.79k] ------------------ 1031| 690| UA_String_clear(&bnBufStr); 1032| 4.48k| } 1033| | 1034| | /* Print the qualified name */ 1035| 8.55k| UA_QualifiedName *qn = &elm->targetName; 1036| 8.55k| if(qn->namespaceIndex > 0) { ------------------ | Branch (1036:12): [True: 420, False: 8.13k] ------------------ 1037| 420| char nsStr[8]; /* Enough for a uint16 */ 1038| 420| itoaUnsigned(qn->namespaceIndex, nsStr, 10); 1039| 420| res |= UA_String_append(&tmp, UA_STRING(nsStr)); 1040| 420| res |= UA_String_append(&tmp, UA_STRING(":")); 1041| 420| } 1042| 8.55k| res |= UA_String_escapeAppend(&tmp, qn->name, esc); 1043| 8.55k| } 1044| | 1045| | /* Encoding failed, clean up */ 1046| 761| if(res != UA_STATUSCODE_GOOD) { ------------------ | | 17| 761|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (1046:8): [True: 0, False: 761] ------------------ 1047| 0| UA_String_clear(&tmp); 1048| 0| return res; 1049| 0| } 1050| | 1051| 761| return moveTmpToOut(&tmp, out); 1052| 761|} ua_util.c:moveTmpToOut: 960| 761|moveTmpToOut(UA_String *tmp, UA_String *out) { 961| | /* Output has zero length */ 962| 761| if(tmp->length == 0) { ------------------ | Branch (962:8): [True: 0, False: 761] ------------------ 963| 0| UA_assert(tmp->data == NULL); ------------------ | | 399| 0|# define UA_assert(ignore) assert(ignore) ------------------ | Branch (963:9): [True: 0, False: 0] ------------------ 964| 0| if(out->data == NULL) ------------------ | Branch (964:12): [True: 0, False: 0] ------------------ 965| 0| out->data = (UA_Byte*)UA_EMPTY_ARRAY_SENTINEL; ------------------ | | 755| 0|#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) ------------------ 966| 0| out->length = 0; 967| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 968| 0| } 969| | 970| | /* No output buffer provided, return the tmp buffer */ 971| 761| if(out->length == 0) { ------------------ | Branch (971:8): [True: 761, False: 0] ------------------ 972| 761| *out = *tmp; 973| 761| return UA_STATUSCODE_GOOD; ------------------ | | 17| 761|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 974| 761| } 975| | 976| | /* The provided buffer is too short */ 977| 0| if(out->length < tmp->length) { ------------------ | Branch (977:8): [True: 0, False: 0] ------------------ 978| 0| UA_String_clear(tmp); 979| 0| return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED; ------------------ | | 47| 0|#define UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED ((UA_StatusCode) 0x80080000) ------------------ 980| 0| } 981| | 982| | /* Copy output to the provided buffer */ 983| 0| memcpy(out->data, tmp->data, tmp->length); 984| 0| out->length = tmp->length; 985| 0| UA_String_clear(tmp); 986| 0| return UA_STATUSCODE_GOOD; ------------------ | | 17| 0|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ 987| 0|} ua_types.c:isTrue: 167| 11.0k|isTrue(uint8_t expr) { 168| 11.0k| return expr; 169| 11.0k|} ua_util.c:isReservedAnd: 83| 11.4M|isReservedAnd(u8 c) { 84| 11.4M| return (c == '/' || c == '.' || c == '<' || c == '>' || ------------------ | Branch (84:13): [True: 106k, False: 11.3M] | Branch (84:25): [True: 148k, False: 11.2M] | Branch (84:37): [True: 13.7k, False: 11.1M] | Branch (84:49): [True: 846, False: 11.1M] ------------------ 85| 11.1M| c == ':' || c == '#' || c == '!' || c == '&'); ------------------ | Branch (85:13): [True: 30.3k, False: 11.1M] | Branch (85:25): [True: 1.96k, False: 11.1M] | Branch (85:37): [True: 7.26k, False: 11.1M] | Branch (85:49): [True: 12.2k, False: 11.1M] ------------------ 86| 11.4M|} ua_util.c:isReservedPercent: 95| 11.1M|isReservedPercent(u8 c) { 96| 11.1M| return (c == ';' || c == '%' || c <= ' ' || c == 127); ------------------ | Branch (96:13): [True: 1.35k, False: 11.1M] | Branch (96:26): [True: 12.2k, False: 11.0M] | Branch (96:38): [True: 5.16M, False: 5.93M] | Branch (96:50): [True: 3.56M, False: 2.36M] ------------------ 97| 11.1M|} ua_util.c:isReservedPercentExtended: 100| 11.1M|isReservedPercentExtended(u8 c) { 101| 11.1M| return (isReservedPercent(c) || c == ':' || c == '#' || c == '[' || c == ']' || ------------------ | Branch (101:13): [True: 8.74M, False: 2.36M] | Branch (101:37): [True: 29.5k, False: 2.34M] | Branch (101:49): [True: 1.75k, False: 2.33M] | Branch (101:61): [True: 4.31k, False: 2.33M] | Branch (101:73): [True: 2.70k, False: 2.33M] ------------------ 102| 2.33M| c == '&' || c == '(' || c == ')' || c == ',' || c == '<' || c == '>' || ------------------ | Branch (102:13): [True: 10.7k, False: 2.32M] | Branch (102:25): [True: 9.00k, False: 2.31M] | Branch (102:37): [True: 613, False: 2.31M] | Branch (102:49): [True: 11.0k, False: 2.29M] | Branch (102:61): [True: 13.5k, False: 2.28M] | Branch (102:73): [True: 337, False: 2.28M] ------------------ 103| 2.28M| c == '`' || c == '/' || c == '\\' || c == '"' || c == '\'' ); ------------------ | Branch (103:13): [True: 12.1k, False: 2.27M] | Branch (103:25): [True: 106k, False: 2.16M] | Branch (103:37): [True: 2.76k, False: 2.16M] | Branch (103:50): [True: 24.6k, False: 2.14M] | Branch (103:62): [True: 77.0k, False: 2.06M] ------------------ 104| 11.1M|} ua_types_lex.c:isReservedPercentExtended: 100| 6.45k|isReservedPercentExtended(u8 c) { 101| 6.45k| return (isReservedPercent(c) || c == ':' || c == '#' || c == '[' || c == ']' || ------------------ | Branch (101:13): [True: 24, False: 6.43k] | Branch (101:37): [True: 2, False: 6.43k] | Branch (101:49): [True: 4, False: 6.42k] | Branch (101:61): [True: 7, False: 6.41k] | Branch (101:73): [True: 4, False: 6.41k] ------------------ 102| 6.41k| c == '&' || c == '(' || c == ')' || c == ',' || c == '<' || c == '>' || ------------------ | Branch (102:13): [True: 2, False: 6.41k] | Branch (102:25): [True: 2, False: 6.41k] | Branch (102:37): [True: 3, False: 6.40k] | Branch (102:49): [True: 2, False: 6.40k] | Branch (102:61): [True: 714, False: 5.69k] | Branch (102:73): [True: 6, False: 5.68k] ------------------ 103| 5.68k| c == '`' || c == '/' || c == '\\' || c == '"' || c == '\'' ); ------------------ | Branch (103:13): [True: 3, False: 5.68k] | Branch (103:25): [True: 2.34k, False: 3.33k] | Branch (103:37): [True: 2, False: 3.33k] | Branch (103:50): [True: 2, False: 3.33k] | Branch (103:62): [True: 3, False: 3.33k] ------------------ 104| 6.45k|} ua_types_lex.c:isReservedPercent: 95| 6.45k|isReservedPercent(u8 c) { 96| 6.45k| return (c == ';' || c == '%' || c <= ' ' || c == 127); ------------------ | Branch (96:13): [True: 4, False: 6.45k] | Branch (96:26): [True: 0, False: 6.45k] | Branch (96:38): [True: 17, False: 6.43k] | Branch (96:50): [True: 3, False: 6.43k] ------------------ 97| 6.45k|} ua_types_lex.c:isReservedAnd: 83| 81.3k|isReservedAnd(u8 c) { 84| 81.3k| return (c == '/' || c == '.' || c == '<' || c == '>' || ------------------ | Branch (84:13): [True: 2.55k, False: 78.8k] | Branch (84:25): [True: 1.67k, False: 77.1k] | Branch (84:37): [True: 5.68k, False: 71.4k] | Branch (84:49): [True: 1, False: 71.4k] ------------------ 85| 71.4k| c == ':' || c == '#' || c == '!' || c == '&'); ------------------ | Branch (85:13): [True: 1, False: 71.4k] | Branch (85:25): [True: 2, False: 71.4k] | Branch (85:37): [True: 1, False: 71.4k] | Branch (85:49): [True: 0, False: 71.4k] ------------------ 86| 81.3k|} LLVMFuzzerTestOneInput: 14| 3.69k|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 15| 3.69k| if(size <= 1) ------------------ | Branch (15:8): [True: 1, False: 3.69k] ------------------ 16| 1| return 0; 17| | 18| | /* Use the first byte as a selector to choose which parsing function to fuzz */ 19| 3.69k| uint8_t selector = data[0]; 20| 3.69k| const uint8_t *payload = data + 1; 21| 3.69k| size_t payload_size = size - 1; 22| | 23| 3.69k| UA_String str; 24| 3.69k| UA_StatusCode retval = UA_ByteString_allocBuffer(&str, payload_size); 25| 3.69k| if(retval != UA_STATUSCODE_GOOD) ------------------ | | 17| 3.69k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (25:8): [True: 0, False: 3.69k] ------------------ 26| 0| return 0; 27| 3.69k| memcpy(str.data, payload, payload_size); 28| | 29| 3.69k| switch(selector % 8) { 30| 170| case 0: { ------------------ | Branch (30:5): [True: 170, False: 3.52k] ------------------ 31| 170| UA_NodeId id; 32| 170| UA_NodeId_init(&id); 33| 170| UA_NodeId_parse(&id, str); 34| 170| UA_NodeId_clear(&id); 35| 170| break; 36| 0| } 37| 817| case 1: { ------------------ | Branch (37:5): [True: 817, False: 2.87k] ------------------ 38| 817| UA_DateTime dt; 39| 817| UA_DateTime_parse(&dt, str); 40| 817| break; 41| 0| } 42| 58| case 2: { ------------------ | Branch (42:5): [True: 58, False: 3.63k] ------------------ 43| 58| UA_Guid guid; 44| 58| UA_Guid_init(&guid); 45| 58| UA_Guid_parse(&guid, str); 46| 58| break; 47| 0| } 48| 476| case 3: { ------------------ | Branch (48:5): [True: 476, False: 3.21k] ------------------ 49| 476| UA_ExpandedNodeId enid; 50| 476| UA_ExpandedNodeId_init(&enid); 51| 476| UA_ExpandedNodeId_parse(&enid, str); 52| 476| UA_ExpandedNodeId_clear(&enid); 53| 476| break; 54| 0| } 55| 152| case 4: { ------------------ | Branch (55:5): [True: 152, False: 3.54k] ------------------ 56| 152| UA_QualifiedName qn; 57| 152| UA_QualifiedName_init(&qn); 58| 152| UA_QualifiedName_parse(&qn, str); 59| 152| UA_QualifiedName_clear(&qn); 60| 152| break; 61| 0| } 62| 1.00k| case 5: { ------------------ | Branch (62:5): [True: 1.00k, False: 2.68k] ------------------ 63| 1.00k| UA_RelativePath rp; 64| 1.00k| UA_RelativePath_init(&rp); 65| 1.00k| UA_StatusCode ret = UA_RelativePath_parse(&rp, str); 66| 1.00k| if(ret == UA_STATUSCODE_GOOD) { ------------------ | | 17| 1.00k|#define UA_STATUSCODE_GOOD ((UA_StatusCode) 0x00000000) ------------------ | Branch (66:12): [True: 761, False: 247] ------------------ 67| 761| UA_String printed = UA_STRING_NULL; 68| 761| UA_RelativePath_print(&rp, &printed); 69| 761| UA_String_clear(&printed); 70| 761| } 71| 1.00k| UA_RelativePath_clear(&rp); 72| 1.00k| break; 73| 0| } 74| 585| case 6: { ------------------ | Branch (74:5): [True: 585, False: 3.10k] ------------------ 75| 585| UA_SimpleAttributeOperand sao; 76| 585| UA_SimpleAttributeOperand_init(&sao); 77| 585| UA_SimpleAttributeOperand_parse(&sao, str); 78| 585| UA_SimpleAttributeOperand_clear(&sao); 79| 585| break; 80| 0| } 81| 426| case 7: { ------------------ | Branch (81:5): [True: 426, False: 3.26k] ------------------ 82| 426| UA_ReadValueId rvi; 83| 426| UA_ReadValueId_init(&rvi); 84| 426| UA_ReadValueId_parse(&rvi, str); 85| 426| UA_ReadValueId_clear(&rvi); 86| 426| break; 87| 0| } 88| 0| default: break; ------------------ | Branch (88:5): [True: 0, False: 3.69k] ------------------ 89| 3.69k| } 90| | 91| 3.69k| UA_String_clear(&str); 92| 3.69k| return 0; 93| 3.69k|} fuzz_parse_string.cc:_ZL14UA_NodeId_initP9UA_NodeId: 243| 170|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL15UA_NodeId_clearP9UA_NodeId: 243| 170|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL12UA_Guid_initP7UA_Guid: 243| 58|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL22UA_ExpandedNodeId_initP17UA_ExpandedNodeId: 243| 476|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL23UA_ExpandedNodeId_clearP17UA_ExpandedNodeId: 243| 476|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL21UA_QualifiedName_initP16UA_QualifiedName: 243| 152|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL22UA_QualifiedName_clearP16UA_QualifiedName: 243| 152|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL20UA_RelativePath_initP15UA_RelativePath: 243| 1.00k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL15UA_String_clearP9UA_String: 243| 4.45k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL21UA_RelativePath_clearP15UA_RelativePath: 243| 1.00k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL30UA_SimpleAttributeOperand_initP25UA_SimpleAttributeOperand: 243| 585|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL31UA_SimpleAttributeOperand_clearP25UA_SimpleAttributeOperand: 243| 585|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL19UA_ReadValueId_initP14UA_ReadValueId: 243| 426|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl fuzz_parse_string.cc:_ZL20UA_ReadValueId_clearP14UA_ReadValueId: 243| 426|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types.c:UA_ByteString_init: 243| 4.38k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_String_init: 243| 690|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_String_equal: 243| 11.6k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_String_clear: 243| 690|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_util.c:UA_NodeId_equal: 243| 14.6k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_String_copy: 243| 18.0k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_NodeId_clear: 243| 163|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_ExpandedNodeId_clear: 243| 403|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_QualifiedName_clear: 243| 1.16k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePath_init: 243| 1.94k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePathElement_init: 243| 14.8k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePathElement_clear: 243| 620|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_RelativePath_clear: 243| 247|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_AttributeOperand_init: 243| 1.01k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_SimpleAttributeOperand_init: 243| 127|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_String_init: 243| 127|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_NodeId_init: 243| 127|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_NodeId_equal: 243| 1.51k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_QualifiedName_init: 243| 16.6k|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_AttributeOperand_clear: 243| 999|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_SimpleAttributeOperand_clear: 243| 45|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl ua_types_lex.c:UA_ReadValueId_init: 243| 12|# define UA_INLINABLE(decl, impl) static UA_INLINE decl impl