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