flb_utils.c:flb_log_check: 103| 204M|static inline int flb_log_check(int l) { 104| 204M| struct flb_worker *w; 105| 204M| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 204M|#define FLB_TLS_GET(key) key ------------------ 106| 204M| if (!w && l <= 3) { ------------------ | Branch (106:9): [True: 204M, False: 0] | Branch (106:15): [True: 2.10k, False: 204M] ------------------ 107| 2.10k| return FLB_TRUE; ------------------ | | 26| 2.10k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2.10k|#define FLB_FALSE 0 | | ------------------ ------------------ 108| 2.10k| } 109| | 110| 204M| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (110:9): [True: 204M, False: 0] | Branch (110:22): [True: 0, False: 0] ------------------ 111| 204M| return FLB_FALSE; ------------------ | | 25| 204M|#define FLB_FALSE 0 ------------------ 112| 204M| } 113| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 114| 204M|} flb_gzip.c:flb_log_check: 103| 1.71k|static inline int flb_log_check(int l) { 104| 1.71k| struct flb_worker *w; 105| 1.71k| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 1.71k|#define FLB_TLS_GET(key) key ------------------ 106| 1.71k| if (!w && l <= 3) { ------------------ | Branch (106:9): [True: 1.71k, False: 0] | Branch (106:15): [True: 1.71k, False: 0] ------------------ 107| 1.71k| return FLB_TRUE; ------------------ | | 26| 1.71k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 1.71k|#define FLB_FALSE 0 | | ------------------ ------------------ 108| 1.71k| } 109| | 110| 0| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (110:9): [True: 0, False: 0] | Branch (110:22): [True: 0, False: 0] ------------------ 111| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 112| 0| } 113| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 114| 0|} flb_log.c:flb_log_check: 103| 69|static inline int flb_log_check(int l) { 104| 69| struct flb_worker *w; 105| 69| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 69|#define FLB_TLS_GET(key) key ------------------ 106| 69| if (!w && l <= 3) { ------------------ | Branch (106:9): [True: 69, False: 0] | Branch (106:15): [True: 69, False: 0] ------------------ 107| 69| return FLB_TRUE; ------------------ | | 26| 69|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 69|#define FLB_FALSE 0 | | ------------------ ------------------ 108| 69| } 109| | 110| 0| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (110:9): [True: 0, False: 0] | Branch (110:22): [True: 0, False: 0] ------------------ 111| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 112| 0| } 113| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 114| 0|} utils_fuzzer.c:flb_malloc: 67| 6.12k|void *flb_malloc(const size_t size) { 68| | 69| 6.12k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 6.12k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 6.12k] ------------------ 72| 0| return NULL; 73| 0| } 74| 6.12k|#endif 75| | 76| 6.12k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 6.12k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 6.12k| return malloc(size); 81| 6.12k|} utils_fuzzer.c:flb_fuzz_get_probability: 56| 6.12k|static inline int flb_fuzz_get_probability(int val) { 57| 6.12k| flb_malloc_p += 1; 58| 6.12k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 6.12k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 6.12k] ------------------ 60| 0| return 1; 61| 0| } 62| 6.12k| return 0; 63| 6.12k|} utils_fuzzer.c:flb_free: 126| 519k|static inline void flb_free(void *ptr) { 127| 519k| free(ptr); 128| 519k|} flb_uri.c:flb_calloc: 84| 2.04k|void *flb_calloc(size_t n, const size_t size) { 85| 2.04k| if (size == 0) { ------------------ | Branch (85:9): [True: 0, False: 2.04k] ------------------ 86| 0| return NULL; 87| 0| } 88| 2.04k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 89| | // Add chance of failure. Used by fuzzing to test error-handling code. 90| 2.04k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (90:8): [True: 0, False: 2.04k] ------------------ 91| 0| return NULL; 92| 0| } 93| 2.04k|#endif 94| | 95| 2.04k| return calloc(n, size); 96| 2.04k|} flb_uri.c:flb_fuzz_get_probability: 56| 7.97k|static inline int flb_fuzz_get_probability(int val) { 57| 7.97k| flb_malloc_p += 1; 58| 7.97k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 7.97k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 7.97k] ------------------ 60| 0| return 1; 61| 0| } 62| 7.97k| return 0; 63| 7.97k|} flb_uri.c:flb_malloc: 67| 5.93k|void *flb_malloc(const size_t size) { 68| | 69| 5.93k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 5.93k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 5.93k] ------------------ 72| 0| return NULL; 73| 0| } 74| 5.93k|#endif 75| | 76| 5.93k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 5.93k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 5.93k| return malloc(size); 81| 5.93k|} flb_uri.c:flb_free: 126| 7.97k|static inline void flb_free(void *ptr) { 127| 7.97k| free(ptr); 128| 7.97k|} flb_hash_table.c:flb_calloc: 84| 161k|void *flb_calloc(size_t n, const size_t size) { 85| 161k| if (size == 0) { ------------------ | Branch (85:9): [True: 0, False: 161k] ------------------ 86| 0| return NULL; 87| 0| } 88| 161k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 89| | // Add chance of failure. Used by fuzzing to test error-handling code. 90| 161k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (90:8): [True: 0, False: 161k] ------------------ 91| 0| return NULL; 92| 0| } 93| 161k|#endif 94| | 95| 161k| return calloc(n, size); 96| 161k|} flb_hash_table.c:flb_fuzz_get_probability: 56| 574k|static inline int flb_fuzz_get_probability(int val) { 57| 574k| flb_malloc_p += 1; 58| 574k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 574k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 574k] ------------------ 60| 0| return 1; 61| 0| } 62| 574k| return 0; 63| 574k|} flb_hash_table.c:flb_free: 126| 574k|static inline void flb_free(void *ptr) { 127| 574k| free(ptr); 128| 574k|} flb_hash_table.c:flb_malloc: 67| 413k|void *flb_malloc(const size_t size) { 68| | 69| 413k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 413k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 413k] ------------------ 72| 0| return NULL; 73| 0| } 74| 413k|#endif 75| | 76| 413k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 413k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 413k| return malloc(size); 81| 413k|} flb_sds.c:flb_malloc: 67| 6.12k|void *flb_malloc(const size_t size) { 68| | 69| 6.12k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 6.12k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 6.12k] ------------------ 72| 0| return NULL; 73| 0| } 74| 6.12k|#endif 75| | 76| 6.12k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 6.12k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 6.12k| return malloc(size); 81| 6.12k|} flb_sds.c:flb_fuzz_get_probability: 56| 6.12k|static inline int flb_fuzz_get_probability(int val) { 57| 6.12k| flb_malloc_p += 1; 58| 6.12k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 6.12k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 6.12k] ------------------ 60| 0| return 1; 61| 0| } 62| 6.12k| return 0; 63| 6.12k|} flb_sds.c:flb_realloc: 100| 975k|{ 101| 975k| return realloc(ptr, size); 102| 975k|} flb_sds.c:flb_free: 126| 6.12k|static inline void flb_free(void *ptr) { 127| 6.12k| free(ptr); 128| 6.12k|} flb_utils.c:flb_free: 126| 14.8k|static inline void flb_free(void *ptr) { 127| 14.8k| free(ptr); 128| 14.8k|} flb_utils.c:flb_malloc: 67| 11.9k|void *flb_malloc(const size_t size) { 68| | 69| 11.9k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 11.9k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 11.9k] ------------------ 72| 0| return NULL; 73| 0| } 74| 11.9k|#endif 75| | 76| 11.9k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 11.9k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 11.9k| return malloc(size); 81| 11.9k|} flb_utils.c:flb_fuzz_get_probability: 56| 11.9k|static inline int flb_fuzz_get_probability(int val) { 57| 11.9k| flb_malloc_p += 1; 58| 11.9k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 11.9k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 11.9k] ------------------ 60| 0| return 1; 61| 0| } 62| 11.9k| return 0; 63| 11.9k|} flb_utils.c:flb_realloc: 100| 53.2k|{ 101| 53.2k| return realloc(ptr, size); 102| 53.2k|} flb_slist.c:flb_malloc: 67| 2.04k|void *flb_malloc(const size_t size) { 68| | 69| 2.04k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 2.04k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 2.04k] ------------------ 72| 0| return NULL; 73| 0| } 74| 2.04k|#endif 75| | 76| 2.04k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 2.04k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 2.04k| return malloc(size); 81| 2.04k|} flb_slist.c:flb_fuzz_get_probability: 56| 2.04k|static inline int flb_fuzz_get_probability(int val) { 57| 2.04k| flb_malloc_p += 1; 58| 2.04k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 2.04k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 2.04k] ------------------ 60| 0| return 1; 61| 0| } 62| 2.04k| return 0; 63| 2.04k|} flb_slist.c:flb_free: 126| 2.04k|static inline void flb_free(void *ptr) { 127| 2.04k| free(ptr); 128| 2.04k|} flb_gzip.c:flb_malloc: 67| 4.48k|void *flb_malloc(const size_t size) { 68| | 69| 4.48k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 4.48k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 4.48k] ------------------ 72| 0| return NULL; 73| 0| } 74| 4.48k|#endif 75| | 76| 4.48k| if (size == 0) { ------------------ | Branch (76:9): [True: 2, False: 4.48k] ------------------ 77| 2| return NULL; 78| 2| } 79| | 80| 4.48k| return malloc(size); 81| 4.48k|} flb_gzip.c:flb_fuzz_get_probability: 56| 4.48k|static inline int flb_fuzz_get_probability(int val) { 57| 4.48k| flb_malloc_p += 1; 58| 4.48k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 4.48k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 4.48k] ------------------ 60| 0| return 1; 61| 0| } 62| 4.48k| return 0; 63| 4.48k|} flb_gzip.c:flb_free: 126| 400|static inline void flb_free(void *ptr) { 127| 400| free(ptr); 128| 400|} flb_regex.c:flb_malloc: 67| 2.04k|void *flb_malloc(const size_t size) { 68| | 69| 2.04k|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 2.04k| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 0, False: 2.04k] ------------------ 72| 0| return NULL; 73| 0| } 74| 2.04k|#endif 75| | 76| 2.04k| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 2.04k] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 2.04k| return malloc(size); 81| 2.04k|} flb_regex.c:flb_fuzz_get_probability: 56| 2.04k|static inline int flb_fuzz_get_probability(int val) { 57| 2.04k| flb_malloc_p += 1; 58| 2.04k| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 2.04k| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 0, False: 2.04k] ------------------ 60| 0| return 1; 61| 0| } 62| 2.04k| return 0; 63| 2.04k|} flb_regex.c:flb_free: 126| 2.04k|static inline void flb_free(void *ptr) { 127| 2.04k| free(ptr); 128| 2.04k|} flb_sds.c:flb_sds_alloc: 68| 975k|{ 69| 975k| return (size_t) FLB_SDS_HEADER(s)->alloc; ------------------ | | 46| 975k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 975k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 70| 975k|} flb_sds.c:flb_sds_avail: 73| 18.8M|{ 74| 18.8M| struct flb_sds *h; 75| | 76| 18.8M| h = FLB_SDS_HEADER(s); ------------------ | | 46| 18.8M|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 18.8M|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 77| 18.8M| return (size_t) (h->alloc - h->len); 78| 18.8M|} flb_sds.c:flb_sds_len: 49| 8.34M|{ 50| 8.34M| return (size_t) FLB_SDS_HEADER(s)->len; ------------------ | | 46| 8.34M|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 8.34M|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 51| 8.34M|} flb_utils.c:flb_vector8_load: 92| 596M|{ 93| |#if defined(FLB_SIMD_SSE2) 94| | *v = _mm_loadu_si128((const __m128i *) s); 95| |#elif defined(FLB_SIMD_NEON) 96| | *v = vld1q_u8(s); 97| |#else 98| 596M| memset(v, 0, sizeof(flb_vector8)); 99| 596M|#endif 100| 596M|} flb_utils.c:flb_vector8_has_le: 207| 596M|{ 208| 596M| bool result = false; 209| | 210| 596M|#if defined(FLB_SIMD_NONE) 211| | /* 212| | * To find bytes <= c, we can use bitwise operations to find bytes < c+1, 213| | * but it only works if c+1 <= 128 and if the highest bit in v is not set. 214| | * 215| | * Adapted from 216| | * 217| | * https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord 218| | */ 219| 596M| if ((int64_t) v >= 0 && c < 0x80) { ------------------ | Branch (219:6): [True: 596M, False: 0] | Branch (219:26): [True: 596M, False: 0] ------------------ 220| 596M| result = (v - flb_vector8_broadcast(c + 1)) & ~v & flb_vector8_broadcast(0x80); 221| 596M| } 222| 0| else { 223| 0| size_t i; 224| 0| for (i = 0; i < sizeof(flb_vector8); i++) { ------------------ | Branch (224:16): [True: 0, False: 0] ------------------ 225| 0| if (((const uint8_t *) &v)[i] <= c) { ------------------ | Branch (225:8): [True: 0, False: 0] ------------------ 226| 0| result = true; 227| 0| break; 228| 0| } 229| 0| } 230| 0| } 231| | 232| 596M| return result; 233| |#else 234| | /* 235| | * Use saturating subtraction to find bytes <= c, which will present as 236| | * NUL bytes. This approach is a workaround for the lack of unsigned 237| | * comparison instructions on some architectures. 238| | */ 239| | result = flb_vector8_has_zero(flb_vector8_ssub(v, flb_vector8_broadcast(c))); 240| |#endif 241| | 242| 0| return result; 243| 596M|} flb_utils.c:flb_vector8_broadcast: 166| 1.19G|{ 167| |#if defined(FLB_SIMD_SSE2) 168| | return _mm_set1_epi8(c); 169| |#elif defined(FLB_SIMD_NEON) 170| | return vdupq_n_u8(c); 171| |#else 172| 1.19G| return ~UINT64CONST(0) / 0xFF * c; ------------------ | | 27| 1.19G|#define UINT64CONST(x) (x##ULL) ------------------ 173| 1.19G|#endif 174| 1.19G|} flb_uri.c:flb_strdup: 45| 5.93k|{ 46| 5.93k| return flb_strndup(s, strlen(s)); 47| 5.93k|} flb_uri.c:flb_strndup: 31| 5.93k|{ 32| 5.93k| char *str; 33| | 34| 5.93k| str = (char *) flb_malloc(n + 1); 35| 5.93k| if (!str) { ------------------ | Branch (35:9): [True: 0, False: 5.93k] ------------------ 36| 0| return NULL; 37| 0| } 38| 5.93k| memcpy(str, s, n); 39| 5.93k| str[n] = '\0'; 40| | 41| 5.93k| return str; 42| 5.93k|} flb_hash_table.c:flb_strndup: 31| 157k|{ 32| 157k| char *str; 33| | 34| 157k| str = (char *) flb_malloc(n + 1); 35| 157k| if (!str) { ------------------ | Branch (35:9): [True: 0, False: 157k] ------------------ 36| 0| return NULL; 37| 0| } 38| 157k| memcpy(str, s, n); 39| 157k| str[n] = '\0'; 40| | 41| 157k| return str; 42| 157k|} flb_utils.c:flb_strdup: 45| 569|{ 46| 569| return flb_strndup(s, strlen(s)); 47| 569|} flb_utils.c:flb_strndup: 31| 569|{ 32| 569| char *str; 33| | 34| 569| str = (char *) flb_malloc(n + 1); 35| 569| if (!str) { ------------------ | Branch (35:9): [True: 0, False: 569] ------------------ 36| 0| return NULL; 37| 0| } 38| 569| memcpy(str, s, n); 39| 569| str[n] = '\0'; 40| | 41| 569| return str; 42| 569|} flb_uri.c:flb_uri_to_encode: 44| 8.34M|{ 45| 8.34M| if ((c >= 48 && c <= 57) || /* 0-9 */ ------------------ | Branch (45:10): [True: 3.73M, False: 4.60M] | Branch (45:21): [True: 2.01M, False: 1.72M] ------------------ 46| 8.34M| (c >= 65 && c <= 90) || /* A-Z */ ------------------ | Branch (46:10): [True: 1.62M, False: 4.70M] | Branch (46:21): [True: 412k, False: 1.21M] ------------------ 47| 8.34M| (c >= 97 && c <= 122) || /* a-z */ ------------------ | Branch (47:10): [True: 1.10M, False: 4.81M] | Branch (47:21): [True: 1.02M, False: 74.1k] ------------------ 48| 8.34M| (c == '?' || c == '&' || c == '-' || c == '_' || c == '.' || ------------------ | Branch (48:10): [True: 14.0k, False: 4.87M] | Branch (48:22): [True: 13.0k, False: 4.86M] | Branch (48:34): [True: 16.2k, False: 4.84M] | Branch (48:46): [True: 27.7k, False: 4.81M] | Branch (48:58): [True: 13.2k, False: 4.80M] ------------------ 49| 4.88M| c == '~' || c == '/' || c == '=')) { ------------------ | Branch (49:10): [True: 13.5k, False: 4.79M] | Branch (49:22): [True: 29.9k, False: 4.76M] | Branch (49:34): [True: 13.7k, False: 4.74M] ------------------ 50| 3.59M| return FLB_FALSE; ------------------ | | 25| 3.59M|#define FLB_FALSE 0 ------------------ 51| 3.59M| } 52| | 53| 4.74M| return FLB_TRUE; ------------------ | | 26| 4.74M|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 4.74M|#define FLB_FALSE 0 | | ------------------ ------------------ 54| 8.34M|} flb_hash_table.c:XXH_INLINE_XXH3_64bits: 4562| 420k|{ 4563| 420k| return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default); 4564| 420k|} flb_hash_table.c:XXH3_64bits_internal: 4539| 420k|{ 4540| 420k| XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN); ------------------ | | 1543| 420k|# define XXH_ASSERT(c) ((void)0) ------------------ 4541| | /* 4542| | * If an action is to be taken if `secretLen` condition is not respected, 4543| | * it should be done here. 4544| | * For now, it's a contract pre-condition. 4545| | * Adding a check and a branch here would cost performance at every hash. 4546| | * Also, note that function signature doesn't offer room to return an error. 4547| | */ 4548| 420k| if (len <= 16) ------------------ | Branch (4548:9): [True: 411k, False: 9.21k] ------------------ 4549| 411k| return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64); 4550| 9.21k| if (len <= 128) ------------------ | Branch (4550:9): [True: 3.26k, False: 5.94k] ------------------ 4551| 3.26k| return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); 4552| 5.94k| if (len <= XXH3_MIDSIZE_MAX) ------------------ | | 3599| 5.94k|#define XXH3_MIDSIZE_MAX 240 ------------------ | Branch (4552:9): [True: 0, False: 5.94k] ------------------ 4553| 0| return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64); 4554| 5.94k| return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen); 4555| 5.94k|} flb_hash_table.c:XXH3_len_0to16_64b: 3503| 411k|{ 3504| 411k| XXH_ASSERT(len <= 16); ------------------ | | 1543| 411k|# define XXH_ASSERT(c) ((void)0) ------------------ 3505| 411k| { if (XXH_likely(len > 8)) return XXH3_len_9to16_64b(input, len, secret, seed); ------------------ | | 2703| 411k|# define XXH_likely(x) __builtin_expect(x, 1) | | ------------------ | | | Branch (2703:27): [True: 567, False: 411k] | | ------------------ ------------------ 3506| 411k| if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed); ------------------ | | 2703| 411k|# define XXH_likely(x) __builtin_expect(x, 1) | | ------------------ | | | Branch (2703:27): [True: 1.04k, False: 409k] | | ------------------ ------------------ 3507| 409k| if (len) return XXH3_len_1to3_64b(input, len, secret, seed); ------------------ | Branch (3507:13): [True: 409k, False: 201] ------------------ 3508| 201| return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64))); 3509| 409k| } 3510| 409k|} flb_hash_table.c:XXH3_len_9to16_64b: 3486| 567|{ 3487| 567| XXH_ASSERT(input != NULL); ------------------ | | 1543| 567|# define XXH_ASSERT(c) ((void)0) ------------------ 3488| 567| XXH_ASSERT(secret != NULL); ------------------ | | 1543| 567|# define XXH_ASSERT(c) ((void)0) ------------------ 3489| 567| XXH_ASSERT(9 <= len && len <= 16); ------------------ | | 1543| 567|# define XXH_ASSERT(c) ((void)0) ------------------ 3490| 567| { xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed; 3491| 567| xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed; 3492| 567| xxh_u64 const input_lo = XXH_readLE64(input) ^ bitflip1; 3493| 567| xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2; 3494| 567| xxh_u64 const acc = len 3495| 567| + XXH_swap64(input_lo) + input_hi 3496| 567| + XXH3_mul128_fold64(input_lo, input_hi); 3497| 567| return XXH3_avalanche(acc); 3498| 567| } 3499| 567|} flb_hash_table.c:XXH_swap64: 2345| 567|{ 2346| 567| return ((x << 56) & 0xff00000000000000ULL) | 2347| 567| ((x << 40) & 0x00ff000000000000ULL) | 2348| 567| ((x << 24) & 0x0000ff0000000000ULL) | 2349| 567| ((x << 8) & 0x000000ff00000000ULL) | 2350| 567| ((x >> 8) & 0x00000000ff000000ULL) | 2351| 567| ((x >> 24) & 0x0000000000ff0000ULL) | 2352| 567| ((x >> 40) & 0x000000000000ff00ULL) | 2353| 567| ((x >> 56) & 0x00000000000000ffULL); 2354| 567|} flb_hash_table.c:XXH3_mul128_fold64: 3373| 30.8k|{ 3374| 30.8k| XXH128_hash_t product = XXH_mult64to128(lhs, rhs); ------------------ | | 210| 30.8k|# define XXH128_hash_t XXH_IPREF(XXH128_hash_t) | | ------------------ | | | | 197| 30.8k|# define XXH_IPREF(Id) XXH_NAMESPACE ## Id | | ------------------ ------------------ 3375| 30.8k| return product.low64 ^ product.high64; 3376| 30.8k|} flb_hash_table.c:XXH_mult64to128: 3239| 30.8k|{ 3240| | /* 3241| | * GCC/Clang __uint128_t method. 3242| | * 3243| | * On most 64-bit targets, GCC and Clang define a __uint128_t type. 3244| | * This is usually the best way as it usually uses a native long 64-bit 3245| | * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64. 3246| | * 3247| | * Usually. 3248| | * 3249| | * Despite being a 32-bit platform, Clang (and emscripten) define this type 3250| | * despite not having the arithmetic for it. This results in a laggy 3251| | * compiler builtin call which calculates a full 128-bit multiply. 3252| | * In that case it is best to use the portable one. 3253| | * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677 3254| | */ 3255| 30.8k|#if defined(__GNUC__) && !defined(__wasm__) \ 3256| 30.8k| && defined(__SIZEOF_INT128__) \ 3257| 30.8k| || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128) 3258| | 3259| 30.8k| __uint128_t const product = (__uint128_t)lhs * (__uint128_t)rhs; 3260| 30.8k| XXH128_hash_t r128; ------------------ | | 210| 30.8k|# define XXH128_hash_t XXH_IPREF(XXH128_hash_t) | | ------------------ | | | | 197| 30.8k|# define XXH_IPREF(Id) XXH_NAMESPACE ## Id | | ------------------ ------------------ 3261| 30.8k| r128.low64 = (xxh_u64)(product); 3262| 30.8k| r128.high64 = (xxh_u64)(product >> 64); 3263| 30.8k| return r128; 3264| | 3265| | /* 3266| | * MSVC for x64's _umul128 method. 3267| | * 3268| | * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct); 3269| | * 3270| | * This compiles to single operand MUL on x64. 3271| | */ 3272| |#elif defined(_M_X64) || defined(_M_IA64) 3273| | 3274| |#ifndef _MSC_VER 3275| |# pragma intrinsic(_umul128) 3276| |#endif 3277| | xxh_u64 product_high; 3278| | xxh_u64 const product_low = _umul128(lhs, rhs, &product_high); 3279| | XXH128_hash_t r128; 3280| | r128.low64 = product_low; 3281| | r128.high64 = product_high; 3282| | return r128; 3283| | 3284| | /* 3285| | * MSVC for ARM64's __umulh method. 3286| | * 3287| | * This compiles to the same MUL + UMULH as GCC/Clang's __uint128_t method. 3288| | */ 3289| |#elif defined(_M_ARM64) 3290| | 3291| |#ifndef _MSC_VER 3292| |# pragma intrinsic(__umulh) 3293| |#endif 3294| | XXH128_hash_t r128; 3295| | r128.low64 = lhs * rhs; 3296| | r128.high64 = __umulh(lhs, rhs); 3297| | return r128; 3298| | 3299| |#else 3300| | /* 3301| | * Portable scalar method. Optimized for 32-bit and 64-bit ALUs. 3302| | * 3303| | * This is a fast and simple grade school multiply, which is shown below 3304| | * with base 10 arithmetic instead of base 0x100000000. 3305| | * 3306| | * 9 3 // D2 lhs = 93 3307| | * x 7 5 // D2 rhs = 75 3308| | * ---------- 3309| | * 1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15 3310| | * 4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45 3311| | * 2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21 3312| | * + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63 3313| | * --------- 3314| | * 2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27 3315| | * + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67 3316| | * --------- 3317| | * 6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975 3318| | * 3319| | * The reasons for adding the products like this are: 3320| | * 1. It avoids manual carry tracking. Just like how 3321| | * (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX. 3322| | * This avoids a lot of complexity. 3323| | * 3324| | * 2. It hints for, and on Clang, compiles to, the powerful UMAAL 3325| | * instruction available in ARM's Digital Signal Processing extension 3326| | * in 32-bit ARMv6 and later, which is shown below: 3327| | * 3328| | * void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm) 3329| | * { 3330| | * xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm; 3331| | * *RdLo = (xxh_u32)(product & 0xFFFFFFFF); 3332| | * *RdHi = (xxh_u32)(product >> 32); 3333| | * } 3334| | * 3335| | * This instruction was designed for efficient long multiplication, and 3336| | * allows this to be calculated in only 4 instructions at speeds 3337| | * comparable to some 64-bit ALUs. 3338| | * 3339| | * 3. It isn't terrible on other platforms. Usually this will be a couple 3340| | * of 32-bit ADD/ADCs. 3341| | */ 3342| | 3343| | /* First calculate all of the cross products. */ 3344| | xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF); 3345| | xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32, rhs & 0xFFFFFFFF); 3346| | xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32); 3347| | xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32, rhs >> 32); 3348| | 3349| | /* Now add the products together. These will never overflow. */ 3350| | xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi; 3351| | xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32) + hi_hi; 3352| | xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF); 3353| | 3354| | XXH128_hash_t r128; 3355| | r128.low64 = lower; 3356| | r128.high64 = upper; 3357| | return r128; 3358| |#endif 3359| 30.8k|} flb_hash_table.c:XXH3_avalanche: 3390| 9.78k|{ 3391| 9.78k| h64 = XXH_xorshift64(h64, 37); 3392| 9.78k| h64 *= 0x165667919E3779F9ULL; 3393| 9.78k| h64 = XXH_xorshift64(h64, 32); 3394| 9.78k| return h64; 3395| 9.78k|} flb_hash_table.c:XXH_xorshift64: 3380| 20.6k|{ 3381| 20.6k| XXH_ASSERT(0 <= shift && shift < 64); ------------------ | | 1543| 20.6k|# define XXH_ASSERT(c) ((void)0) ------------------ 3382| 20.6k| return v64 ^ (v64 >> shift); 3383| 20.6k|} flb_hash_table.c:XXH3_len_4to8_64b: 3470| 1.04k|{ 3471| 1.04k| XXH_ASSERT(input != NULL); ------------------ | | 1543| 1.04k|# define XXH_ASSERT(c) ((void)0) ------------------ 3472| 1.04k| XXH_ASSERT(secret != NULL); ------------------ | | 1543| 1.04k|# define XXH_ASSERT(c) ((void)0) ------------------ 3473| 1.04k| XXH_ASSERT(4 <= len && len <= 8); ------------------ | | 1543| 1.04k|# define XXH_ASSERT(c) ((void)0) ------------------ 3474| 1.04k| seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32; 3475| 1.04k| { xxh_u32 const input1 = XXH_readLE32(input); 3476| 1.04k| xxh_u32 const input2 = XXH_readLE32(input + len - 4); 3477| 1.04k| xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed; 3478| 1.04k| xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32); 3479| 1.04k| xxh_u64 const keyed = input64 ^ bitflip; 3480| 1.04k| return XXH3_rrmxmx(keyed, len); 3481| 1.04k| } 3482| 1.04k|} flb_hash_table.c:XXH_swap32: 1801| 1.04k|{ 1802| 1.04k| return ((x << 24) & 0xff000000 ) | 1803| 1.04k| ((x << 8) & 0x00ff0000 ) | 1804| 1.04k| ((x >> 8) & 0x0000ff00 ) | 1805| 1.04k| ((x >> 24) & 0x000000ff ); 1806| 1.04k|} flb_hash_table.c:XXH_readLE32: 1850| 821k|{ 1851| 821k| return XXH_CPU_LITTLE_ENDIAN ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr)); ------------------ | | 1723| 821k|# define XXH_CPU_LITTLE_ENDIAN 1 | | ------------------ | | | Branch (1723:35): [Folded - Ignored] | | ------------------ ------------------ 1852| 821k|} flb_hash_table.c:XXH_read32: 1688| 821k|{ 1689| 821k| xxh_u32 val; 1690| 821k| XXH_memcpy(&val, memPtr, sizeof(val)); 1691| 821k| return val; 1692| 821k|} flb_hash_table.c:XXH_memcpy: 1481| 901k|{ 1482| 901k| return memcpy(dest,src,size); 1483| 901k|} flb_hash_table.c:XXH3_rrmxmx: 3403| 1.04k|{ 3404| | /* this mix is inspired by Pelle Evensen's rrmxmx */ 3405| 1.04k| h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24); ------------------ | | 1777| 1.04k|# define XXH_rotl64 __builtin_rotateleft64 ------------------ h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24); ------------------ | | 1777| 1.04k|# define XXH_rotl64 __builtin_rotateleft64 ------------------ 3406| 1.04k| h64 *= 0x9FB21C651E98DF25ULL; 3407| 1.04k| h64 ^= (h64 >> 35) + len ; 3408| 1.04k| h64 *= 0x9FB21C651E98DF25ULL; 3409| 1.04k| return XXH_xorshift64(h64, 28); 3410| 1.04k|} flb_hash_table.c:XXH3_len_1to3_64b: 3448| 409k|{ 3449| 409k| XXH_ASSERT(input != NULL); ------------------ | | 1543| 409k|# define XXH_ASSERT(c) ((void)0) ------------------ 3450| 409k| XXH_ASSERT(1 <= len && len <= 3); ------------------ | | 1543| 409k|# define XXH_ASSERT(c) ((void)0) ------------------ 3451| 409k| XXH_ASSERT(secret != NULL); ------------------ | | 1543| 409k|# define XXH_ASSERT(c) ((void)0) ------------------ 3452| | /* 3453| | * len = 1: combined = { input[0], 0x01, input[0], input[0] } 3454| | * len = 2: combined = { input[1], 0x02, input[0], input[1] } 3455| | * len = 3: combined = { input[2], 0x03, input[0], input[1] } 3456| | */ 3457| 409k| { xxh_u8 const c1 = input[0]; 3458| 409k| xxh_u8 const c2 = input[len >> 1]; 3459| 409k| xxh_u8 const c3 = input[len - 1]; 3460| 409k| xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2 << 24) 3461| 409k| | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8); 3462| 409k| xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed; 3463| 409k| xxh_u64 const keyed = (xxh_u64)combined ^ bitflip; 3464| 409k| return XXH64_avalanche(keyed); 3465| 409k| } 3466| 409k|} flb_hash_table.c:XXH64_avalanche: 2448| 409k|{ 2449| 409k| h64 ^= h64 >> 33; 2450| 409k| h64 *= XXH_PRIME64_2; ------------------ | | 2418| 409k|#define XXH_PRIME64_2 0xC2B2AE3D27D4EB4FULL /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */ ------------------ 2451| 409k| h64 ^= h64 >> 29; 2452| 409k| h64 *= XXH_PRIME64_3; ------------------ | | 2419| 409k|#define XXH_PRIME64_3 0x165667B19E3779F9ULL /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */ ------------------ 2453| 409k| h64 ^= h64 >> 32; 2454| 409k| return h64; 2455| 409k|} flb_hash_table.c:XXH_readLE64: 2389| 79.5k|{ 2390| 79.5k| return XXH_CPU_LITTLE_ENDIAN ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr)); ------------------ | | 1723| 79.5k|# define XXH_CPU_LITTLE_ENDIAN 1 | | ------------------ | | | Branch (1723:35): [Folded - Ignored] | | ------------------ ------------------ 2391| 79.5k|} flb_hash_table.c:XXH_read64: 2331| 79.5k|{ 2332| 79.5k| xxh_u64 val; 2333| 79.5k| XXH_memcpy(&val, memPtr, sizeof(val)); 2334| 79.5k| return val; 2335| 79.5k|} flb_hash_table.c:XXH3_len_17to128_64b: 3575| 3.26k|{ 3576| 3.26k| XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize; ------------------ | | 1543| 3.26k|# define XXH_ASSERT(c) ((void)0) ------------------ 3577| 3.26k| XXH_ASSERT(16 < len && len <= 128); ------------------ | | 1543| 3.26k|# define XXH_ASSERT(c) ((void)0) ------------------ 3578| | 3579| 3.26k| { xxh_u64 acc = len * XXH_PRIME64_1; ------------------ | | 2417| 3.26k|#define XXH_PRIME64_1 0x9E3779B185EBCA87ULL /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */ ------------------ 3580| 3.26k| if (len > 32) { ------------------ | Branch (3580:13): [True: 0, False: 3.26k] ------------------ 3581| 0| if (len > 64) { ------------------ | Branch (3581:17): [True: 0, False: 0] ------------------ 3582| 0| if (len > 96) { ------------------ | Branch (3582:21): [True: 0, False: 0] ------------------ 3583| 0| acc += XXH3_mix16B(input+48, secret+96, seed); 3584| 0| acc += XXH3_mix16B(input+len-64, secret+112, seed); 3585| 0| } 3586| 0| acc += XXH3_mix16B(input+32, secret+64, seed); 3587| 0| acc += XXH3_mix16B(input+len-48, secret+80, seed); 3588| 0| } 3589| 0| acc += XXH3_mix16B(input+16, secret+32, seed); 3590| 0| acc += XXH3_mix16B(input+len-32, secret+48, seed); 3591| 0| } 3592| 3.26k| acc += XXH3_mix16B(input+0, secret+0, seed); 3593| 3.26k| acc += XXH3_mix16B(input+len-16, secret+16, seed); 3594| | 3595| 3.26k| return XXH3_avalanche(acc); 3596| 3.26k| } 3597| 3.26k|} flb_hash_table.c:XXH3_mix16B: 3540| 6.52k|{ 3541| |#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \ 3542| | && defined(__i386__) && defined(__SSE2__) /* x86 + SSE2 */ \ 3543| | && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable like XXH32 hack */ 3544| | /* 3545| | * UGLY HACK: 3546| | * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in 3547| | * slower code. 3548| | * 3549| | * By forcing seed64 into a register, we disrupt the cost model and 3550| | * cause it to scalarize. See `XXH32_round()` 3551| | * 3552| | * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600, 3553| | * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on 3554| | * GCC 9.2, despite both emitting scalar code. 3555| | * 3556| | * GCC generates much better scalar code than Clang for the rest of XXH3, 3557| | * which is why finding a more optimal codepath is an interest. 3558| | */ 3559| | XXH_COMPILER_GUARD(seed64); 3560| |#endif 3561| 6.52k| { xxh_u64 const input_lo = XXH_readLE64(input); 3562| 6.52k| xxh_u64 const input_hi = XXH_readLE64(input+8); 3563| 6.52k| return XXH3_mul128_fold64( 3564| 6.52k| input_lo ^ (XXH_readLE64(secret) + seed64), 3565| 6.52k| input_hi ^ (XXH_readLE64(secret+8) - seed64) 3566| 6.52k| ); 3567| 6.52k| } 3568| 6.52k|} flb_hash_table.c:XXH3_hashLong_64b_default: 4485| 5.94k|{ 4486| 5.94k| (void)seed64; (void)secret; (void)secretLen; 4487| 5.94k| return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc); ------------------ | | 4314| 5.94k|#define XXH3_accumulate_512 XXH3_accumulate_512_sse2 ------------------ return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc); ------------------ | | 4315| 5.94k|#define XXH3_scrambleAcc XXH3_scrambleAcc_sse2 ------------------ 4488| 5.94k|} flb_hash_table.c:XXH3_hashLong_64b_internal: 4450| 5.94k|{ 4451| 5.94k| XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC; ------------------ | | 1010| 5.94k|# define XXH_ALIGN(n) alignas(n) ------------------ XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC; ------------------ | | 4442| 5.94k|#define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \ | | ------------------ | | | | 1890| 5.94k|#define XXH_PRIME32_3 0xC2B2AE3DU /*!< 0b11000010101100101010111000111101 */ | | ------------------ | | #define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \ | | ------------------ | | | | 2417| 5.94k|#define XXH_PRIME64_1 0x9E3779B185EBCA87ULL /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */ | | ------------------ | | #define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \ | | ------------------ | | | | 2418| 5.94k|#define XXH_PRIME64_2 0xC2B2AE3D27D4EB4FULL /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */ | | ------------------ | | #define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \ | | ------------------ | | | | 2419| 5.94k|#define XXH_PRIME64_3 0x165667B19E3779F9ULL /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */ | | ------------------ | | 4443| 5.94k| XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 } | | ------------------ | | | | 2420| 5.94k|#define XXH_PRIME64_4 0x85EBCA77C2B2AE63ULL /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */ | | ------------------ | | XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 } | | ------------------ | | | | 1889| 5.94k|#define XXH_PRIME32_2 0x85EBCA77U /*!< 0b10000101111010111100101001110111 */ | | ------------------ | | XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 } | | ------------------ | | | | 2421| 5.94k|#define XXH_PRIME64_5 0x27D4EB2F165667C5ULL /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */ | | ------------------ | | XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 } | | ------------------ | | | | 1888| 5.94k|#define XXH_PRIME32_1 0x9E3779B1U /*!< 0b10011110001101110111100110110001 */ | | ------------------ ------------------ 4452| | 4453| 5.94k| XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc512, f_scramble); 4454| | 4455| | /* converge into final hash */ 4456| 5.94k| XXH_STATIC_ASSERT(sizeof(acc) == 64); ------------------ | | 1555| 5.94k|# define XXH_STATIC_ASSERT(c) XXH_STATIC_ASSERT_WITH_MESSAGE((c),#c) | | ------------------ | | | | 1549| 5.94k|# define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { _Static_assert((c),m); } while(0) | | | | ------------------ | | | | | Branch (1549:85): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 4457| | /* do not align on 8, so that the secret is different from the accumulator */ 4458| 5.94k|#define XXH_SECRET_MERGEACCS_START 11 4459| 5.94k| XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START); ------------------ | | 1543| 5.94k|# define XXH_ASSERT(c) ((void)0) ------------------ 4460| 5.94k| return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1); ------------------ | | 4458| 5.94k|#define XXH_SECRET_MERGEACCS_START 11 ------------------ return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1); ------------------ | | 2417| 5.94k|#define XXH_PRIME64_1 0x9E3779B185EBCA87ULL /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */ ------------------ 4461| 5.94k|} flb_hash_table.c:XXH3_hashLong_internal_loop: 4380| 5.94k|{ 4381| 5.94k| size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE; ------------------ | | 3657| 5.94k|#define XXH_STRIPE_LEN 64 ------------------ size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE; ------------------ | | 3658| 5.94k|#define XXH_SECRET_CONSUME_RATE 8 /* nb of secret bytes consumed at each accumulation */ ------------------ 4382| 5.94k| size_t const block_len = XXH_STRIPE_LEN * nbStripesPerBlock; ------------------ | | 3657| 5.94k|#define XXH_STRIPE_LEN 64 ------------------ 4383| 5.94k| size_t const nb_blocks = (len - 1) / block_len; 4384| | 4385| 5.94k| size_t n; 4386| | 4387| 5.94k| XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); ------------------ | | 1543| 5.94k|# define XXH_ASSERT(c) ((void)0) ------------------ 4388| | 4389| 25.4k| for (n = 0; n < nb_blocks; n++) { ------------------ | Branch (4389:17): [True: 19.5k, False: 5.94k] ------------------ 4390| 19.5k| XXH3_accumulate(acc, input + n*block_len, secret, nbStripesPerBlock, f_acc512); 4391| 19.5k| f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN); ------------------ | | 3657| 19.5k|#define XXH_STRIPE_LEN 64 ------------------ 4392| 19.5k| } 4393| | 4394| | /* last partial block */ 4395| 5.94k| XXH_ASSERT(len > XXH_STRIPE_LEN); ------------------ | | 1543| 5.94k|# define XXH_ASSERT(c) ((void)0) ------------------ 4396| 5.94k| { size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN; ------------------ | | 3657| 5.94k|#define XXH_STRIPE_LEN 64 ------------------ 4397| 5.94k| XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE)); ------------------ | | 1543| 5.94k|# define XXH_ASSERT(c) ((void)0) ------------------ 4398| 5.94k| XXH3_accumulate(acc, input + nb_blocks*block_len, secret, nbStripes, f_acc512); 4399| | 4400| | /* last stripe */ 4401| 5.94k| { const xxh_u8* const p = input + len - XXH_STRIPE_LEN; ------------------ | | 3657| 5.94k|#define XXH_STRIPE_LEN 64 ------------------ 4402| 5.94k|#define XXH_SECRET_LASTACC_START 7 /* not aligned on 8, last secret is different from acc & scrambler */ 4403| 5.94k| f_acc512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START); ------------------ | | 3657| 5.94k|#define XXH_STRIPE_LEN 64 ------------------ f_acc512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START); ------------------ | | 4402| 5.94k|#define XXH_SECRET_LASTACC_START 7 /* not aligned on 8, last secret is different from acc & scrambler */ ------------------ 4404| 5.94k| } } 4405| 5.94k|} flb_hash_table.c:XXH3_accumulate: 4363| 25.4k|{ 4364| 25.4k| size_t n; 4365| 391k| for (n = 0; n < nbStripes; n++ ) { ------------------ | Branch (4365:17): [True: 365k, False: 25.4k] ------------------ 4366| 365k| const xxh_u8* const in = input + n*XXH_STRIPE_LEN; ------------------ | | 3657| 365k|#define XXH_STRIPE_LEN 64 ------------------ 4367| 365k| XXH_PREFETCH(in + XXH_PREFETCH_DIST); ------------------ | | 3154| 365k|# define XXH_PREFETCH(ptr) __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */) ------------------ 4368| 365k| f_acc512(acc, 4369| 365k| in, 4370| 365k| secret + n*XXH_SECRET_CONSUME_RATE); ------------------ | | 3658| 365k|#define XXH_SECRET_CONSUME_RATE 8 /* nb of secret bytes consumed at each accumulation */ ------------------ 4371| 365k| } 4372| 25.4k|} flb_hash_table.c:XXH3_mergeAccs: 4417| 5.94k|{ 4418| 5.94k| xxh_u64 result64 = start; 4419| 5.94k| size_t i = 0; 4420| | 4421| 29.7k| for (i = 0; i < 4; i++) { ------------------ | Branch (4421:17): [True: 23.7k, False: 5.94k] ------------------ 4422| 23.7k| result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i); 4423| |#if defined(__clang__) /* Clang */ \ 4424| | && (defined(__arm__) || defined(__thumb__)) /* ARMv7 */ \ 4425| | && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \ 4426| | && !defined(XXH_ENABLE_AUTOVECTORIZE) /* Define to disable */ 4427| | /* 4428| | * UGLY HACK: 4429| | * Prevent autovectorization on Clang ARMv7-a. Exact same problem as 4430| | * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b. 4431| | * XXH3_64bits, len == 256, Snapdragon 835: 4432| | * without hack: 2063.7 MB/s 4433| | * with hack: 2560.7 MB/s 4434| | */ 4435| | XXH_COMPILER_GUARD(result64); 4436| |#endif 4437| 23.7k| } 4438| | 4439| 5.94k| return XXH3_avalanche(result64); 4440| 5.94k|} flb_hash_table.c:XXH3_mix2Accs: 4409| 23.7k|{ 4410| 23.7k| return XXH3_mul128_fold64( 4411| 23.7k| acc[0] ^ XXH_readLE64(secret), 4412| 23.7k| acc[1] ^ XXH_readLE64(secret+8) ); 4413| 23.7k|} flb_hash_table.c:XXH3_accumulate_512_sse2: 3934| 371k|{ 3935| | /* SSE2 is just a half-scale version of the AVX2 version. */ 3936| 371k| XXH_ASSERT((((size_t)acc) & 15) == 0); ------------------ | | 1543| 371k|# define XXH_ASSERT(c) ((void)0) ------------------ 3937| 371k| { __m128i* const xacc = (__m128i *) acc; 3938| | /* Unaligned. This is mainly for pointer arithmetic, and because 3939| | * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ 3940| 371k| const __m128i* const xinput = (const __m128i *) input; 3941| | /* Unaligned. This is mainly for pointer arithmetic, and because 3942| | * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ 3943| 371k| const __m128i* const xsecret = (const __m128i *) secret; 3944| | 3945| 371k| size_t i; 3946| 1.85M| for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) { ------------------ | | 3657| 1.85M|#define XXH_STRIPE_LEN 64 ------------------ | Branch (3946:19): [True: 1.48M, False: 371k] ------------------ 3947| | /* data_vec = xinput[i]; */ 3948| 1.48M| __m128i const data_vec = _mm_loadu_si128 (xinput+i); 3949| | /* key_vec = xsecret[i]; */ 3950| 1.48M| __m128i const key_vec = _mm_loadu_si128 (xsecret+i); 3951| | /* data_key = data_vec ^ key_vec; */ 3952| 1.48M| __m128i const data_key = _mm_xor_si128 (data_vec, key_vec); 3953| | /* data_key_lo = data_key >> 32; */ 3954| 1.48M| __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); 3955| | /* product = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */ 3956| 1.48M| __m128i const product = _mm_mul_epu32 (data_key, data_key_lo); 3957| | /* xacc[i] += swap(data_vec); */ 3958| 1.48M| __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2)); 3959| 1.48M| __m128i const sum = _mm_add_epi64(xacc[i], data_swap); 3960| | /* xacc[i] += product; */ 3961| 1.48M| xacc[i] = _mm_add_epi64(product, sum); 3962| 1.48M| } } 3963| 371k|} flb_hash_table.c:XXH3_scrambleAcc_sse2: 3967| 19.5k|{ 3968| 19.5k| XXH_ASSERT((((size_t)acc) & 15) == 0); ------------------ | | 1543| 19.5k|# define XXH_ASSERT(c) ((void)0) ------------------ 3969| 19.5k| { __m128i* const xacc = (__m128i*) acc; 3970| | /* Unaligned. This is mainly for pointer arithmetic, and because 3971| | * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */ 3972| 19.5k| const __m128i* const xsecret = (const __m128i *) secret; 3973| 19.5k| const __m128i prime32 = _mm_set1_epi32((int)XXH_PRIME32_1); ------------------ | | 1888| 19.5k|#define XXH_PRIME32_1 0x9E3779B1U /*!< 0b10011110001101110111100110110001 */ ------------------ 3974| | 3975| 19.5k| size_t i; 3976| 97.5k| for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) { ------------------ | | 3657| 97.5k|#define XXH_STRIPE_LEN 64 ------------------ | Branch (3976:19): [True: 78.0k, False: 19.5k] ------------------ 3977| | /* xacc[i] ^= (xacc[i] >> 47) */ 3978| 78.0k| __m128i const acc_vec = xacc[i]; 3979| 78.0k| __m128i const shifted = _mm_srli_epi64 (acc_vec, 47); 3980| 78.0k| __m128i const data_vec = _mm_xor_si128 (acc_vec, shifted); 3981| | /* xacc[i] ^= xsecret[i]; */ 3982| 78.0k| __m128i const key_vec = _mm_loadu_si128 (xsecret+i); 3983| 78.0k| __m128i const data_key = _mm_xor_si128 (data_vec, key_vec); 3984| | 3985| | /* xacc[i] *= XXH_PRIME32_1; */ 3986| 78.0k| __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1)); 3987| 78.0k| __m128i const prod_lo = _mm_mul_epu32 (data_key, prime32); 3988| 78.0k| __m128i const prod_hi = _mm_mul_epu32 (data_key_hi, prime32); 3989| 78.0k| xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32)); 3990| 78.0k| } 3991| 19.5k| } 3992| 19.5k|} mz_adler32: 40| 4.08k|{ 41| 4.08k| mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); 42| 4.08k| size_t block_len = buf_len % 5552; 43| 4.08k| if (!ptr) ------------------ | Branch (43:9): [True: 0, False: 4.08k] ------------------ 44| 0| return MZ_ADLER32_INIT; ------------------ | | 237| 0|#define MZ_ADLER32_INIT (1) ------------------ 45| 7.07k| while (buf_len) ------------------ | Branch (45:12): [True: 2.99k, False: 4.08k] ------------------ 46| 2.99k| { 47| 1.04M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (47:21): [True: 1.04M, False: 2.99k] ------------------ 48| 1.04M| { 49| 1.04M| s1 += ptr[0], s2 += s1; 50| 1.04M| s1 += ptr[1], s2 += s1; 51| 1.04M| s1 += ptr[2], s2 += s1; 52| 1.04M| s1 += ptr[3], s2 += s1; 53| 1.04M| s1 += ptr[4], s2 += s1; 54| 1.04M| s1 += ptr[5], s2 += s1; 55| 1.04M| s1 += ptr[6], s2 += s1; 56| 1.04M| s1 += ptr[7], s2 += s1; 57| 1.04M| } 58| 9.42k| for (; i < block_len; ++i) ------------------ | Branch (58:16): [True: 6.42k, False: 2.99k] ------------------ 59| 6.42k| s1 += *ptr++, s2 += s1; 60| 2.99k| s1 %= 65521U, s2 %= 65521U; 61| 2.99k| buf_len -= block_len; 62| 2.99k| block_len = 5552; 63| 2.99k| } 64| 4.08k| return (s2 << 16) + s1; 65| 4.08k|} mz_crc32: 95| 4.18k|{ 96| 4.18k| static const mz_uint32 s_crc_table[256] = 97| 4.18k| { 98| 4.18k| 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 99| 4.18k| 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 100| 4.18k| 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 101| 4.18k| 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 102| 4.18k| 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 103| 4.18k| 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 104| 4.18k| 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 105| 4.18k| 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 106| 4.18k| 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 107| 4.18k| 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 108| 4.18k| 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 109| 4.18k| 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 110| 4.18k| 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 111| 4.18k| 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 112| 4.18k| 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 113| 4.18k| 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 114| 4.18k| 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 115| 4.18k| 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 116| 4.18k| 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 117| 4.18k| 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 118| 4.18k| 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 119| 4.18k| 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 120| 4.18k| 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 121| 4.18k| 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 122| 4.18k| 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 123| 4.18k| 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 124| 4.18k| 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 125| 4.18k| 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 126| 4.18k| 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 127| 4.18k| 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 128| 4.18k| 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 129| 4.18k| 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 130| 4.18k| 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 131| 4.18k| 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 132| 4.18k| 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 133| 4.18k| 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 134| 4.18k| 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 135| 4.18k| }; 136| | 137| 4.18k| mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF; 138| 4.18k| const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr; 139| | 140| 4.21M| while (buf_len >= 4) ------------------ | Branch (140:12): [True: 4.20M, False: 4.18k] ------------------ 141| 4.20M| { 142| 4.20M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ 143| 4.20M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ 144| 4.20M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ 145| 4.20M| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; ------------------ | | 508| 4.20M|#define crc32 mz_crc32 ------------------ 146| 4.20M| pByte_buf += 4; 147| 4.20M| buf_len -= 4; 148| 4.20M| } 149| | 150| 13.8k| while (buf_len) ------------------ | Branch (150:12): [True: 9.67k, False: 4.18k] ------------------ 151| 9.67k| { 152| 9.67k| crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 9.67k|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 9.67k|#define crc32 mz_crc32 ------------------ crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; ------------------ | | 508| 9.67k|#define crc32 mz_crc32 ------------------ 153| 9.67k| ++pByte_buf; 154| 9.67k| --buf_len; 155| 9.67k| } 156| | 157| 4.18k| return ~crc32; ------------------ | | 508| 4.18k|#define crc32 mz_crc32 ------------------ 158| 4.18k|} miniz_def_alloc_func: 167| 4.48k|{ 168| 4.48k| (void)opaque, (void)items, (void)size; 169| 4.48k| return MZ_MALLOC(items * size); ------------------ | | 54| 4.48k|#define MZ_MALLOC(x) malloc(x) ------------------ 170| 4.48k|} miniz_def_free_func: 172| 4.48k|{ 173| 4.48k| (void)opaque, (void)address; 174| 4.48k| MZ_FREE(address); ------------------ | | 55| 4.48k|#define MZ_FREE(x) free(x) ------------------ 175| 4.48k|} mz_deflateInit2: 197| 2.04k|{ 198| 2.04k| tdefl_compressor *pComp; 199| 2.04k| mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy); 200| | 201| 2.04k| if (!pStream) ------------------ | Branch (201:9): [True: 0, False: 2.04k] ------------------ 202| 0| return MZ_STREAM_ERROR; 203| 2.04k| if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 256| 2.04k|#define MZ_DEFLATED 8 ------------------ if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 311| 2.04k|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) ------------------ | | 311| 2.04k|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ | Branch (203:9): [True: 0, False: 2.04k] | Branch (203:37): [True: 0, False: 2.04k] | Branch (203:56): [True: 0, False: 2.04k] | Branch (203:77): [True: 2.04k, False: 0] | Branch (203:120): [True: 0, False: 2.04k] ------------------ 204| 0| return MZ_PARAM_ERROR; 205| | 206| 2.04k| pStream->data_type = 0; 207| 2.04k| pStream->adler = MZ_ADLER32_INIT; ------------------ | | 237| 2.04k|#define MZ_ADLER32_INIT (1) ------------------ 208| 2.04k| pStream->msg = NULL; 209| 2.04k| pStream->reserved = 0; 210| 2.04k| pStream->total_in = 0; 211| 2.04k| pStream->total_out = 0; 212| 2.04k| if (!pStream->zalloc) ------------------ | Branch (212:9): [True: 2.04k, False: 0] ------------------ 213| 2.04k| pStream->zalloc = miniz_def_alloc_func; 214| 2.04k| if (!pStream->zfree) ------------------ | Branch (214:9): [True: 2.04k, False: 0] ------------------ 215| 2.04k| pStream->zfree = miniz_def_free_func; 216| | 217| 2.04k| pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor)); 218| 2.04k| if (!pComp) ------------------ | Branch (218:9): [True: 0, False: 2.04k] ------------------ 219| 0| return MZ_MEM_ERROR; 220| | 221| 2.04k| pStream->state = (struct mz_internal_state *)pComp; 222| | 223| 2.04k| if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) ------------------ | Branch (223:9): [True: 0, False: 2.04k] ------------------ 224| 0| { 225| 0| mz_deflateEnd(pStream); 226| 0| return MZ_PARAM_ERROR; 227| 0| } 228| | 229| 2.04k| return MZ_OK; 230| 2.04k|} mz_deflate: 242| 4.08k|{ 243| 4.08k| size_t in_bytes, out_bytes; 244| 4.08k| mz_ulong orig_total_in, orig_total_out; 245| 4.08k| int mz_status = MZ_OK; 246| | 247| 4.08k| if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) ------------------ | Branch (247:9): [True: 0, False: 4.08k] | Branch (247:23): [True: 0, False: 4.08k] | Branch (247:44): [True: 0, False: 4.08k] | Branch (247:59): [True: 0, False: 4.08k] | Branch (247:82): [True: 0, False: 4.08k] ------------------ 248| 0| return MZ_STREAM_ERROR; 249| 4.08k| if (!pStream->avail_out) ------------------ | Branch (249:9): [True: 0, False: 4.08k] ------------------ 250| 0| return MZ_BUF_ERROR; 251| | 252| 4.08k| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (252:9): [True: 0, False: 4.08k] ------------------ 253| 0| flush = MZ_SYNC_FLUSH; 254| | 255| 4.08k| if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE) ------------------ | Branch (255:9): [True: 0, False: 4.08k] ------------------ 256| 0| return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; ------------------ | Branch (256:16): [True: 0, False: 0] ------------------ 257| | 258| 4.08k| orig_total_in = pStream->total_in; 259| 4.08k| orig_total_out = pStream->total_out; 260| 4.08k| for (;;) 261| 4.08k| { 262| 4.08k| tdefl_status defl_status; 263| 4.08k| in_bytes = pStream->avail_in; 264| 4.08k| out_bytes = pStream->avail_out; 265| | 266| 4.08k| defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush); 267| 4.08k| pStream->next_in += (mz_uint)in_bytes; 268| 4.08k| pStream->avail_in -= (mz_uint)in_bytes; 269| 4.08k| pStream->total_in += (mz_uint)in_bytes; 270| 4.08k| pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state); 271| | 272| 4.08k| pStream->next_out += (mz_uint)out_bytes; 273| 4.08k| pStream->avail_out -= (mz_uint)out_bytes; 274| 4.08k| pStream->total_out += (mz_uint)out_bytes; 275| | 276| 4.08k| if (defl_status < 0) ------------------ | Branch (276:13): [True: 0, False: 4.08k] ------------------ 277| 0| { 278| 0| mz_status = MZ_STREAM_ERROR; 279| 0| break; 280| 0| } 281| 4.08k| else if (defl_status == TDEFL_STATUS_DONE) ------------------ | Branch (281:18): [True: 2.04k, False: 2.04k] ------------------ 282| 2.04k| { 283| 2.04k| mz_status = MZ_STREAM_END; 284| 2.04k| break; 285| 2.04k| } 286| 2.04k| else if (!pStream->avail_out) ------------------ | Branch (286:18): [True: 0, False: 2.04k] ------------------ 287| 0| break; 288| 2.04k| else if ((!pStream->avail_in) && (flush != MZ_FINISH)) ------------------ | Branch (288:18): [True: 2.04k, False: 0] | Branch (288:42): [True: 2.04k, False: 0] ------------------ 289| 2.04k| { 290| 2.04k| if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) ------------------ | Branch (290:17): [True: 0, False: 2.04k] | Branch (290:28): [True: 2.04k, False: 0] | Branch (290:68): [True: 0, False: 0] ------------------ 291| 2.04k| break; 292| 0| return MZ_BUF_ERROR; /* Can't make forward progress without some input. 293| | */ 294| 2.04k| } 295| 4.08k| } 296| 4.08k| return mz_status; 297| 4.08k|} mz_deflateEnd: 300| 2.04k|{ 301| 2.04k| if (!pStream) ------------------ | Branch (301:9): [True: 0, False: 2.04k] ------------------ 302| 0| return MZ_STREAM_ERROR; 303| 2.04k| if (pStream->state) ------------------ | Branch (303:9): [True: 2.04k, False: 0] ------------------ 304| 2.04k| { 305| 2.04k| pStream->zfree(pStream->opaque, pStream->state); 306| 2.04k| pStream->state = NULL; 307| 2.04k| } 308| 2.04k| return MZ_OK; 309| 2.04k|} mz_deflateBound: 312| 2.04k|{ 313| 2.04k| (void)pStream; 314| | /* This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.) */ 315| 2.04k| return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5); ------------------ | | 59| 2.04k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (59:23): [True: 2.04k, False: 0] | | ------------------ ------------------ 316| 2.04k|} mz_compressBound: 354| 2.04k|{ 355| 2.04k| return mz_deflateBound(NULL, source_len); 356| 2.04k|} mz_inflateInit2: 372| 2.43k|{ 373| 2.43k| inflate_state *pDecomp; 374| 2.43k| if (!pStream) ------------------ | Branch (374:9): [True: 0, False: 2.43k] ------------------ 375| 0| return MZ_STREAM_ERROR; 376| 2.43k| if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) ------------------ | | 311| 2.43k|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) ------------------ | | 311| 2.43k|#define MZ_DEFAULT_WINDOW_BITS 15 ------------------ | Branch (376:9): [True: 2.43k, False: 0] | Branch (376:52): [True: 0, False: 2.43k] ------------------ 377| 0| return MZ_PARAM_ERROR; 378| | 379| 2.43k| pStream->data_type = 0; 380| 2.43k| pStream->adler = 0; 381| 2.43k| pStream->msg = NULL; 382| 2.43k| pStream->total_in = 0; 383| 2.43k| pStream->total_out = 0; 384| 2.43k| pStream->reserved = 0; 385| 2.43k| if (!pStream->zalloc) ------------------ | Branch (385:9): [True: 2.43k, False: 0] ------------------ 386| 2.43k| pStream->zalloc = miniz_def_alloc_func; 387| 2.43k| if (!pStream->zfree) ------------------ | Branch (387:9): [True: 2.43k, False: 0] ------------------ 388| 2.43k| pStream->zfree = miniz_def_free_func; 389| | 390| 2.43k| pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state)); 391| 2.43k| if (!pDecomp) ------------------ | Branch (391:9): [True: 0, False: 2.43k] ------------------ 392| 0| return MZ_MEM_ERROR; 393| | 394| 2.43k| pStream->state = (struct mz_internal_state *)pDecomp; 395| | 396| 2.43k| tinfl_init(&pDecomp->m_decomp); ------------------ | | 93| 2.43k| do \ | | 94| 2.43k| { \ | | 95| 2.43k| (r)->m_state = 0; \ | | 96| 2.43k| } \ | | 97| 2.43k| MZ_MACRO_END | | ------------------ | | | | 26| 2.43k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 397| 2.43k| pDecomp->m_dict_ofs = 0; 398| 2.43k| pDecomp->m_dict_avail = 0; 399| 2.43k| pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; 400| 2.43k| pDecomp->m_first_call = 1; 401| 2.43k| pDecomp->m_has_flushed = 0; 402| 2.43k| pDecomp->m_window_bits = window_bits; 403| | 404| 2.43k| return MZ_OK; 405| 2.43k|} mz_inflate: 439| 2.43k|{ 440| 2.43k| inflate_state *pState; 441| 2.43k| mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; 442| 2.43k| size_t in_bytes, out_bytes, orig_avail_in; 443| 2.43k| tinfl_status status; 444| | 445| 2.43k| if ((!pStream) || (!pStream->state)) ------------------ | Branch (445:9): [True: 0, False: 2.43k] | Branch (445:23): [True: 0, False: 2.43k] ------------------ 446| 0| return MZ_STREAM_ERROR; 447| 2.43k| if (flush == MZ_PARTIAL_FLUSH) ------------------ | Branch (447:9): [True: 0, False: 2.43k] ------------------ 448| 0| flush = MZ_SYNC_FLUSH; 449| 2.43k| if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) ------------------ | Branch (449:9): [True: 2.43k, False: 0] | Branch (449:20): [True: 2.43k, False: 0] | Branch (449:48): [True: 0, False: 2.43k] ------------------ 450| 0| return MZ_STREAM_ERROR; 451| | 452| 2.43k| pState = (inflate_state *)pStream->state; 453| 2.43k| if (pState->m_window_bits > 0) ------------------ | Branch (453:9): [True: 0, False: 2.43k] ------------------ 454| 0| decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; 455| 2.43k| orig_avail_in = pStream->avail_in; 456| | 457| 2.43k| first_call = pState->m_first_call; 458| 2.43k| pState->m_first_call = 0; 459| 2.43k| if (pState->m_last_status < 0) ------------------ | Branch (459:9): [True: 0, False: 2.43k] ------------------ 460| 0| return MZ_DATA_ERROR; 461| | 462| 2.43k| if (pState->m_has_flushed && (flush != MZ_FINISH)) ------------------ | Branch (462:9): [True: 0, False: 2.43k] | Branch (462:34): [True: 0, False: 0] ------------------ 463| 0| return MZ_STREAM_ERROR; 464| 2.43k| pState->m_has_flushed |= (flush == MZ_FINISH); 465| | 466| 2.43k| if ((flush == MZ_FINISH) && (first_call)) ------------------ | Branch (466:9): [True: 2.43k, False: 0] | Branch (466:33): [True: 2.43k, False: 0] ------------------ 467| 2.43k| { 468| | /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */ 469| 2.43k| decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF; 470| 2.43k| in_bytes = pStream->avail_in; 471| 2.43k| out_bytes = pStream->avail_out; 472| 2.43k| status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags); 473| 2.43k| pState->m_last_status = status; 474| 2.43k| pStream->next_in += (mz_uint)in_bytes; 475| 2.43k| pStream->avail_in -= (mz_uint)in_bytes; 476| 2.43k| pStream->total_in += (mz_uint)in_bytes; 477| 2.43k| pStream->adler = tinfl_get_adler32(&pState->m_decomp); ------------------ | | 98| 2.43k|#define tinfl_get_adler32(r) (r)->m_check_adler32 ------------------ 478| 2.43k| pStream->next_out += (mz_uint)out_bytes; 479| 2.43k| pStream->avail_out -= (mz_uint)out_bytes; 480| 2.43k| pStream->total_out += (mz_uint)out_bytes; 481| | 482| 2.43k| if (status < 0) ------------------ | Branch (482:13): [True: 253, False: 2.18k] ------------------ 483| 253| return MZ_DATA_ERROR; 484| 2.18k| else if (status != TINFL_STATUS_DONE) ------------------ | Branch (484:18): [True: 69, False: 2.11k] ------------------ 485| 69| { 486| 69| pState->m_last_status = TINFL_STATUS_FAILED; 487| 69| return MZ_BUF_ERROR; 488| 69| } 489| 2.11k| return MZ_STREAM_END; 490| 2.43k| } 491| | /* flush != MZ_FINISH then we must assume there's more input. */ 492| 0| if (flush != MZ_FINISH) ------------------ | Branch (492:9): [True: 0, False: 0] ------------------ 493| 0| decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; 494| | 495| 0| if (pState->m_dict_avail) ------------------ | Branch (495:9): [True: 0, False: 0] ------------------ 496| 0| { 497| 0| n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); ------------------ | | 60| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 0] | | ------------------ ------------------ 498| 0| memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); 499| 0| pStream->next_out += n; 500| 0| pStream->avail_out -= n; 501| 0| pStream->total_out += n; 502| 0| pState->m_dict_avail -= n; 503| 0| pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); ------------------ | | 55| 0|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 504| 0| return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; ------------------ | Branch (504:17): [True: 0, False: 0] | Branch (504:65): [True: 0, False: 0] ------------------ 505| 0| } 506| | 507| 0| for (;;) 508| 0| { 509| 0| in_bytes = pStream->avail_in; 510| 0| out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; ------------------ | | 55| 0|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 511| | 512| 0| status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags); 513| 0| pState->m_last_status = status; 514| | 515| 0| pStream->next_in += (mz_uint)in_bytes; 516| 0| pStream->avail_in -= (mz_uint)in_bytes; 517| 0| pStream->total_in += (mz_uint)in_bytes; 518| 0| pStream->adler = tinfl_get_adler32(&pState->m_decomp); ------------------ | | 98| 0|#define tinfl_get_adler32(r) (r)->m_check_adler32 ------------------ 519| | 520| 0| pState->m_dict_avail = (mz_uint)out_bytes; 521| | 522| 0| n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); ------------------ | | 60| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 0] | | ------------------ ------------------ 523| 0| memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); 524| 0| pStream->next_out += n; 525| 0| pStream->avail_out -= n; 526| 0| pStream->total_out += n; 527| 0| pState->m_dict_avail -= n; 528| 0| pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); ------------------ | | 55| 0|#define TINFL_LZ_DICT_SIZE 32768 ------------------ 529| | 530| 0| if (status < 0) ------------------ | Branch (530:13): [True: 0, False: 0] ------------------ 531| 0| return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */ 532| 0| else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) ------------------ | Branch (532:18): [True: 0, False: 0] | Branch (532:63): [True: 0, False: 0] ------------------ 533| 0| return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */ 534| 0| else if (flush == MZ_FINISH) ------------------ | Branch (534:18): [True: 0, False: 0] ------------------ 535| 0| { 536| | /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */ 537| 0| if (status == TINFL_STATUS_DONE) ------------------ | Branch (537:17): [True: 0, False: 0] ------------------ 538| 0| return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; ------------------ | Branch (538:24): [True: 0, False: 0] ------------------ 539| | /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */ 540| 0| else if (!pStream->avail_out) ------------------ | Branch (540:22): [True: 0, False: 0] ------------------ 541| 0| return MZ_BUF_ERROR; 542| 0| } 543| 0| else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) ------------------ | Branch (543:18): [True: 0, False: 0] | Branch (543:51): [True: 0, False: 0] | Branch (543:75): [True: 0, False: 0] | Branch (543:100): [True: 0, False: 0] ------------------ 544| 0| break; 545| 0| } 546| | 547| 0| return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; ------------------ | Branch (547:13): [True: 0, False: 0] | Branch (547:46): [True: 0, False: 0] ------------------ 548| 0|} mz_inflateEnd: 551| 2.43k|{ 552| 2.43k| if (!pStream) ------------------ | Branch (552:9): [True: 0, False: 2.43k] ------------------ 553| 0| return MZ_STREAM_ERROR; 554| 2.43k| if (pStream->state) ------------------ | Branch (554:9): [True: 2.43k, False: 0] ------------------ 555| 2.43k| { 556| 2.43k| pStream->zfree(pStream->opaque, pStream->state); 557| 2.43k| pStream->state = NULL; 558| 2.43k| } 559| 2.43k| return MZ_OK; 560| 2.43k|} tdefl_compress: 1271| 4.08k|{ 1272| 4.08k| if (!d) ------------------ | Branch (1272:9): [True: 0, False: 4.08k] ------------------ 1273| 0| { 1274| 0| if (pIn_buf_size) ------------------ | Branch (1274:13): [True: 0, False: 0] ------------------ 1275| 0| *pIn_buf_size = 0; 1276| 0| if (pOut_buf_size) ------------------ | Branch (1276:13): [True: 0, False: 0] ------------------ 1277| 0| *pOut_buf_size = 0; 1278| 0| return TDEFL_STATUS_BAD_PARAM; 1279| 0| } 1280| | 1281| 4.08k| d->m_pIn_buf = pIn_buf; 1282| 4.08k| d->m_pIn_buf_size = pIn_buf_size; 1283| 4.08k| d->m_pOut_buf = pOut_buf; 1284| 4.08k| d->m_pOut_buf_size = pOut_buf_size; 1285| 4.08k| d->m_pSrc = (const mz_uint8 *)(pIn_buf); 1286| 4.08k| d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; ------------------ | Branch (1286:25): [True: 4.08k, False: 0] ------------------ 1287| 4.08k| d->m_out_buf_ofs = 0; 1288| 4.08k| d->m_flush = flush; 1289| | 1290| 4.08k| if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || ------------------ | Branch (1290:9): [True: 0, False: 4.08k] | Branch (1290:43): [True: 4.08k, False: 0] | Branch (1290:65): [True: 0, False: 0] | Branch (1290:94): [True: 0, False: 4.08k] ------------------ 1291| 4.08k| (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) ------------------ | Branch (1291:10): [True: 0, False: 4.08k] | Branch (1291:34): [True: 0, False: 0] | Branch (1291:63): [True: 4.08k, False: 0] | Branch (1291:79): [True: 2.04k, False: 2.04k] | Branch (1291:96): [True: 0, False: 2.04k] | Branch (1291:110): [True: 4.08k, False: 0] | Branch (1291:127): [True: 4.08k, False: 0] | Branch (1291:145): [True: 0, False: 4.08k] ------------------ 1292| 0| { 1293| 0| if (pIn_buf_size) ------------------ | Branch (1293:13): [True: 0, False: 0] ------------------ 1294| 0| *pIn_buf_size = 0; 1295| 0| if (pOut_buf_size) ------------------ | Branch (1295:13): [True: 0, False: 0] ------------------ 1296| 0| *pOut_buf_size = 0; 1297| 0| return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); 1298| 0| } 1299| 4.08k| d->m_wants_to_finish |= (flush == TDEFL_FINISH); 1300| | 1301| 4.08k| if ((d->m_output_flush_remaining) || (d->m_finished)) ------------------ | Branch (1301:9): [True: 0, False: 4.08k] | Branch (1301:42): [True: 0, False: 4.08k] ------------------ 1302| 0| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 1303| | 1304| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN 1305| | if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && 1306| | ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && 1307| | ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0)) 1308| | { 1309| | if (!tdefl_compress_fast(d)) 1310| | return d->m_prev_return_status; 1311| | } 1312| | else 1313| |#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ 1314| 4.08k| { 1315| 4.08k| if (!tdefl_compress_normal(d)) ------------------ | Branch (1315:13): [True: 0, False: 4.08k] ------------------ 1316| 0| return d->m_prev_return_status; 1317| 4.08k| } 1318| | 1319| 4.08k| if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) ------------------ | Branch (1319:9): [True: 4.08k, False: 0] | Branch (1319:77): [True: 4.08k, False: 0] ------------------ 1320| 4.08k| d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf); 1321| | 1322| 4.08k| if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) ------------------ | Branch (1322:9): [True: 2.04k, False: 2.04k] | Branch (1322:20): [True: 2.04k, False: 0] | Branch (1322:46): [True: 2.04k, False: 0] | Branch (1322:70): [True: 2.04k, False: 0] ------------------ 1323| 2.04k| { 1324| 2.04k| if (tdefl_flush_block(d, flush) < 0) ------------------ | Branch (1324:13): [True: 0, False: 2.04k] ------------------ 1325| 0| return d->m_prev_return_status; 1326| 2.04k| d->m_finished = (flush == TDEFL_FINISH); 1327| 2.04k| if (flush == TDEFL_FULL_FLUSH) ------------------ | Branch (1327:13): [True: 0, False: 2.04k] ------------------ 1328| 0| { 1329| 0| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 62| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1330| 0| MZ_CLEAR_ARR(d->m_next); ------------------ | | 62| 0|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1331| 0| d->m_dict_size = 0; 1332| 0| } 1333| 2.04k| } 1334| | 1335| 4.08k| return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); 1336| 4.08k|} tdefl_init: 1345| 2.04k|{ 1346| 2.04k| d->m_pPut_buf_func = pPut_buf_func; 1347| 2.04k| d->m_pPut_buf_user = pPut_buf_user; 1348| 2.04k| d->m_flags = (mz_uint)(flags); 1349| 2.04k| d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; 1350| 2.04k| d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; 1351| 2.04k| d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; 1352| 2.04k| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (1352:9): [True: 2.04k, False: 0] ------------------ 1353| 2.04k| MZ_CLEAR_ARR(d->m_hash); ------------------ | | 62| 2.04k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1354| 2.04k| d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0; 1355| 2.04k| d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0; 1356| 2.04k| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 1357| 2.04k| d->m_pLZ_flags = d->m_lz_code_buf; 1358| 2.04k| *d->m_pLZ_flags = 0; 1359| 2.04k| d->m_num_flags_left = 8; 1360| 2.04k| d->m_pOutput_buf = d->m_output_buf; 1361| 2.04k| d->m_pOutput_buf_end = d->m_output_buf; 1362| 2.04k| d->m_prev_return_status = TDEFL_STATUS_OKAY; 1363| 2.04k| d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; 1364| 2.04k| d->m_adler32 = 1; 1365| 2.04k| d->m_pIn_buf = NULL; 1366| 2.04k| d->m_pOut_buf = NULL; 1367| 2.04k| d->m_pIn_buf_size = NULL; 1368| 2.04k| d->m_pOut_buf_size = NULL; 1369| 2.04k| d->m_flush = TDEFL_NO_FLUSH; 1370| 2.04k| d->m_pSrc = NULL; 1371| 2.04k| d->m_src_buf_left = 0; 1372| 2.04k| d->m_out_buf_ofs = 0; 1373| 2.04k| if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) ------------------ | Branch (1373:9): [True: 2.04k, False: 0] ------------------ 1374| 2.04k| MZ_CLEAR_ARR(d->m_dict); ------------------ | | 62| 2.04k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 1375| 2.04k| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 1376| 2.04k| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 1377| 2.04k| return TDEFL_STATUS_OKAY; 1378| 2.04k|} tdefl_get_adler32: 1386| 4.08k|{ 1387| 4.08k| return d->m_adler32; 1388| 4.08k|} tdefl_create_comp_flags_from_zip_params: 1469| 2.04k|{ 1470| 2.04k| mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); ------------------ | | 60| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1470:45): [True: 0, False: 2.04k] | Branch (1470:101): [True: 2.04k, False: 0] ------------------ 1471| 2.04k| if (window_bits > 0) ------------------ | Branch (1471:9): [True: 0, False: 2.04k] ------------------ 1472| 0| comp_flags |= TDEFL_WRITE_ZLIB_HEADER; 1473| | 1474| 2.04k| if (!level) ------------------ | Branch (1474:9): [True: 0, False: 2.04k] ------------------ 1475| 0| comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; 1476| 2.04k| else if (strategy == MZ_FILTERED) ------------------ | Branch (1476:14): [True: 0, False: 2.04k] ------------------ 1477| 0| comp_flags |= TDEFL_FILTER_MATCHES; 1478| 2.04k| else if (strategy == MZ_HUFFMAN_ONLY) ------------------ | Branch (1478:14): [True: 0, False: 2.04k] ------------------ 1479| 0| comp_flags &= ~TDEFL_MAX_PROBES_MASK; 1480| 2.04k| else if (strategy == MZ_FIXED) ------------------ | Branch (1480:14): [True: 0, False: 2.04k] ------------------ 1481| 0| comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; 1482| 2.04k| else if (strategy == MZ_RLE) ------------------ | Branch (1482:14): [True: 0, False: 2.04k] ------------------ 1483| 0| comp_flags |= TDEFL_RLE_MATCHES; 1484| | 1485| 2.04k| return comp_flags; 1486| 2.04k|} miniz_tdef.c:tdefl_flush_output_buffer: 1250| 4.08k|{ 1251| 4.08k| if (d->m_pIn_buf_size) ------------------ | Branch (1251:9): [True: 4.08k, False: 0] ------------------ 1252| 4.08k| { 1253| 4.08k| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 1254| 4.08k| } 1255| | 1256| 4.08k| if (d->m_pOut_buf_size) ------------------ | Branch (1256:9): [True: 4.08k, False: 0] ------------------ 1257| 4.08k| { 1258| 4.08k| size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining); ------------------ | | 60| 4.08k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 4.08k] | | ------------------ ------------------ 1259| 4.08k| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n); 1260| 4.08k| d->m_output_flush_ofs += (mz_uint)n; 1261| 4.08k| d->m_output_flush_remaining -= (mz_uint)n; 1262| 4.08k| d->m_out_buf_ofs += n; 1263| | 1264| 4.08k| *d->m_pOut_buf_size = d->m_out_buf_ofs; 1265| 4.08k| } 1266| | 1267| 4.08k| return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; ------------------ | Branch (1267:13): [True: 2.04k, False: 2.04k] | Branch (1267:30): [True: 2.04k, False: 0] ------------------ 1268| 4.08k|} miniz_tdef.c:tdefl_compress_normal: 1105| 4.08k|{ 1106| 4.08k| const mz_uint8 *pSrc = d->m_pSrc; 1107| 4.08k| size_t src_buf_left = d->m_src_buf_left; 1108| 4.08k| tdefl_flush flush = d->m_flush; 1109| | 1110| 3.70M| while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) ------------------ | Branch (1110:12): [True: 3.49M, False: 211k] | Branch (1110:31): [True: 211k, False: 717] | Branch (1110:42): [True: 209k, False: 2.04k] ------------------ 1111| 3.70M| { 1112| 3.70M| mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos; 1113| | /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */ 1114| 3.70M| if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) ------------------ | Branch (1114:13): [True: 3.70M, False: 2.04k] ------------------ 1115| 3.70M| { 1116| 3.70M| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2; 1117| 3.70M| mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK]; 1118| 3.70M| mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); ------------------ | | 60| 3.70M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 210k, False: 3.49M] | | ------------------ ------------------ 1119| 3.70M| const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; ------------------ | Branch (1119:40): [True: 3.70M, False: 0] ------------------ 1120| 3.70M| src_buf_left -= num_bytes_to_process; 1121| 3.70M| d->m_lookahead_size += num_bytes_to_process; 1122| 11.5M| while (pSrc != pSrc_end) ------------------ | Branch (1122:20): [True: 7.81M, False: 3.70M] ------------------ 1123| 7.81M| { 1124| 7.81M| mz_uint8 c = *pSrc++; 1125| 7.81M| d->m_dict[dst_pos] = c; 1126| 7.81M| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1126:21): [True: 0, False: 7.81M] ------------------ 1127| 0| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1128| 7.81M| hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 1129| 7.81M| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1130| 7.81M| d->m_hash[hash] = (mz_uint16)(ins_pos); 1131| 7.81M| dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; 1132| 7.81M| ins_pos++; 1133| 7.81M| } 1134| 3.70M| } 1135| 2.04k| else 1136| 2.04k| { 1137| 528k| while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1137:20): [True: 528k, False: 0] | Branch (1137:38): [True: 526k, False: 2.04k] ------------------ 1138| 526k| { 1139| 526k| mz_uint8 c = *pSrc++; 1140| 526k| mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; 1141| 526k| src_buf_left--; 1142| 526k| d->m_dict[dst_pos] = c; 1143| 526k| if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) ------------------ | Branch (1143:21): [True: 524k, False: 2.04k] ------------------ 1144| 524k| d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; 1145| 526k| if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) ------------------ | Branch (1145:21): [True: 522k, False: 4.08k] ------------------ 1146| 522k| { 1147| 522k| mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; 1148| 522k| mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); 1149| 522k| d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; 1150| 522k| d->m_hash[hash] = (mz_uint16)(ins_pos); 1151| 522k| } 1152| 526k| } 1153| 2.04k| } 1154| 3.70M| d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); ------------------ | | 60| 3.70M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 3.70M] | | ------------------ ------------------ 1155| 3.70M| if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) ------------------ | Branch (1155:13): [True: 3.49M, False: 209k] | Branch (1155:25): [True: 1.32k, False: 3.49M] ------------------ 1156| 1.32k| break; 1157| | 1158| | /* Simple lazy/greedy parsing state machine. */ 1159| 3.70M| len_to_move = 1; 1160| 3.70M| cur_match_dist = 0; 1161| 3.70M| cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); ------------------ | Branch (1161:25): [True: 0, False: 3.70M] ------------------ 1162| 3.70M| cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; 1163| 3.70M| if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) ------------------ | Branch (1163:13): [True: 0, False: 3.70M] ------------------ 1164| 0| { 1165| 0| if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) ------------------ | Branch (1165:17): [True: 0, False: 0] | Branch (1165:37): [True: 0, False: 0] ------------------ 1166| 0| { 1167| 0| mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; 1168| 0| cur_match_len = 0; 1169| 0| while (cur_match_len < d->m_lookahead_size) ------------------ | Branch (1169:24): [True: 0, False: 0] ------------------ 1170| 0| { 1171| 0| if (d->m_dict[cur_pos + cur_match_len] != c) ------------------ | Branch (1171:25): [True: 0, False: 0] ------------------ 1172| 0| break; 1173| 0| cur_match_len++; 1174| 0| } 1175| 0| if (cur_match_len < TDEFL_MIN_MATCH_LEN) ------------------ | Branch (1175:21): [True: 0, False: 0] ------------------ 1176| 0| cur_match_len = 0; 1177| 0| else 1178| 0| cur_match_dist = 1; 1179| 0| } 1180| 0| } 1181| 3.70M| else 1182| 3.70M| { 1183| 3.70M| tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len); 1184| 3.70M| } 1185| 3.70M| if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) ------------------ | Branch (1185:14): [True: 103k, False: 3.59M] | Branch (1185:56): [True: 8.94k, False: 95.0k] | Branch (1185:91): [True: 2.04k, False: 3.69M] | Branch (1185:123): [True: 0, False: 3.69M] | Branch (1185:162): [True: 0, False: 0] ------------------ 1186| 10.9k| { 1187| 10.9k| cur_match_dist = cur_match_len = 0; 1188| 10.9k| } 1189| 3.70M| if (d->m_saved_match_len) ------------------ | Branch (1189:13): [True: 0, False: 3.70M] ------------------ 1190| 0| { 1191| 0| if (cur_match_len > d->m_saved_match_len) ------------------ | Branch (1191:17): [True: 0, False: 0] ------------------ 1192| 0| { 1193| 0| tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); 1194| 0| if (cur_match_len >= 128) ------------------ | Branch (1194:21): [True: 0, False: 0] ------------------ 1195| 0| { 1196| 0| tdefl_record_match(d, cur_match_len, cur_match_dist); 1197| 0| d->m_saved_match_len = 0; 1198| 0| len_to_move = cur_match_len; 1199| 0| } 1200| 0| else 1201| 0| { 1202| 0| d->m_saved_lit = d->m_dict[cur_pos]; 1203| 0| d->m_saved_match_dist = cur_match_dist; 1204| 0| d->m_saved_match_len = cur_match_len; 1205| 0| } 1206| 0| } 1207| 0| else 1208| 0| { 1209| 0| tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); 1210| 0| len_to_move = d->m_saved_match_len - 1; 1211| 0| d->m_saved_match_len = 0; 1212| 0| } 1213| 0| } 1214| 3.70M| else if (!cur_match_dist) ------------------ | Branch (1214:18): [True: 3.47M, False: 226k] ------------------ 1215| 3.47M| tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); ------------------ | | 60| 3.47M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 3.47M, False: 0] | | ------------------ ------------------ 1216| 226k| else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) ------------------ | Branch (1216:18): [True: 226k, False: 0] | Branch (1216:43): [True: 0, False: 0] | Branch (1216:79): [True: 0, False: 0] ------------------ 1217| 226k| { 1218| 226k| tdefl_record_match(d, cur_match_len, cur_match_dist); 1219| 226k| len_to_move = cur_match_len; 1220| 226k| } 1221| 0| else 1222| 0| { 1223| 0| d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; ------------------ | | 60| 0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 0, False: 0] | | ------------------ ------------------ 1224| 0| d->m_saved_match_dist = cur_match_dist; 1225| 0| d->m_saved_match_len = cur_match_len; 1226| 0| } 1227| | /* Move the lookahead forward by len_to_move bytes. */ 1228| 3.70M| d->m_lookahead_pos += len_to_move; 1229| 3.70M| MZ_ASSERT(d->m_lookahead_size >= len_to_move); ------------------ | | 47| 3.70M|#define MZ_ASSERT(x) assert(x) ------------------ 1230| 3.70M| d->m_lookahead_size -= len_to_move; 1231| 3.70M| d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); ------------------ | | 60| 3.70M|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 3.70M, False: 0] | | ------------------ ------------------ 1232| | /* Check if it's time to flush the current LZ codes to the internal output buffer. */ 1233| 3.70M| if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || ------------------ | Branch (1233:13): [True: 0, False: 3.70M] ------------------ 1234| 3.70M| ((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) ------------------ | Branch (1234:14): [True: 4.06k, False: 3.69M] | Branch (1234:52): [True: 43, False: 4.01k] | Branch (1234:143): [True: 0, False: 4.01k] ------------------ 1235| 43| { 1236| 43| int n; 1237| 43| d->m_pSrc = pSrc; 1238| 43| d->m_src_buf_left = src_buf_left; 1239| 43| if ((n = tdefl_flush_block(d, 0)) != 0) ------------------ | Branch (1239:17): [True: 0, False: 43] ------------------ 1240| 0| return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 19| 0|#define MZ_FALSE (0) ------------------ return (n < 0) ? MZ_FALSE : MZ_TRUE; ------------------ | | 20| 0|#define MZ_TRUE (1) ------------------ | Branch (1240:24): [True: 0, False: 0] ------------------ 1241| 43| } 1242| 3.70M| } 1243| | 1244| 4.08k| d->m_pSrc = pSrc; 1245| 4.08k| d->m_src_buf_left = src_buf_left; 1246| 4.08k| return MZ_TRUE; ------------------ | | 20| 4.08k|#define MZ_TRUE (1) ------------------ 1247| 4.08k|} miniz_tdef.c:tdefl_find_match: 834| 3.70M|{ 835| 3.70M| mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len; 836| 3.70M| mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; 837| 3.70M| const mz_uint8 *s = d->m_dict + pos, *p, *q; 838| 3.70M| mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; 839| 3.70M| MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); ------------------ | | 47| 3.70M|#define MZ_ASSERT(x) assert(x) ------------------ 840| 3.70M| if (max_match_len <= match_len) ------------------ | Branch (840:9): [True: 2.77k, False: 3.70M] ------------------ 841| 2.77k| return; 842| 3.70M| for (;;) 843| 5.08M| { 844| 5.08M| for (;;) 845| 6.52M| { 846| 6.52M| if (--num_probes_left == 0) ------------------ | Branch (846:17): [True: 27.6k, False: 6.49M] ------------------ 847| 27.6k| return; 848| 6.49M|#define TDEFL_PROBE \ 849| 6.49M| next_probe_pos = d->m_next[probe_pos]; \ 850| 6.49M| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ 851| 6.49M| return; \ 852| 6.49M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ 853| 6.49M| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ 854| 6.49M| break; 855| 12.6M| TDEFL_PROBE; ------------------ | | 849| 6.49M| next_probe_pos = d->m_next[probe_pos]; \ | | 850| 6.49M| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (850:9): [True: 2.73M, False: 3.76M] | | | Branch (850:30): [True: 0, False: 3.76M] | | ------------------ | | 851| 6.49M| return; \ | | 852| 6.49M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 853| 3.76M| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (853:9): [True: 1.66M, False: 2.09M] | | | Branch (853:53): [True: 1.33M, False: 332k] | | ------------------ | | 854| 3.76M| break; ------------------ 856| 12.6M| TDEFL_PROBE; ------------------ | | 849| 2.42M| next_probe_pos = d->m_next[probe_pos]; \ | | 850| 2.42M| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (850:9): [True: 671k, False: 1.75M] | | | Branch (850:30): [True: 0, False: 1.75M] | | ------------------ | | 851| 2.42M| return; \ | | 852| 2.42M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 853| 1.75M| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (853:9): [True: 236k, False: 1.52M] | | | Branch (853:53): [True: 36.1k, False: 200k] | | ------------------ | | 854| 1.75M| break; ------------------ 857| 3.48M| TDEFL_PROBE; ------------------ | | 849| 1.72M| next_probe_pos = d->m_next[probe_pos]; \ | | 850| 1.72M| if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ | | ------------------ | | | Branch (850:9): [True: 258k, False: 1.46M] | | | Branch (850:30): [True: 0, False: 1.46M] | | ------------------ | | 851| 1.72M| return; \ | | 852| 1.72M| probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ | | 853| 1.46M| if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ | | ------------------ | | | Branch (853:9): [True: 164k, False: 1.29M] | | | Branch (853:53): [True: 27.5k, False: 136k] | | ------------------ | | 854| 1.46M| break; ------------------ 858| 2.89M| } 859| 1.39M| if (!dist) ------------------ | Branch (859:13): [True: 0, False: 1.39M] ------------------ 860| 0| break; 861| 1.39M| p = s; 862| 1.39M| q = d->m_dict + probe_pos; 863| 14.2M| for (probe_len = 0; probe_len < max_match_len; probe_len++) ------------------ | Branch (863:29): [True: 14.1M, False: 8.01k] ------------------ 864| 14.1M| if (*p++ != *q++) ------------------ | Branch (864:17): [True: 1.38M, False: 12.8M] ------------------ 865| 1.38M| break; 866| 1.39M| if (probe_len > match_len) ------------------ | Branch (866:13): [True: 660k, False: 736k] ------------------ 867| 660k| { 868| 660k| *pMatch_dist = dist; 869| 660k| if ((*pMatch_len = match_len = probe_len) == max_match_len) ------------------ | Branch (869:17): [True: 8.01k, False: 652k] ------------------ 870| 8.01k| return; 871| 652k| c0 = d->m_dict[pos + match_len]; 872| 652k| c1 = d->m_dict[pos + match_len - 1]; 873| 652k| } 874| 1.39M| } 875| 3.70M|} miniz_tdef.c:tdefl_record_literal: 1064| 3.47M|{ 1065| 3.47M| d->m_total_lz_bytes++; 1066| 3.47M| *d->m_pLZ_code_buf++ = lit; 1067| 3.47M| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); 1068| 3.47M| if (--d->m_num_flags_left == 0) ------------------ | Branch (1068:9): [True: 433k, False: 3.04M] ------------------ 1069| 433k| { 1070| 433k| d->m_num_flags_left = 8; 1071| 433k| d->m_pLZ_flags = d->m_pLZ_code_buf++; 1072| 433k| } 1073| 3.47M| d->m_huff_count[0][lit]++; 1074| 3.47M|} miniz_tdef.c:tdefl_record_match: 1077| 226k|{ 1078| 226k| mz_uint32 s0, s1; 1079| | 1080| 226k| MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE)); ------------------ | | 47| 226k|#define MZ_ASSERT(x) assert(x) ------------------ 1081| | 1082| 226k| d->m_total_lz_bytes += match_len; 1083| | 1084| 226k| d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); 1085| | 1086| 226k| match_dist -= 1; 1087| 226k| d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); 1088| 226k| d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); 1089| 226k| d->m_pLZ_code_buf += 3; 1090| | 1091| 226k| *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); 1092| 226k| if (--d->m_num_flags_left == 0) ------------------ | Branch (1092:9): [True: 28.5k, False: 197k] ------------------ 1093| 28.5k| { 1094| 28.5k| d->m_num_flags_left = 8; 1095| 28.5k| d->m_pLZ_flags = d->m_pLZ_code_buf++; 1096| 28.5k| } 1097| | 1098| 226k| s0 = s_tdefl_small_dist_sym[match_dist & 511]; 1099| 226k| s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; 1100| 226k| d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; ------------------ | Branch (1100:24): [True: 129k, False: 97.1k] ------------------ 1101| 226k| d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; 1102| 226k|} miniz_tdef.c:tdefl_flush_block: 609| 2.08k|{ 610| 2.08k| mz_uint saved_bit_buf, saved_bits_in; 611| 2.08k| mz_uint8 *pSaved_output_buf; 612| 2.08k| mz_bool comp_block_succeeded = MZ_FALSE; ------------------ | | 19| 2.08k|#define MZ_FALSE (0) ------------------ 613| 2.08k| int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; ------------------ | Branch (613:28): [True: 0, False: 2.08k] | Branch (613:80): [True: 0, False: 0] ------------------ 614| 2.08k| mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf; ------------------ | Branch (614:36): [True: 2.08k, False: 0] | Branch (614:68): [True: 0, False: 2.08k] ------------------ 615| | 616| 2.08k| d->m_pOutput_buf = pOutput_buf_start; 617| 2.08k| d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; 618| | 619| 2.08k| MZ_ASSERT(!d->m_output_flush_remaining); ------------------ | | 47| 2.08k|#define MZ_ASSERT(x) assert(x) ------------------ 620| 2.08k| d->m_output_flush_ofs = 0; 621| 2.08k| d->m_output_flush_remaining = 0; 622| | 623| 2.08k| *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); 624| 2.08k| d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); 625| | 626| 2.08k| if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) ------------------ | Branch (626:9): [True: 0, False: 2.08k] | Branch (626:51): [True: 0, False: 0] ------------------ 627| 0| { 628| 0| const mz_uint8 cmf = 0x78; 629| 0| mz_uint8 flg, flevel = 3; 630| 0| mz_uint header, i, mz_un = sizeof(s_tdefl_num_probes) / sizeof(mz_uint); 631| | 632| | /* Determine compression level by reversing the process in tdefl_create_comp_flags_from_zip_params() */ 633| 0| for (i = 0; i < mz_un; i++) ------------------ | Branch (633:21): [True: 0, False: 0] ------------------ 634| 0| if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) break; ------------------ | Branch (634:17): [True: 0, False: 0] ------------------ 635| | 636| 0| if (i < 2) ------------------ | Branch (636:13): [True: 0, False: 0] ------------------ 637| 0| flevel = 0; 638| 0| else if (i < 6) ------------------ | Branch (638:18): [True: 0, False: 0] ------------------ 639| 0| flevel = 1; 640| 0| else if (i == 6) ------------------ | Branch (640:18): [True: 0, False: 0] ------------------ 641| 0| flevel = 2; 642| | 643| 0| header = cmf << 8 | (flevel << 6); 644| 0| header += 31 - (header % 31); 645| 0| flg = header & 0xFF; 646| | 647| 0| TDEFL_PUT_BITS(cmf, 8); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 648| 0| TDEFL_PUT_BITS(flg, 8); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 649| 0| } 650| | 651| 2.08k| TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); ------------------ | | 277| 2.08k| do \ | | 278| 2.08k| { \ | | 279| 2.08k| mz_uint bits = b; \ | | 280| 2.08k| mz_uint len = l; \ | | 281| 2.08k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.08k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.08k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.08k| d->m_bits_in += len; \ | | 284| 2.08k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 4, False: 2.08k] | | ------------------ | | 285| 2.08k| { \ | | 286| 4| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 4, False: 0] | | ------------------ | | 287| 4| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 4| d->m_bit_buffer >>= 8; \ | | 289| 4| d->m_bits_in -= 8; \ | | 290| 4| } \ | | 291| 2.08k| } \ | | 292| 2.08k| MZ_MACRO_END | | ------------------ | | | | 26| 2.08k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 652| | 653| 2.08k| pSaved_output_buf = d->m_pOutput_buf; 654| 2.08k| saved_bit_buf = d->m_bit_buffer; 655| 2.08k| saved_bits_in = d->m_bits_in; 656| | 657| 2.08k| if (!use_raw_block) ------------------ | Branch (657:9): [True: 2.08k, False: 0] ------------------ 658| 2.08k| comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48)); ------------------ | Branch (658:56): [True: 0, False: 2.08k] | Branch (658:104): [True: 22, False: 2.06k] ------------------ 659| | 660| | /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */ 661| 2.08k| if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && ------------------ | Branch (661:10): [True: 0, False: 2.08k] | Branch (661:30): [True: 2.07k, False: 9] | Branch (661:55): [True: 118, False: 1.95k] ------------------ 662| 2.08k| ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) ------------------ | Branch (662:9): [True: 118, False: 0] ------------------ 663| 118| { 664| 118| mz_uint i; 665| 118| d->m_pOutput_buf = pSaved_output_buf; 666| 118| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 667| 118| TDEFL_PUT_BITS(0, 2); ------------------ | | 277| 118| do \ | | 278| 118| { \ | | 279| 118| mz_uint bits = b; \ | | 280| 118| mz_uint len = l; \ | | 281| 118| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 118|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 118| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 118| d->m_bits_in += len; \ | | 284| 125| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 7, False: 118] | | ------------------ | | 285| 118| { \ | | 286| 7| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 7, False: 0] | | ------------------ | | 287| 7| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 7| d->m_bit_buffer >>= 8; \ | | 289| 7| d->m_bits_in -= 8; \ | | 290| 7| } \ | | 291| 118| } \ | | 292| 118| MZ_MACRO_END | | ------------------ | | | | 26| 118|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 668| 118| if (d->m_bits_in) ------------------ | Branch (668:13): [True: 114, False: 4] ------------------ 669| 114| { 670| 114| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 277| 114| do \ | | 278| 114| { \ | | 279| 114| mz_uint bits = b; \ | | 280| 114| mz_uint len = l; \ | | 281| 114| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 114|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 114| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 114| d->m_bits_in += len; \ | | 284| 228| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 114, False: 114] | | ------------------ | | 285| 114| { \ | | 286| 114| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 114, False: 0] | | ------------------ | | 287| 114| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 114| d->m_bit_buffer >>= 8; \ | | 289| 114| d->m_bits_in -= 8; \ | | 290| 114| } \ | | 291| 114| } \ | | 292| 114| MZ_MACRO_END | | ------------------ | | | | 26| 114|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 671| 114| } 672| 354| for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) ------------------ | Branch (672:21): [True: 236, False: 118] ------------------ 673| 236| { 674| 236| TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); ------------------ | | 277| 236| do \ | | 278| 236| { \ | | 279| 236| mz_uint bits = b; \ | | 280| 236| mz_uint len = l; \ | | 281| 236| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 236|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 236| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 236| d->m_bits_in += len; \ | | 284| 708| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 472, False: 236] | | ------------------ | | 285| 472| { \ | | 286| 472| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 472, False: 0] | | ------------------ | | 287| 472| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 472| d->m_bit_buffer >>= 8; \ | | 289| 472| d->m_bits_in -= 8; \ | | 290| 472| } \ | | 291| 236| } \ | | 292| 236| MZ_MACRO_END | | ------------------ | | | | 26| 236|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 675| 236| } 676| 472k| for (i = 0; i < d->m_total_lz_bytes; ++i) ------------------ | Branch (676:21): [True: 472k, False: 118] ------------------ 677| 472k| { 678| 472k| TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); ------------------ | | 277| 472k| do \ | | 278| 472k| { \ | | 279| 472k| mz_uint bits = b; \ | | 280| 472k| mz_uint len = l; \ | | 281| 472k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 472k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 472k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 472k| d->m_bits_in += len; \ | | 284| 944k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 472k, False: 472k] | | ------------------ | | 285| 472k| { \ | | 286| 472k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 472k, False: 0] | | ------------------ | | 287| 472k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 472k| d->m_bit_buffer >>= 8; \ | | 289| 472k| d->m_bits_in -= 8; \ | | 290| 472k| } \ | | 291| 472k| } \ | | 292| 472k| MZ_MACRO_END | | ------------------ | | | | 26| 472k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 679| 472k| } 680| 118| } 681| | /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */ 682| 1.96k| else if (!comp_block_succeeded) ------------------ | Branch (682:14): [True: 0, False: 1.96k] ------------------ 683| 0| { 684| 0| d->m_pOutput_buf = pSaved_output_buf; 685| 0| d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; 686| 0| tdefl_compress_block(d, MZ_TRUE); ------------------ | | 20| 0|#define MZ_TRUE (1) ------------------ 687| 0| } 688| | 689| 2.08k| if (flush) ------------------ | Branch (689:9): [True: 2.04k, False: 43] ------------------ 690| 2.04k| { 691| 2.04k| if (flush == TDEFL_FINISH) ------------------ | Branch (691:13): [True: 2.04k, False: 0] ------------------ 692| 2.04k| { 693| 2.04k| if (d->m_bits_in) ------------------ | Branch (693:17): [True: 1.67k, False: 364] ------------------ 694| 1.67k| { 695| 1.67k| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 277| 1.67k| do \ | | 278| 1.67k| { \ | | 279| 1.67k| mz_uint bits = b; \ | | 280| 1.67k| mz_uint len = l; \ | | 281| 1.67k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 1.67k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 1.67k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 1.67k| d->m_bits_in += len; \ | | 284| 3.35k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 1.67k, False: 1.67k] | | ------------------ | | 285| 1.67k| { \ | | 286| 1.67k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 1.67k, False: 0] | | ------------------ | | 287| 1.67k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 1.67k| d->m_bit_buffer >>= 8; \ | | 289| 1.67k| d->m_bits_in -= 8; \ | | 290| 1.67k| } \ | | 291| 1.67k| } \ | | 292| 1.67k| MZ_MACRO_END | | ------------------ | | | | 26| 1.67k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 696| 1.67k| } 697| 2.04k| if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) ------------------ | Branch (697:17): [True: 0, False: 2.04k] ------------------ 698| 0| { 699| 0| mz_uint i, a = d->m_adler32; 700| 0| for (i = 0; i < 4; i++) ------------------ | Branch (700:29): [True: 0, False: 0] ------------------ 701| 0| { 702| 0| TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 703| 0| a <<= 8; 704| 0| } 705| 0| } 706| 2.04k| } 707| 0| else 708| 0| { 709| 0| mz_uint i, z = 0; 710| 0| TDEFL_PUT_BITS(0, 3); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 711| 0| if (d->m_bits_in) ------------------ | Branch (711:17): [True: 0, False: 0] ------------------ 712| 0| { 713| 0| TDEFL_PUT_BITS(0, 8 - d->m_bits_in); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 714| 0| } 715| 0| for (i = 2; i; --i, z ^= 0xFFFF) ------------------ | Branch (715:25): [True: 0, False: 0] ------------------ 716| 0| { 717| 0| TDEFL_PUT_BITS(z & 0xFFFF, 16); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| mz_uint bits = b; \ | | 280| 0| mz_uint len = l; \ | | 281| 0| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 0|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 0| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 0| d->m_bits_in += len; \ | | 284| 0| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 0, False: 0] | | ------------------ | | 285| 0| { \ | | 286| 0| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 0, False: 0] | | ------------------ | | 287| 0| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 0| d->m_bit_buffer >>= 8; \ | | 289| 0| d->m_bits_in -= 8; \ | | 290| 0| } \ | | 291| 0| } \ | | 292| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 718| 0| } 719| 0| } 720| 2.04k| } 721| | 722| 2.08k| MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); ------------------ | | 47| 2.08k|#define MZ_ASSERT(x) assert(x) ------------------ 723| | 724| 2.08k| memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); 725| 2.08k| memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); 726| | 727| 2.08k| d->m_pLZ_code_buf = d->m_lz_code_buf + 1; 728| 2.08k| d->m_pLZ_flags = d->m_lz_code_buf; 729| 2.08k| d->m_num_flags_left = 8; 730| 2.08k| d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; 731| 2.08k| d->m_total_lz_bytes = 0; 732| 2.08k| d->m_block_index++; 733| | 734| 2.08k| if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) ------------------ | Branch (734:9): [True: 2.08k, False: 0] ------------------ 735| 2.08k| { 736| 2.08k| if (d->m_pPut_buf_func) ------------------ | Branch (736:13): [True: 0, False: 2.08k] ------------------ 737| 0| { 738| 0| *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; 739| 0| if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) ------------------ | Branch (739:17): [True: 0, False: 0] ------------------ 740| 0| return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); 741| 0| } 742| 2.08k| else if (pOutput_buf_start == d->m_output_buf) ------------------ | Branch (742:18): [True: 2.08k, False: 0] ------------------ 743| 2.08k| { 744| 2.08k| int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); ------------------ | | 60| 2.08k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 2.08k, False: 0] | | ------------------ ------------------ 745| 2.08k| memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy); 746| 2.08k| d->m_out_buf_ofs += bytes_to_copy; 747| 2.08k| if ((n -= bytes_to_copy) != 0) ------------------ | Branch (747:17): [True: 0, False: 2.08k] ------------------ 748| 0| { 749| 0| d->m_output_flush_ofs = bytes_to_copy; 750| 0| d->m_output_flush_remaining = n; 751| 0| } 752| 2.08k| } 753| 0| else 754| 0| { 755| 0| d->m_out_buf_ofs += n; 756| 0| } 757| 2.08k| } 758| | 759| 2.08k| return d->m_output_flush_remaining; 760| 2.08k|} miniz_tdef.c:tdefl_compress_block: 598| 2.08k|{ 599| 2.08k| if (static_block) ------------------ | Branch (599:9): [True: 22, False: 2.06k] ------------------ 600| 22| tdefl_start_static_block(d); 601| 2.06k| else 602| 2.06k| tdefl_start_dynamic_block(d); 603| 2.08k| return tdefl_compress_lz_codes(d); 604| 2.08k|} miniz_tdef.c:tdefl_start_static_block: 430| 22|{ 431| 22| mz_uint i; 432| 22| mz_uint8 *p = &d->m_huff_code_sizes[0][0]; 433| | 434| 3.19k| for (i = 0; i <= 143; ++i) ------------------ | Branch (434:17): [True: 3.16k, False: 22] ------------------ 435| 3.16k| *p++ = 8; 436| 2.48k| for (; i <= 255; ++i) ------------------ | Branch (436:12): [True: 2.46k, False: 22] ------------------ 437| 2.46k| *p++ = 9; 438| 550| for (; i <= 279; ++i) ------------------ | Branch (438:12): [True: 528, False: 22] ------------------ 439| 528| *p++ = 7; 440| 198| for (; i <= 287; ++i) ------------------ | Branch (440:12): [True: 176, False: 22] ------------------ 441| 176| *p++ = 8; 442| | 443| 22| memset(d->m_huff_code_sizes[1], 5, 32); 444| | 445| 22| tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE); ------------------ | | 20| 22|#define MZ_TRUE (1) ------------------ 446| 22| tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE); ------------------ | | 20| 22|#define MZ_TRUE (1) ------------------ 447| | 448| 22| TDEFL_PUT_BITS(1, 2); ------------------ | | 277| 22| do \ | | 278| 22| { \ | | 279| 22| mz_uint bits = b; \ | | 280| 22| mz_uint len = l; \ | | 281| 22| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 22|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 22| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 22| d->m_bits_in += len; \ | | 284| 30| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 8, False: 22] | | ------------------ | | 285| 22| { \ | | 286| 8| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 8, False: 0] | | ------------------ | | 287| 8| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 8| d->m_bit_buffer >>= 8; \ | | 289| 8| d->m_bits_in -= 8; \ | | 290| 8| } \ | | 291| 22| } \ | | 292| 22| MZ_MACRO_END | | ------------------ | | | | 26| 22|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 449| 22|} miniz_tdef.c:tdefl_optimize_huffman_table: 224| 6.23k|{ 225| 6.23k| int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; 226| 6.23k| mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; 227| 6.23k| MZ_CLEAR_ARR(num_codes); ------------------ | | 62| 6.23k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 228| 6.23k| if (static_table) ------------------ | Branch (228:9): [True: 44, False: 6.18k] ------------------ 229| 44| { 230| 7.08k| for (i = 0; i < table_len; i++) ------------------ | Branch (230:21): [True: 7.04k, False: 44] ------------------ 231| 7.04k| num_codes[d->m_huff_code_sizes[table_num][i]]++; 232| 44| } 233| 6.18k| else 234| 6.18k| { 235| 6.18k| tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms; 236| 6.18k| int num_used_syms = 0; 237| 6.18k| const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; 238| 705k| for (i = 0; i < table_len; i++) ------------------ | Branch (238:21): [True: 699k, False: 6.18k] ------------------ 239| 699k| if (pSym_count[i]) ------------------ | Branch (239:17): [True: 352k, False: 346k] ------------------ 240| 352k| { 241| 352k| syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; 242| 352k| syms0[num_used_syms++].m_sym_index = (mz_uint16)i; 243| 352k| } 244| | 245| 6.18k| pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); 246| 6.18k| tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); 247| | 248| 358k| for (i = 0; i < num_used_syms; i++) ------------------ | Branch (248:21): [True: 352k, False: 6.18k] ------------------ 249| 352k| num_codes[pSyms[i].m_key]++; 250| | 251| 6.18k| tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit); 252| | 253| 6.18k| MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]); ------------------ | | 62| 6.18k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 254| 6.18k| MZ_CLEAR_ARR(d->m_huff_codes[table_num]); ------------------ | | 62| 6.18k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 255| 82.4k| for (i = 1, j = num_used_syms; i <= code_size_limit; i++) ------------------ | Branch (255:40): [True: 76.2k, False: 6.18k] ------------------ 256| 429k| for (l = num_codes[i]; l > 0; l--) ------------------ | Branch (256:36): [True: 352k, False: 76.2k] ------------------ 257| 352k| d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); 258| 6.18k| } 259| | 260| 6.23k| next_code[1] = 0; 261| 76.9k| for (j = 0, i = 2; i <= code_size_limit; i++) ------------------ | Branch (261:24): [True: 70.7k, False: 6.23k] ------------------ 262| 70.7k| next_code[i] = j = ((j + num_codes[i - 1]) << 1); 263| | 264| 712k| for (i = 0; i < table_len; i++) ------------------ | Branch (264:17): [True: 706k, False: 6.23k] ------------------ 265| 706k| { 266| 706k| mz_uint rev_code = 0, code, code_size; 267| 706k| if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) ------------------ | Branch (267:13): [True: 346k, False: 359k] ------------------ 268| 346k| continue; 269| 359k| code = next_code[code_size]++; 270| 3.03M| for (l = code_size; l > 0; l--, code >>= 1) ------------------ | Branch (270:29): [True: 2.67M, False: 359k] ------------------ 271| 2.67M| rev_code = (rev_code << 1) | (code & 1); 272| 359k| d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; 273| 359k| } 274| 6.23k|} miniz_tdef.c:tdefl_radix_sort_syms: 106| 6.18k|{ 107| 6.18k| mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; 108| 6.18k| tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; 109| 6.18k| MZ_CLEAR_ARR(hist); ------------------ | | 62| 6.18k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 110| 358k| for (i = 0; i < num_syms; i++) ------------------ | Branch (110:17): [True: 352k, False: 6.18k] ------------------ 111| 352k| { 112| 352k| mz_uint freq = pSyms0[i].m_key; 113| 352k| hist[freq & 0xFF]++; 114| 352k| hist[256 + ((freq >> 8) & 0xFF)]++; 115| 352k| } 116| 12.1k| while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) ------------------ | Branch (116:12): [True: 6.18k, False: 6.01k] | Branch (116:34): [True: 6.01k, False: 174] ------------------ 117| 6.01k| total_passes--; 118| 12.5k| for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) ------------------ | Branch (118:36): [True: 6.36k, False: 6.18k] ------------------ 119| 6.36k| { 120| 6.36k| const mz_uint32 *pHist = &hist[pass << 8]; 121| 6.36k| mz_uint offsets[256], cur_ofs = 0; 122| 1.63M| for (i = 0; i < 256; i++) ------------------ | Branch (122:21): [True: 1.62M, False: 6.36k] ------------------ 123| 1.62M| { 124| 1.62M| offsets[i] = cur_ofs; 125| 1.62M| cur_ofs += pHist[i]; 126| 1.62M| } 127| 392k| for (i = 0; i < num_syms; i++) ------------------ | Branch (127:21): [True: 386k, False: 6.36k] ------------------ 128| 386k| pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i]; 129| 6.36k| { 130| 6.36k| tdefl_sym_freq *t = pCur_syms; 131| 6.36k| pCur_syms = pNew_syms; 132| 6.36k| pNew_syms = t; 133| 6.36k| } 134| 6.36k| } 135| 6.18k| return pCur_syms; 136| 6.18k|} miniz_tdef.c:tdefl_calculate_minimum_redundancy: 140| 6.18k|{ 141| 6.18k| int root, leaf, next, avbl, used, dpth; 142| 6.18k| if (n == 0) ------------------ | Branch (142:9): [True: 20, False: 6.16k] ------------------ 143| 20| return; 144| 6.16k| else if (n == 1) ------------------ | Branch (144:14): [True: 60, False: 6.10k] ------------------ 145| 60| { 146| 60| A[0].m_key = 1; 147| 60| return; 148| 60| } 149| 6.10k| A[0].m_key += A[1].m_key; 150| 6.10k| root = 0; 151| 6.10k| leaf = 2; 152| 346k| for (next = 1; next < n - 1; next++) ------------------ | Branch (152:20): [True: 340k, False: 6.10k] ------------------ 153| 340k| { 154| 340k| if (leaf >= n || A[root].m_key < A[leaf].m_key) ------------------ | Branch (154:13): [True: 41.0k, False: 299k] | Branch (154:26): [True: 127k, False: 171k] ------------------ 155| 168k| { 156| 168k| A[next].m_key = A[root].m_key; 157| 168k| A[root++].m_key = (mz_uint16)next; 158| 168k| } 159| 171k| else 160| 171k| A[next].m_key = A[leaf++].m_key; 161| 340k| if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) ------------------ | Branch (161:13): [True: 43.9k, False: 296k] | Branch (161:27): [True: 294k, False: 1.91k] | Branch (161:42): [True: 127k, False: 166k] ------------------ 162| 171k| { 163| 171k| A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); 164| 171k| A[root++].m_key = (mz_uint16)next; 165| 171k| } 166| 168k| else 167| 168k| A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); 168| 340k| } 169| 6.10k| A[n - 2].m_key = 0; 170| 346k| for (next = n - 3; next >= 0; next--) ------------------ | Branch (170:24): [True: 340k, False: 6.10k] ------------------ 171| 340k| A[next].m_key = A[A[next].m_key].m_key + 1; 172| 6.10k| avbl = 1; 173| 6.10k| used = dpth = 0; 174| 6.10k| root = n - 2; 175| 6.10k| next = n - 1; 176| 54.1k| while (avbl > 0) ------------------ | Branch (176:12): [True: 48.0k, False: 6.10k] ------------------ 177| 48.0k| { 178| 394k| while (root >= 0 && (int)A[root].m_key == dpth) ------------------ | Branch (178:16): [True: 382k, False: 12.2k] | Branch (178:29): [True: 346k, False: 35.8k] ------------------ 179| 346k| { 180| 346k| used++; 181| 346k| root--; 182| 346k| } 183| 400k| while (avbl > used) ------------------ | Branch (183:16): [True: 352k, False: 48.0k] ------------------ 184| 352k| { 185| 352k| A[next--].m_key = (mz_uint16)(dpth); 186| 352k| avbl--; 187| 352k| } 188| 48.0k| avbl = 2 * used; 189| 48.0k| dpth++; 190| 48.0k| used = 0; 191| 48.0k| } 192| 6.10k|} miniz_tdef.c:tdefl_huffman_enforce_max_code_size: 200| 6.18k|{ 201| 6.18k| int i; 202| 6.18k| mz_uint32 total = 0; 203| 6.18k| if (code_list_len <= 1) ------------------ | Branch (203:9): [True: 80, False: 6.10k] ------------------ 204| 80| return; 205| 126k| for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) ------------------ | Branch (205:33): [True: 120k, False: 6.10k] ------------------ 206| 120k| pNum_codes[max_code_size] += pNum_codes[i]; 207| 81.2k| for (i = max_code_size; i > 0; i--) ------------------ | Branch (207:29): [True: 75.0k, False: 6.10k] ------------------ 208| 75.0k| total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); 209| 6.67k| while (total != (1UL << max_code_size)) ------------------ | Branch (209:12): [True: 568, False: 6.10k] ------------------ 210| 568| { 211| 568| pNum_codes[max_code_size]--; 212| 772| for (i = max_code_size - 1; i > 0; i--) ------------------ | Branch (212:37): [True: 772, False: 0] ------------------ 213| 772| if (pNum_codes[i]) ------------------ | Branch (213:17): [True: 568, False: 204] ------------------ 214| 568| { 215| 568| pNum_codes[i]--; 216| 568| pNum_codes[i + 1] += 2; 217| 568| break; 218| 568| } 219| 568| total--; 220| 568| } 221| 6.10k|} miniz_tdef.c:tdefl_start_dynamic_block: 343| 2.06k|{ 344| 2.06k| int num_lit_codes, num_dist_codes, num_bit_lengths; 345| 2.06k| mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index; 346| 2.06k| mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF; 347| | 348| 2.06k| d->m_huff_count[0][256] = 1; 349| | 350| 2.06k| tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); ------------------ | | 19| 2.06k|#define MZ_FALSE (0) ------------------ 351| 2.06k| tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); ------------------ | | 19| 2.06k|#define MZ_FALSE (0) ------------------ 352| | 353| 18.2k| for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) ------------------ | Branch (353:31): [True: 18.2k, False: 20] ------------------ 354| 18.2k| if (d->m_huff_code_sizes[0][num_lit_codes - 1]) ------------------ | Branch (354:13): [True: 2.04k, False: 16.1k] ------------------ 355| 2.04k| break; 356| 24.1k| for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) ------------------ | Branch (356:31): [True: 24.1k, False: 66] ------------------ 357| 24.1k| if (d->m_huff_code_sizes[1][num_dist_codes - 1]) ------------------ | Branch (357:13): [True: 1.99k, False: 22.1k] ------------------ 358| 1.99k| break; 359| | 360| 2.06k| memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); 361| 2.06k| memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); 362| 2.06k| total_code_sizes_to_pack = num_lit_codes + num_dist_codes; 363| 2.06k| num_packed_code_sizes = 0; 364| 2.06k| rle_z_count = 0; 365| 2.06k| rle_repeat_count = 0; 366| | 367| 2.06k| memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); 368| 615k| for (i = 0; i < total_code_sizes_to_pack; i++) ------------------ | Branch (368:17): [True: 613k, False: 2.06k] ------------------ 369| 613k| { 370| 613k| mz_uint8 code_size = code_sizes_to_pack[i]; 371| 613k| if (!code_size) ------------------ | Branch (371:13): [True: 282k, False: 331k] ------------------ 372| 282k| { 373| 282k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 295| 282k| { \ | | 296| 282k| if (rle_repeat_count) \ | | ------------------ | | | Branch (296:13): [True: 22.5k, False: 259k] | | ------------------ | | 297| 282k| { \ | | 298| 22.5k| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (298:17): [True: 19.8k, False: 2.70k] | | ------------------ | | 299| 22.5k| { \ | | 300| 19.8k| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 301| 44.5k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (301:24): [True: 24.7k, False: 19.8k] | | ------------------ | | 302| 24.7k| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 303| 19.8k| } \ | | 304| 22.5k| else \ | | 305| 22.5k| { \ | | 306| 2.70k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 307| 2.70k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 308| 2.70k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 309| 2.70k| } \ | | 310| 22.5k| rle_repeat_count = 0; \ | | 311| 22.5k| } \ | | 312| 282k| } ------------------ 374| 282k| if (++rle_z_count == 138) ------------------ | Branch (374:17): [True: 54, False: 282k] ------------------ 375| 54| { 376| 54| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 315| 54| { \ | | 316| 54| if (rle_z_count) \ | | ------------------ | | | Branch (316:13): [True: 54, False: 0] | | ------------------ | | 317| 54| { \ | | 318| 54| if (rle_z_count < 3) \ | | ------------------ | | | Branch (318:17): [True: 0, False: 54] | | ------------------ | | 319| 54| { \ | | 320| 0| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 321| 0| while (rle_z_count--) \ | | ------------------ | | | Branch (321:24): [True: 0, False: 0] | | ------------------ | | 322| 0| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 323| 0| } \ | | 324| 54| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (324:22): [True: 0, False: 54] | | ------------------ | | 325| 54| { \ | | 326| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 327| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 328| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 329| 0| } \ | | 330| 54| else \ | | 331| 54| { \ | | 332| 54| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 333| 54| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 334| 54| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 335| 54| } \ | | 336| 54| rle_z_count = 0; \ | | 337| 54| } \ | | 338| 54| } ------------------ 377| 54| } 378| 282k| } 379| 331k| else 380| 331k| { 381| 331k| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 315| 331k| { \ | | 316| 331k| if (rle_z_count) \ | | ------------------ | | | Branch (316:13): [True: 95.0k, False: 236k] | | ------------------ | | 317| 331k| { \ | | 318| 95.0k| if (rle_z_count < 3) \ | | ------------------ | | | Branch (318:17): [True: 66.6k, False: 28.3k] | | ------------------ | | 319| 95.0k| { \ | | 320| 66.6k| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 321| 151k| while (rle_z_count--) \ | | ------------------ | | | Branch (321:24): [True: 84.5k, False: 66.6k] | | ------------------ | | 322| 84.5k| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 323| 66.6k| } \ | | 324| 95.0k| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (324:22): [True: 24.8k, False: 3.53k] | | ------------------ | | 325| 28.3k| { \ | | 326| 24.8k| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 327| 24.8k| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 328| 24.8k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 329| 24.8k| } \ | | 330| 28.3k| else \ | | 331| 28.3k| { \ | | 332| 3.53k| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 333| 3.53k| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 334| 3.53k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 335| 3.53k| } \ | | 336| 95.0k| rle_z_count = 0; \ | | 337| 95.0k| } \ | | 338| 331k| } ------------------ 382| 331k| if (code_size != prev_code_size) ------------------ | Branch (382:17): [True: 218k, False: 112k] ------------------ 383| 218k| { 384| 218k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 295| 218k| { \ | | 296| 218k| if (rle_repeat_count) \ | | ------------------ | | | Branch (296:13): [True: 31.3k, False: 187k] | | ------------------ | | 297| 218k| { \ | | 298| 31.3k| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (298:17): [True: 26.5k, False: 4.82k] | | ------------------ | | 299| 31.3k| { \ | | 300| 26.5k| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 301| 59.8k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (301:24): [True: 33.3k, False: 26.5k] | | ------------------ | | 302| 33.3k| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 303| 26.5k| } \ | | 304| 31.3k| else \ | | 305| 31.3k| { \ | | 306| 4.82k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 307| 4.82k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 308| 4.82k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 309| 4.82k| } \ | | 310| 31.3k| rle_repeat_count = 0; \ | | 311| 31.3k| } \ | | 312| 218k| } ------------------ 385| 218k| d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); 386| 218k| packed_code_sizes[num_packed_code_sizes++] = code_size; 387| 218k| } 388| 112k| else if (++rle_repeat_count == 6) ------------------ | Branch (388:22): [True: 4.52k, False: 108k] ------------------ 389| 4.52k| { 390| 4.52k| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 295| 4.52k| { \ | | 296| 4.52k| if (rle_repeat_count) \ | | ------------------ | | | Branch (296:13): [True: 4.52k, False: 0] | | ------------------ | | 297| 4.52k| { \ | | 298| 4.52k| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (298:17): [True: 0, False: 4.52k] | | ------------------ | | 299| 4.52k| { \ | | 300| 0| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 301| 0| while (rle_repeat_count--) \ | | ------------------ | | | Branch (301:24): [True: 0, False: 0] | | ------------------ | | 302| 0| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 303| 0| } \ | | 304| 4.52k| else \ | | 305| 4.52k| { \ | | 306| 4.52k| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 307| 4.52k| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 308| 4.52k| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 309| 4.52k| } \ | | 310| 4.52k| rle_repeat_count = 0; \ | | 311| 4.52k| } \ | | 312| 4.52k| } ------------------ 391| 4.52k| } 392| 331k| } 393| 613k| prev_code_size = code_size; 394| 613k| } 395| 2.06k| if (rle_repeat_count) ------------------ | Branch (395:9): [True: 540, False: 1.52k] ------------------ 396| 540| { 397| 540| TDEFL_RLE_PREV_CODE_SIZE(); ------------------ | | 295| 540| { \ | | 296| 540| if (rle_repeat_count) \ | | ------------------ | | | Branch (296:13): [True: 540, False: 0] | | ------------------ | | 297| 540| { \ | | 298| 540| if (rle_repeat_count < 3) \ | | ------------------ | | | Branch (298:17): [True: 480, False: 60] | | ------------------ | | 299| 540| { \ | | 300| 480| d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ | | 301| 1.06k| while (rle_repeat_count--) \ | | ------------------ | | | Branch (301:24): [True: 582, False: 480] | | ------------------ | | 302| 582| packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ | | 303| 480| } \ | | 304| 540| else \ | | 305| 540| { \ | | 306| 60| d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ | | 307| 60| packed_code_sizes[num_packed_code_sizes++] = 16; \ | | 308| 60| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ | | 309| 60| } \ | | 310| 540| rle_repeat_count = 0; \ | | 311| 540| } \ | | 312| 540| } ------------------ 398| 540| } 399| 1.52k| else 400| 1.52k| { 401| 1.52k| TDEFL_RLE_ZERO_CODE_SIZE(); ------------------ | | 315| 1.52k| { \ | | 316| 1.52k| if (rle_z_count) \ | | ------------------ | | | Branch (316:13): [True: 20, False: 1.50k] | | ------------------ | | 317| 1.52k| { \ | | 318| 20| if (rle_z_count < 3) \ | | ------------------ | | | Branch (318:17): [True: 20, False: 0] | | ------------------ | | 319| 20| { \ | | 320| 20| d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ | | 321| 40| while (rle_z_count--) \ | | ------------------ | | | Branch (321:24): [True: 20, False: 20] | | ------------------ | | 322| 20| packed_code_sizes[num_packed_code_sizes++] = 0; \ | | 323| 20| } \ | | 324| 20| else if (rle_z_count <= 10) \ | | ------------------ | | | Branch (324:22): [True: 0, False: 0] | | ------------------ | | 325| 0| { \ | | 326| 0| d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ | | 327| 0| packed_code_sizes[num_packed_code_sizes++] = 17; \ | | 328| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ | | 329| 0| } \ | | 330| 0| else \ | | 331| 0| { \ | | 332| 0| d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ | | 333| 0| packed_code_sizes[num_packed_code_sizes++] = 18; \ | | 334| 0| packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ | | 335| 0| } \ | | 336| 20| rle_z_count = 0; \ | | 337| 20| } \ | | 338| 1.52k| } ------------------ 402| 1.52k| } 403| | 404| 2.06k| tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); ------------------ | | 19| 2.06k|#define MZ_FALSE (0) ------------------ 405| | 406| 2.06k| TDEFL_PUT_BITS(2, 2); ------------------ | | 277| 2.06k| do \ | | 278| 2.06k| { \ | | 279| 2.06k| mz_uint bits = b; \ | | 280| 2.06k| mz_uint len = l; \ | | 281| 2.06k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.06k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.06k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.06k| d->m_bits_in += len; \ | | 284| 2.06k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 6, False: 2.06k] | | ------------------ | | 285| 2.06k| { \ | | 286| 6| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 6, False: 0] | | ------------------ | | 287| 6| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 6| d->m_bit_buffer >>= 8; \ | | 289| 6| d->m_bits_in -= 8; \ | | 290| 6| } \ | | 291| 2.06k| } \ | | 292| 2.06k| MZ_MACRO_END | | ------------------ | | | | 26| 2.06k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 407| | 408| 2.06k| TDEFL_PUT_BITS(num_lit_codes - 257, 5); ------------------ | | 277| 2.06k| do \ | | 278| 2.06k| { \ | | 279| 2.06k| mz_uint bits = b; \ | | 280| 2.06k| mz_uint len = l; \ | | 281| 2.06k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.06k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.06k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.06k| d->m_bits_in += len; \ | | 284| 4.11k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 2.05k, False: 2.06k] | | ------------------ | | 285| 2.06k| { \ | | 286| 2.05k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 2.05k, False: 0] | | ------------------ | | 287| 2.05k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 2.05k| d->m_bit_buffer >>= 8; \ | | 289| 2.05k| d->m_bits_in -= 8; \ | | 290| 2.05k| } \ | | 291| 2.06k| } \ | | 292| 2.06k| MZ_MACRO_END | | ------------------ | | | | 26| 2.06k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 409| 2.06k| TDEFL_PUT_BITS(num_dist_codes - 1, 5); ------------------ | | 277| 2.06k| do \ | | 278| 2.06k| { \ | | 279| 2.06k| mz_uint bits = b; \ | | 280| 2.06k| mz_uint len = l; \ | | 281| 2.06k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.06k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.06k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.06k| d->m_bits_in += len; \ | | 284| 2.07k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 11, False: 2.06k] | | ------------------ | | 285| 2.06k| { \ | | 286| 11| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 11, False: 0] | | ------------------ | | 287| 11| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 11| d->m_bit_buffer >>= 8; \ | | 289| 11| d->m_bits_in -= 8; \ | | 290| 11| } \ | | 291| 2.06k| } \ | | 292| 2.06k| MZ_MACRO_END | | ------------------ | | | | 26| 2.06k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 410| | 411| 7.75k| for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) ------------------ | Branch (411:32): [True: 7.75k, False: 0] ------------------ 412| 7.75k| if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) ------------------ | Branch (412:13): [True: 2.06k, False: 5.68k] ------------------ 413| 2.06k| break; 414| 2.06k| num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); ------------------ | | 59| 2.06k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (59:23): [True: 0, False: 2.06k] | | ------------------ ------------------ 415| 2.06k| TDEFL_PUT_BITS(num_bit_lengths - 4, 4); ------------------ | | 277| 2.06k| do \ | | 278| 2.06k| { \ | | 279| 2.06k| mz_uint bits = b; \ | | 280| 2.06k| mz_uint len = l; \ | | 281| 2.06k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.06k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.06k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.06k| d->m_bits_in += len; \ | | 284| 4.11k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 2.05k, False: 2.06k] | | ------------------ | | 285| 2.06k| { \ | | 286| 2.05k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 2.05k, False: 0] | | ------------------ | | 287| 2.05k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 2.05k| d->m_bit_buffer >>= 8; \ | | 289| 2.05k| d->m_bits_in -= 8; \ | | 290| 2.05k| } \ | | 291| 2.06k| } \ | | 292| 2.06k| MZ_MACRO_END | | ------------------ | | | | 26| 2.06k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 416| 35.5k| for (i = 0; (int)i < num_bit_lengths; i++) ------------------ | Branch (416:17): [True: 33.4k, False: 2.06k] ------------------ 417| 33.4k| TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); ------------------ | | 277| 35.5k| do \ | | 278| 35.5k| { \ | | 279| 33.4k| mz_uint bits = b; \ | | 280| 33.4k| mz_uint len = l; \ | | 281| 33.4k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 33.4k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 33.4k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 33.4k| d->m_bits_in += len; \ | | 284| 45.6k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 12.1k, False: 33.4k] | | ------------------ | | 285| 33.4k| { \ | | 286| 12.1k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 12.1k, False: 0] | | ------------------ | | 287| 12.1k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 12.1k| d->m_bit_buffer >>= 8; \ | | 289| 12.1k| d->m_bits_in -= 8; \ | | 290| 12.1k| } \ | | 291| 33.4k| } \ | | 292| 35.5k| MZ_MACRO_END | | ------------------ | | | | 26| 35.5k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 418| | 419| 404k| for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;) ------------------ | Branch (419:39): [True: 402k, False: 2.06k] ------------------ 420| 402k| { 421| 402k| mz_uint code = packed_code_sizes[packed_code_sizes_index++]; 422| 402k| MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); ------------------ | | 47| 402k|#define MZ_ASSERT(x) assert(x) ------------------ 423| 402k| TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); ------------------ | | 277| 402k| do \ | | 278| 402k| { \ | | 279| 402k| mz_uint bits = b; \ | | 280| 402k| mz_uint len = l; \ | | 281| 402k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 402k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 402k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 402k| d->m_bits_in += len; \ | | 284| 533k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 130k, False: 402k] | | ------------------ | | 285| 402k| { \ | | 286| 130k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 130k, False: 0] | | ------------------ | | 287| 130k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 130k| d->m_bit_buffer >>= 8; \ | | 289| 130k| d->m_bits_in -= 8; \ | | 290| 130k| } \ | | 291| 402k| } \ | | 292| 402k| MZ_MACRO_END | | ------------------ | | | | 26| 402k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 424| 402k| if (code >= 16) ------------------ | Branch (424:13): [True: 40.5k, False: 361k] ------------------ 425| 40.5k| TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); ------------------ | | 277| 40.5k| do \ | | 278| 40.5k| { \ | | 279| 40.5k| mz_uint bits = b; \ | | 280| 40.5k| mz_uint len = l; \ | | 281| 40.5k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 40.5k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 40.5k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 40.5k| d->m_bits_in += len; \ | | 284| 55.9k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 15.4k, False: 40.5k] | | ------------------ | | 285| 40.5k| { \ | | 286| 15.4k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 15.4k, False: 0] | | ------------------ | | 287| 15.4k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 15.4k| d->m_bit_buffer >>= 8; \ | | 289| 15.4k| d->m_bits_in -= 8; \ | | 290| 15.4k| } \ | | 291| 40.5k| } \ | | 292| 40.5k| MZ_MACRO_END | | ------------------ | | | | 26| 40.5k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 426| 402k| } 427| 2.06k|} miniz_tdef.c:tdefl_compress_lz_codes: 550| 2.08k|{ 551| 2.08k| mz_uint flags; 552| 2.08k| mz_uint8 *pLZ_codes; 553| | 554| 2.08k| flags = 1; 555| 3.70M| for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) ------------------ | Branch (555:40): [True: 3.70M, False: 2.08k] ------------------ 556| 3.70M| { 557| 3.70M| if (flags == 1) ------------------ | Branch (557:13): [True: 463k, False: 3.23M] ------------------ 558| 463k| flags = *pLZ_codes++ | 0x100; 559| 3.70M| if (flags & 1) ------------------ | Branch (559:13): [True: 226k, False: 3.47M] ------------------ 560| 226k| { 561| 226k| mz_uint sym, num_extra_bits; 562| 226k| mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); 563| 226k| pLZ_codes += 3; 564| | 565| 226k| MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 47| 226k|#define MZ_ASSERT(x) assert(x) ------------------ 566| 226k| TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); ------------------ | | 277| 226k| do \ | | 278| 226k| { \ | | 279| 226k| mz_uint bits = b; \ | | 280| 226k| mz_uint len = l; \ | | 281| 226k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 226k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 226k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 226k| d->m_bits_in += len; \ | | 284| 351k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 124k, False: 226k] | | ------------------ | | 285| 226k| { \ | | 286| 124k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 124k, False: 0] | | ------------------ | | 287| 124k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 124k| d->m_bit_buffer >>= 8; \ | | 289| 124k| d->m_bits_in -= 8; \ | | 290| 124k| } \ | | 291| 226k| } \ | | 292| 226k| MZ_MACRO_END | | ------------------ | | | | 26| 226k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 567| 226k| TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); ------------------ | | 277| 226k| do \ | | 278| 226k| { \ | | 279| 226k| mz_uint bits = b; \ | | 280| 226k| mz_uint len = l; \ | | 281| 226k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 226k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 226k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 226k| d->m_bits_in += len; \ | | 284| 241k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 14.6k, False: 226k] | | ------------------ | | 285| 226k| { \ | | 286| 14.6k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 14.6k, False: 0] | | ------------------ | | 287| 14.6k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 14.6k| d->m_bit_buffer >>= 8; \ | | 289| 14.6k| d->m_bits_in -= 8; \ | | 290| 14.6k| } \ | | 291| 226k| } \ | | 292| 226k| MZ_MACRO_END | | ------------------ | | | | 26| 226k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 568| | 569| 226k| if (match_dist < 512) ------------------ | Branch (569:17): [True: 129k, False: 97.1k] ------------------ 570| 129k| { 571| 129k| sym = s_tdefl_small_dist_sym[match_dist]; 572| 129k| num_extra_bits = s_tdefl_small_dist_extra[match_dist]; 573| 129k| } 574| 97.1k| else 575| 97.1k| { 576| 97.1k| sym = s_tdefl_large_dist_sym[match_dist >> 8]; 577| 97.1k| num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8]; 578| 97.1k| } 579| 226k| MZ_ASSERT(d->m_huff_code_sizes[1][sym]); ------------------ | | 47| 226k|#define MZ_ASSERT(x) assert(x) ------------------ 580| 226k| TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); ------------------ | | 277| 226k| do \ | | 278| 226k| { \ | | 279| 226k| mz_uint bits = b; \ | | 280| 226k| mz_uint len = l; \ | | 281| 226k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 226k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 226k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 226k| d->m_bits_in += len; \ | | 284| 329k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 102k, False: 226k] | | ------------------ | | 285| 226k| { \ | | 286| 102k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 102k, False: 0] | | ------------------ | | 287| 102k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 102k| d->m_bit_buffer >>= 8; \ | | 289| 102k| d->m_bits_in -= 8; \ | | 290| 102k| } \ | | 291| 226k| } \ | | 292| 226k| MZ_MACRO_END | | ------------------ | | | | 26| 226k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 581| 226k| TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); ------------------ | | 277| 226k| do \ | | 278| 226k| { \ | | 279| 226k| mz_uint bits = b; \ | | 280| 226k| mz_uint len = l; \ | | 281| 226k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 226k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 226k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 226k| d->m_bits_in += len; \ | | 284| 397k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 170k, False: 226k] | | ------------------ | | 285| 226k| { \ | | 286| 170k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 170k, False: 0] | | ------------------ | | 287| 170k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 170k| d->m_bit_buffer >>= 8; \ | | 289| 170k| d->m_bits_in -= 8; \ | | 290| 170k| } \ | | 291| 226k| } \ | | 292| 226k| MZ_MACRO_END | | ------------------ | | | | 26| 226k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 582| 226k| } 583| 3.47M| else 584| 3.47M| { 585| 3.47M| mz_uint lit = *pLZ_codes++; 586| 3.47M| MZ_ASSERT(d->m_huff_code_sizes[0][lit]); ------------------ | | 47| 3.47M|#define MZ_ASSERT(x) assert(x) ------------------ 587| 3.47M| TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); ------------------ | | 277| 3.47M| do \ | | 278| 3.47M| { \ | | 279| 3.47M| mz_uint bits = b; \ | | 280| 3.47M| mz_uint len = l; \ | | 281| 3.47M| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 3.47M|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 3.47M| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 3.47M| d->m_bits_in += len; \ | | 284| 6.73M| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 3.25M, False: 3.47M] | | ------------------ | | 285| 3.47M| { \ | | 286| 3.25M| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 3.25M, False: 0] | | ------------------ | | 287| 3.25M| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 3.25M| d->m_bit_buffer >>= 8; \ | | 289| 3.25M| d->m_bits_in -= 8; \ | | 290| 3.25M| } \ | | 291| 3.47M| } \ | | 292| 3.47M| MZ_MACRO_END | | ------------------ | | | | 26| 3.47M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 588| 3.47M| } 589| 3.70M| } 590| | 591| 2.08k| TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); ------------------ | | 277| 2.08k| do \ | | 278| 2.08k| { \ | | 279| 2.08k| mz_uint bits = b; \ | | 280| 2.08k| mz_uint len = l; \ | | 281| 2.08k| MZ_ASSERT(bits <= ((1U << len) - 1U)); \ | | ------------------ | | | | 47| 2.08k|#define MZ_ASSERT(x) assert(x) | | ------------------ | | 282| 2.08k| d->m_bit_buffer |= (bits << d->m_bits_in); \ | | 283| 2.08k| d->m_bits_in += len; \ | | 284| 4.27k| while (d->m_bits_in >= 8) \ | | ------------------ | | | Branch (284:16): [True: 2.19k, False: 2.08k] | | ------------------ | | 285| 2.19k| { \ | | 286| 2.19k| if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ | | ------------------ | | | Branch (286:17): [True: 2.19k, False: 0] | | ------------------ | | 287| 2.19k| *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ | | 288| 2.19k| d->m_bit_buffer >>= 8; \ | | 289| 2.19k| d->m_bits_in -= 8; \ | | 290| 2.19k| } \ | | 291| 2.08k| } \ | | 292| 2.08k| MZ_MACRO_END | | ------------------ | | | | 26| 2.08k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 592| | 593| 2.08k| return (d->m_pOutput_buf < d->m_pOutput_buf_end); 594| 2.08k|} tinfl_decompress: 187| 2.43k|{ 188| 2.43k| static const mz_uint16 s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 }; 189| 2.43k| static const mz_uint8 s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 }; 190| 2.43k| static const mz_uint16 s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 }; 191| 2.43k| static const mz_uint8 s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; 192| 2.43k| static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; 193| 2.43k| static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 }; 194| | 195| 2.43k| mz_int16 *pTrees[3]; 196| 2.43k| mz_uint8 *pCode_sizes[3]; 197| | 198| 2.43k| tinfl_status status = TINFL_STATUS_FAILED; 199| 2.43k| mz_uint32 num_bits, dist, counter, num_extra; 200| 2.43k| tinfl_bit_buf_t bit_buf; 201| 2.43k| const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size; 202| 2.43k| mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL; ------------------ | Branch (202:67): [True: 2.43k, False: 0] ------------------ 203| 2.43k| size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start; ------------------ | Branch (203:32): [True: 2.43k, False: 0] ------------------ 204| | 205| | /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */ 206| 2.43k| if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) ------------------ | Branch (206:9): [True: 0, False: 2.43k] | Branch (206:58): [True: 0, False: 2.43k] ------------------ 207| 0| { 208| 0| *pIn_buf_size = *pOut_buf_size = 0; 209| 0| return TINFL_STATUS_BAD_PARAM; 210| 0| } 211| | 212| 2.43k| pTrees[0] = r->m_tree_0; 213| 2.43k| pTrees[1] = r->m_tree_1; 214| 2.43k| pTrees[2] = r->m_tree_2; 215| 2.43k| pCode_sizes[0] = r->m_code_size_0; 216| 2.43k| pCode_sizes[1] = r->m_code_size_1; 217| 2.43k| pCode_sizes[2] = r->m_code_size_2; 218| | 219| 2.43k| num_bits = r->m_num_bits; 220| 2.43k| bit_buf = r->m_bit_buf; 221| 2.43k| dist = r->m_dist; 222| 2.43k| counter = r->m_counter; 223| 2.43k| num_extra = r->m_num_extra; 224| 2.43k| dist_from_out_buf_start = r->m_dist_from_out_buf_start; 225| 2.43k| TINFL_CR_BEGIN ------------------ | | 41| 4.87k| switch (r->m_state) \ | | ------------------ | | | Branch (41:13): [True: 0, False: 2.43k] | | ------------------ | | 42| 4.87k| { \ | | 43| 2.43k| case 0: | | ------------------ | | | Branch (43:9): [True: 2.43k, False: 0] | | ------------------ ------------------ 226| | 227| 2.43k| bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; 228| 2.43k| r->m_z_adler32 = r->m_check_adler32 = 1; 229| 2.43k| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (229:9): [True: 0, False: 2.43k] ------------------ 230| 0| { 231| 0| TINFL_GET_BYTE(1, r->m_zhdr0); ------------------ | | 65| 0| do \ | | 66| 0| { \ | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (67:16): [True: 0, False: 0] | | ------------------ | | 68| 0| { \ | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 45| 0| do \ | | | | 46| 0| { \ | | | | 47| 0| status = result; \ | | | | ------------------ | | | | | Branch (47:18): [True: 0, False: 0] | | | | ------------------ | | | | 48| 0| r->m_state = state_index; \ | | | | 49| 0| goto common_exit; \ | | | | 50| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 70| 0| } \ | | 71| 0| c = *pIn_buf_cur++; \ | | 72| 0| } \ | | 73| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 232| 0| TINFL_GET_BYTE(2, r->m_zhdr1); ------------------ | | 65| 0| do \ | | 66| 0| { \ | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (67:16): [True: 0, False: 0] | | ------------------ | | 68| 0| { \ | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 45| 0| do \ | | | | 46| 0| { \ | | | | 47| 0| status = result; \ | | | | ------------------ | | | | | Branch (47:18): [True: 0, False: 0] | | | | ------------------ | | | | 48| 0| r->m_state = state_index; \ | | | | 49| 0| goto common_exit; \ | | | | 50| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 70| 0| } \ | | 71| 0| c = *pIn_buf_cur++; \ | | 72| 0| } \ | | 73| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 233| 0| counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); ------------------ | Branch (233:20): [True: 0, False: 0] | Branch (233:67): [True: 0, False: 0] | Branch (233:88): [True: 0, False: 0] ------------------ 234| 0| if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (234:13): [True: 0, False: 0] ------------------ 235| 0| counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); ------------------ | Branch (235:25): [True: 0, False: 0] | Branch (235:72): [True: 0, False: 0] ------------------ 236| 0| if (counter) ------------------ | Branch (236:13): [True: 0, False: 0] ------------------ 237| 0| { 238| 0| TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); ------------------ | | 54| 0| do \ | | 55| 0| { \ | | 56| 0| for (;;) \ | | 57| 0| { \ | | 58| 0| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 0| do \ | | | | 46| 0| { \ | | | | 47| 0| status = result; \ | | | | 48| 0| r->m_state = state_index; \ | | | | 49| 0| goto common_exit; \ | | | | 50| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 0| } \ | | 60| 0| } \ | | 61| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 239| 0| } 240| 0| } 241| | 242| 2.43k| do 243| 8.09k| { 244| 8.09k| TINFL_GET_BITS(3, r->m_final, 3); ------------------ | | 95| 8.09k| do \ | | 96| 8.09k| { \ | | 97| 8.09k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 4.56k, False: 3.52k] | | ------------------ | | 98| 8.09k| { \ | | 99| 4.56k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 4.56k| do \ | | | | 77| 4.56k| { \ | | | | 78| 4.56k| mz_uint c; \ | | | | 79| 4.56k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 4.56k| do \ | | | | | | 66| 4.56k| { \ | | | | | | 67| 4.56k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 3, False: 4.55k] | | | | | | ------------------ | | | | | | 68| 4.56k| { \ | | | | | | 69| 3| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 3| do \ | | | | | | | | 46| 3| { \ | | | | | | | | 47| 6| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | | | 48| 3| r->m_state = state_index; \ | | | | | | | | 49| 3| goto common_exit; \ | | | | | | | | 50| 3| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 3| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 3| } \ | | | | | | 71| 4.56k| c = *pIn_buf_cur++; \ | | | | | | 72| 4.55k| } \ | | | | | | 73| 4.56k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 4.56k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 4.56k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 4.55k| num_bits += 8; \ | | | | 82| 4.55k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 4.55k] | | | | ------------------ | | ------------------ | | 100| 4.56k| } \ | | 101| 8.09k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 8.08k| bit_buf >>= (n); \ | | 103| 8.08k| num_bits -= (n); \ | | 104| 8.08k| } \ | | 105| 8.09k| MZ_MACRO_END | | ------------------ | | | | 26| 8.09k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 245| 8.08k| r->m_type = r->m_final >> 1; 246| 8.08k| if (r->m_type == 0) ------------------ | Branch (246:13): [True: 2.53k, False: 5.55k] ------------------ 247| 2.53k| { 248| 2.53k| TINFL_SKIP_BITS(5, num_bits & 7); ------------------ | | 84| 2.53k| do \ | | 85| 2.53k| { \ | | 86| 2.53k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 2.53k] | | ------------------ | | 87| 2.53k| { \ | | 88| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 0| do \ | | | | 77| 0| { \ | | | | 78| 0| mz_uint c; \ | | | | 79| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 0| do \ | | | | | | 66| 0| { \ | | | | | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 68| 0| { \ | | | | | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 0| do \ | | | | | | | | 46| 0| { \ | | | | | | | | 47| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 48| 0| r->m_state = state_index; \ | | | | | | | | 49| 0| goto common_exit; \ | | | | | | | | 50| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 0| } \ | | | | | | 71| 0| c = *pIn_buf_cur++; \ | | | | | | 72| 0| } \ | | | | | | 73| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 0| num_bits += 8; \ | | | | 82| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 89| 0| } \ | | 90| 2.53k| bit_buf >>= (n); \ | | 91| 2.53k| num_bits -= (n); \ | | 92| 2.53k| } \ | | 93| 2.53k| MZ_MACRO_END | | ------------------ | | | | 26| 2.53k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 249| 12.6k| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (249:31): [True: 10.1k, False: 2.53k] ------------------ 250| 10.1k| { 251| 10.1k| if (num_bits) ------------------ | Branch (251:21): [True: 3.02k, False: 7.11k] ------------------ 252| 3.02k| TINFL_GET_BITS(6, r->m_raw_header[counter], 8); ------------------ | | 95| 3.02k| do \ | | 96| 3.02k| { \ | | 97| 3.02k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 0, False: 3.02k] | | ------------------ | | 98| 3.02k| { \ | | 99| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 0| do \ | | | | 77| 0| { \ | | | | 78| 0| mz_uint c; \ | | | | 79| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 0| do \ | | | | | | 66| 0| { \ | | | | | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 68| 0| { \ | | | | | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 0| do \ | | | | | | | | 46| 0| { \ | | | | | | | | 47| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 48| 0| r->m_state = state_index; \ | | | | | | | | 49| 0| goto common_exit; \ | | | | | | | | 50| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 0| } \ | | | | | | 71| 0| c = *pIn_buf_cur++; \ | | | | | | 72| 0| } \ | | | | | | 73| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 0| num_bits += 8; \ | | | | 82| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 100| 0| } \ | | 101| 3.02k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 3.02k| bit_buf >>= (n); \ | | 103| 3.02k| num_bits -= (n); \ | | 104| 3.02k| } \ | | 105| 3.02k| MZ_MACRO_END | | ------------------ | | | | 26| 3.02k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 253| 7.11k| else 254| 7.11k| TINFL_GET_BYTE(7, r->m_raw_header[counter]); ------------------ | | 65| 7.11k| do \ | | 66| 7.11k| { \ | | 67| 7.11k| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (67:16): [True: 3, False: 7.11k] | | ------------------ | | 68| 7.11k| { \ | | 69| 3| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 45| 3| do \ | | | | 46| 3| { \ | | | | 47| 6| status = result; \ | | | | ------------------ | | | | | Branch (47:18): [True: 0, False: 3] | | | | ------------------ | | | | 48| 3| r->m_state = state_index; \ | | | | 49| 3| goto common_exit; \ | | | | 50| 3| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 3| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 70| 3| } \ | | 71| 7.11k| c = *pIn_buf_cur++; \ | | 72| 7.11k| } \ | | 73| 7.11k| MZ_MACRO_END | | ------------------ | | | | 26| 7.11k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 255| 10.1k| } 256| 2.53k| if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) ------------------ | Branch (256:17): [True: 61, False: 2.47k] ------------------ 257| 61| { 258| 61| TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); ------------------ | | 54| 61| do \ | | 55| 61| { \ | | 56| 61| for (;;) \ | | 57| 61| { \ | | 58| 61| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 61| do \ | | | | 46| 61| { \ | | | | 47| 61| status = result; \ | | | | 48| 61| r->m_state = state_index; \ | | | | 49| 61| goto common_exit; \ | | | | 50| 61| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 61| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 61|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 61| } \ | | 60| 61| } \ | | 61| 61| MZ_MACRO_END | | ------------------ | | | | 26| 61|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 259| 61| } 260| 2.79k| while ((counter) && (num_bits)) ------------------ | Branch (260:20): [True: 1.74k, False: 1.04k] | Branch (260:33): [True: 324, False: 1.42k] ------------------ 261| 324| { 262| 324| TINFL_GET_BITS(51, dist, 8); ------------------ | | 95| 324| do \ | | 96| 324| { \ | | 97| 324| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 0, False: 324] | | ------------------ | | 98| 324| { \ | | 99| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 0| do \ | | | | 77| 0| { \ | | | | 78| 0| mz_uint c; \ | | | | 79| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 0| do \ | | | | | | 66| 0| { \ | | | | | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 68| 0| { \ | | | | | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 0| do \ | | | | | | | | 46| 0| { \ | | | | | | | | 47| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 48| 0| r->m_state = state_index; \ | | | | | | | | 49| 0| goto common_exit; \ | | | | | | | | 50| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 0| } \ | | | | | | 71| 0| c = *pIn_buf_cur++; \ | | | | | | 72| 0| } \ | | | | | | 73| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 0| num_bits += 8; \ | | | | 82| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 100| 0| } \ | | 101| 324| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 324| bit_buf >>= (n); \ | | 103| 324| num_bits -= (n); \ | | 104| 324| } \ | | 105| 324| MZ_MACRO_END | | ------------------ | | | | 26| 324|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 263| 324| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (263:24): [True: 1, False: 323] ------------------ 264| 1| { 265| 1| TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 45| 1| do \ | | 46| 1| { \ | | 47| 1| status = result; \ | | 48| 1| r->m_state = state_index; \ | | 49| 1| goto common_exit; \ | | 50| 1| case state_index:; \ | | ------------------ | | | Branch (50:9): [True: 0, False: 2.43k] | | ------------------ | | 51| 0| } \ | | 52| 1| MZ_MACRO_END | | ------------------ | | | | 26| 1|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 266| 1| } 267| 323| *pOut_buf_cur++ = (mz_uint8)dist; 268| 323| counter--; 269| 323| } 270| 3.89k| while (counter) ------------------ | Branch (270:20): [True: 1.44k, False: 2.44k] ------------------ 271| 1.44k| { 272| 1.44k| size_t n; 273| 1.44k| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (273:24): [True: 7, False: 1.43k] ------------------ 274| 7| { 275| 7| TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 45| 7| do \ | | 46| 7| { \ | | 47| 7| status = result; \ | | 48| 7| r->m_state = state_index; \ | | 49| 7| goto common_exit; \ | | 50| 7| case state_index:; \ | | ------------------ | | | Branch (50:9): [True: 0, False: 2.43k] | | ------------------ | | 51| 0| } \ | | 52| 7| MZ_MACRO_END | | ------------------ | | | | 26| 7|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 276| 7| } 277| 1.43k| while (pIn_buf_cur >= pIn_buf_end) ------------------ | Branch (277:24): [True: 19, False: 1.42k] ------------------ 278| 19| { 279| 19| TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); ------------------ | | 45| 19| do \ | | 46| 19| { \ | | 47| 38| status = result; \ | | ------------------ | | | Branch (47:18): [True: 0, False: 19] | | ------------------ | | 48| 19| r->m_state = state_index; \ | | 49| 19| goto common_exit; \ | | 50| 19| case state_index:; \ | | ------------------ | | | Branch (50:9): [True: 0, False: 2.43k] | | ------------------ | | 51| 0| } \ | | 52| 19| MZ_MACRO_END | | ------------------ | | | | 26| 19|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 280| 19| } 281| 1.42k| n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter); ------------------ | | 60| 2.84k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (60:23): [True: 23, False: 1.39k] | | | Branch (60:25): [True: 343, False: 1.07k] | | | Branch (60:38): [True: 6, False: 17] | | ------------------ ------------------ 282| 1.42k| TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); ------------------ | | 37| 1.42k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 283| 1.42k| pIn_buf_cur += n; 284| 1.42k| pOut_buf_cur += n; 285| 1.42k| counter -= (mz_uint)n; 286| 1.42k| } 287| 2.47k| } 288| 5.55k| else if (r->m_type == 3) ------------------ | Branch (288:18): [True: 13, False: 5.53k] ------------------ 289| 13| { 290| 13| TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); ------------------ | | 54| 13| do \ | | 55| 13| { \ | | 56| 13| for (;;) \ | | 57| 13| { \ | | 58| 13| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 13| do \ | | | | 46| 13| { \ | | | | 47| 13| status = result; \ | | | | 48| 13| r->m_state = state_index; \ | | | | 49| 13| goto common_exit; \ | | | | 50| 13| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 13| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 13|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 13| } \ | | 60| 13| } \ | | 61| 13| MZ_MACRO_END | | ------------------ | | | | 26| 13|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 291| 13| } 292| 5.53k| else 293| 5.53k| { 294| 5.53k| if (r->m_type == 1) ------------------ | Branch (294:17): [True: 2.20k, False: 3.33k] ------------------ 295| 2.20k| { 296| 2.20k| mz_uint8 *p = r->m_code_size_0; 297| 2.20k| mz_uint i; 298| 2.20k| r->m_table_sizes[0] = 288; 299| 2.20k| r->m_table_sizes[1] = 32; 300| 2.20k| TINFL_MEMSET(r->m_code_size_1, 5, 32); ------------------ | | 38| 2.20k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 301| 319k| for (i = 0; i <= 143; ++i) ------------------ | Branch (301:29): [True: 317k, False: 2.20k] ------------------ 302| 317k| *p++ = 8; 303| 248k| for (; i <= 255; ++i) ------------------ | Branch (303:24): [True: 246k, False: 2.20k] ------------------ 304| 246k| *p++ = 9; 305| 55.0k| for (; i <= 279; ++i) ------------------ | Branch (305:24): [True: 52.8k, False: 2.20k] ------------------ 306| 52.8k| *p++ = 7; 307| 19.8k| for (; i <= 287; ++i) ------------------ | Branch (307:24): [True: 17.6k, False: 2.20k] ------------------ 308| 17.6k| *p++ = 8; 309| 2.20k| } 310| 3.33k| else 311| 3.33k| { 312| 13.3k| for (counter = 0; counter < 3; counter++) ------------------ | Branch (312:35): [True: 10.0k, False: 3.33k] ------------------ 313| 10.0k| { 314| 10.0k| TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); ------------------ | | 95| 10.0k| do \ | | 96| 10.0k| { \ | | 97| 10.0k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 4.73k, False: 5.26k] | | ------------------ | | 98| 10.0k| { \ | | 99| 4.73k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 4.73k| do \ | | | | 77| 4.73k| { \ | | | | 78| 4.73k| mz_uint c; \ | | | | 79| 4.73k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 4.73k| do \ | | | | | | 66| 4.73k| { \ | | | | | | 67| 4.73k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 3, False: 4.73k] | | | | | | ------------------ | | | | | | 68| 4.73k| { \ | | | | | | 69| 3| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 3| do \ | | | | | | | | 46| 3| { \ | | | | | | | | 47| 6| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | | | 48| 3| r->m_state = state_index; \ | | | | | | | | 49| 3| goto common_exit; \ | | | | | | | | 50| 3| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 3| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 3| } \ | | | | | | 71| 4.73k| c = *pIn_buf_cur++; \ | | | | | | 72| 4.73k| } \ | | | | | | 73| 4.73k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 4.73k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 4.73k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 4.73k| num_bits += 8; \ | | | | 82| 4.73k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 4.73k] | | | | ------------------ | | ------------------ | | 100| 4.73k| } \ | | 101| 10.0k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 10.0k| bit_buf >>= (n); \ | | 103| 10.0k| num_bits -= (n); \ | | 104| 10.0k| } \ | | 105| 10.0k| MZ_MACRO_END | | ------------------ | | | | 26| 10.0k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 315| 10.0k| r->m_table_sizes[counter] += s_min_table_sizes[counter]; 316| 10.0k| } 317| 3.33k| MZ_CLEAR_ARR(r->m_code_size_2); ------------------ | | 62| 3.33k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 318| 51.8k| for (counter = 0; counter < r->m_table_sizes[2]; counter++) ------------------ | Branch (318:35): [True: 48.5k, False: 3.32k] ------------------ 319| 48.5k| { 320| 48.5k| mz_uint s; 321| 48.5k| TINFL_GET_BITS(14, s, 3); ------------------ | | 95| 48.5k| do \ | | 96| 48.5k| { \ | | 97| 48.5k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 16.7k, False: 31.8k] | | ------------------ | | 98| 48.5k| { \ | | 99| 16.7k| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 16.7k| do \ | | | | 77| 16.7k| { \ | | | | 78| 16.7k| mz_uint c; \ | | | | 79| 16.7k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 16.7k| do \ | | | | | | 66| 16.7k| { \ | | | | | | 67| 16.7k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 5, False: 16.7k] | | | | | | ------------------ | | | | | | 68| 16.7k| { \ | | | | | | 69| 5| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 5| do \ | | | | | | | | 46| 5| { \ | | | | | | | | 47| 10| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | | | 48| 5| r->m_state = state_index; \ | | | | | | | | 49| 5| goto common_exit; \ | | | | | | | | 50| 5| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 5| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 5|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 5| } \ | | | | | | 71| 16.7k| c = *pIn_buf_cur++; \ | | | | | | 72| 16.7k| } \ | | | | | | 73| 16.7k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 16.7k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 16.7k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 16.7k| num_bits += 8; \ | | | | 82| 16.7k| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 16.7k] | | | | ------------------ | | ------------------ | | 100| 16.7k| } \ | | 101| 48.5k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 48.5k| bit_buf >>= (n); \ | | 103| 48.5k| num_bits -= (n); \ | | 104| 48.5k| } \ | | 105| 48.5k| MZ_MACRO_END | | ------------------ | | | | 26| 48.5k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 322| 48.5k| r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s; 323| 48.5k| } 324| 3.32k| r->m_table_sizes[2] = 19; 325| 3.32k| } 326| 19.7k| for (; (int)r->m_type >= 0; r->m_type--) ------------------ | Branch (326:20): [True: 14.3k, False: 5.47k] ------------------ 327| 14.3k| { 328| 14.3k| int tree_next, tree_cur; 329| 14.3k| mz_int16 *pLookUp; 330| 14.3k| mz_int16 *pTree; 331| 14.3k| mz_uint8 *pCode_size; 332| 14.3k| mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; 333| 14.3k| pLookUp = r->m_look_up[r->m_type]; 334| 14.3k| pTree = pTrees[r->m_type]; 335| 14.3k| pCode_size = pCode_sizes[r->m_type]; 336| 14.3k| MZ_CLEAR_ARR(total_syms); ------------------ | | 62| 14.3k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 337| 14.3k| TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0])); ------------------ | | 38| 14.3k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) ------------------ 338| 14.3k| tinfl_clear_tree(r); 339| 1.76M| for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) ------------------ | Branch (339:29): [True: 1.75M, False: 14.3k] ------------------ 340| 1.75M| total_syms[pCode_size[i]]++; 341| 14.3k| used_syms = 0, total = 0; 342| 14.3k| next_code[0] = next_code[1] = 0; 343| 229k| for (i = 1; i <= 15; ++i) ------------------ | Branch (343:29): [True: 214k, False: 14.3k] ------------------ 344| 214k| { 345| 214k| used_syms += total_syms[i]; 346| 214k| next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); 347| 214k| } 348| 14.3k| if ((65536 != total) && (used_syms > 1)) ------------------ | Branch (348:21): [True: 1.48k, False: 12.8k] | Branch (348:41): [True: 35, False: 1.45k] ------------------ 349| 35| { 350| 35| TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); ------------------ | | 54| 35| do \ | | 55| 35| { \ | | 56| 35| for (;;) \ | | 57| 35| { \ | | 58| 35| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 35| do \ | | | | 46| 35| { \ | | | | 47| 35| status = result; \ | | | | 48| 35| r->m_state = state_index; \ | | | | 49| 35| goto common_exit; \ | | | | 50| 35| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 35| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 35|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 35| } \ | | 60| 35| } \ | | 61| 35| MZ_MACRO_END | | ------------------ | | | | 26| 35|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 351| 35| } 352| 1.76M| for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) ------------------ | Branch (352:53): [True: 1.74M, False: 14.2k] ------------------ 353| 1.74M| { 354| 1.74M| mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index]; 355| 1.74M| if (!code_size) ------------------ | Branch (355:25): [True: 636k, False: 1.10M] ------------------ 356| 636k| continue; 357| 1.10M| cur_code = next_code[code_size]++; 358| 9.64M| for (l = code_size; l > 0; l--, cur_code >>= 1) ------------------ | Branch (358:41): [True: 8.53M, False: 1.10M] ------------------ 359| 8.53M| rev_code = (rev_code << 1) | (cur_code & 1); 360| 1.10M| if (code_size <= TINFL_FAST_LOOKUP_BITS) ------------------ | Branch (360:25): [True: 1.09M, False: 12.7k] ------------------ 361| 1.09M| { 362| 1.09M| mz_int16 k = (mz_int16)((code_size << 9) | sym_index); 363| 14.2M| while (rev_code < TINFL_FAST_LOOKUP_SIZE) ------------------ | Branch (363:32): [True: 13.1M, False: 1.09M] ------------------ 364| 13.1M| { 365| 13.1M| pLookUp[rev_code] = k; 366| 13.1M| rev_code += (1 << code_size); 367| 13.1M| } 368| 1.09M| continue; 369| 1.09M| } 370| 12.7k| if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) ------------------ | Branch (370:25): [True: 4.43k, False: 8.31k] ------------------ 371| 4.43k| { 372| 4.43k| pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; 373| 4.43k| tree_cur = tree_next; 374| 4.43k| tree_next -= 2; 375| 4.43k| } 376| 12.7k| rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); 377| 24.1k| for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) ------------------ | Branch (377:41): [True: 11.4k, False: 12.7k] ------------------ 378| 11.4k| { 379| 11.4k| tree_cur -= ((rev_code >>= 1) & 1); 380| 11.4k| if (!pTree[-tree_cur - 1]) ------------------ | Branch (380:29): [True: 4.16k, False: 7.27k] ------------------ 381| 4.16k| { 382| 4.16k| pTree[-tree_cur - 1] = (mz_int16)tree_next; 383| 4.16k| tree_cur = tree_next; 384| 4.16k| tree_next -= 2; 385| 4.16k| } 386| 7.27k| else 387| 7.27k| tree_cur = pTree[-tree_cur - 1]; 388| 11.4k| } 389| 12.7k| tree_cur -= ((rev_code >>= 1) & 1); 390| 12.7k| pTree[-tree_cur - 1] = (mz_int16)sym_index; 391| 12.7k| } 392| 14.2k| if (r->m_type == 2) ------------------ | Branch (392:21): [True: 3.31k, False: 10.9k] ------------------ 393| 3.31k| { 394| 485k| for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) ------------------ | Branch (394:39): [True: 481k, False: 3.30k] ------------------ 395| 481k| { 396| 481k| mz_uint s; 397| 481k| TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); ------------------ | | 143| 481k| do \ | | 144| 481k| { \ | | 145| 481k| int temp; \ | | 146| 481k| mz_uint code_len, c; \ | | 147| 481k| if (num_bits < 15) \ | | ------------------ | | | Branch (147:13): [True: 88.8k, False: 393k] | | ------------------ | | 148| 481k| { \ | | 149| 88.8k| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (149:17): [True: 114, False: 88.6k] | | ------------------ | | 150| 88.8k| { \ | | 151| 114| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 112| 114| do \ | | | | 113| 120| { \ | | | | 114| 120| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 115| 120| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (115:13): [True: 120, False: 0] | | | | ------------------ | | | | 116| 120| { \ | | | | 117| 120| code_len = temp >> 9; \ | | | | 118| 120| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (118:17): [True: 113, False: 7] | | | | | Branch (118:31): [True: 104, False: 9] | | | | ------------------ | | | | 119| 120| break; \ | | | | 120| 120| } \ | | | | 121| 120| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (121:18): [True: 0, False: 0] | | | | ------------------ | | | | 122| 0| { \ | | | | 123| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 124| 0| do \ | | | | 125| 0| { \ | | | | 126| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 127| 0| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (127:22): [True: 0, False: 0] | | | | | Branch (127:36): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (128:17): [True: 0, False: 0] | | | | ------------------ | | | | 129| 0| break; \ | | | | 130| 0| } \ | | | | 131| 120| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 16| do \ | | | | | | 66| 16| { \ | | | | | | 67| 16| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 6, False: 10] | | | | | | ------------------ | | | | | | 68| 16| { \ | | | | | | 69| 6| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 6| do \ | | | | | | | | 46| 6| { \ | | | | | | | | 47| 12| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | | | 48| 6| r->m_state = state_index; \ | | | | | | | | 49| 6| goto common_exit; \ | | | | | | | | 50| 6| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 6| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 6|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 6| } \ | | | | | | 71| 16| c = *pIn_buf_cur++; \ | | | | | | 72| 10| } \ | | | | | | 73| 120| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 120|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 132| 16| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 133| 10| num_bits += 8; \ | | | | 134| 10| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (134:14): [True: 6, False: 4] | | | | ------------------ | | ------------------ | | 152| 108| } \ | | 153| 88.8k| else \ | | 154| 88.8k| { \ | | 155| 88.6k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 156| 88.6k| pIn_buf_cur += 2; \ | | 157| 88.6k| num_bits += 16; \ | | 158| 88.6k| } \ | | 159| 88.8k| } \ | | 160| 481k| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (160:13): [True: 481k, False: 0] | | ------------------ | | 161| 481k| code_len = temp >> 9, temp &= 511; \ | | 162| 481k| else \ | | 163| 481k| { \ | | 164| 0| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 165| 0| do \ | | 166| 0| { \ | | 167| 0| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 168| 0| } while (temp < 0); \ | | ------------------ | | | Branch (168:22): [True: 0, False: 0] | | ------------------ | | 169| 0| } \ | | 170| 481k| sym = temp; \ | | 171| 481k| bit_buf >>= code_len; \ | | 172| 481k| num_bits -= code_len; \ | | 173| 481k| } \ | | 174| 481k| MZ_MACRO_END | | ------------------ | | | | 26| 481k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 398| 481k| if (dist < 16) ------------------ | Branch (398:29): [True: 430k, False: 51.4k] ------------------ 399| 430k| { 400| 430k| r->m_len_codes[counter++] = (mz_uint8)dist; 401| 430k| continue; 402| 430k| } 403| 51.4k| if ((dist == 16) && (!counter)) ------------------ | Branch (403:29): [True: 18.6k, False: 32.8k] | Branch (403:45): [True: 3, False: 18.6k] ------------------ 404| 3| { 405| 3| TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); ------------------ | | 54| 3| do \ | | 55| 3| { \ | | 56| 3| for (;;) \ | | 57| 3| { \ | | 58| 3| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 3| do \ | | | | 46| 3| { \ | | | | 47| 3| status = result; \ | | | | 48| 3| r->m_state = state_index; \ | | | | 49| 3| goto common_exit; \ | | | | 50| 3| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 3| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 3| } \ | | 60| 3| } \ | | 61| 3| MZ_MACRO_END | | ------------------ | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 406| 3| } 407| 51.4k| num_extra = "\02\03\07"[dist - 16]; 408| 51.4k| TINFL_GET_BITS(18, s, num_extra); ------------------ | | 95| 51.4k| do \ | | 96| 51.4k| { \ | | 97| 51.4k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 7, False: 51.4k] | | ------------------ | | 98| 51.4k| { \ | | 99| 7| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 7| do \ | | | | 77| 7| { \ | | | | 78| 7| mz_uint c; \ | | | | 79| 7| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 7| do \ | | | | | | 66| 7| { \ | | | | | | 67| 7| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 3, False: 4] | | | | | | ------------------ | | | | | | 68| 7| { \ | | | | | | 69| 3| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 3| do \ | | | | | | | | 46| 3| { \ | | | | | | | | 47| 6| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | | | 48| 3| r->m_state = state_index; \ | | | | | | | | 49| 3| goto common_exit; \ | | | | | | | | 50| 3| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 3| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 3| } \ | | | | | | 71| 7| c = *pIn_buf_cur++; \ | | | | | | 72| 4| } \ | | | | | | 73| 7| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 7|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 7| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 4| num_bits += 8; \ | | | | 82| 4| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 4] | | | | ------------------ | | ------------------ | | 100| 7| } \ | | 101| 51.4k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 51.4k| bit_buf >>= (n); \ | | 103| 51.4k| num_bits -= (n); \ | | 104| 51.4k| } \ | | 105| 51.4k| MZ_MACRO_END | | ------------------ | | | | 26| 51.4k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 409| 51.4k| s += "\03\03\013"[dist - 16]; 410| 51.4k| TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); ------------------ | | 38| 102k|#define TINFL_MEMSET(p, c, l) memset(p, c, l) | | ------------------ | | | Branch (38:41): [True: 18.6k, False: 32.8k] | | ------------------ ------------------ 411| 51.4k| counter += s; 412| 51.4k| } 413| 3.30k| if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) ------------------ | Branch (413:25): [True: 9, False: 3.29k] ------------------ 414| 9| { 415| 9| TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); ------------------ | | 54| 9| do \ | | 55| 9| { \ | | 56| 9| for (;;) \ | | 57| 9| { \ | | 58| 9| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 9| do \ | | | | 46| 9| { \ | | | | 47| 9| status = result; \ | | | | 48| 9| r->m_state = state_index; \ | | | | 49| 9| goto common_exit; \ | | | | 50| 9| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 9| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 9|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 9| } \ | | 60| 9| } \ | | 61| 9| MZ_MACRO_END | | ------------------ | | | | 26| 9|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 416| 9| } 417| 3.29k| TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]); ------------------ | | 37| 3.29k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 418| 3.29k| TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]); ------------------ | | 37| 3.29k|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) ------------------ 419| 3.29k| } 420| 14.2k| } 421| 5.47k| for (;;) 422| 1.29M| { 423| 1.29M| mz_uint8 *pSrc; 424| 1.29M| for (;;) 425| 359M| { 426| 359M| if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) ------------------ | Branch (426:25): [True: 49.2M, False: 309M] | Branch (426:62): [True: 1.83k, False: 309M] ------------------ 427| 49.2M| { 428| 49.2M| TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); ------------------ | | 143| 49.2M| do \ | | 144| 49.2M| { \ | | 145| 49.2M| int temp; \ | | 146| 49.2M| mz_uint code_len, c; \ | | 147| 49.2M| if (num_bits < 15) \ | | ------------------ | | | Branch (147:13): [True: 5.25k, False: 49.2M] | | ------------------ | | 148| 49.2M| { \ | | 149| 5.25k| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (149:17): [True: 3.01k, False: 2.23k] | | ------------------ | | 150| 5.25k| { \ | | 151| 3.01k| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 112| 3.01k| do \ | | | | 113| 3.82k| { \ | | | | 114| 3.82k| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 115| 3.82k| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (115:13): [True: 3.66k, False: 159] | | | | ------------------ | | | | 116| 3.82k| { \ | | | | 117| 3.66k| code_len = temp >> 9; \ | | | | 118| 3.66k| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (118:17): [True: 3.65k, False: 4] | | | | | Branch (118:31): [True: 2.72k, False: 935] | | | | ------------------ | | | | 119| 3.66k| break; \ | | | | 120| 3.66k| } \ | | | | 121| 3.82k| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (121:18): [True: 108, False: 51] | | | | ------------------ | | | | 122| 159| { \ | | | | 123| 108| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 124| 108| do \ | | | | 125| 190| { \ | | | | 126| 190| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 127| 190| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (127:22): [True: 108, False: 82] | | | | | Branch (127:36): [True: 82, False: 26] | | | | ------------------ | | | | 128| 108| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (128:17): [True: 82, False: 26] | | | | ------------------ | | | | 129| 108| break; \ | | | | 130| 108| } \ | | | | 131| 3.82k| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 1.01k| do \ | | | | | | 66| 1.01k| { \ | | | | | | 67| 1.01k| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 35, False: 981] | | | | | | ------------------ | | | | | | 68| 1.01k| { \ | | | | | | 69| 35| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 35| do \ | | | | | | | | 46| 35| { \ | | | | | | | | 47| 70| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 35] | | | | | | | | ------------------ | | | | | | | | 48| 35| r->m_state = state_index; \ | | | | | | | | 49| 35| goto common_exit; \ | | | | | | | | 50| 35| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 35| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 35|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 35| } \ | | | | | | 71| 1.01k| c = *pIn_buf_cur++; \ | | | | | | 72| 981| } \ | | | | | | 73| 3.82k| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 3.82k|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 132| 1.01k| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 133| 981| num_bits += 8; \ | | | | 134| 981| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (134:14): [True: 804, False: 177] | | | | ------------------ | | ------------------ | | 152| 2.98k| } \ | | 153| 5.25k| else \ | | 154| 5.25k| { \ | | 155| 2.23k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 156| 2.23k| pIn_buf_cur += 2; \ | | 157| 2.23k| num_bits += 16; \ | | 158| 2.23k| } \ | | 159| 5.25k| } \ | | 160| 49.2M| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (160:13): [True: 49.2M, False: 568] | | ------------------ | | 161| 49.2M| code_len = temp >> 9, temp &= 511; \ | | 162| 49.2M| else \ | | 163| 49.2M| { \ | | 164| 568| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 165| 568| do \ | | 166| 1.64k| { \ | | 167| 1.64k| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 168| 1.64k| } while (temp < 0); \ | | ------------------ | | | Branch (168:22): [True: 1.07k, False: 568] | | ------------------ | | 169| 568| } \ | | 170| 49.2M| sym = temp; \ | | 171| 49.2M| bit_buf >>= code_len; \ | | 172| 49.2M| num_bits -= code_len; \ | | 173| 49.2M| } \ | | 174| 49.2M| MZ_MACRO_END | | ------------------ | | | | 26| 49.2M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 429| 49.2M| if (counter >= 256) ------------------ | Branch (429:29): [True: 6.42k, False: 49.2M] ------------------ 430| 6.42k| break; 431| 49.2M| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (431:32): [True: 48, False: 49.2M] ------------------ 432| 48| { 433| 48| TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 45| 48| do \ | | 46| 48| { \ | | 47| 48| status = result; \ | | 48| 48| r->m_state = state_index; \ | | 49| 48| goto common_exit; \ | | 50| 48| case state_index:; \ | | ------------------ | | | Branch (50:9): [True: 0, False: 2.43k] | | ------------------ | | 51| 0| } \ | | 52| 48| MZ_MACRO_END | | ------------------ | | | | 26| 48|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 434| 48| } 435| 49.2M| *pOut_buf_cur++ = (mz_uint8)counter; 436| 49.2M| } 437| 309M| else 438| 309M| { 439| 309M| int sym2; 440| 309M| mz_uint code_len; 441| 309M|#if TINFL_USE_64BIT_BITBUF 442| 309M| if (num_bits < 30) ------------------ | Branch (442:29): [True: 860k, False: 309M] ------------------ 443| 860k| { 444| 860k| bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); ------------------ | | 70| 860k|#define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) ------------------ 445| 860k| pIn_buf_cur += 4; 446| 860k| num_bits += 32; 447| 860k| } 448| |#else 449| | if (num_bits < 15) 450| | { 451| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 452| | pIn_buf_cur += 2; 453| | num_bits += 16; 454| | } 455| |#endif 456| 309M| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (456:29): [True: 309M, False: 12.3k] ------------------ 457| 309M| code_len = sym2 >> 9; 458| 12.3k| else 459| 12.3k| { 460| 12.3k| code_len = TINFL_FAST_LOOKUP_BITS; 461| 12.3k| do 462| 26.2k| { 463| 26.2k| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 464| 26.2k| } while (sym2 < 0); ------------------ | Branch (464:38): [True: 13.8k, False: 12.3k] ------------------ 465| 12.3k| } 466| 309M| counter = sym2; 467| 309M| bit_buf >>= code_len; 468| 309M| num_bits -= code_len; 469| 309M| if (counter & 256) ------------------ | Branch (469:29): [True: 1.20M, False: 308M] ------------------ 470| 1.20M| break; 471| | 472| |#if !TINFL_USE_64BIT_BITBUF 473| | if (num_bits < 15) 474| | { 475| | bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); 476| | pIn_buf_cur += 2; 477| | num_bits += 16; 478| | } 479| |#endif 480| 308M| if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) ------------------ | Branch (480:29): [True: 308M, False: 9.33k] ------------------ 481| 308M| code_len = sym2 >> 9; 482| 9.33k| else 483| 9.33k| { 484| 9.33k| code_len = TINFL_FAST_LOOKUP_BITS; 485| 9.33k| do 486| 20.3k| { 487| 20.3k| sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; 488| 20.3k| } while (sym2 < 0); ------------------ | Branch (488:38): [True: 11.0k, False: 9.33k] ------------------ 489| 9.33k| } 490| 308M| bit_buf >>= code_len; 491| 308M| num_bits -= code_len; 492| | 493| 308M| pOut_buf_cur[0] = (mz_uint8)counter; 494| 308M| if (sym2 & 256) ------------------ | Branch (494:29): [True: 82.8k, False: 308M] ------------------ 495| 82.8k| { 496| 82.8k| pOut_buf_cur++; 497| 82.8k| counter = sym2; 498| 82.8k| break; 499| 82.8k| } 500| 308M| pOut_buf_cur[1] = (mz_uint8)sym2; 501| 308M| pOut_buf_cur += 2; 502| 308M| } 503| 359M| } 504| 1.29M| if ((counter &= 511) == 256) ------------------ | Branch (504:21): [True: 5.32k, False: 1.28M] ------------------ 505| 5.32k| break; 506| | 507| 1.28M| num_extra = s_length_extra[counter - 257]; 508| 1.28M| counter = s_length_base[counter - 257]; 509| 1.28M| if (num_extra) ------------------ | Branch (509:21): [True: 65.1k, False: 1.22M] ------------------ 510| 65.1k| { 511| 65.1k| mz_uint extra_bits; 512| 65.1k| TINFL_GET_BITS(25, extra_bits, num_extra); ------------------ | | 95| 65.1k| do \ | | 96| 65.1k| { \ | | 97| 65.1k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 29, False: 65.0k] | | ------------------ | | 98| 65.1k| { \ | | 99| 29| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 29| do \ | | | | 77| 29| { \ | | | | 78| 29| mz_uint c; \ | | | | 79| 29| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 29| do \ | | | | | | 66| 29| { \ | | | | | | 67| 29| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 6, False: 23] | | | | | | ------------------ | | | | | | 68| 29| { \ | | | | | | 69| 6| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 6| do \ | | | | | | | | 46| 6| { \ | | | | | | | | 47| 12| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | | | 48| 6| r->m_state = state_index; \ | | | | | | | | 49| 6| goto common_exit; \ | | | | | | | | 50| 6| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 6| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 6|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 6| } \ | | | | | | 71| 29| c = *pIn_buf_cur++; \ | | | | | | 72| 23| } \ | | | | | | 73| 29| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 29|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 29| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 23| num_bits += 8; \ | | | | 82| 23| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 23] | | | | ------------------ | | ------------------ | | 100| 29| } \ | | 101| 65.1k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 65.1k| bit_buf >>= (n); \ | | 103| 65.1k| num_bits -= (n); \ | | 104| 65.1k| } \ | | 105| 65.1k| MZ_MACRO_END | | ------------------ | | | | 26| 65.1k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 513| 65.1k| counter += extra_bits; 514| 65.1k| } 515| | 516| 1.28M| TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); ------------------ | | 143| 1.28M| do \ | | 144| 1.28M| { \ | | 145| 1.28M| int temp; \ | | 146| 1.28M| mz_uint code_len, c; \ | | 147| 1.28M| if (num_bits < 15) \ | | ------------------ | | | Branch (147:13): [True: 2.30k, False: 1.28M] | | ------------------ | | 148| 1.28M| { \ | | 149| 2.30k| if ((pIn_buf_end - pIn_buf_cur) < 2) \ | | ------------------ | | | Branch (149:17): [True: 437, False: 1.86k] | | ------------------ | | 150| 2.30k| { \ | | 151| 437| TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ | | ------------------ | | | | 112| 437| do \ | | | | 113| 452| { \ | | | | 114| 452| temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ | | | | 115| 452| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (115:13): [True: 431, False: 21] | | | | ------------------ | | | | 116| 452| { \ | | | | 117| 431| code_len = temp >> 9; \ | | | | 118| 431| if ((code_len) && (num_bits >= code_len)) \ | | | | ------------------ | | | | | Branch (118:17): [True: 398, False: 33] | | | | | Branch (118:31): [True: 386, False: 12] | | | | ------------------ | | | | 119| 431| break; \ | | | | 120| 431| } \ | | | | 121| 452| else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ | | | | ------------------ | | | | | Branch (121:18): [True: 9, False: 12] | | | | ------------------ | | | | 122| 21| { \ | | | | 123| 9| code_len = TINFL_FAST_LOOKUP_BITS; \ | | | | 124| 9| do \ | | | | 125| 23| { \ | | | | 126| 23| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | | | 127| 23| } while ((temp < 0) && (num_bits >= (code_len + 1))); \ | | | | ------------------ | | | | | Branch (127:22): [True: 19, False: 4] | | | | | Branch (127:36): [True: 14, False: 5] | | | | ------------------ | | | | 128| 9| if (temp >= 0) \ | | | | ------------------ | | | | | Branch (128:17): [True: 4, False: 5] | | | | ------------------ | | | | 129| 9| break; \ | | | | 130| 9| } \ | | | | 131| 452| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 62| do \ | | | | | | 66| 62| { \ | | | | | | 67| 62| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 32, False: 30] | | | | | | ------------------ | | | | | | 68| 62| { \ | | | | | | 69| 32| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 32| do \ | | | | | | | | 46| 32| { \ | | | | | | | | 47| 64| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 32] | | | | | | | | ------------------ | | | | | | | | 48| 32| r->m_state = state_index; \ | | | | | | | | 49| 32| goto common_exit; \ | | | | | | | | 50| 32| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 32| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 32|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 32| } \ | | | | | | 71| 62| c = *pIn_buf_cur++; \ | | | | | | 72| 30| } \ | | | | | | 73| 452| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 452|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 132| 62| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 133| 30| num_bits += 8; \ | | | | 134| 30| } while (num_bits < 15); | | | | ------------------ | | | | | Branch (134:14): [True: 15, False: 15] | | | | ------------------ | | ------------------ | | 152| 405| } \ | | 153| 2.30k| else \ | | 154| 2.30k| { \ | | 155| 1.86k| bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ | | 156| 1.86k| pIn_buf_cur += 2; \ | | 157| 1.86k| num_bits += 16; \ | | 158| 1.86k| } \ | | 159| 2.30k| } \ | | 160| 1.28M| if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ | | ------------------ | | | Branch (160:13): [True: 1.28M, False: 2.99k] | | ------------------ | | 161| 1.28M| code_len = temp >> 9, temp &= 511; \ | | 162| 1.28M| else \ | | 163| 1.28M| { \ | | 164| 2.99k| code_len = TINFL_FAST_LOOKUP_BITS; \ | | 165| 2.99k| do \ | | 166| 11.3k| { \ | | 167| 11.3k| temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ | | 168| 11.3k| } while (temp < 0); \ | | ------------------ | | | Branch (168:22): [True: 8.34k, False: 2.99k] | | ------------------ | | 169| 2.99k| } \ | | 170| 1.28M| sym = temp; \ | | 171| 1.28M| bit_buf >>= code_len; \ | | 172| 1.28M| num_bits -= code_len; \ | | 173| 1.28M| } \ | | 174| 1.28M| MZ_MACRO_END | | ------------------ | | | | 26| 1.28M|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 517| 1.28M| num_extra = s_dist_extra[dist]; 518| 1.28M| dist = s_dist_base[dist]; 519| 1.28M| if (num_extra) ------------------ | Branch (519:21): [True: 198k, False: 1.08M] ------------------ 520| 198k| { 521| 198k| mz_uint extra_bits; 522| 198k| TINFL_GET_BITS(27, extra_bits, num_extra); ------------------ | | 95| 198k| do \ | | 96| 198k| { \ | | 97| 198k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 469, False: 197k] | | ------------------ | | 98| 198k| { \ | | 99| 469| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 469| do \ | | | | 77| 479| { \ | | | | 78| 479| mz_uint c; \ | | | | 79| 479| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 479| do \ | | | | | | 66| 479| { \ | | | | | | 67| 479| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 3, False: 476] | | | | | | ------------------ | | | | | | 68| 479| { \ | | | | | | 69| 3| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 3| do \ | | | | | | | | 46| 3| { \ | | | | | | | | 47| 6| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 3] | | | | | | | | ------------------ | | | | | | | | 48| 3| r->m_state = state_index; \ | | | | | | | | 49| 3| goto common_exit; \ | | | | | | | | 50| 3| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 3| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 3|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 3| } \ | | | | | | 71| 479| c = *pIn_buf_cur++; \ | | | | | | 72| 476| } \ | | | | | | 73| 479| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 479|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 479| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 476| num_bits += 8; \ | | | | 82| 476| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 10, False: 466] | | | | ------------------ | | ------------------ | | 100| 469| } \ | | 101| 198k| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 198k| bit_buf >>= (n); \ | | 103| 198k| num_bits -= (n); \ | | 104| 198k| } \ | | 105| 198k| MZ_MACRO_END | | ------------------ | | | | 26| 198k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 523| 198k| dist += extra_bits; 524| 198k| } 525| | 526| 1.28M| dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; 527| 1.28M| if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) ------------------ | Branch (527:22): [True: 7, False: 1.28M] | Branch (527:35): [True: 7, False: 1.28M] | Branch (527:69): [True: 0, False: 1.28M] | Branch (527:102): [True: 14, False: 0] ------------------ 528| 14| { 529| 14| TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); ------------------ | | 54| 14| do \ | | 55| 14| { \ | | 56| 14| for (;;) \ | | 57| 14| { \ | | 58| 14| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 14| do \ | | | | 46| 14| { \ | | | | 47| 14| status = result; \ | | | | 48| 14| r->m_state = state_index; \ | | | | 49| 14| goto common_exit; \ | | | | 50| 14| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 14| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 14|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 14| } \ | | 60| 14| } \ | | 61| 14| MZ_MACRO_END | | ------------------ | | | | 26| 14|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 530| 14| } 531| | 532| 1.28M| pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask); 533| | 534| 1.28M| if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) ------------------ | | 59| 1.28M|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (59:23): [True: 1.28M, False: 0] | | ------------------ ------------------ | Branch (534:21): [True: 13, False: 1.28M] ------------------ 535| 13| { 536| 691| while (counter--) ------------------ | Branch (536:28): [True: 691, False: 0] ------------------ 537| 691| { 538| 691| while (pOut_buf_cur >= pOut_buf_end) ------------------ | Branch (538:32): [True: 13, False: 678] ------------------ 539| 13| { 540| 13| TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); ------------------ | | 45| 13| do \ | | 46| 13| { \ | | 47| 13| status = result; \ | | 48| 13| r->m_state = state_index; \ | | 49| 13| goto common_exit; \ | | 50| 13| case state_index:; \ | | ------------------ | | | Branch (50:9): [True: 0, False: 2.43k] | | ------------------ | | 51| 0| } \ | | 52| 13| MZ_MACRO_END | | ------------------ | | | | 26| 13|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 541| 13| } 542| 678| *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask]; 543| 678| } 544| 0| continue; 545| 13| } 546| |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES 547| | else if ((counter >= 9) && (counter <= dist)) 548| | { 549| | const mz_uint8 *pSrc_end = pSrc + (counter & ~7); 550| | do 551| | { 552| |#ifdef MINIZ_UNALIGNED_USE_MEMCPY 553| | memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2); 554| |#else 555| | ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; 556| | ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; 557| |#endif 558| | pOut_buf_cur += 8; 559| | } while ((pSrc += 8) < pSrc_end); 560| | if ((counter &= 7) < 3) 561| | { 562| | if (counter) 563| | { 564| | pOut_buf_cur[0] = pSrc[0]; 565| | if (counter > 1) 566| | pOut_buf_cur[1] = pSrc[1]; 567| | pOut_buf_cur += counter; 568| | } 569| | continue; 570| | } 571| | } 572| |#endif 573| 79.3M| while(counter>2) ------------------ | Branch (573:23): [True: 78.0M, False: 1.28M] ------------------ 574| 78.0M| { 575| 78.0M| pOut_buf_cur[0] = pSrc[0]; 576| 78.0M| pOut_buf_cur[1] = pSrc[1]; 577| 78.0M| pOut_buf_cur[2] = pSrc[2]; 578| 78.0M| pOut_buf_cur += 3; 579| 78.0M| pSrc += 3; 580| 78.0M| counter -= 3; 581| 78.0M| } 582| 1.28M| if (counter > 0) ------------------ | Branch (582:21): [True: 109k, False: 1.17M] ------------------ 583| 109k| { 584| 109k| pOut_buf_cur[0] = pSrc[0]; 585| 109k| if (counter > 1) ------------------ | Branch (585:25): [True: 40.9k, False: 68.8k] ------------------ 586| 40.9k| pOut_buf_cur[1] = pSrc[1]; 587| 109k| pOut_buf_cur += counter; 588| 109k| } 589| 1.28M| } 590| 5.47k| } 591| 8.08k| } while (!(r->m_final & 1)); ------------------ | Branch (591:14): [True: 5.65k, False: 2.11k] ------------------ 592| | 593| | /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */ 594| | /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */ 595| 2.11k| TINFL_SKIP_BITS(32, num_bits & 7); ------------------ | | 84| 2.11k| do \ | | 85| 2.11k| { \ | | 86| 2.11k| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 2.11k] | | ------------------ | | 87| 2.11k| { \ | | 88| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 0| do \ | | | | 77| 0| { \ | | | | 78| 0| mz_uint c; \ | | | | 79| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 0| do \ | | | | | | 66| 0| { \ | | | | | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 68| 0| { \ | | | | | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 0| do \ | | | | | | | | 46| 0| { \ | | | | | | | | 47| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 48| 0| r->m_state = state_index; \ | | | | | | | | 49| 0| goto common_exit; \ | | | | | | | | 50| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 0| } \ | | | | | | 71| 0| c = *pIn_buf_cur++; \ | | | | | | 72| 0| } \ | | | | | | 73| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 0| num_bits += 8; \ | | | | 82| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 89| 0| } \ | | 90| 2.11k| bit_buf >>= (n); \ | | 91| 2.11k| num_bits -= (n); \ | | 92| 2.11k| } \ | | 93| 2.43k| MZ_MACRO_END | | ------------------ | | | | 26| 2.43k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 596| 2.26k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (596:12): [True: 2.26k, False: 0] | Branch (596:44): [True: 145, False: 2.11k] ------------------ 597| 145| { 598| 145| --pIn_buf_cur; 599| 145| num_bits -= 8; 600| 145| } 601| 2.11k| bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits); 602| 2.11k| MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */ ------------------ | | 47| 2.11k|#define MZ_ASSERT(x) assert(x) ------------------ 603| | 604| 2.11k| if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) ------------------ | Branch (604:9): [True: 0, False: 2.11k] ------------------ 605| 0| { 606| 0| for (counter = 0; counter < 4; ++counter) ------------------ | Branch (606:27): [True: 0, False: 0] ------------------ 607| 0| { 608| 0| mz_uint s; 609| 0| if (num_bits) ------------------ | Branch (609:17): [True: 0, False: 0] ------------------ 610| 0| TINFL_GET_BITS(41, s, 8); ------------------ | | 95| 0| do \ | | 96| 0| { \ | | 97| 0| if (num_bits < (mz_uint)(n)) \ | | ------------------ | | | Branch (97:13): [True: 0, False: 0] | | ------------------ | | 98| 0| { \ | | 99| 0| TINFL_NEED_BITS(state_index, n); \ | | ------------------ | | | | 76| 0| do \ | | | | 77| 0| { \ | | | | 78| 0| mz_uint c; \ | | | | 79| 0| TINFL_GET_BYTE(state_index, c); \ | | | | ------------------ | | | | | | 65| 0| do \ | | | | | | 66| 0| { \ | | | | | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | | | | | ------------------ | | | | | | | Branch (67:16): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 68| 0| { \ | | | | | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | | | | | ------------------ | | | | | | | | 45| 0| do \ | | | | | | | | 46| 0| { \ | | | | | | | | 47| 0| status = result; \ | | | | | | | | ------------------ | | | | | | | | | Branch (47:18): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 48| 0| r->m_state = state_index; \ | | | | | | | | 49| 0| goto common_exit; \ | | | | | | | | 50| 0| case state_index:; \ | | | | | | | | ------------------ | | | | | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | | | | | ------------------ | | | | | | | | 51| 0| } \ | | | | | | | | 52| 0| MZ_MACRO_END | | | | | | | | ------------------ | | | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 70| 0| } \ | | | | | | 71| 0| c = *pIn_buf_cur++; \ | | | | | | 72| 0| } \ | | | | | | 73| 0| MZ_MACRO_END | | | | | | ------------------ | | | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 80| 0| bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ | | | | 81| 0| num_bits += 8; \ | | | | 82| 0| } while (num_bits < (mz_uint)(n)) | | | | ------------------ | | | | | Branch (82:14): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 100| 0| } \ | | 101| 0| b = bit_buf & ((1 << (n)) - 1); \ | | 102| 0| bit_buf >>= (n); \ | | 103| 0| num_bits -= (n); \ | | 104| 0| } \ | | 105| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 611| 0| else 612| 0| TINFL_GET_BYTE(42, s); ------------------ | | 65| 0| do \ | | 66| 0| { \ | | 67| 0| while (pIn_buf_cur >= pIn_buf_end) \ | | ------------------ | | | Branch (67:16): [True: 0, False: 0] | | ------------------ | | 68| 0| { \ | | 69| 0| TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ | | ------------------ | | | | 45| 0| do \ | | | | 46| 0| { \ | | | | 47| 0| status = result; \ | | | | ------------------ | | | | | Branch (47:18): [True: 0, False: 0] | | | | ------------------ | | | | 48| 0| r->m_state = state_index; \ | | | | 49| 0| goto common_exit; \ | | | | 50| 0| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 0| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 70| 0| } \ | | 71| 0| c = *pIn_buf_cur++; \ | | 72| 0| } \ | | 73| 0| MZ_MACRO_END | | ------------------ | | | | 26| 0|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 613| 0| r->m_z_adler32 = (r->m_z_adler32 << 8) | s; 614| 0| } 615| 0| } 616| 2.43k| TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); ------------------ | | 54| 2.11k| do \ | | 55| 2.11k| { \ | | 56| 2.11k| for (;;) \ | | 57| 2.11k| { \ | | 58| 2.11k| TINFL_CR_RETURN(state_index, result); \ | | ------------------ | | | | 45| 2.11k| do \ | | | | 46| 2.11k| { \ | | | | 47| 2.11k| status = result; \ | | | | 48| 2.11k| r->m_state = state_index; \ | | | | 49| 2.11k| goto common_exit; \ | | | | 50| 2.11k| case state_index:; \ | | | | ------------------ | | | | | Branch (50:9): [True: 0, False: 2.43k] | | | | ------------------ | | | | 51| 0| } \ | | | | 52| 2.11k| MZ_MACRO_END | | | | ------------------ | | | | | | 26| 2.11k|#define MZ_MACRO_END while (0) | | | | | | ------------------ | | | | | | | Branch (26:29): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 59| 2.11k| } \ | | 60| 2.11k| } \ | | 61| 2.11k| MZ_MACRO_END | | ------------------ | | | | 26| 2.11k|#define MZ_MACRO_END while (0) | | | | ------------------ | | | | | Branch (26:29): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 617| | 618| 2.43k| TINFL_CR_FINISH ------------------ | | 62| 2.43k|#define TINFL_CR_FINISH } ------------------ 619| | 620| 2.43k|common_exit: 621| | /* As long as we aren't telling the caller that we NEED more input to make forward progress: */ 622| | /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */ 623| | /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */ 624| 2.43k| if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) ------------------ | Branch (624:9): [True: 2.43k, False: 0] | Branch (624:54): [True: 2.32k, False: 118] ------------------ 625| 2.32k| { 626| 2.65k| while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) ------------------ | Branch (626:16): [True: 2.65k, False: 0] | Branch (626:48): [True: 334, False: 2.32k] ------------------ 627| 334| { 628| 334| --pIn_buf_cur; 629| 334| num_bits -= 8; 630| 334| } 631| 2.32k| } 632| 2.43k| r->m_num_bits = num_bits; 633| 2.43k| r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits); 634| 2.43k| r->m_dist = dist; 635| 2.43k| r->m_counter = counter; 636| 2.43k| r->m_num_extra = num_extra; 637| 2.43k| r->m_dist_from_out_buf_start = dist_from_out_buf_start; 638| 2.43k| *pIn_buf_size = pIn_buf_cur - pIn_buf_next; 639| 2.43k| *pOut_buf_size = pOut_buf_cur - pOut_buf_next; 640| 2.43k| if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) ------------------ | Branch (640:9): [True: 2.43k, False: 0] | Branch (640:89): [True: 2.18k, False: 253] ------------------ 641| 2.18k| { 642| 2.18k| const mz_uint8 *ptr = pOut_buf_next; 643| 2.18k| size_t buf_len = *pOut_buf_size; 644| 2.18k| mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; 645| 2.18k| size_t block_len = buf_len % 5552; 646| 125k| while (buf_len) ------------------ | Branch (646:16): [True: 122k, False: 2.18k] ------------------ 647| 122k| { 648| 84.3M| for (i = 0; i + 7 < block_len; i += 8, ptr += 8) ------------------ | Branch (648:25): [True: 84.2M, False: 122k] ------------------ 649| 84.2M| { 650| 84.2M| s1 += ptr[0], s2 += s1; 651| 84.2M| s1 += ptr[1], s2 += s1; 652| 84.2M| s1 += ptr[2], s2 += s1; 653| 84.2M| s1 += ptr[3], s2 += s1; 654| 84.2M| s1 += ptr[4], s2 += s1; 655| 84.2M| s1 += ptr[5], s2 += s1; 656| 84.2M| s1 += ptr[6], s2 += s1; 657| 84.2M| s1 += ptr[7], s2 += s1; 658| 84.2M| } 659| 129k| for (; i < block_len; ++i) ------------------ | Branch (659:20): [True: 6.77k, False: 122k] ------------------ 660| 6.77k| s1 += *ptr++, s2 += s1; 661| 122k| s1 %= 65521U, s2 %= 65521U; 662| 122k| buf_len -= block_len; 663| 122k| block_len = 5552; 664| 122k| } 665| 2.18k| r->m_check_adler32 = (s2 << 16) + s1; 666| 2.18k| if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) ------------------ | Branch (666:13): [True: 2.11k, False: 69] | Branch (666:46): [True: 0, False: 2.11k] | Branch (666:95): [True: 0, False: 0] ------------------ 667| 0| status = TINFL_STATUS_ADLER32_MISMATCH; 668| 2.18k| } 669| 2.43k| return status; 670| 2.43k|} miniz_tinfl.c:tinfl_clear_tree: 177| 14.3k|{ 178| 14.3k| if (r->m_type == 0) ------------------ | Branch (178:9): [True: 5.49k, False: 8.82k] ------------------ 179| 5.49k| MZ_CLEAR_ARR(r->m_tree_0); ------------------ | | 62| 5.49k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 180| 8.82k| else if (r->m_type == 1) ------------------ | Branch (180:14): [True: 5.49k, False: 3.32k] ------------------ 181| 5.49k| MZ_CLEAR_ARR(r->m_tree_1); ------------------ | | 62| 5.49k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 182| 3.32k| else 183| 3.32k| MZ_CLEAR_ARR(r->m_tree_2); ------------------ | | 62| 3.32k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj)) ------------------ 184| 14.3k|} flb_uri.c:mk_list_init: 49| 2.04k|{ 50| 2.04k| list->next = list; 51| 2.04k| list->prev = list; 52| 2.04k|} flb_uri.c:mk_list_add: 64| 3.89k|{ 65| 3.89k| __mk_list_add(_new, head->prev, head); 66| 3.89k|} flb_uri.c:__mk_list_add: 56| 3.89k|{ 57| 3.89k| next->prev = _new; 58| 3.89k| _new->next = next; 59| 3.89k| _new->prev = prev; 60| 3.89k| prev->next = _new; 61| 3.89k|} flb_uri.c:mk_list_del: 146| 3.89k|{ 147| 3.89k| __mk_list_del(entry->prev, entry->next); 148| 3.89k| entry->prev = NULL; 149| 3.89k| entry->next = NULL; 150| 3.89k|} flb_uri.c:__mk_list_del: 140| 3.89k|{ 141| 3.89k| prev->next = next; 142| 3.89k| next->prev = prev; 143| 3.89k|} flb_hash_table.c:mk_list_init: 49| 115k|{ 50| 115k| list->next = list; 51| 115k| list->prev = list; 52| 115k|} flb_hash_table.c:mk_list_del: 146| 314k|{ 147| 314k| __mk_list_del(entry->prev, entry->next); 148| 314k| entry->prev = NULL; 149| 314k| entry->next = NULL; 150| 314k|} flb_hash_table.c:__mk_list_del: 140| 314k|{ 141| 314k| prev->next = next; 142| 314k| next->prev = prev; 143| 314k|} flb_hash_table.c:mk_list_add: 64| 314k|{ 65| 314k| __mk_list_add(_new, head->prev, head); 66| 314k|} flb_hash_table.c:__mk_list_add: 56| 314k|{ 57| 314k| next->prev = _new; 58| 314k| _new->next = next; 59| 314k| _new->prev = prev; 60| 314k| prev->next = _new; 61| 314k|} flb_utils.c:mk_list_init: 49| 4.08k|{ 50| 4.08k| list->next = list; 51| 4.08k| list->prev = list; 52| 4.08k|} flb_utils.c:mk_list_add: 64| 5.11k|{ 65| 5.11k| __mk_list_add(_new, head->prev, head); 66| 5.11k|} flb_utils.c:__mk_list_add: 56| 5.11k|{ 57| 5.11k| next->prev = _new; 58| 5.11k| _new->next = next; 59| 5.11k| _new->prev = prev; 60| 5.11k| prev->next = _new; 61| 5.11k|} flb_utils.c:mk_list_del: 146| 5.11k|{ 147| 5.11k| __mk_list_del(entry->prev, entry->next); 148| 5.11k| entry->prev = NULL; 149| 5.11k| entry->next = NULL; 150| 5.11k|} flb_utils.c:__mk_list_del: 140| 5.11k|{ 141| 5.11k| prev->next = next; 142| 5.11k| next->prev = prev; 143| 5.11k|} flb_slist.c:mk_list_init: 49| 2.04k|{ 50| 2.04k| list->next = list; 51| 2.04k| list->prev = list; 52| 2.04k|} flb_slist.c:mk_list_add: 64| 2.04k|{ 65| 2.04k| __mk_list_add(_new, head->prev, head); 66| 2.04k|} flb_slist.c:__mk_list_add: 56| 2.04k|{ 57| 2.04k| next->prev = _new; 58| 2.04k| _new->next = next; 59| 2.04k| _new->prev = prev; 60| 2.04k| prev->next = _new; 61| 2.04k|} flb_slist.c:mk_list_del: 146| 2.04k|{ 147| 2.04k| __mk_list_del(entry->prev, entry->next); 148| 2.04k| entry->prev = NULL; 149| 2.04k| entry->next = NULL; 150| 2.04k|} flb_slist.c:__mk_list_del: 140| 2.04k|{ 141| 2.04k| prev->next = next; 142| 2.04k| next->prev = prev; 143| 2.04k|} flb_slist.c:mk_list_size: 162| 2.04k|{ 163| 2.04k| int ret = 0; 164| 2.04k| struct mk_list *it; 165| 4.08k| for (it = head->next; it != head; it = it->next, ret++); ------------------ | Branch (165:27): [True: 2.04k, False: 2.04k] ------------------ 166| 2.04k| return ret; 167| 2.04k|} flb_uri.c:mk_mem_free: 98| 3.89k|{ 99| |#ifdef MALLOC_JEMALLOC 100| | je_free(ptr); 101| |#else 102| 3.89k| free(ptr); 103| 3.89k|#endif 104| 3.89k|} mk_string.c:mk_mem_alloc: 49| 10.5k|{ 50| |#ifdef MALLOC_JEMALLOC 51| | void *aux = je_malloc(size); 52| |#else 53| 10.5k| void *aux = malloc(size); 54| 10.5k|#endif 55| | 56| 10.5k| if (mk_unlikely(!aux && size)) { ------------------ | | 116| 10.5k| #define mk_unlikely(x) __builtin_expect((x),0) | | ------------------ | | | Branch (116:26): [True: 0, False: 10.5k] | | | Branch (116:44): [True: 0, False: 10.5k] | | | Branch (116:44): [True: 0, False: 0] | | ------------------ ------------------ 57| 0| perror("malloc"); 58| 0| return NULL; 59| 0| } 60| | 61| 10.5k| return aux; 62| 10.5k|} mk_string_char_search: 268| 10.7k|{ 269| 10.7k| char *p; 270| | 271| 10.7k| if (len < 0) { ------------------ | Branch (271:9): [True: 0, False: 10.7k] ------------------ 272| 0| len = strlen(string); 273| 0| } 274| | 275| 10.7k| p = memchr(string, c, len); 276| 10.7k| if (p) { ------------------ | Branch (276:9): [True: 5.21k, False: 5.56k] ------------------ 277| 5.21k| return (p - string); 278| 5.21k| } 279| | 280| 5.56k| return -1; 281| 10.7k|} mk_string_copy_substr: 572| 10.5k|{ 573| 10.5k| unsigned int size, bytes; 574| 10.5k| char *buffer = 0; 575| | 576| 10.5k| if (pos_init > pos_end) { ------------------ | Branch (576:9): [True: 18, False: 10.5k] ------------------ 577| 18| return NULL; 578| 18| } 579| | 580| 10.5k| size = (unsigned int) (pos_end - pos_init) + 1; 581| 10.5k| if (size <= 2) { ------------------ | Branch (581:9): [True: 371, False: 10.1k] ------------------ 582| 371| size = 4; 583| 371| } 584| | 585| 10.5k| buffer = mk_mem_alloc(size); 586| | 587| 10.5k| if (!buffer) { ------------------ | Branch (587:9): [True: 0, False: 10.5k] ------------------ 588| 0| return NULL; 589| 0| } 590| | 591| 10.5k| bytes = pos_end - pos_init; 592| 10.5k| memcpy(buffer, string + pos_init, bytes); 593| 10.5k| buffer[bytes] = '\0'; 594| | 595| 10.5k| return (char *) buffer; 596| 10.5k|} onigenc_unicode_is_code_ctype: 183| 53.0k|{ 184| 53.0k| if ( 185| 53.0k|#ifdef USE_UNICODE_PROPERTIES 186| 53.0k| ctype <= ONIGENC_MAX_STD_CTYPE && ------------------ | | 309| 53.0k|#define ONIGENC_MAX_STD_CTYPE ONIGENC_CTYPE_ASCII | | ------------------ | | | | 308| 106k|#define ONIGENC_CTYPE_ASCII 14 | | ------------------ ------------------ | Branch (186:7): [True: 53.0k, False: 0] ------------------ 187| 53.0k|#endif 188| 53.0k| code < 256) { ------------------ | Branch (188:7): [True: 53.0k, False: 0] ------------------ 189| 53.0k| return ONIGENC_IS_UNICODE_ISO_8859_1_CTYPE(code, ctype); ------------------ | | 33| 53.0k| ((EncUNICODE_ISO_8859_1_CtypeTable[code] & CTYPE_TO_BIT(ctype)) != 0) | | ------------------ | | | | 113| 53.0k|#define CTYPE_TO_BIT(ctype) (1<<(ctype)) | | ------------------ ------------------ 190| 53.0k| } 191| | 192| 0| if (ctype >= CODE_RANGES_NUM) { ------------------ | | 179| 0|#define CODE_RANGES_NUM numberof(CodeRanges) | | ------------------ | | | | 129| 0|# define numberof(array) (int )(sizeof(array) / sizeof((array)[0])) | | ------------------ ------------------ | Branch (192:7): [True: 0, False: 0] ------------------ 193| 0| return ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 194| 0| } 195| | 196| 0| return onig_is_in_code_range((UChar* )CodeRanges[ctype], code); 197| 0|} utf_8.c:mbc_enc_len: 317| 11.4M|{ 318| 11.4M| int firstbyte = *p++; 319| 11.4M| state_t s; 320| 11.4M| s = trans[0][firstbyte]; 321| 11.4M| if (s < 0) return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1) : ------------------ | | 345| 8.54M|#define ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(n) (n) ------------------ | Branch (321:7): [True: 10.7M, False: 704k] | Branch (321:21): [True: 8.54M, False: 2.17M] ------------------ 322| 10.7M| ONIGENC_CONSTRUCT_MBCLEN_INVALID(); ------------------ | | 349| 2.17M|#define ONIGENC_CONSTRUCT_MBCLEN_INVALID() (-1) ------------------ 323| | 324| 704k| if (p == e) return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(EncLen_UTF8[firstbyte]-1); ------------------ | | 352| 1.50k|#define ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n) (-1-(n)) ------------------ | Branch (324:7): [True: 1.50k, False: 702k] ------------------ 325| 702k| s = trans[s][*p++]; 326| 702k| if (s < 0) return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(2) : ------------------ | | 345| 54.1k|#define ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(n) (n) ------------------ | Branch (326:7): [True: 656k, False: 46.2k] | Branch (326:21): [True: 54.1k, False: 602k] ------------------ 327| 656k| ONIGENC_CONSTRUCT_MBCLEN_INVALID(); ------------------ | | 349| 602k|#define ONIGENC_CONSTRUCT_MBCLEN_INVALID() (-1) ------------------ 328| | 329| 46.2k| if (p == e) return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(EncLen_UTF8[firstbyte]-2); ------------------ | | 352| 511|#define ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n) (-1-(n)) ------------------ | Branch (329:7): [True: 511, False: 45.7k] ------------------ 330| 45.7k| s = trans[s][*p++]; 331| 45.7k| if (s < 0) return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(3) : ------------------ | | 345| 6.53k|#define ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(n) (n) ------------------ | Branch (331:7): [True: 32.4k, False: 13.2k] | Branch (331:21): [True: 6.53k, False: 25.9k] ------------------ 332| 32.4k| ONIGENC_CONSTRUCT_MBCLEN_INVALID(); ------------------ | | 349| 25.9k|#define ONIGENC_CONSTRUCT_MBCLEN_INVALID() (-1) ------------------ 333| | 334| 13.2k| if (p == e) return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(EncLen_UTF8[firstbyte]-3); ------------------ | | 352| 541|#define ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n) (-1-(n)) ------------------ | Branch (334:7): [True: 541, False: 12.6k] ------------------ 335| 12.6k| s = trans[s][*p++]; 336| | 337| 12.6k|#ifndef USE_UTF8_31BITS 338| 12.6k| return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(4) : ------------------ | | 345| 11.8k|#define ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(n) (n) ------------------ | Branch (338:10): [True: 11.8k, False: 846] ------------------ 339| 12.6k| ONIGENC_CONSTRUCT_MBCLEN_INVALID(); ------------------ | | 349| 846|#define ONIGENC_CONSTRUCT_MBCLEN_INVALID() (-1) ------------------ 340| |#else 341| | if (s < 0) return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(4) : 342| | ONIGENC_CONSTRUCT_MBCLEN_INVALID(); 343| | 344| | if (p == e) return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(EncLen_UTF8[firstbyte]-4); 345| | s = trans[s][*p++]; 346| | if (s < 0) return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(5) : 347| | ONIGENC_CONSTRUCT_MBCLEN_INVALID(); 348| | 349| | if (p == e) return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(EncLen_UTF8[firstbyte]-5); 350| | s = trans[s][*p++]; 351| | return s == ACCEPT ? ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(6) : 352| | ONIGENC_CONSTRUCT_MBCLEN_INVALID(); 353| |#endif 354| 13.2k|} utf_8.c:is_mbc_newline: 358| 2.17M|{ 359| 2.17M| if (p < end) { ------------------ | Branch (359:7): [True: 2.17M, False: 0] ------------------ 360| 2.17M| if (*p == 0x0a) return 1; ------------------ | Branch (360:9): [True: 9.02k, False: 2.16M] ------------------ 361| | 362| |#ifdef USE_UNICODE_ALL_LINE_TERMINATORS 363| | if (*p == 0x0b || *p == 0x0c || *p == 0x0d) return 1; 364| | if (p + 1 < end) { 365| | if (*(p+1) == 0x85 && *p == 0xc2) /* U+0085 */ 366| | return 1; 367| | if (p + 2 < end) { 368| | if ((*(p+2) == 0xa8 || *(p+2) == 0xa9) 369| | && *(p+1) == 0x80 && *p == 0xe2) /* U+2028, U+2029 */ 370| | return 1; 371| | } 372| | } 373| |#endif 374| 2.17M| } 375| | 376| 2.16M| return 0; 377| 2.17M|} utf_8.c:mbc_to_code: 381| 185k|{ 382| 185k| int c, len; 383| 185k| OnigCodePoint n; 384| | 385| 185k| len = mbc_enc_len(p, end, enc); 386| 185k| c = *p++; 387| 185k| if (len > 1) { ------------------ | Branch (387:7): [True: 0, False: 185k] ------------------ 388| 0| len--; 389| 0| n = c & ((1 << (6 - len)) - 1); 390| 0| while (len--) { ------------------ | Branch (390:12): [True: 0, False: 0] ------------------ 391| 0| c = *p++; 392| 0| n = (n << 6) | (c & ((1 << 6) - 1)); 393| 0| } 394| 0| return n; 395| 0| } 396| 185k| else { 397| 185k|#ifdef USE_INVALID_CODE_SCHEME 398| 185k| if (c > 0xfd) { ------------------ | Branch (398:9): [True: 0, False: 185k] ------------------ 399| 0| return ((c == 0xfe) ? INVALID_CODE_FE : INVALID_CODE_FF); ------------------ | | 44| 0|# define INVALID_CODE_FE 0xfffffffe ------------------ return ((c == 0xfe) ? INVALID_CODE_FE : INVALID_CODE_FF); ------------------ | | 45| 0|# define INVALID_CODE_FF 0xffffffff ------------------ | Branch (399:15): [True: 0, False: 0] ------------------ 400| 0| } 401| 185k|#endif 402| 185k| return (OnigCodePoint )c; 403| 185k| } 404| 185k|} utf_8.c:code_to_mbclen: 408| 12.2k|{ 409| 12.2k| if ((code & 0xffffff80) == 0) return 1; ------------------ | Branch (409:12): [True: 12.2k, False: 0] ------------------ 410| 0| else if ((code & 0xfffff800) == 0) return 2; ------------------ | Branch (410:12): [True: 0, False: 0] ------------------ 411| 0| else if ((code & 0xffff0000) == 0) return 3; ------------------ | Branch (411:12): [True: 0, False: 0] ------------------ 412| 0|#ifndef USE_UTF8_31BITS 413| 0| else if (code <= VALID_CODE_LIMIT) return 4; ------------------ | | 49| 0|#define VALID_CODE_LIMIT 0x0010ffff ------------------ | Branch (413:12): [True: 0, False: 0] ------------------ 414| |#else 415| | else if ((code & 0xffe00000) == 0) return 4; 416| | else if ((code & 0xfc000000) == 0) return 5; 417| | else if (code <= VALID_CODE_LIMIT) return 6; 418| |#endif 419| 0|#ifdef USE_INVALID_CODE_SCHEME 420| 0| else if (code == INVALID_CODE_FE) return 1; ------------------ | | 44| 0|# define INVALID_CODE_FE 0xfffffffe ------------------ | Branch (420:12): [True: 0, False: 0] ------------------ 421| 0| else if (code == INVALID_CODE_FF) return 1; ------------------ | | 45| 0|# define INVALID_CODE_FF 0xffffffff ------------------ | Branch (421:12): [True: 0, False: 0] ------------------ 422| 0|#endif 423| 0| else 424| 0| return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE; ------------------ | | 694| 0|#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 ------------------ 425| 12.2k|} onig_bbuf_init: 143| 2.04k|{ 144| 2.04k| if (size <= 0) { ------------------ | Branch (144:7): [True: 0, False: 2.04k] ------------------ 145| 0| size = 0; 146| 0| buf->p = NULL; 147| 0| } 148| 2.04k| else { 149| 2.04k| buf->p = (UChar* )xmalloc(size); ------------------ | | 142| 2.04k|# define xmalloc malloc ------------------ 150| 2.04k| if (IS_NULL(buf->p)) return(ONIGERR_MEMORY); ------------------ | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 2.04k] | | ------------------ ------------------ if (IS_NULL(buf->p)) return(ONIGERR_MEMORY); ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 151| 2.04k| } 152| | 153| 2.04k| buf->alloc = (unsigned int )size; 154| 2.04k| buf->used = 0; 155| 2.04k| return 0; 156| 2.04k|} onig_free_body: 5535| 2.04k|{ 5536| 2.04k| if (IS_NOT_NULL(reg)) { ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ 5537| 2.04k| if (IS_NOT_NULL(reg->p)) xfree(reg->p); ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ if (IS_NOT_NULL(reg->p)) xfree(reg->p); ------------------ | | 145| 2.04k|# define xfree free ------------------ 5538| 2.04k| if (IS_NOT_NULL(reg->exact)) xfree(reg->exact); ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ if (IS_NOT_NULL(reg->exact)) xfree(reg->exact); ------------------ | | 145| 2.04k|# define xfree free ------------------ 5539| 2.04k| if (IS_NOT_NULL(reg->repeat_range)) xfree(reg->repeat_range); ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 2.04k] | | ------------------ ------------------ if (IS_NOT_NULL(reg->repeat_range)) xfree(reg->repeat_range); ------------------ | | 145| 0|# define xfree free ------------------ 5540| 2.04k| if (IS_NOT_NULL(reg->chain)) onig_free(reg->chain); ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 2.04k] | | ------------------ ------------------ 5541| | 5542| 2.04k|#ifdef USE_NAMED_GROUP 5543| 2.04k| onig_names_free(reg); 5544| 2.04k|#endif 5545| 2.04k| } 5546| 2.04k|} onig_free: 5550| 2.04k|{ 5551| 2.04k| if (IS_NOT_NULL(reg)) { ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ 5552| 2.04k| onig_free_body(reg); 5553| 2.04k| xfree(reg); ------------------ | | 145| 2.04k|# define xfree free ------------------ 5554| 2.04k| } 5555| 2.04k|} onig_compile: 5620| 2.04k|{ 5621| 2.04k|#define COMPILE_INIT_SIZE 20 5622| | 5623| 2.04k| int r; 5624| 2.04k| OnigDistance init_size; 5625| 2.04k| Node* root; 5626| 2.04k| ScanEnv scan_env = {0}; 5627| 2.04k|#ifdef USE_SUBEXP_CALL 5628| 2.04k| UnsetAddrList uslist; 5629| 2.04k|#endif 5630| | 5631| 2.04k| if (IS_NOT_NULL(einfo)) einfo->par = (UChar* )NULL; ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ 5632| | 5633| |#ifdef RUBY 5634| | scan_env.sourcefile = sourcefile; 5635| | scan_env.sourceline = sourceline; 5636| |#endif 5637| | 5638| |#ifdef ONIG_DEBUG 5639| | print_enc_string(stderr, reg->enc, pattern, pattern_end); 5640| |#endif 5641| | 5642| 2.04k| if (reg->alloc == 0) { ------------------ | Branch (5642:7): [True: 2.04k, False: 0] ------------------ 5643| 2.04k| init_size = (pattern_end - pattern) * 2; 5644| 2.04k| if (init_size <= 0) init_size = COMPILE_INIT_SIZE; ------------------ | | 5621| 0|#define COMPILE_INIT_SIZE 20 ------------------ | Branch (5644:9): [True: 0, False: 2.04k] ------------------ 5645| 2.04k| r = BBUF_INIT(reg, init_size); ------------------ | | 460| 2.04k|#define BBUF_INIT(buf,size) onig_bbuf_init((BBuf* )(buf), (size)) ------------------ 5646| 2.04k| if (r != 0) goto end; ------------------ | Branch (5646:9): [True: 0, False: 2.04k] ------------------ 5647| 2.04k| } 5648| 0| else 5649| 0| reg->used = 0; 5650| | 5651| 2.04k| reg->num_mem = 0; 5652| 2.04k| reg->num_repeat = 0; 5653| 2.04k| reg->num_null_check = 0; 5654| 2.04k| reg->repeat_range_alloc = 0; 5655| 2.04k| reg->repeat_range = (OnigRepeatRange* )NULL; 5656| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 5657| | reg->num_comb_exp_check = 0; 5658| |#endif 5659| | 5660| 2.04k| r = onig_parse_make_tree(&root, pattern, pattern_end, reg, &scan_env); 5661| 2.04k| if (r != 0) goto err; ------------------ | Branch (5661:7): [True: 0, False: 2.04k] ------------------ 5662| | 5663| |#ifdef ONIG_DEBUG_PARSE_TREE 5664| |# if 0 5665| | fprintf(stderr, "ORIGINAL PARSE TREE:\n"); 5666| | print_tree(stderr, root); 5667| |# endif 5668| |#endif 5669| | 5670| 2.04k|#ifdef USE_NAMED_GROUP 5671| | /* mixed use named group and no-named group */ 5672| 2.04k| if (scan_env.num_named > 0 && ------------------ | Branch (5672:7): [True: 2.04k, False: 0] ------------------ 5673| 2.04k| IS_SYNTAX_BV(scan_env.syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) && ------------------ | | 332| 4.08k|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 2.04k, False: 0] | | ------------------ ------------------ 5674| 2.04k| !ONIG_IS_OPTION_ON(reg->options, ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 479| 2.04k|#define ONIG_IS_OPTION_ON(options,option) ((options) & (option)) ------------------ | Branch (5674:7): [True: 2.04k, False: 0] ------------------ 5675| 2.04k| if (scan_env.num_named != scan_env.num_mem) ------------------ | Branch (5675:9): [True: 0, False: 2.04k] ------------------ 5676| 0| r = disable_noname_group_capture(&root, reg, &scan_env); 5677| 2.04k| else 5678| 2.04k| r = numbered_ref_check(root); 5679| | 5680| 2.04k| if (r != 0) goto err; ------------------ | Branch (5680:9): [True: 0, False: 2.04k] ------------------ 5681| 2.04k| } 5682| 2.04k|#endif 5683| | 5684| 2.04k|#ifdef USE_SUBEXP_CALL 5685| 2.04k| if (scan_env.num_call > 0) { ------------------ | Branch (5685:7): [True: 0, False: 2.04k] ------------------ 5686| 0| r = unset_addr_list_init(&uslist, scan_env.num_call); 5687| 0| if (r != 0) goto err; ------------------ | Branch (5687:9): [True: 0, False: 0] ------------------ 5688| 0| scan_env.unset_addr_list = &uslist; 5689| 0| r = setup_subexp_call(root, &scan_env); 5690| 0| if (r != 0) goto err_unset; ------------------ | Branch (5690:9): [True: 0, False: 0] ------------------ 5691| 0| r = subexp_recursive_check_trav(root, &scan_env); 5692| 0| if (r < 0) goto err_unset; ------------------ | Branch (5692:9): [True: 0, False: 0] ------------------ 5693| 0| r = subexp_inf_recursive_check_trav(root, &scan_env); 5694| 0| if (r != 0) goto err_unset; ------------------ | Branch (5694:9): [True: 0, False: 0] ------------------ 5695| | 5696| 0| reg->num_call = scan_env.num_call; 5697| 0| } 5698| 2.04k| else 5699| 2.04k| reg->num_call = 0; 5700| 2.04k|#endif 5701| | 5702| 2.04k| r = setup_tree(root, reg, 0, &scan_env); 5703| 2.04k| if (r != 0) goto err_unset; ------------------ | Branch (5703:7): [True: 0, False: 2.04k] ------------------ 5704| | 5705| |#ifdef ONIG_DEBUG_PARSE_TREE 5706| | print_tree(stderr, root); 5707| |#endif 5708| | 5709| 2.04k| reg->capture_history = scan_env.capture_history; 5710| 2.04k| reg->bt_mem_start = scan_env.bt_mem_start; 5711| 2.04k| reg->bt_mem_start |= reg->capture_history; 5712| 2.04k| if (IS_FIND_CONDITION(reg->options)) ------------------ | | 400| 2.04k|#define IS_FIND_CONDITION(option) ((option) & \ | | ------------------ | | | Branch (400:35): [True: 0, False: 2.04k] | | ------------------ | | 401| 2.04k| (ONIG_OPTION_FIND_LONGEST | ONIG_OPTION_FIND_NOT_EMPTY)) | | ------------------ | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ONIG_OPTION_FIND_LONGEST | ONIG_OPTION_FIND_NOT_EMPTY)) | | ------------------ | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5713| 0| BIT_STATUS_ON_ALL(reg->bt_mem_end); ------------------ | | 369| 0|#define BIT_STATUS_ON_ALL(stats) (stats) = ~((BitStatusType )0) ------------------ 5714| 2.04k| else { 5715| 2.04k| reg->bt_mem_end = scan_env.bt_mem_end; 5716| 2.04k| reg->bt_mem_end |= reg->capture_history; 5717| 2.04k| } 5718| | 5719| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 5720| | if (scan_env.backrefed_mem == 0 5721| |# ifdef USE_SUBEXP_CALL 5722| | || scan_env.num_call == 0 5723| |# endif 5724| | ) { 5725| | setup_comb_exp_check(root, 0, &scan_env); 5726| |# ifdef USE_SUBEXP_CALL 5727| | if (scan_env.has_recursion != 0) { 5728| | scan_env.num_comb_exp_check = 0; 5729| | } 5730| | else 5731| |# endif 5732| | if (scan_env.comb_exp_max_regnum > 0) { 5733| | int i; 5734| | for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) { 5735| | if (BIT_STATUS_AT(scan_env.backrefed_mem, i) != 0) { 5736| | scan_env.num_comb_exp_check = 0; 5737| | break; 5738| | } 5739| | } 5740| | } 5741| | } 5742| | 5743| | reg->num_comb_exp_check = scan_env.num_comb_exp_check; 5744| |#endif 5745| | 5746| 2.04k| clear_optimize_info(reg); 5747| 2.04k|#ifndef ONIG_DONT_OPTIMIZE 5748| 2.04k| r = set_optimize_info_from_tree(root, reg, &scan_env); 5749| 2.04k| if (r != 0) goto err_unset; ------------------ | Branch (5749:7): [True: 0, False: 2.04k] ------------------ 5750| 2.04k|#endif 5751| | 5752| 2.04k| if (IS_NOT_NULL(scan_env.mem_nodes_dynamic)) { ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 2.04k] | | ------------------ ------------------ 5753| 0| xfree(scan_env.mem_nodes_dynamic); ------------------ | | 145| 0|# define xfree free ------------------ 5754| 0| scan_env.mem_nodes_dynamic = (Node** )NULL; 5755| 0| } 5756| | 5757| 2.04k| r = compile_tree(root, reg); 5758| 2.04k| if (r == 0) { ------------------ | Branch (5758:7): [True: 2.04k, False: 0] ------------------ 5759| 2.04k| r = add_opcode(reg, OP_END); 5760| 2.04k|#ifdef USE_SUBEXP_CALL 5761| 2.04k| if (scan_env.num_call > 0) { ------------------ | Branch (5761:9): [True: 0, False: 2.04k] ------------------ 5762| 0| r = unset_addr_list_fix(&uslist, reg); 5763| 0| unset_addr_list_end(&uslist); 5764| 0| if (r) goto err; ------------------ | Branch (5764:11): [True: 0, False: 0] ------------------ 5765| 0| } 5766| 2.04k|#endif 5767| | 5768| 2.04k| if ((reg->num_repeat != 0) || (reg->bt_mem_end != 0)) ------------------ | Branch (5768:9): [True: 0, False: 2.04k] | Branch (5768:35): [True: 0, False: 2.04k] ------------------ 5769| 0| reg->stack_pop_level = STACK_POP_LEVEL_ALL; ------------------ | | 352| 0|#define STACK_POP_LEVEL_ALL 2 ------------------ 5770| 2.04k| else { 5771| 2.04k| if (reg->bt_mem_start != 0) ------------------ | Branch (5771:11): [True: 0, False: 2.04k] ------------------ 5772| 0| reg->stack_pop_level = STACK_POP_LEVEL_MEM_START; ------------------ | | 351| 0|#define STACK_POP_LEVEL_MEM_START 1 ------------------ 5773| 2.04k| else 5774| 2.04k| reg->stack_pop_level = STACK_POP_LEVEL_FREE; ------------------ | | 350| 2.04k|#define STACK_POP_LEVEL_FREE 0 ------------------ 5775| 2.04k| } 5776| 2.04k| } 5777| 0|#ifdef USE_SUBEXP_CALL 5778| 0| else if (scan_env.num_call > 0) { ------------------ | Branch (5778:12): [True: 0, False: 0] ------------------ 5779| 0| unset_addr_list_end(&uslist); 5780| 0| } 5781| 2.04k|#endif 5782| 2.04k| onig_node_free(root); 5783| | 5784| |#ifdef ONIG_DEBUG_COMPILE 5785| |# ifdef USE_NAMED_GROUP 5786| | onig_print_names(stderr, reg); 5787| |# endif 5788| | print_compiled_byte_code_list(stderr, reg); 5789| |#endif 5790| | 5791| 2.04k| end: 5792| 2.04k| return r; 5793| | 5794| 0| err_unset: 5795| 0|#ifdef USE_SUBEXP_CALL 5796| 0| if (scan_env.num_call > 0) { ------------------ | Branch (5796:7): [True: 0, False: 0] ------------------ 5797| 0| unset_addr_list_end(&uslist); 5798| 0| } 5799| 0|#endif 5800| 0| err: 5801| 0| if (IS_NOT_NULL(scan_env.error)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 5802| 0| if (IS_NOT_NULL(einfo)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 5803| 0| einfo->enc = scan_env.enc; 5804| 0| einfo->par = scan_env.error; 5805| 0| einfo->par_end = scan_env.error_end; 5806| 0| } 5807| 0| } 5808| | 5809| 0| onig_node_free(root); 5810| 0| if (IS_NOT_NULL(scan_env.mem_nodes_dynamic)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 5811| 0| xfree(scan_env.mem_nodes_dynamic); ------------------ | | 145| 0|# define xfree free ------------------ 5812| 0| return r; 5813| 0|} onig_reg_init: 5821| 2.04k|{ 5822| 2.04k| if (! onig_inited) ------------------ | Branch (5822:7): [True: 0, False: 2.04k] ------------------ 5823| 0| onig_init(); 5824| | 5825| 2.04k| if (IS_NULL(reg)) ------------------ | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 2.04k] | | ------------------ ------------------ 5826| 0| return ONIGERR_INVALID_ARGUMENT; ------------------ | | 643| 0|#define ONIGERR_INVALID_ARGUMENT -30 ------------------ 5827| | 5828| 2.04k| (reg)->exact = (UChar* )NULL; 5829| 2.04k| (reg)->chain = (regex_t* )NULL; 5830| 2.04k| (reg)->p = (UChar* )NULL; 5831| 2.04k| (reg)->name_table = (void* )NULL; 5832| 2.04k| (reg)->repeat_range = (OnigRepeatRange* )NULL; 5833| | 5834| 2.04k| if (ONIGENC_IS_UNDEF(enc)) ------------------ | | 317| 2.04k|#define ONIGENC_IS_UNDEF(enc) ((enc) == ONIG_ENCODING_UNDEF) | | ------------------ | | | | 281| 2.04k|#define ONIG_ENCODING_UNDEF ((OnigEncoding )0) | | ------------------ | | | Branch (317:40): [True: 0, False: 2.04k] | | ------------------ ------------------ 5835| 0| return ONIGERR_DEFAULT_ENCODING_IS_NOT_SET; ------------------ | | 640| 0|#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SET -21 ------------------ 5836| | 5837| 2.04k| if ((option & (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) ------------------ | | 462| 2.04k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | ------------------ | | | | 461| 2.04k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | ------------------ | | | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | ------------------ | | | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if ((option & (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) ------------------ | | 463| 2.04k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | ------------------ | | | | 462| 2.04k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 461| 2.04k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5837:7): [True: 0, False: 2.04k] ------------------ 5838| 2.04k| == (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 462| 2.04k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | ------------------ | | | | 461| 2.04k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | ------------------ | | | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | ------------------ | | | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ == (ONIG_OPTION_DONT_CAPTURE_GROUP|ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 463| 2.04k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | ------------------ | | | | 462| 2.04k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | ------------------ | | | | | | 461| 2.04k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | ------------------ | | | | | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | ------------------ | | | | | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5839| 0| return ONIGERR_INVALID_COMBINATION_OF_OPTIONS; ------------------ | | 696| 0|#define ONIGERR_INVALID_COMBINATION_OF_OPTIONS -403 ------------------ 5840| 0| } 5841| | 5842| 2.04k| if ((option & ONIG_OPTION_NEGATE_SINGLELINE) != 0) { ------------------ | | 461| 2.04k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | ------------------ | | | | 460| 2.04k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 459| 2.04k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (5842:7): [True: 0, False: 2.04k] ------------------ 5843| 0| option |= syntax->options; 5844| 0| option &= ~ONIG_OPTION_SINGLELINE; ------------------ | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | ------------------ | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 5845| 0| } 5846| 2.04k| else 5847| 2.04k| option |= syntax->options; 5848| | 5849| 2.04k| (reg)->enc = enc; 5850| 2.04k| (reg)->options = option; 5851| 2.04k| (reg)->syntax = syntax; 5852| 2.04k| (reg)->optimize = 0; 5853| | 5854| 2.04k| (reg)->alloc = 0; 5855| 2.04k| (reg)->used = 0; 5856| | 5857| 2.04k| (reg)->case_fold_flag = case_fold_flag; 5858| 2.04k| return 0; 5859| 2.04k|} onig_new: 5879| 2.04k|{ 5880| 2.04k| int r; 5881| | 5882| 2.04k| *reg = (regex_t* )xmalloc(sizeof(regex_t)); ------------------ | | 142| 2.04k|# define xmalloc malloc ------------------ 5883| 2.04k| if (IS_NULL(*reg)) return ONIGERR_MEMORY; ------------------ | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 2.04k] | | ------------------ ------------------ if (IS_NULL(*reg)) return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 5884| | 5885| 2.04k| r = onig_reg_init(*reg, option, ONIGENC_CASE_FOLD_DEFAULT, enc, syntax); ------------------ | | 131| 2.04k|#define ONIGENC_CASE_FOLD_DEFAULT OnigDefaultCaseFoldFlag ------------------ 5886| 2.04k| if (r) goto err; ------------------ | Branch (5886:7): [True: 0, False: 2.04k] ------------------ 5887| | 5888| 2.04k| r = onig_compile(*reg, pattern, pattern_end, einfo); 5889| 2.04k| if (r) { ------------------ | Branch (5889:7): [True: 0, False: 2.04k] ------------------ 5890| 0| err: 5891| 0| onig_free(*reg); 5892| 0| *reg = NULL; 5893| 0| } 5894| 2.04k| return r; 5895| 2.04k|} onig_init: 5905| 2.04k|{ 5906| 2.04k| if (onig_inited != 0) ------------------ | Branch (5906:7): [True: 0, False: 2.04k] ------------------ 5907| 0| return 0; 5908| | 5909| 2.04k| onig_inited = 1; 5910| | 5911| |#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER) 5912| | _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); 5913| |#endif 5914| | 5915| 2.04k| onigenc_init(); 5916| | /* onigenc_set_default_caseconv_table((UChar* )0); */ 5917| | 5918| |#ifdef ONIG_DEBUG_STATISTICS 5919| | onig_statistics_init(); 5920| |#endif 5921| | 5922| 2.04k| return 0; 5923| 2.04k|} onig_end: 5959| 2.04k|{ 5960| 2.04k| exec_end_call_list(); 5961| | 5962| |#ifdef ONIG_DEBUG_STATISTICS 5963| | onig_print_statistics(stderr); 5964| |#endif 5965| | 5966| |#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER) 5967| | _CrtDumpMemoryLeaks(); 5968| |#endif 5969| | 5970| 2.04k| onig_inited = 0; 5971| | 5972| 2.04k| return 0; 5973| 2.04k|} onig_is_code_in_cc_len: 5998| 6.12k|{ 5999| 6.12k| int found; 6000| | 6001| 6.12k| if (elen > 1 || (code >= SINGLE_BYTE_SIZE)) { ------------------ | | 426| 6.12k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (6001:7): [True: 0, False: 6.12k] | Branch (6001:19): [True: 0, False: 6.12k] ------------------ 6002| 0| if (IS_NULL(cc->mbuf)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 6003| 0| found = 0; 6004| 0| } 6005| 0| else { 6006| 0| found = (onig_is_in_code_range(cc->mbuf->p, code) != 0 ? 1 : 0); ------------------ | Branch (6006:16): [True: 0, False: 0] ------------------ 6007| 0| } 6008| 0| } 6009| 6.12k| else { 6010| 6.12k| found = (BITSET_AT(cc->bs, code) == 0 ? 0 : 1); ------------------ | | 448| 6.12k|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 6.12k|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 6.12k|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (6010:14): [True: 0, False: 6.12k] ------------------ 6011| 6.12k| } 6012| | 6013| 6.12k| if (IS_NCCLASS_NOT(cc)) ------------------ | | 809| 6.12k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 6.12k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 6.12k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 6.12k, False: 0] | | | | ------------------ | | ------------------ ------------------ 6014| 6.12k| return !found; 6015| 0| else 6016| 0| return found; 6017| 6.12k|} onig_is_code_in_cc: 6021| 6.12k|{ 6022| 6.12k| int len; 6023| | 6024| 6.12k| if (ONIGENC_MBC_MINLEN(enc) > 1) { ------------------ | | 367| 6.12k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (6024:7): [True: 0, False: 6.12k] ------------------ 6025| 0| len = 2; 6026| 0| } 6027| 6.12k| else { 6028| 6.12k| len = ONIGENC_CODE_TO_MBCLEN(enc, code); ------------------ | | 370| 6.12k|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code,enc) ------------------ 6029| 6.12k| } 6030| 6.12k| return onig_is_code_in_cc_len(len, code, cc); 6031| 6.12k|} regcomp.c:numbered_ref_check: 1989| 36.7k|{ 1990| 36.7k| int r = 0; 1991| | 1992| 36.7k| switch (NTYPE(node)) { ------------------ | | 69| 36.7k|#define NTYPE(node) ((node)->u.base.type) ------------------ 1993| 2.04k| case NT_LIST: ------------------ | | 46| 2.04k|#define NT_LIST 8 ------------------ | Branch (1993:3): [True: 2.04k, False: 34.6k] ------------------ 1994| 2.04k| case NT_ALT: ------------------ | | 47| 2.04k|#define NT_ALT 9 ------------------ | Branch (1994:3): [True: 0, False: 36.7k] ------------------ 1995| 18.3k| do { 1996| 18.3k| r = numbered_ref_check(NCAR(node)); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1997| 18.3k| } while (r == 0 && IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 18.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 16.3k, False: 2.04k] | | ------------------ ------------------ | Branch (1997:14): [True: 18.3k, False: 0] ------------------ 1998| 2.04k| break; 1999| 8.16k| case NT_QTFR: ------------------ | | 43| 8.16k|#define NT_QTFR 5 ------------------ | Branch (1999:3): [True: 8.16k, False: 28.5k] ------------------ 2000| 8.16k| r = numbered_ref_check(NQTFR(node)->target); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 2001| 8.16k| break; 2002| 8.16k| case NT_ENCLOSE: ------------------ | | 44| 8.16k|#define NT_ENCLOSE 6 ------------------ | Branch (2002:3): [True: 8.16k, False: 28.5k] ------------------ 2003| 8.16k| r = numbered_ref_check(NENCLOSE(node)->target); ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2004| 8.16k| break; 2005| | 2006| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (2006:3): [True: 0, False: 36.7k] ------------------ 2007| 0| if (! IS_BACKREF_NAME_REF(NBREF(node))) ------------------ | | 163| 0|#define IS_BACKREF_NAME_REF(bn) (((bn)->state & NST_NAME_REF) != 0) | | ------------------ | | | | 139| 0|#define NST_NAME_REF (1<<11) | | ------------------ ------------------ | Branch (2007:9): [True: 0, False: 0] ------------------ 2008| 0| return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED; ------------------ | | 678| 0|#define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED -209 ------------------ 2009| 0| break; 2010| | 2011| 4.08k| case NT_ANCHOR: ------------------ | | 45| 4.08k|#define NT_ANCHOR 7 ------------------ | Branch (2011:3): [True: 4.08k, False: 32.6k] ------------------ 2012| 4.08k| if (NANCHOR(node)->target) ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ | Branch (2012:9): [True: 0, False: 4.08k] ------------------ 2013| 0| r = numbered_ref_check(NANCHOR(node)->target); ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 2014| 4.08k| break; 2015| | 2016| 14.2k| default: ------------------ | Branch (2016:3): [True: 14.2k, False: 22.4k] ------------------ 2017| 14.2k| break; 2018| 36.7k| } 2019| | 2020| 36.7k| return r; 2021| 36.7k|} regcomp.c:get_min_match_length: 2157| 8.16k|{ 2158| 8.16k| OnigDistance tmin; 2159| 8.16k| int r = 0; 2160| | 2161| 8.16k| *min = 0; 2162| 8.16k| switch (NTYPE(node)) { ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ 2163| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (2163:3): [True: 0, False: 8.16k] ------------------ 2164| 0| { 2165| 0| int i; 2166| 0| int* backs; 2167| 0| Node** nodes = SCANENV_MEM_NODES(env); ------------------ | | 287| 0| (IS_NOT_NULL((senv)->mem_nodes_dynamic) ? \ | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 288| 0| (senv)->mem_nodes_dynamic : (senv)->mem_nodes_static) ------------------ 2168| 0| BRefNode* br = NBREF(node); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 2169| 0| if (br->state & NST_RECURSION) break; ------------------ | | 135| 0|#define NST_RECURSION (1<<7) ------------------ | Branch (2169:11): [True: 0, False: 0] ------------------ 2170| | 2171| 0| backs = BACKREFS_P(br); ------------------ | | 120| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static); | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2172| 0| if (backs[0] > env->num_mem) return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ | Branch (2172:11): [True: 0, False: 0] ------------------ 2173| 0| r = get_min_match_length(nodes[backs[0]], min, env); 2174| 0| if (r != 0) break; ------------------ | Branch (2174:11): [True: 0, False: 0] ------------------ 2175| 0| for (i = 1; i < br->back_num; i++) { ------------------ | Branch (2175:19): [True: 0, False: 0] ------------------ 2176| 0| if (backs[i] > env->num_mem) return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ | Branch (2176:6): [True: 0, False: 0] ------------------ 2177| 0| r = get_min_match_length(nodes[backs[i]], &tmin, env); 2178| 0| if (r != 0) break; ------------------ | Branch (2178:6): [True: 0, False: 0] ------------------ 2179| 0| if (*min > tmin) *min = tmin; ------------------ | Branch (2179:6): [True: 0, False: 0] ------------------ 2180| 0| } 2181| 0| } 2182| 0| break; 2183| | 2184| 0|#ifdef USE_SUBEXP_CALL 2185| 0| case NT_CALL: ------------------ | | 48| 0|#define NT_CALL 10 ------------------ | Branch (2185:3): [True: 0, False: 8.16k] ------------------ 2186| 0| if (IS_CALL_RECURSION(NCALL(node))) { ------------------ | | 161| 0|#define IS_CALL_RECURSION(cn) (((cn)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (161:40): [True: 0, False: 0] | | ------------------ ------------------ 2187| 0| EncloseNode* en = NENCLOSE(NCALL(node)->target); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2188| 0| if (IS_ENCLOSE_MIN_FIXED(en)) ------------------ | | 152| 0|#define IS_ENCLOSE_MIN_FIXED(en) (((en)->state & NST_MIN_FIXED) != 0) | | ------------------ | | | | 128| 0|#define NST_MIN_FIXED (1<<0) | | ------------------ | | | Branch (152:40): [True: 0, False: 0] | | ------------------ ------------------ 2189| 0| *min = en->min_len; 2190| 0| } 2191| 0| else 2192| 0| r = get_min_match_length(NCALL(node)->target, min, env); ------------------ | | 84| 0|#define NCALL(node) (&((node)->u.call)) ------------------ 2193| 0| break; 2194| 0|#endif 2195| | 2196| 0| case NT_LIST: ------------------ | | 46| 0|#define NT_LIST 8 ------------------ | Branch (2196:3): [True: 0, False: 8.16k] ------------------ 2197| 0| do { 2198| 0| r = get_min_match_length(NCAR(node), &tmin, env); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 2199| 0| if (r == 0) *min += tmin; ------------------ | Branch (2199:11): [True: 0, False: 0] ------------------ 2200| 0| } while (r == 0 && IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2200:14): [True: 0, False: 0] ------------------ 2201| 0| break; 2202| | 2203| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (2203:3): [True: 0, False: 8.16k] ------------------ 2204| 0| { 2205| 0| Node *x, *y; 2206| 0| y = node; 2207| 0| do { 2208| 0| x = NCAR(y); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 2209| 0| r = get_min_match_length(x, &tmin, env); 2210| 0| if (r != 0) break; ------------------ | Branch (2210:6): [True: 0, False: 0] ------------------ 2211| 0| if (y == node) *min = tmin; ------------------ | Branch (2211:6): [True: 0, False: 0] ------------------ 2212| 0| else if (*min > tmin) *min = tmin; ------------------ | Branch (2212:11): [True: 0, False: 0] ------------------ 2213| 0| } while (r == 0 && IS_NOT_NULL(y = NCDR(y))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2213:16): [True: 0, False: 0] ------------------ 2214| 0| } 2215| 0| break; 2216| | 2217| 0| case NT_STR: ------------------ | | 38| 0|#define NT_STR 0 ------------------ | Branch (2217:3): [True: 0, False: 8.16k] ------------------ 2218| 0| { 2219| 0| StrNode* sn = NSTR(node); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 2220| 0| *min = sn->end - sn->s; 2221| 0| } 2222| 0| break; 2223| | 2224| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2224:3): [True: 0, False: 8.16k] ------------------ 2225| 0| *min = 1; 2226| 0| break; 2227| | 2228| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (2228:3): [True: 6.12k, False: 2.04k] ------------------ 2229| 8.16k| case NT_CANY: ------------------ | | 41| 8.16k|#define NT_CANY 3 ------------------ | Branch (2229:3): [True: 2.04k, False: 6.12k] ------------------ 2230| 8.16k| *min = 1; 2231| 8.16k| break; 2232| | 2233| 0| case NT_QTFR: ------------------ | | 43| 0|#define NT_QTFR 5 ------------------ | Branch (2233:3): [True: 0, False: 8.16k] ------------------ 2234| 0| { 2235| 0| QtfrNode* qn = NQTFR(node); ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 2236| | 2237| 0| if (qn->lower > 0) { ------------------ | Branch (2237:11): [True: 0, False: 0] ------------------ 2238| 0| r = get_min_match_length(qn->target, min, env); 2239| 0| if (r == 0) ------------------ | Branch (2239:6): [True: 0, False: 0] ------------------ 2240| 0| *min = distance_multiply(*min, qn->lower); 2241| 0| } 2242| 0| } 2243| 0| break; 2244| | 2245| 0| case NT_ENCLOSE: ------------------ | | 44| 0|#define NT_ENCLOSE 6 ------------------ | Branch (2245:3): [True: 0, False: 8.16k] ------------------ 2246| 0| { 2247| 0| EncloseNode* en = NENCLOSE(node); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2248| 0| switch (en->type) { ------------------ | Branch (2248:15): [True: 0, False: 0] ------------------ 2249| 0| case ENCLOSE_MEMORY: ------------------ | | 94| 0|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (2249:7): [True: 0, False: 0] ------------------ 2250| 0| if (IS_ENCLOSE_MIN_FIXED(en)) ------------------ | | 152| 0|#define IS_ENCLOSE_MIN_FIXED(en) (((en)->state & NST_MIN_FIXED) != 0) | | ------------------ | | | | 128| 0|#define NST_MIN_FIXED (1<<0) | | ------------------ | | | Branch (152:40): [True: 0, False: 0] | | ------------------ ------------------ 2251| 0| *min = en->min_len; 2252| 0| else { 2253| 0| if (IS_ENCLOSE_MARK1(NENCLOSE(node))) ------------------ | | 150| 0|#define IS_ENCLOSE_MARK1(en) (((en)->state & NST_MARK1) != 0) | | ------------------ | | | | 131| 0|#define NST_MARK1 (1<<3) | | ------------------ | | | Branch (150:40): [True: 0, False: 0] | | ------------------ ------------------ 2254| 0| *min = 0; /* recursive */ 2255| 0| else { 2256| 0| SET_ENCLOSE_STATUS(node, NST_MARK1); ------------------ | | 144| 0|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 2257| 0| r = get_min_match_length(en->target, min, env); 2258| 0| CLEAR_ENCLOSE_STATUS(node, NST_MARK1); ------------------ | | 145| 0|#define CLEAR_ENCLOSE_STATUS(node,f) (node)->u.enclose.state &= ~(f) ------------------ 2259| 0| if (r == 0) { ------------------ | Branch (2259:10): [True: 0, False: 0] ------------------ 2260| 0| en->min_len = *min; 2261| 0| SET_ENCLOSE_STATUS(node, NST_MIN_FIXED); ------------------ | | 144| 0|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 2262| 0| } 2263| 0| } 2264| 0| } 2265| 0| break; 2266| | 2267| 0| case ENCLOSE_OPTION: ------------------ | | 95| 0|#define ENCLOSE_OPTION (1<<1) ------------------ | Branch (2267:7): [True: 0, False: 0] ------------------ 2268| 0| case ENCLOSE_STOP_BACKTRACK: ------------------ | | 96| 0|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ | Branch (2268:7): [True: 0, False: 0] ------------------ 2269| 0| case ENCLOSE_CONDITION: ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (2269:7): [True: 0, False: 0] ------------------ 2270| 0| r = get_min_match_length(en->target, min, env); 2271| 0| break; 2272| | 2273| 0| case ENCLOSE_ABSENT: ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ | Branch (2273:7): [True: 0, False: 0] ------------------ 2274| 0| break; 2275| 0| } 2276| 0| } 2277| 0| break; 2278| | 2279| 0| case NT_ANCHOR: ------------------ | | 45| 0|#define NT_ANCHOR 7 ------------------ | Branch (2279:3): [True: 0, False: 8.16k] ------------------ 2280| 0| default: ------------------ | Branch (2280:3): [True: 0, False: 8.16k] ------------------ 2281| 0| break; 2282| 8.16k| } 2283| | 2284| 8.16k| return r; 2285| 8.16k|} regcomp.c:distance_multiply: 108| 8.16k|{ 109| 8.16k| if (m == 0) return 0; ------------------ | Branch (109:7): [True: 0, False: 8.16k] ------------------ 110| | 111| 8.16k| if (d < ONIG_INFINITE_DISTANCE / m) ------------------ | | 85| 8.16k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (111:7): [True: 8.16k, False: 0] ------------------ 112| 8.16k| return d * m; 113| 0| else 114| 0| return ONIG_INFINITE_DISTANCE; ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 115| 8.16k|} regcomp.c:setup_tree: 3879| 36.7k|{ 3880| 36.7k| int type; 3881| 36.7k| int r = 0; 3882| | 3883| 36.7k|restart: 3884| 36.7k| type = NTYPE(node); ------------------ | | 69| 36.7k|#define NTYPE(node) ((node)->u.base.type) ------------------ 3885| 36.7k| switch (type) { 3886| 2.04k| case NT_LIST: ------------------ | | 46| 2.04k|#define NT_LIST 8 ------------------ | Branch (3886:3): [True: 2.04k, False: 34.6k] ------------------ 3887| 2.04k| { 3888| 2.04k| Node* prev = NULL_NODE; ------------------ | | 283| 2.04k|#define NULL_NODE ((Node* )0) ------------------ 3889| 18.3k| do { 3890| 18.3k| r = setup_tree(NCAR(node), reg, state, env); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 3891| 18.3k| if (IS_NOT_NULL(prev) && r == 0) { ------------------ | | 312| 36.7k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 16.3k, False: 2.04k] | | ------------------ ------------------ | Branch (3891:27): [True: 16.3k, False: 0] ------------------ 3892| 16.3k| r = next_setup(prev, NCAR(node), reg); ------------------ | | 86| 16.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 16.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 3893| 16.3k| } 3894| 18.3k| prev = NCAR(node); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 3895| 18.3k| } while (r == 0 && IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 18.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 16.3k, False: 2.04k] | | ------------------ ------------------ | Branch (3895:16): [True: 18.3k, False: 0] ------------------ 3896| 2.04k| } 3897| 2.04k| break; 3898| | 3899| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (3899:3): [True: 0, False: 36.7k] ------------------ 3900| 0| do { 3901| 0| r = setup_tree(NCAR(node), reg, (state | IN_ALT), env); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ r = setup_tree(NCAR(node), reg, (state | IN_ALT), env); ------------------ | | 3268| 0|#define IN_ALT (1<<0) ------------------ 3902| 0| } while (r == 0 && IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3902:14): [True: 0, False: 0] ------------------ 3903| 0| break; 3904| | 3905| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (3905:3): [True: 6.12k, False: 30.6k] ------------------ 3906| 6.12k| break; 3907| | 3908| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (3908:3): [True: 6.12k, False: 30.6k] ------------------ 3909| 6.12k| if (IS_IGNORECASE(reg->options) && !NSTRING_IS_RAW(node)) { ------------------ | | 396| 12.2k|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 6.12k|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (396:35): [True: 0, False: 6.12k] | | ------------------ ------------------ if (IS_IGNORECASE(reg->options) && !NSTRING_IS_RAW(node)) { ------------------ | | 114| 0|#define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) | | ------------------ | | | | 104| 0|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ ------------------ | Branch (3909:40): [True: 0, False: 0] ------------------ 3910| 0| r = expand_case_fold_string(node, reg, state); 3911| 0| } 3912| 6.12k| break; 3913| | 3914| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (3914:3): [True: 0, False: 36.7k] ------------------ 3915| 2.04k| case NT_CANY: ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (3915:3): [True: 2.04k, False: 34.6k] ------------------ 3916| 2.04k| break; 3917| | 3918| 0|#ifdef USE_SUBEXP_CALL 3919| 0| case NT_CALL: ------------------ | | 48| 0|#define NT_CALL 10 ------------------ | Branch (3919:3): [True: 0, False: 36.7k] ------------------ 3920| 0| break; 3921| 0|#endif 3922| | 3923| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (3923:3): [True: 0, False: 36.7k] ------------------ 3924| 0| { 3925| 0| int i; 3926| 0| int* p; 3927| 0| Node** nodes = SCANENV_MEM_NODES(env); ------------------ | | 287| 0| (IS_NOT_NULL((senv)->mem_nodes_dynamic) ? \ | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 288| 0| (senv)->mem_nodes_dynamic : (senv)->mem_nodes_static) ------------------ 3928| 0| BRefNode* br = NBREF(node); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 3929| 0| p = BACKREFS_P(br); ------------------ | | 120| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static); | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3930| 0| for (i = 0; i < br->back_num; i++) { ------------------ | Branch (3930:19): [True: 0, False: 0] ------------------ 3931| 0| if (p[i] > env->num_mem) return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ | Branch (3931:6): [True: 0, False: 0] ------------------ 3932| 0| BIT_STATUS_ON_AT(env->backrefed_mem, p[i]); ------------------ | | 373| 0|#define BIT_STATUS_ON_AT(stats,n) do {\ | | 374| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (374:7): [True: 0, False: 0] | | ------------------ | | 375| 0| (stats) |= (1 << (n));\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded - Ignored] | | ------------------ ------------------ 3933| 0| BIT_STATUS_ON_AT(env->bt_mem_start, p[i]); ------------------ | | 373| 0|#define BIT_STATUS_ON_AT(stats,n) do {\ | | 374| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (374:7): [True: 0, False: 0] | | ------------------ | | 375| 0| (stats) |= (1 << (n));\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded - Ignored] | | ------------------ ------------------ 3934| 0|#ifdef USE_BACKREF_WITH_LEVEL 3935| 0| if (IS_BACKREF_NEST_LEVEL(br)) { ------------------ | | 164| 0|#define IS_BACKREF_NEST_LEVEL(bn) (((bn)->state & NST_NEST_LEVEL) != 0) | | ------------------ | | | | 141| 0|#define NST_NEST_LEVEL (1<<13) | | ------------------ | | | Branch (164:40): [True: 0, False: 0] | | ------------------ ------------------ 3936| 0| BIT_STATUS_ON_AT(env->bt_mem_end, p[i]); ------------------ | | 373| 0|#define BIT_STATUS_ON_AT(stats,n) do {\ | | 374| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (374:7): [True: 0, False: 0] | | ------------------ | | 375| 0| (stats) |= (1 << (n));\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded - Ignored] | | ------------------ ------------------ 3937| 0| } 3938| 0|#endif 3939| 0| SET_ENCLOSE_STATUS(nodes[p[i]], NST_MEM_BACKREFED); ------------------ | | 144| 0|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 3940| 0| } 3941| 0| } 3942| 0| break; 3943| | 3944| 8.16k| case NT_QTFR: ------------------ | | 43| 8.16k|#define NT_QTFR 5 ------------------ | Branch (3944:3): [True: 8.16k, False: 28.5k] ------------------ 3945| 8.16k| { 3946| 8.16k| OnigDistance d; 3947| 8.16k| QtfrNode* qn = NQTFR(node); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 3948| 8.16k| Node* target = qn->target; 3949| | 3950| 8.16k| if ((state & IN_REPEAT) != 0) { ------------------ | | 3270| 8.16k|#define IN_REPEAT (1<<2) ------------------ | Branch (3950:11): [True: 0, False: 8.16k] ------------------ 3951| 0| qn->state |= NST_IN_REPEAT; ------------------ | | 140| 0|#define NST_IN_REPEAT (1<<12) /* STK_REPEAT is nested in stack. */ ------------------ 3952| 0| } 3953| | 3954| 8.16k| if (IS_REPEAT_INFINITE(qn->upper) || qn->upper >= 1) { ------------------ | | 422| 16.3k|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 8.16k|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 8.16k, False: 0] | | ------------------ ------------------ | Branch (3954:44): [True: 0, False: 0] ------------------ 3955| 8.16k| r = get_min_match_length(target, &d, env); 3956| 8.16k| if (r) break; ------------------ | Branch (3956:6): [True: 0, False: 8.16k] ------------------ 3957| 8.16k| if (d == 0) { ------------------ | Branch (3957:6): [True: 0, False: 8.16k] ------------------ 3958| 0| qn->target_empty_info = NQ_TARGET_IS_EMPTY; ------------------ | | 123| 0|#define NQ_TARGET_IS_EMPTY 1 ------------------ 3959| 0|#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 3960| 0| r = quantifiers_memory_node_info(target); 3961| 0| if (r < 0) break; ------------------ | Branch (3961:8): [True: 0, False: 0] ------------------ 3962| 0| if (r > 0) { ------------------ | Branch (3962:8): [True: 0, False: 0] ------------------ 3963| 0| qn->target_empty_info = r; 3964| 0| } 3965| 0|#endif 3966| |#if 0 3967| | r = get_max_match_length(target, &d, env); 3968| | if (r == 0 && d == 0) { 3969| | /* ()* ==> ()?, ()+ ==> () */ 3970| | qn->upper = 1; 3971| | if (qn->lower > 1) qn->lower = 1; 3972| | if (NTYPE(target) == NT_STR) { 3973| | qn->upper = qn->lower = 0; /* /(?:)+/ ==> // */ 3974| | } 3975| | } 3976| |#endif 3977| 0| } 3978| 8.16k| } 3979| | 3980| 8.16k| state |= IN_REPEAT; ------------------ | | 3270| 8.16k|#define IN_REPEAT (1<<2) ------------------ 3981| 8.16k| if (qn->lower != qn->upper) ------------------ | Branch (3981:11): [True: 8.16k, False: 0] ------------------ 3982| 8.16k| state |= IN_VAR_REPEAT; ------------------ | | 3271| 8.16k|#define IN_VAR_REPEAT (1<<3) ------------------ 3983| 8.16k| r = setup_tree(target, reg, state, env); 3984| 8.16k| if (r) break; ------------------ | Branch (3984:11): [True: 0, False: 8.16k] ------------------ 3985| | 3986| | /* expand string */ 3987| 8.16k|#define EXPAND_STRING_MAX_LENGTH 100 3988| 8.16k| if (NTYPE(target) == NT_STR) { ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(target) == NT_STR) { ------------------ | | 38| 8.16k|#define NT_STR 0 ------------------ | Branch (3988:11): [True: 0, False: 8.16k] ------------------ 3989| 0| if (qn->lower > 1) { ------------------ | Branch (3989:6): [True: 0, False: 0] ------------------ 3990| 0| int i, n = qn->lower; 3991| 0| OnigDistance len = NSTRING_LEN(target); ------------------ | | 108| 0|#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s) ------------------ 3992| 0| StrNode* sn = NSTR(target); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 3993| 0| Node* np; 3994| | 3995| 0| np = onig_node_new_str(sn->s, sn->end); 3996| 0| if (IS_NULL(np)) return ONIGERR_MEMORY; ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NULL(np)) return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 3997| 0| NSTR(np)->flag = sn->flag; ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 3998| | 3999| 0| for (i = 1; i < n && (i+1) * len <= EXPAND_STRING_MAX_LENGTH; i++) { ------------------ | | 3987| 0|#define EXPAND_STRING_MAX_LENGTH 100 ------------------ | Branch (3999:16): [True: 0, False: 0] | Branch (3999:25): [True: 0, False: 0] ------------------ 4000| 0| r = onig_node_str_cat(np, sn->s, sn->end); 4001| 0| if (r) { ------------------ | Branch (4001:10): [True: 0, False: 0] ------------------ 4002| 0| onig_node_free(np); 4003| 0| return r; 4004| 0| } 4005| 0| } 4006| 0| if (i < qn->upper || IS_REPEAT_INFINITE(qn->upper)) { ------------------ | | 422| 0|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 0|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4006:8): [True: 0, False: 0] ------------------ 4007| 0| Node *np1, *np2; 4008| | 4009| 0| qn->lower -= i; 4010| 0| if (! IS_REPEAT_INFINITE(qn->upper)) ------------------ | | 422| 0|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 0|#define REPEAT_INFINITE -1 | | ------------------ ------------------ | Branch (4010:10): [True: 0, False: 0] ------------------ 4011| 0| qn->upper -= i; 4012| | 4013| 0| np1 = onig_node_new_list(np, NULL); 4014| 0| if (IS_NULL(np1)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 4015| 0| onig_node_free(np); 4016| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 4017| 0| } 4018| 0| swap_node(np1, node); 4019| 0| np2 = onig_node_list_add(node, np1); 4020| 0| if (IS_NULL(np2)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 4021| 0| onig_node_free(np1); 4022| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 4023| 0| } 4024| 0| } 4025| 0| else { 4026| 0| swap_node(np, node); 4027| 0| onig_node_free(np); 4028| 0| } 4029| 0| break; /* break case NT_QTFR: */ 4030| 0| } 4031| 0| } 4032| | 4033| |#ifdef USE_OP_PUSH_OR_JUMP_EXACT 4034| | if (qn->greedy && (qn->target_empty_info != 0)) { 4035| | if (NTYPE(target) == NT_QTFR) { 4036| | QtfrNode* tqn = NQTFR(target); 4037| | if (IS_NOT_NULL(tqn->head_exact)) { 4038| | qn->head_exact = tqn->head_exact; 4039| | tqn->head_exact = NULL; 4040| | } 4041| | } 4042| | else { 4043| | qn->head_exact = get_head_value_node(qn->target, 1, reg); 4044| | } 4045| | } 4046| |#endif 4047| 8.16k| } 4048| 8.16k| break; 4049| | 4050| 8.16k| case NT_ENCLOSE: ------------------ | | 44| 8.16k|#define NT_ENCLOSE 6 ------------------ | Branch (4050:3): [True: 8.16k, False: 28.5k] ------------------ 4051| 8.16k| { 4052| 8.16k| EncloseNode* en = NENCLOSE(node); ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 4053| | 4054| 8.16k| switch (en->type) { ------------------ | Branch (4054:15): [True: 0, False: 8.16k] ------------------ 4055| 0| case ENCLOSE_OPTION: ------------------ | | 95| 0|#define ENCLOSE_OPTION (1<<1) ------------------ | Branch (4055:7): [True: 0, False: 8.16k] ------------------ 4056| 0| { 4057| 0| OnigOptionType options = reg->options; 4058| 0| reg->options = NENCLOSE(node)->option; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 4059| 0| r = setup_tree(NENCLOSE(node)->target, reg, state, env); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 4060| 0| reg->options = options; 4061| 0| } 4062| 0| break; 4063| | 4064| 8.16k| case ENCLOSE_MEMORY: ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (4064:7): [True: 8.16k, False: 0] ------------------ 4065| 8.16k| if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 0) { ------------------ | | 3268| 8.16k|#define IN_ALT (1<<0) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 0) { ------------------ | | 3269| 8.16k|#define IN_NOT (1<<1) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 0) { ------------------ | | 3271| 8.16k|#define IN_VAR_REPEAT (1<<3) ------------------ if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 0) { ------------------ | | 3272| 8.16k|#define IN_CALL (1<<4) ------------------ | Branch (4065:6): [True: 0, False: 8.16k] ------------------ 4066| 0| BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum); ------------------ | | 373| 0|#define BIT_STATUS_ON_AT(stats,n) do {\ | | 374| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (374:7): [True: 0, False: 0] | | ------------------ | | 375| 0| (stats) |= (1 << (n));\ | | 376| 0| else\ | | 377| 0| (stats) |= 1;\ | | 378| 0|} while (0) | | ------------------ | | | Branch (378:10): [Folded - Ignored] | | ------------------ ------------------ 4067| | /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */ 4068| 0| } 4069| 8.16k| if (IS_ENCLOSE_CALLED(en)) ------------------ | | 147| 8.16k|#define IS_ENCLOSE_CALLED(en) (((en)->state & NST_CALLED) != 0) | | ------------------ | | | | 136| 8.16k|#define NST_CALLED (1<<8) | | ------------------ | | | Branch (147:40): [True: 0, False: 8.16k] | | ------------------ ------------------ 4070| 0| state |= IN_CALL; ------------------ | | 3272| 0|#define IN_CALL (1<<4) ------------------ 4071| 8.16k| if (IS_ENCLOSE_RECURSION(en)) ------------------ | | 149| 8.16k|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 8.16k|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 8.16k] | | ------------------ ------------------ 4072| 0| state |= IN_RECCALL; ------------------ | | 3273| 0|#define IN_RECCALL (1<<5) ------------------ 4073| 8.16k| else if ((state & IN_RECCALL) != 0) ------------------ | | 3273| 8.16k|#define IN_RECCALL (1<<5) ------------------ | Branch (4073:11): [True: 0, False: 8.16k] ------------------ 4074| 0| SET_CALL_RECURSION(node); ------------------ | | 160| 0|#define SET_CALL_RECURSION(node) (node)->u.call.state |= NST_RECURSION | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ ------------------ 4075| 8.16k| r = setup_tree(en->target, reg, state, env); 4076| 8.16k| break; 4077| | 4078| 0| case ENCLOSE_STOP_BACKTRACK: ------------------ | | 96| 0|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ | Branch (4078:7): [True: 0, False: 8.16k] ------------------ 4079| 0| { 4080| 0| Node* target = en->target; 4081| 0| r = setup_tree(target, reg, state, env); 4082| 0| if (NTYPE(target) == NT_QTFR) { ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(target) == NT_QTFR) { ------------------ | | 43| 0|#define NT_QTFR 5 ------------------ | Branch (4082:8): [True: 0, False: 0] ------------------ 4083| 0| QtfrNode* tqn = NQTFR(target); ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 4084| 0| if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 && ------------------ | | 422| 0|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 0|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4084:44): [True: 0, False: 0] ------------------ 4085| 0| tqn->greedy != 0) { /* (?>a*), a*+ etc... */ ------------------ | Branch (4085:3): [True: 0, False: 0] ------------------ 4086| 0| int qtype = NTYPE(tqn->target); ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ 4087| 0| if (IS_NODE_TYPE_SIMPLE(qtype)) ------------------ | | 66| 0| ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 53| 0|#define BIT_NT_STR NTYPE2BIT(NT_STR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 54| 0|#define BIT_NT_CCLASS NTYPE2BIT(NT_CCLASS) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 55| 0|#define BIT_NT_CTYPE NTYPE2BIT(NT_CTYPE) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | | Branch (66:3): [True: 0, False: 0] | | ------------------ | | 67| 0| BIT_NT_CANY | BIT_NT_BREF)) != 0) | | ------------------ | | | | 56| 0|#define BIT_NT_CANY NTYPE2BIT(NT_CANY) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_BREF)) != 0) | | ------------------ | | | | 57| 0|#define BIT_NT_BREF NTYPE2BIT(NT_BREF) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ ------------------ 4088| 0| SET_ENCLOSE_STATUS(node, NST_STOP_BT_SIMPLE_REPEAT); ------------------ | | 144| 0|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 4089| 0| } 4090| 0| } 4091| 0| } 4092| 0| break; 4093| | 4094| 0| case ENCLOSE_CONDITION: ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (4094:7): [True: 0, False: 8.16k] ------------------ 4095| 0|#ifdef USE_NAMED_GROUP 4096| 0| if (! IS_ENCLOSE_NAME_REF(NENCLOSE(node)) && ------------------ | | 158| 0|#define IS_ENCLOSE_NAME_REF(en) (((en)->state & NST_NAME_REF) != 0) | | ------------------ | | | | 139| 0|#define NST_NAME_REF (1<<11) | | ------------------ ------------------ | Branch (4096:6): [True: 0, False: 0] ------------------ 4097| 0| env->num_named > 0 && ------------------ | Branch (4097:6): [True: 0, False: 0] ------------------ 4098| 0| IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) && ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 4099| 0| !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) { ------------------ | | 479| 0|#define ONIG_IS_OPTION_ON(options,option) ((options) & (option)) ------------------ | Branch (4099:6): [True: 0, False: 0] ------------------ 4100| 0| return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED; ------------------ | | 678| 0|#define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED -209 ------------------ 4101| 0| } 4102| 0|#endif 4103| 0| if (NENCLOSE(node)->regnum > env->num_mem) ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ | Branch (4103:6): [True: 0, False: 0] ------------------ 4104| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 4105| 0| r = setup_tree(NENCLOSE(node)->target, reg, state, env); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 4106| 0| break; 4107| | 4108| 0| case ENCLOSE_ABSENT: ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ | Branch (4108:7): [True: 0, False: 8.16k] ------------------ 4109| 0| r = setup_tree(NENCLOSE(node)->target, reg, state, env); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 4110| 0| break; 4111| 8.16k| } 4112| 8.16k| } 4113| 8.16k| break; 4114| | 4115| 8.16k| case NT_ANCHOR: ------------------ | | 45| 4.08k|#define NT_ANCHOR 7 ------------------ | Branch (4115:3): [True: 4.08k, False: 32.6k] ------------------ 4116| 4.08k| { 4117| 4.08k| AnchorNode* an = NANCHOR(node); ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 4118| | 4119| 4.08k| switch (an->type) { ------------------ | Branch (4119:15): [True: 4.08k, False: 0] ------------------ 4120| 0| case ANCHOR_PREC_READ: ------------------ | | 551| 0|#define ANCHOR_PREC_READ (1<<10) ------------------ | Branch (4120:7): [True: 0, False: 4.08k] ------------------ 4121| 0| r = setup_tree(an->target, reg, state, env); 4122| 0| break; 4123| 0| case ANCHOR_PREC_READ_NOT: ------------------ | | 552| 0|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (4123:7): [True: 0, False: 4.08k] ------------------ 4124| 0| r = setup_tree(an->target, reg, (state | IN_NOT), env); ------------------ | | 3269| 0|#define IN_NOT (1<<1) ------------------ 4125| 0| break; 4126| | 4127| |/* allowed node types in look-behind */ 4128| 0|#define ALLOWED_TYPE_IN_LB \ 4129| 0| ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ 4130| 0| BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) 4131| | 4132| 0|#define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION ) 4133| 0|#define ALLOWED_ENCLOSE_IN_LB_NOT ENCLOSE_OPTION 4134| | 4135| 0|#define ALLOWED_ANCHOR_IN_LB \ 4136| 0|( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ 4137| 0| ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ 4138| 0| ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ 4139| 0| ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) 4140| 0|#define ALLOWED_ANCHOR_IN_LB_NOT \ 4141| 0|( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ 4142| 0| ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ 4143| 0| ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ 4144| 0| ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) 4145| | 4146| 0| case ANCHOR_LOOK_BEHIND: ------------------ | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ | Branch (4146:7): [True: 0, False: 4.08k] ------------------ 4147| 0| { 4148| 0| r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB, ------------------ | | 4129| 0| ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 61| 0|#define BIT_NT_LIST NTYPE2BIT(NT_LIST) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 62| 0|#define BIT_NT_ALT NTYPE2BIT(NT_ALT) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 53| 0|#define BIT_NT_STR NTYPE2BIT(NT_STR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 54| 0|#define BIT_NT_CCLASS NTYPE2BIT(NT_CCLASS) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 55| 0|#define BIT_NT_CTYPE NTYPE2BIT(NT_CTYPE) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | 4130| 0| BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 56| 0|#define BIT_NT_CANY NTYPE2BIT(NT_CANY) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 60| 0|#define BIT_NT_ANCHOR NTYPE2BIT(NT_ANCHOR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 59| 0|#define BIT_NT_ENCLOSE NTYPE2BIT(NT_ENCLOSE) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 58| 0|#define BIT_NT_QTFR NTYPE2BIT(NT_QTFR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 63| 0|#define BIT_NT_CALL NTYPE2BIT(NT_CALL) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ ------------------ 4149| 0| ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB); ------------------ | | 4132| 0|#define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION ) | | ------------------ | | | | 94| 0|#define ENCLOSE_MEMORY (1<<0) | | ------------------ | | #define ALLOWED_ENCLOSE_IN_LB ( ENCLOSE_MEMORY | ENCLOSE_OPTION ) | | ------------------ | | | | 95| 0|#define ENCLOSE_OPTION (1<<1) | | ------------------ ------------------ ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB); ------------------ | | 4135| 0|#define ALLOWED_ANCHOR_IN_LB \ | | 4136| 0|( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) | | ------------------ | | ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) | | ------------------ | | ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 541| 0|#define ANCHOR_BEGIN_LINE (1<<1) | | ------------------ | | 4137| 0| ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 545| 0|#define ANCHOR_END_LINE (1<<5) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 559| 0|#define ANCHOR_KEEP (1<<16) | | ------------------ | | 4138| 0| ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ | | ------------------ | | | | 547| 0|#define ANCHOR_WORD_BOUND (1<<6) | | ------------------ | | ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ | | ------------------ | | | | 548| 0|#define ANCHOR_NOT_WORD_BOUND (1<<7) | | ------------------ | | 4139| 0| ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) | | ------------------ | | | | 549| 0|#define ANCHOR_WORD_BEGIN (1<<8) | | ------------------ | | ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) | | ------------------ | | | | 550| 0|#define ANCHOR_WORD_END (1<<9) | | ------------------ ------------------ 4150| 0| if (r < 0) return r; ------------------ | Branch (4150:8): [True: 0, False: 0] ------------------ 4151| 0| if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; ------------------ | | 665| 0|#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN -122 ------------------ | Branch (4151:8): [True: 0, False: 0] ------------------ 4152| 0| if (NTYPE(node) != NT_ANCHOR) goto restart; ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(node) != NT_ANCHOR) goto restart; ------------------ | | 45| 0|#define NT_ANCHOR 7 ------------------ | Branch (4152:8): [True: 0, False: 0] ------------------ 4153| 0| r = setup_tree(an->target, reg, (state | IN_LOOK_BEHIND), env); ------------------ | | 3274| 0|#define IN_LOOK_BEHIND (1<<6) ------------------ 4154| 0| if (r != 0) return r; ------------------ | Branch (4154:8): [True: 0, False: 0] ------------------ 4155| 0| r = setup_look_behind(node, reg, env); 4156| 0| } 4157| 0| break; 4158| | 4159| 0| case ANCHOR_LOOK_BEHIND_NOT: ------------------ | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) ------------------ | Branch (4159:7): [True: 0, False: 4.08k] ------------------ 4160| 0| { 4161| 0| r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB, ------------------ | | 4129| 0| ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 61| 0|#define BIT_NT_LIST NTYPE2BIT(NT_LIST) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 62| 0|#define BIT_NT_ALT NTYPE2BIT(NT_ALT) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 53| 0|#define BIT_NT_STR NTYPE2BIT(NT_STR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 54| 0|#define BIT_NT_CCLASS NTYPE2BIT(NT_CCLASS) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ( BIT_NT_LIST | BIT_NT_ALT | BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE | \ | | ------------------ | | | | 55| 0|#define BIT_NT_CTYPE NTYPE2BIT(NT_CTYPE) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | 4130| 0| BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 56| 0|#define BIT_NT_CANY NTYPE2BIT(NT_CANY) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 60| 0|#define BIT_NT_ANCHOR NTYPE2BIT(NT_ANCHOR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 59| 0|#define BIT_NT_ENCLOSE NTYPE2BIT(NT_ENCLOSE) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 58| 0|#define BIT_NT_QTFR NTYPE2BIT(NT_QTFR) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_ANCHOR | BIT_NT_ENCLOSE | BIT_NT_QTFR | BIT_NT_CALL ) | | ------------------ | | | | 63| 0|#define BIT_NT_CALL NTYPE2BIT(NT_CALL) | | | | ------------------ | | | | | | 51| 0|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ ------------------ 4162| 0| ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT); ------------------ | | 4133| 0|#define ALLOWED_ENCLOSE_IN_LB_NOT ENCLOSE_OPTION | | ------------------ | | | | 95| 0|#define ENCLOSE_OPTION (1<<1) | | ------------------ ------------------ ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT); ------------------ | | 4140| 0|#define ALLOWED_ANCHOR_IN_LB_NOT \ | | 4141| 0|( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) | | ------------------ | | ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) | | ------------------ | | ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | \ | | ------------------ | | | | 541| 0|#define ANCHOR_BEGIN_LINE (1<<1) | | ------------------ | | 4142| 0| ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 545| 0|#define ANCHOR_END_LINE (1<<5) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) | | ------------------ | | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION | ANCHOR_KEEP | \ | | ------------------ | | | | 559| 0|#define ANCHOR_KEEP (1<<16) | | ------------------ | | 4143| 0| ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ | | ------------------ | | | | 547| 0|#define ANCHOR_WORD_BOUND (1<<6) | | ------------------ | | ANCHOR_WORD_BOUND | ANCHOR_NOT_WORD_BOUND | \ | | ------------------ | | | | 548| 0|#define ANCHOR_NOT_WORD_BOUND (1<<7) | | ------------------ | | 4144| 0| ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) | | ------------------ | | | | 549| 0|#define ANCHOR_WORD_BEGIN (1<<8) | | ------------------ | | ANCHOR_WORD_BEGIN | ANCHOR_WORD_END ) | | ------------------ | | | | 550| 0|#define ANCHOR_WORD_END (1<<9) | | ------------------ ------------------ 4163| 0| if (r < 0) return r; ------------------ | Branch (4163:8): [True: 0, False: 0] ------------------ 4164| 0| if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; ------------------ | | 665| 0|#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN -122 ------------------ | Branch (4164:8): [True: 0, False: 0] ------------------ 4165| 0| if (NTYPE(node) != NT_ANCHOR) goto restart; ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(node) != NT_ANCHOR) goto restart; ------------------ | | 45| 0|#define NT_ANCHOR 7 ------------------ | Branch (4165:8): [True: 0, False: 0] ------------------ 4166| 0| r = setup_tree(an->target, reg, (state | IN_NOT | IN_LOOK_BEHIND), ------------------ | | 3269| 0|#define IN_NOT (1<<1) ------------------ r = setup_tree(an->target, reg, (state | IN_NOT | IN_LOOK_BEHIND), ------------------ | | 3274| 0|#define IN_LOOK_BEHIND (1<<6) ------------------ 4167| 0| env); 4168| 0| if (r != 0) return r; ------------------ | Branch (4168:8): [True: 0, False: 0] ------------------ 4169| 0| r = setup_look_behind(node, reg, env); 4170| 0| } 4171| 0| break; 4172| 4.08k| } 4173| 4.08k| } 4174| 4.08k| break; 4175| | 4176| 4.08k| default: ------------------ | Branch (4176:3): [True: 0, False: 36.7k] ------------------ 4177| 0| break; 4178| 36.7k| } 4179| | 4180| 36.7k| return r; 4181| 36.7k|} regcomp.c:next_setup: 3333| 16.3k|{ 3334| 16.3k| int type; 3335| | 3336| 24.4k| retry: 3337| 24.4k| type = NTYPE(node); ------------------ | | 69| 24.4k|#define NTYPE(node) ((node)->u.base.type) ------------------ 3338| 24.4k| if (type == NT_QTFR) { ------------------ | | 43| 24.4k|#define NT_QTFR 5 ------------------ | Branch (3338:7): [True: 8.16k, False: 16.3k] ------------------ 3339| 8.16k| QtfrNode* qn = NQTFR(node); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 3340| 8.16k| if (qn->greedy && IS_REPEAT_INFINITE(qn->upper)) { ------------------ | | 422| 8.16k|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 8.16k|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 8.16k, False: 0] | | ------------------ ------------------ | Branch (3340:9): [True: 8.16k, False: 0] ------------------ 3341| 8.16k|#ifdef USE_QTFR_PEEK_NEXT 3342| 8.16k| Node* n = get_head_value_node(next_node, 1, reg); 3343| | /* '\0': for UTF-16BE etc... */ 3344| 8.16k| if (IS_NOT_NULL(n) && NSTR(n)->s[0] != '\0') { ------------------ | | 312| 16.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 6.12k, False: 2.04k] | | ------------------ ------------------ if (IS_NOT_NULL(n) && NSTR(n)->s[0] != '\0') { ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ | Branch (3344:29): [True: 6.12k, False: 0] ------------------ 3345| 6.12k| qn->next_head_exact = n; 3346| 6.12k| } 3347| 8.16k|#endif 3348| | /* automatic possessification a*b ==> (?>a*)b */ 3349| 8.16k| if (qn->lower <= 1) { ------------------ | Branch (3349:11): [True: 8.16k, False: 0] ------------------ 3350| 8.16k| int ttype = NTYPE(qn->target); ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ 3351| 8.16k| if (IS_NODE_TYPE_SIMPLE(ttype)) { ------------------ | | 66| 8.16k| ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 53| 8.16k|#define BIT_NT_STR NTYPE2BIT(NT_STR) | | | | ------------------ | | | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 54| 8.16k|#define BIT_NT_CCLASS NTYPE2BIT(NT_CCLASS) | | | | ------------------ | | | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | ((NTYPE2BIT(type) & (BIT_NT_STR | BIT_NT_CCLASS | BIT_NT_CTYPE |\ | | ------------------ | | | | 55| 8.16k|#define BIT_NT_CTYPE NTYPE2BIT(NT_CTYPE) | | | | ------------------ | | | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | | Branch (66:3): [True: 8.16k, False: 0] | | ------------------ | | 67| 8.16k| BIT_NT_CANY | BIT_NT_BREF)) != 0) | | ------------------ | | | | 56| 8.16k|#define BIT_NT_CANY NTYPE2BIT(NT_CANY) | | | | ------------------ | | | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ | | BIT_NT_CANY | BIT_NT_BREF)) != 0) | | ------------------ | | | | 57| 8.16k|#define BIT_NT_BREF NTYPE2BIT(NT_BREF) | | | | ------------------ | | | | | | 51| 8.16k|#define NTYPE2BIT(type) (1<<(type)) | | | | ------------------ | | ------------------ ------------------ 3352| 8.16k| Node *x, *y; 3353| 8.16k| x = get_head_value_node(qn->target, 0, reg); 3354| 8.16k| if (IS_NOT_NULL(x)) { ------------------ | | 312| 8.16k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 6.12k, False: 2.04k] | | ------------------ ------------------ 3355| 6.12k| y = get_head_value_node(next_node, 0, reg); 3356| 6.12k| if (IS_NOT_NULL(y) && is_not_included(x, y, reg)) { ------------------ | | 312| 12.2k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 6.12k, False: 0] | | ------------------ ------------------ | Branch (3356:28): [True: 6.12k, False: 0] ------------------ 3357| 6.12k| Node* en = onig_node_new_enclose(ENCLOSE_STOP_BACKTRACK); ------------------ | | 96| 6.12k|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ 3358| 6.12k| CHECK_NULL_RETURN_MEMERR(en); ------------------ | | 314| 6.12k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 3359| 6.12k| SET_ENCLOSE_STATUS(en, NST_STOP_BT_SIMPLE_REPEAT); ------------------ | | 144| 6.12k|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 3360| 6.12k| swap_node(node, en); 3361| 6.12k| NENCLOSE(node)->target = en; ------------------ | | 81| 6.12k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 3362| 6.12k| } 3363| 6.12k| } 3364| 8.16k| } 3365| 8.16k| } 3366| 8.16k| } 3367| 8.16k| } 3368| 16.3k| else if (type == NT_ENCLOSE) { ------------------ | | 44| 16.3k|#define NT_ENCLOSE 6 ------------------ | Branch (3368:12): [True: 8.16k, False: 8.16k] ------------------ 3369| 8.16k| EncloseNode* en = NENCLOSE(node); ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 3370| 8.16k| if (en->type == ENCLOSE_MEMORY) { ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (3370:9): [True: 8.16k, False: 0] ------------------ 3371| 8.16k| node = en->target; 3372| 8.16k| goto retry; 3373| 8.16k| } 3374| 8.16k| } 3375| 16.3k| return 0; 3376| 24.4k|} regcomp.c:get_head_value_node: 2746| 22.4k|{ 2747| 22.4k| Node* n = NULL_NODE; ------------------ | | 283| 22.4k|#define NULL_NODE ((Node* )0) ------------------ 2748| | 2749| 22.4k| switch (NTYPE(node)) { ------------------ | | 69| 22.4k|#define NTYPE(node) ((node)->u.base.type) ------------------ 2750| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (2750:3): [True: 0, False: 22.4k] ------------------ 2751| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (2751:3): [True: 0, False: 22.4k] ------------------ 2752| 2.04k| case NT_CANY: ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (2752:3): [True: 2.04k, False: 20.4k] ------------------ 2753| 2.04k|#ifdef USE_SUBEXP_CALL 2754| 2.04k| case NT_CALL: ------------------ | | 48| 2.04k|#define NT_CALL 10 ------------------ | Branch (2754:3): [True: 0, False: 22.4k] ------------------ 2755| 2.04k|#endif 2756| 2.04k| break; 2757| | 2758| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2758:3): [True: 0, False: 22.4k] ------------------ 2759| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (2759:3): [True: 6.12k, False: 16.3k] ------------------ 2760| 6.12k| if (exact == 0) { ------------------ | Branch (2760:9): [True: 6.12k, False: 0] ------------------ 2761| 6.12k| n = node; 2762| 6.12k| } 2763| 6.12k| break; 2764| | 2765| 0| case NT_LIST: ------------------ | | 46| 0|#define NT_LIST 8 ------------------ | Branch (2765:3): [True: 0, False: 22.4k] ------------------ 2766| 0| n = get_head_value_node(NCAR(node), exact, reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 2767| 0| break; 2768| | 2769| 12.2k| case NT_STR: ------------------ | | 38| 12.2k|#define NT_STR 0 ------------------ | Branch (2769:3): [True: 12.2k, False: 10.2k] ------------------ 2770| 12.2k| { 2771| 12.2k| StrNode* sn = NSTR(node); ------------------ | | 76| 12.2k|#define NSTR(node) (&((node)->u.str)) ------------------ 2772| | 2773| 12.2k| if (sn->end <= sn->s) ------------------ | Branch (2773:11): [True: 0, False: 12.2k] ------------------ 2774| 0| break; 2775| | 2776| 12.2k| if (exact == 0 || ------------------ | Branch (2776:11): [True: 6.12k, False: 6.12k] ------------------ 2777| 12.2k| NSTRING_IS_RAW(node) || !IS_IGNORECASE(reg->options)) { ------------------ | | 114| 18.3k|#define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) | | ------------------ | | | | 104| 6.12k|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ | | | Branch (114:39): [True: 0, False: 6.12k] | | ------------------ ------------------ NSTRING_IS_RAW(node) || !IS_IGNORECASE(reg->options)) { ------------------ | | 396| 6.12k|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 6.12k|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ ------------------ | Branch (2777:28): [True: 6.12k, False: 0] ------------------ 2778| 12.2k| n = node; 2779| 12.2k| } 2780| 12.2k| } 2781| 0| break; 2782| | 2783| 0| case NT_QTFR: ------------------ | | 43| 0|#define NT_QTFR 5 ------------------ | Branch (2783:3): [True: 0, False: 22.4k] ------------------ 2784| 0| { 2785| 0| QtfrNode* qn = NQTFR(node); ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 2786| 0| if (qn->lower > 0) { ------------------ | Branch (2786:11): [True: 0, False: 0] ------------------ 2787| |#ifdef USE_OP_PUSH_OR_JUMP_EXACT 2788| | if (IS_NOT_NULL(qn->head_exact)) 2789| | n = qn->head_exact; 2790| | else 2791| |#endif 2792| 0| n = get_head_value_node(qn->target, exact, reg); 2793| 0| } 2794| 0| } 2795| 0| break; 2796| | 2797| 0| case NT_ENCLOSE: ------------------ | | 44| 0|#define NT_ENCLOSE 6 ------------------ | Branch (2797:3): [True: 0, False: 22.4k] ------------------ 2798| 0| { 2799| 0| EncloseNode* en = NENCLOSE(node); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2800| 0| switch (en->type) { ------------------ | Branch (2800:15): [True: 0, False: 0] ------------------ 2801| 0| case ENCLOSE_OPTION: ------------------ | | 95| 0|#define ENCLOSE_OPTION (1<<1) ------------------ | Branch (2801:7): [True: 0, False: 0] ------------------ 2802| 0| { 2803| 0| OnigOptionType options = reg->options; 2804| | 2805| 0| reg->options = NENCLOSE(node)->option; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2806| 0| n = get_head_value_node(NENCLOSE(node)->target, exact, reg); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 2807| 0| reg->options = options; 2808| 0| } 2809| 0| break; 2810| | 2811| 0| case ENCLOSE_MEMORY: ------------------ | | 94| 0|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (2811:7): [True: 0, False: 0] ------------------ 2812| 0| case ENCLOSE_STOP_BACKTRACK: ------------------ | | 96| 0|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ | Branch (2812:7): [True: 0, False: 0] ------------------ 2813| 0| case ENCLOSE_CONDITION: ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (2813:7): [True: 0, False: 0] ------------------ 2814| 0| n = get_head_value_node(en->target, exact, reg); 2815| 0| break; 2816| | 2817| 0| case ENCLOSE_ABSENT: ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ | Branch (2817:7): [True: 0, False: 0] ------------------ 2818| 0| break; 2819| 0| } 2820| 0| } 2821| 0| break; 2822| | 2823| 2.04k| case NT_ANCHOR: ------------------ | | 45| 2.04k|#define NT_ANCHOR 7 ------------------ | Branch (2823:3): [True: 2.04k, False: 20.4k] ------------------ 2824| 2.04k| if (NANCHOR(node)->type == ANCHOR_PREC_READ) ------------------ | | 82| 2.04k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ if (NANCHOR(node)->type == ANCHOR_PREC_READ) ------------------ | | 551| 2.04k|#define ANCHOR_PREC_READ (1<<10) ------------------ | Branch (2824:9): [True: 0, False: 2.04k] ------------------ 2825| 0| n = get_head_value_node(NANCHOR(node)->target, exact, reg); ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 2826| 2.04k| break; 2827| | 2828| 0| default: ------------------ | Branch (2828:3): [True: 0, False: 22.4k] ------------------ 2829| 0| break; 2830| 22.4k| } 2831| | 2832| 22.4k| return n; 2833| 22.4k|} regcomp.c:is_not_included: 2551| 6.12k|{ 2552| 6.12k| int i; 2553| 6.12k| OnigDistance len; 2554| 6.12k| OnigCodePoint code; 2555| 6.12k| UChar *p; ------------------ | | 76| 6.12k|# define UChar OnigUChar ------------------ 2556| 6.12k| int ytype; 2557| | 2558| 12.2k| retry: 2559| 12.2k| ytype = NTYPE(y); ------------------ | | 69| 12.2k|#define NTYPE(node) ((node)->u.base.type) ------------------ 2560| 12.2k| switch (NTYPE(x)) { ------------------ | | 69| 12.2k|#define NTYPE(node) ((node)->u.base.type) ------------------ 2561| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2561:3): [True: 0, False: 12.2k] ------------------ 2562| 0| { 2563| 0| switch (ytype) { 2564| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2564:7): [True: 0, False: 0] ------------------ 2565| 0| if (NCTYPE(y)->ctype == NCTYPE(x)->ctype && ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ if (NCTYPE(y)->ctype == NCTYPE(x)->ctype && ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2565:6): [True: 0, False: 0] ------------------ 2566| 0| NCTYPE(y)->not != NCTYPE(x)->not && ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ NCTYPE(y)->not != NCTYPE(x)->not && ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2566:6): [True: 0, False: 0] ------------------ 2567| 0| NCTYPE(y)->ascii_range == NCTYPE(x)->ascii_range) ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ NCTYPE(y)->ascii_range == NCTYPE(x)->ascii_range) ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2567:6): [True: 0, False: 0] ------------------ 2568| 0| return 1; 2569| 0| else 2570| 0| return 0; 2571| 0| break; 2572| | 2573| 0| case NT_CCLASS: ------------------ | | 39| 0|#define NT_CCLASS 1 ------------------ | Branch (2573:7): [True: 0, False: 0] ------------------ 2574| 6.12k| swap: 2575| 6.12k| { 2576| 6.12k| Node* tmp; 2577| 6.12k| tmp = x; x = y; y = tmp; 2578| 6.12k| goto retry; 2579| 0| } 2580| 0| break; 2581| | 2582| 0| case NT_STR: ------------------ | | 38| 0|#define NT_STR 0 ------------------ | Branch (2582:7): [True: 0, False: 0] ------------------ 2583| 0| goto swap; 2584| 0| break; 2585| | 2586| 0| default: ------------------ | Branch (2586:7): [True: 0, False: 0] ------------------ 2587| 0| break; 2588| 0| } 2589| 0| } 2590| 0| break; 2591| | 2592| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (2592:3): [True: 6.12k, False: 6.12k] ------------------ 2593| 6.12k| { 2594| 6.12k| CClassNode* xc = NCCLASS(x); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 2595| 6.12k| switch (ytype) { 2596| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2596:7): [True: 0, False: 6.12k] ------------------ 2597| 0| switch (NCTYPE(y)->ctype) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2598| 0| case ONIGENC_CTYPE_WORD: ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (2598:2): [True: 0, False: 0] ------------------ 2599| 0| if (NCTYPE(y)->not == 0) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2599:8): [True: 0, False: 0] ------------------ 2600| 0| if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) { ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2600:31): [True: 0, False: 0] ------------------ 2601| 0| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (2601:20): [True: 0, False: 0] ------------------ 2602| 0| if (BITSET_AT(xc->bs, i)) { ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (448:36): [True: 0, False: 0] | | ------------------ ------------------ 2603| 0| if (NCTYPE(y)->ascii_range) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2603:9): [True: 0, False: 0] ------------------ 2604| 0| if (IS_CODE_SB_WORD(reg->enc, i)) return 0; ------------------ | | 891| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_WORD(enc,code)) | | ------------------ | | | | 321| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (321:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_WORD(enc,code)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2605| 0| } 2606| 0| else { 2607| 0| if (ONIGENC_IS_CODE_WORD(reg->enc, i)) return 0; ------------------ | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2608| 0| } 2609| 0| } 2610| 0| } 2611| 0| return 1; 2612| 0| } 2613| 0| return 0; 2614| 0| } 2615| 0| else { 2616| 0| if (IS_NOT_NULL(xc->mbuf)) return 0; ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 2617| 0| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (2617:18): [True: 0, False: 0] ------------------ 2618| 0| int is_word; 2619| 0| if (NCTYPE(y)->ascii_range) ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2619:12): [True: 0, False: 0] ------------------ 2620| 0| is_word = IS_CODE_SB_WORD(reg->enc, i); ------------------ | | 891| 0| (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_WORD(enc,code)) | | ------------------ | | | | 321| 0|#define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) | | | | ------------------ | | | | | Branch (321:43): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (ONIGENC_IS_CODE_ASCII(code) && ONIGENC_IS_CODE_WORD(enc,code)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2621| 0| else 2622| 0| is_word = ONIGENC_IS_CODE_WORD(reg->enc, i); ------------------ | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | ------------------ ------------------ 2623| 0| if (! is_word) { ------------------ | Branch (2623:12): [True: 0, False: 0] ------------------ 2624| 0| if (!IS_NCCLASS_NOT(xc)) { ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2624:7): [True: 0, False: 0] ------------------ 2625| 0| if (BITSET_AT(xc->bs, i)) ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (448:36): [True: 0, False: 0] | | ------------------ ------------------ 2626| 0| return 0; 2627| 0| } 2628| 0| else { 2629| 0| if (! BITSET_AT(xc->bs, i)) ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2629:9): [True: 0, False: 0] ------------------ 2630| 0| return 0; 2631| 0| } 2632| 0| } 2633| 0| } 2634| 0| return 1; 2635| 0| } 2636| 0| break; 2637| | 2638| 0| default: ------------------ | Branch (2638:2): [True: 0, False: 0] ------------------ 2639| 0| break; 2640| 0| } 2641| 0| break; 2642| | 2643| 0| case NT_CCLASS: ------------------ | | 39| 0|#define NT_CCLASS 1 ------------------ | Branch (2643:7): [True: 0, False: 6.12k] ------------------ 2644| 0| { 2645| 0| int v; 2646| 0| CClassNode* yc = NCCLASS(y); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 2647| | 2648| 0| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (2648:16): [True: 0, False: 0] ------------------ 2649| 0| v = BITSET_AT(xc->bs, i); ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2650| 0| if ((v != 0 && !IS_NCCLASS_NOT(xc)) || ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2650:11): [True: 0, False: 0] | Branch (2650:21): [True: 0, False: 0] ------------------ 2651| 0| (v == 0 && IS_NCCLASS_NOT(xc))) { ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (2651:4): [True: 0, False: 0] ------------------ 2652| 0| v = BITSET_AT(yc->bs, i); ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2653| 0| if ((v != 0 && !IS_NCCLASS_NOT(yc)) || ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2653:13): [True: 0, False: 0] | Branch (2653:23): [True: 0, False: 0] ------------------ 2654| 0| (v == 0 && IS_NCCLASS_NOT(yc))) ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (2654:6): [True: 0, False: 0] ------------------ 2655| 0| return 0; 2656| 0| } 2657| 0| } 2658| 0| if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) || ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) || ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2658:30): [True: 0, False: 0] ------------------ 2659| 0| (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc))) ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc))) ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (2659:30): [True: 0, False: 0] ------------------ 2660| 0| return 1; 2661| 0| return 0; 2662| 0| } 2663| 0| break; 2664| | 2665| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (2665:7): [True: 6.12k, False: 0] ------------------ 2666| 6.12k| goto swap; 2667| 0| break; 2668| | 2669| 0| default: ------------------ | Branch (2669:7): [True: 0, False: 6.12k] ------------------ 2670| 0| break; 2671| 6.12k| } 2672| 6.12k| } 2673| 0| break; 2674| | 2675| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (2675:3): [True: 6.12k, False: 6.12k] ------------------ 2676| 6.12k| { 2677| 6.12k| StrNode* xs = NSTR(x); ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 2678| 6.12k| if (NSTRING_LEN(x) == 0) ------------------ | | 108| 6.12k|#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s) ------------------ | Branch (2678:11): [True: 0, False: 6.12k] ------------------ 2679| 0| break; 2680| | 2681| 6.12k| switch (ytype) { 2682| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (2682:7): [True: 0, False: 6.12k] ------------------ 2683| 0| switch (NCTYPE(y)->ctype) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2684| 0| case ONIGENC_CTYPE_WORD: ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (2684:2): [True: 0, False: 0] ------------------ 2685| 0| if (NCTYPE(y)->ascii_range) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (2685:8): [True: 0, False: 0] ------------------ 2686| 0| if (ONIGENC_IS_MBC_ASCII_WORD(reg->enc, xs->s, xs->end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2687| 0| return NCTYPE(y)->not; ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2688| 0| else 2689| 0| return !(NCTYPE(y)->not); ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2690| 0| } 2691| 0| else { 2692| 0| if (ONIGENC_IS_MBC_WORD(reg->enc, xs->s, xs->end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2693| 0| return NCTYPE(y)->not; ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2694| 0| else 2695| 0| return !(NCTYPE(y)->not); ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 2696| 0| } 2697| 0| break; 2698| 0| default: ------------------ | Branch (2698:2): [True: 0, False: 0] ------------------ 2699| 0| break; 2700| 0| } 2701| 0| break; 2702| | 2703| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (2703:7): [True: 6.12k, False: 0] ------------------ 2704| 6.12k| { 2705| 6.12k| CClassNode* cc = NCCLASS(y); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 2706| | 2707| 6.12k| code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s, ------------------ | | 369| 6.12k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ 2708| 6.12k| xs->s + ONIGENC_MBC_MAXLEN(reg->enc)); 2709| 6.12k| return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1); ------------------ | Branch (2709:12): [True: 0, False: 6.12k] ------------------ 2710| 0| } 2711| 0| break; 2712| | 2713| 0| case NT_STR: ------------------ | | 38| 0|#define NT_STR 0 ------------------ | Branch (2713:7): [True: 0, False: 6.12k] ------------------ 2714| 0| { 2715| 0| UChar *q; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2716| 0| StrNode* ys = NSTR(y); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 2717| 0| len = NSTRING_LEN(x); ------------------ | | 108| 0|#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s) ------------------ 2718| 0| if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y); ------------------ | | 108| 0|#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s) ------------------ if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y); ------------------ | | 108| 0|#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s) ------------------ | Branch (2718:8): [True: 0, False: 0] ------------------ 2719| 0| if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) { ------------------ | | 115| 0|#define NSTRING_IS_AMBIG(node) (((node)->u.str.flag & NSTR_AMBIG) != 0) | | ------------------ | | | | 105| 0|#define NSTR_AMBIG (1<<1) | | ------------------ | | | Branch (115:39): [True: 0, False: 0] | | ------------------ ------------------ if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) { ------------------ | | 115| 0|#define NSTRING_IS_AMBIG(node) (((node)->u.str.flag & NSTR_AMBIG) != 0) | | ------------------ | | | | 105| 0|#define NSTR_AMBIG (1<<1) | | ------------------ | | | Branch (115:39): [True: 0, False: 0] | | ------------------ ------------------ 2720| | /* tiny version */ 2721| 0| return 0; 2722| 0| } 2723| 0| else { 2724| 0| for (i = 0, p = ys->s, q = xs->s; (OnigDistance )i < len; i++, p++, q++) { ------------------ | Branch (2724:40): [True: 0, False: 0] ------------------ 2725| 0| if (*p != *q) return 1; ------------------ | Branch (2725:12): [True: 0, False: 0] ------------------ 2726| 0| } 2727| 0| } 2728| 0| } 2729| 0| break; 2730| | 2731| 0| default: ------------------ | Branch (2731:7): [True: 0, False: 6.12k] ------------------ 2732| 0| break; 2733| 6.12k| } 2734| 6.12k| } 2735| 0| break; 2736| | 2737| 0| default: ------------------ | Branch (2737:3): [True: 0, False: 12.2k] ------------------ 2738| 0| break; 2739| 12.2k| } 2740| | 2741| 0| return 0; 2742| 12.2k|} regcomp.c:swap_node: 72| 6.12k|{ 73| 6.12k| Node c; 74| 6.12k| c = *a; *a = *b; *b = c; 75| | 76| 6.12k| if (NTYPE(a) == NT_STR) { ------------------ | | 69| 6.12k|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(a) == NT_STR) { ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (76:7): [True: 0, False: 6.12k] ------------------ 77| 0| StrNode* sn = NSTR(a); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 78| 0| if (sn->capa == 0) { ------------------ | Branch (78:9): [True: 0, False: 0] ------------------ 79| 0| size_t len = sn->end - sn->s; 80| 0| sn->s = sn->buf; 81| 0| sn->end = sn->s + len; 82| 0| } 83| 0| } 84| | 85| 6.12k| if (NTYPE(b) == NT_STR) { ------------------ | | 69| 6.12k|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(b) == NT_STR) { ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (85:7): [True: 0, False: 6.12k] ------------------ 86| 0| StrNode* sn = NSTR(b); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 87| 0| if (sn->capa == 0) { ------------------ | Branch (87:9): [True: 0, False: 0] ------------------ 88| 0| size_t len = sn->end - sn->s; 89| 0| sn->s = sn->buf; 90| 0| sn->end = sn->s + len; 91| 0| } 92| 0| } 93| 6.12k|} regcomp.c:distance_add: 97| 73.4k|{ 98| 73.4k| if (d1 == ONIG_INFINITE_DISTANCE || d2 == ONIG_INFINITE_DISTANCE) ------------------ | | 85| 146k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ if (d1 == ONIG_INFINITE_DISTANCE || d2 == ONIG_INFINITE_DISTANCE) ------------------ | | 85| 44.9k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (98:7): [True: 28.5k, False: 44.9k] | Branch (98:39): [True: 4.08k, False: 40.8k] ------------------ 99| 32.6k| return ONIG_INFINITE_DISTANCE; ------------------ | | 85| 32.6k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 100| 40.8k| else { 101| 40.8k| if (d1 <= ONIG_INFINITE_DISTANCE - d2) return d1 + d2; ------------------ | | 85| 40.8k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (101:9): [True: 40.8k, False: 0] ------------------ 102| 0| else return ONIG_INFINITE_DISTANCE; ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 103| 40.8k| } 104| 73.4k|} regcomp.c:clear_optimize_info: 5363| 2.04k|{ 5364| 2.04k| reg->optimize = ONIG_OPTIMIZE_NONE; ------------------ | | 355| 2.04k|#define ONIG_OPTIMIZE_NONE 0 ------------------ 5365| 2.04k| reg->anchor = 0; 5366| 2.04k| reg->anchor_dmin = 0; 5367| 2.04k| reg->anchor_dmax = 0; 5368| 2.04k| reg->sub_anchor = 0; 5369| 2.04k| reg->exact_end = (UChar* )NULL; 5370| 2.04k| reg->threshold_len = 0; 5371| 2.04k| if (IS_NOT_NULL(reg->exact)) { ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 2.04k] | | ------------------ ------------------ 5372| 0| xfree(reg->exact); ------------------ | | 145| 0|# define xfree free ------------------ 5373| 0| reg->exact = (UChar* )NULL; 5374| 0| } 5375| 2.04k|} regcomp.c:set_optimize_info_from_tree: 5303| 2.04k|{ 5304| | 5305| 2.04k| int r; 5306| 2.04k| NodeOptInfo opt; 5307| 2.04k| OptEnv env; 5308| | 5309| 2.04k| env.enc = reg->enc; 5310| 2.04k| env.options = reg->options; 5311| 2.04k| env.case_fold_flag = reg->case_fold_flag; 5312| 2.04k| env.scan_env = scan_env; 5313| 2.04k| clear_mml(&env.mmd); 5314| | 5315| 2.04k| r = optimize_node_left(node, &opt, &env); 5316| 2.04k| if (r) return r; ------------------ | Branch (5316:7): [True: 0, False: 2.04k] ------------------ 5317| | 5318| 2.04k| reg->anchor = opt.anc.left_anchor & (ANCHOR_BEGIN_BUF | ------------------ | | 540| 2.04k|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ 5319| 2.04k| ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML | ------------------ | | 542| 2.04k|#define ANCHOR_BEGIN_POSITION (1<<2) ------------------ ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML | ------------------ | | 556| 2.04k|#define ANCHOR_ANYCHAR_STAR (1<<14) /* ".*" optimize info */ ------------------ ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML | ------------------ | | 557| 2.04k|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ ------------------ 5320| 2.04k| ANCHOR_LOOK_BEHIND); ------------------ | | 553| 2.04k|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ 5321| | 5322| 2.04k| if ((opt.anc.left_anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) != 0) ------------------ | | 553| 2.04k|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ if ((opt.anc.left_anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) != 0) ------------------ | | 552| 2.04k|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (5322:7): [True: 0, False: 2.04k] ------------------ 5323| 0| reg->anchor &= ~ANCHOR_ANYCHAR_STAR_ML; ------------------ | | 557| 0|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ ------------------ 5324| | 5325| 2.04k| reg->anchor |= opt.anc.right_anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF | ------------------ | | 543| 2.04k|#define ANCHOR_END_BUF (1<<3) ------------------ reg->anchor |= opt.anc.right_anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF | ------------------ | | 544| 2.04k|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ 5326| 2.04k| ANCHOR_PREC_READ_NOT); ------------------ | | 552| 2.04k|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ 5327| | 5328| 2.04k| if (reg->anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF)) { ------------------ | | 543| 2.04k|#define ANCHOR_END_BUF (1<<3) ------------------ if (reg->anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF)) { ------------------ | | 544| 2.04k|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ | Branch (5328:7): [True: 0, False: 2.04k] ------------------ 5329| 0| reg->anchor_dmin = opt.len.min; 5330| 0| reg->anchor_dmax = opt.len.max; 5331| 0| } 5332| | 5333| 2.04k| if (opt.exb.len > 0 || opt.exm.len > 0) { ------------------ | Branch (5333:7): [True: 0, False: 2.04k] | Branch (5333:26): [True: 2.04k, False: 0] ------------------ 5334| 2.04k| select_opt_exact_info(reg->enc, &opt.exb, &opt.exm); 5335| 2.04k| if (opt.map.value > 0 && ------------------ | Branch (5335:9): [True: 2.04k, False: 0] ------------------ 5336| 2.04k| comp_opt_exact_or_map_info(&opt.exb, &opt.map) > 0) { ------------------ | Branch (5336:2): [True: 0, False: 2.04k] ------------------ 5337| 0| goto set_map; 5338| 0| } 5339| 2.04k| else { 5340| 2.04k| r = set_optimize_exact_info(reg, &opt.exb); 5341| 2.04k| set_sub_anchor(reg, &opt.exb.anc); 5342| 2.04k| } 5343| 2.04k| } 5344| 0| else if (opt.map.value > 0) { ------------------ | Branch (5344:12): [True: 0, False: 0] ------------------ 5345| 0| set_map: 5346| 0| set_optimize_map_info(reg, &opt.map); 5347| 0| set_sub_anchor(reg, &opt.map.anc); 5348| 0| } 5349| 0| else { 5350| 0| reg->sub_anchor |= opt.anc.left_anchor & ANCHOR_BEGIN_LINE; ------------------ | | 541| 0|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ 5351| 0| if (opt.len.max == 0) ------------------ | Branch (5351:9): [True: 0, False: 0] ------------------ 5352| 0| reg->sub_anchor |= opt.anc.right_anchor & ANCHOR_END_LINE; ------------------ | | 545| 0|#define ANCHOR_END_LINE (1<<5) ------------------ 5353| 0| } 5354| | 5355| |#if defined(ONIG_DEBUG_COMPILE) || defined(ONIG_DEBUG_MATCH) 5356| | print_optimize_info(stderr, reg); 5357| |#endif 5358| 2.04k| return r; 5359| 2.04k|} regcomp.c:clear_mml: 4385| 173k|{ 4386| 173k| mml->min = mml->max = 0; 4387| 173k|} regcomp.c:optimize_node_left: 4866| 42.8k|{ 4867| 42.8k| int type; 4868| 42.8k| int r = 0; 4869| | 4870| 42.8k| clear_node_opt_info(opt); 4871| 42.8k| set_bound_node_opt_info(opt, &env->mmd); 4872| | 4873| 42.8k| type = NTYPE(node); ------------------ | | 69| 42.8k|#define NTYPE(node) ((node)->u.base.type) ------------------ 4874| 42.8k| switch (type) { 4875| 2.04k| case NT_LIST: ------------------ | | 46| 2.04k|#define NT_LIST 8 ------------------ | Branch (4875:3): [True: 2.04k, False: 40.8k] ------------------ 4876| 2.04k| { 4877| 2.04k| OptEnv nenv; 4878| 2.04k| NodeOptInfo nopt; 4879| 2.04k| Node* nd = node; 4880| | 4881| 2.04k| copy_opt_env(&nenv, env); 4882| 18.3k| do { 4883| 18.3k| r = optimize_node_left(NCAR(nd), &nopt, &nenv); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 4884| 18.3k| if (r == 0) { ------------------ | Branch (4884:6): [True: 18.3k, False: 0] ------------------ 4885| 18.3k| add_mml(&nenv.mmd, &nopt.len); 4886| 18.3k| concat_left_node_opt_info(env->enc, opt, &nopt); 4887| 18.3k| } 4888| 18.3k| } while (r == 0 && IS_NOT_NULL(nd = NCDR(nd))); ------------------ | | 312| 18.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 16.3k, False: 2.04k] | | ------------------ ------------------ | Branch (4888:16): [True: 18.3k, False: 0] ------------------ 4889| 2.04k| } 4890| 2.04k| break; 4891| | 4892| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (4892:3): [True: 0, False: 42.8k] ------------------ 4893| 0| { 4894| 0| NodeOptInfo nopt; 4895| 0| Node* nd = node; 4896| | 4897| 0| do { 4898| 0| r = optimize_node_left(NCAR(nd), &nopt, env); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 4899| 0| if (r == 0) { ------------------ | Branch (4899:6): [True: 0, False: 0] ------------------ 4900| 0| if (nd == node) copy_node_opt_info(opt, &nopt); ------------------ | Branch (4900:8): [True: 0, False: 0] ------------------ 4901| 0| else alt_merge_node_opt_info(opt, &nopt, env); 4902| 0| } 4903| 0| } while ((r == 0) && IS_NOT_NULL(nd = NCDR(nd))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4903:16): [True: 0, False: 0] ------------------ 4904| 0| } 4905| 0| break; 4906| | 4907| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (4907:3): [True: 6.12k, False: 36.7k] ------------------ 4908| 6.12k| { 4909| 6.12k| StrNode* sn = NSTR(node); ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 4910| 6.12k| OnigDistance slen = sn->end - sn->s; 4911| 6.12k| int is_raw = NSTRING_IS_RAW(node); ------------------ | | 114| 6.12k|#define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) | | ------------------ | | | | 104| 6.12k|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ ------------------ 4912| | 4913| 6.12k| if (! NSTRING_IS_AMBIG(node)) { ------------------ | | 115| 6.12k|#define NSTRING_IS_AMBIG(node) (((node)->u.str.flag & NSTR_AMBIG) != 0) | | ------------------ | | | | 105| 6.12k|#define NSTR_AMBIG (1<<1) | | ------------------ ------------------ | Branch (4913:11): [True: 6.12k, False: 0] ------------------ 4914| 6.12k| concat_opt_exact_info_str(&opt->exb, sn->s, sn->end, 4915| 6.12k| is_raw, env->enc); 4916| 6.12k| opt->exb.ignore_case = 0; 4917| 6.12k| if (slen > 0) { ------------------ | Branch (4917:6): [True: 6.12k, False: 0] ------------------ 4918| 6.12k| add_char_opt_map_info(&opt->map, *(sn->s), env->enc); 4919| 6.12k| } 4920| 6.12k| set_mml(&opt->len, slen, slen); 4921| 6.12k| } 4922| 0| else { 4923| 0| OnigDistance max; 4924| | 4925| 0| if (NSTRING_IS_DONT_GET_OPT_INFO(node)) { ------------------ | | 117| 0| (((node)->u.str.flag & NSTR_DONT_GET_OPT_INFO) != 0) | | ------------------ | | | | 106| 0|#define NSTR_DONT_GET_OPT_INFO (1<<2) | | ------------------ | | | Branch (117:3): [True: 0, False: 0] | | ------------------ ------------------ 4926| 0| int n = onigenc_strlen(env->enc, sn->s, sn->end); 4927| 0| max = (OnigDistance )ONIGENC_MBC_MAXLEN_DIST(env->enc) * n; ------------------ | | 366| 0|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 365| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 4928| 0| } 4929| 0| else { 4930| 0| concat_opt_exact_info_str(&opt->exb, sn->s, sn->end, 4931| 0| is_raw, env->enc); 4932| 0| opt->exb.ignore_case = 1; 4933| | 4934| 0| if (slen > 0) { ------------------ | Branch (4934:8): [True: 0, False: 0] ------------------ 4935| 0| r = add_char_amb_opt_map_info(&opt->map, sn->s, sn->end, 4936| 0| env->enc, env->case_fold_flag); 4937| 0| if (r != 0) break; ------------------ | Branch (4937:10): [True: 0, False: 0] ------------------ 4938| 0| } 4939| | 4940| 0| max = slen; 4941| 0| } 4942| | 4943| 0| set_mml(&opt->len, slen, max); 4944| 0| } 4945| | 4946| 6.12k| if ((OnigDistance )opt->exb.len == slen) ------------------ | Branch (4946:11): [True: 6.12k, False: 0] ------------------ 4947| 6.12k| opt->exb.reach_end = 1; 4948| 6.12k| } 4949| 0| break; 4950| | 4951| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (4951:3): [True: 6.12k, False: 36.7k] ------------------ 4952| 6.12k| { 4953| 6.12k| int i, z; 4954| 6.12k| CClassNode* cc = NCCLASS(node); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 4955| | 4956| | /* no need to check ignore case. (set in setup_tree()) */ 4957| | 4958| 6.12k| if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) { ------------------ | | 312| 12.2k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 6.12k] | | ------------------ ------------------ if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) { ------------------ | | 809| 6.12k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 6.12k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 6.12k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 6.12k, False: 0] | | | | ------------------ | | ------------------ ------------------ 4959| 6.12k| OnigDistance min = ONIGENC_MBC_MINLEN(env->enc); ------------------ | | 367| 6.12k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 4960| 6.12k| OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc); ------------------ | | 366| 6.12k|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 365| 6.12k|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 4961| | 4962| 6.12k| set_mml(&opt->len, min, max); 4963| 6.12k| } 4964| 0| else { 4965| 0| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (4965:14): [True: 0, False: 0] ------------------ 4966| 0| z = BITSET_AT(cc->bs, i); ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4967| 0| if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) { ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) { ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (4967:9): [True: 0, False: 0] | Branch (4967:14): [True: 0, False: 0] | Branch (4967:39): [True: 0, False: 0] ------------------ 4968| 0| add_char_opt_map_info(&opt->map, (UChar )i, env->enc); 4969| 0| } 4970| 0| } 4971| 0| set_mml(&opt->len, 1, 1); 4972| 0| } 4973| 6.12k| } 4974| 6.12k| break; 4975| | 4976| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (4976:3): [True: 0, False: 42.8k] ------------------ 4977| 0| { 4978| 0| int i, min, max; 4979| 0| int maxcode; 4980| | 4981| 0| max = ONIGENC_MBC_MAXLEN_DIST(env->enc); ------------------ | | 366| 0|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 365| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 4982| | 4983| 0| if (max == 1) { ------------------ | Branch (4983:11): [True: 0, False: 0] ------------------ 4984| 0| min = 1; 4985| | 4986| 0| maxcode = NCTYPE(node)->ascii_range ? 0x80 : SINGLE_BYTE_SIZE; ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ maxcode = NCTYPE(node)->ascii_range ? 0x80 : SINGLE_BYTE_SIZE; ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (4986:12): [True: 0, False: 0] ------------------ 4987| 0| switch (NCTYPE(node)->ctype) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (4987:10): [True: 0, False: 0] ------------------ 4988| 0| case ONIGENC_CTYPE_WORD: ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (4988:2): [True: 0, False: 0] ------------------ 4989| 0| if (NCTYPE(node)->not != 0) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (4989:8): [True: 0, False: 0] ------------------ 4990| 0| for (i = 0; i < SINGLE_BYTE_SIZE; i++) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (4990:18): [True: 0, False: 0] ------------------ 4991| 0| if (! ONIGENC_IS_CODE_WORD(env->enc, i) || i >= maxcode) { ------------------ | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | ------------------ ------------------ | Branch (4991:12): [True: 0, False: 0] | Branch (4991:51): [True: 0, False: 0] ------------------ 4992| 0| add_char_opt_map_info(&opt->map, (UChar )i, env->enc); 4993| 0| } 4994| 0| } 4995| 0| } 4996| 0| else { 4997| 0| for (i = 0; i < maxcode; i++) { ------------------ | Branch (4997:18): [True: 0, False: 0] ------------------ 4998| 0| if (ONIGENC_IS_CODE_WORD(env->enc, i)) { ------------------ | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 4999| 0| add_char_opt_map_info(&opt->map, (UChar )i, env->enc); 5000| 0| } 5001| 0| } 5002| 0| } 5003| 0| break; 5004| 0| } 5005| 0| } 5006| 0| else { 5007| 0| min = ONIGENC_MBC_MINLEN(env->enc); ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 5008| 0| } 5009| 0| set_mml(&opt->len, min, max); 5010| 0| } 5011| 0| break; 5012| | 5013| 2.04k| case NT_CANY: ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (5013:3): [True: 2.04k, False: 40.8k] ------------------ 5014| 2.04k| { 5015| 2.04k| OnigDistance min = ONIGENC_MBC_MINLEN(env->enc); ------------------ | | 367| 2.04k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 5016| 2.04k| OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc); ------------------ | | 366| 2.04k|#define ONIGENC_MBC_MAXLEN_DIST(enc) ONIGENC_MBC_MAXLEN(enc) | | ------------------ | | | | 365| 2.04k|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ 5017| 2.04k| set_mml(&opt->len, min, max); 5018| 2.04k| } 5019| 2.04k| break; 5020| | 5021| 4.08k| case NT_ANCHOR: ------------------ | | 45| 4.08k|#define NT_ANCHOR 7 ------------------ | Branch (5021:3): [True: 4.08k, False: 38.7k] ------------------ 5022| 4.08k| switch (NANCHOR(node)->type) { ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ | Branch (5022:13): [True: 0, False: 4.08k] ------------------ 5023| 0| case ANCHOR_BEGIN_BUF: ------------------ | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ | Branch (5023:5): [True: 0, False: 4.08k] ------------------ 5024| 0| case ANCHOR_BEGIN_POSITION: ------------------ | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) ------------------ | Branch (5024:5): [True: 0, False: 4.08k] ------------------ 5025| 2.04k| case ANCHOR_BEGIN_LINE: ------------------ | | 541| 2.04k|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ | Branch (5025:5): [True: 2.04k, False: 2.04k] ------------------ 5026| 2.04k| case ANCHOR_END_BUF: ------------------ | | 543| 2.04k|#define ANCHOR_END_BUF (1<<3) ------------------ | Branch (5026:5): [True: 0, False: 4.08k] ------------------ 5027| 2.04k| case ANCHOR_SEMI_END_BUF: ------------------ | | 544| 2.04k|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ | Branch (5027:5): [True: 0, False: 4.08k] ------------------ 5028| 4.08k| case ANCHOR_END_LINE: ------------------ | | 545| 4.08k|#define ANCHOR_END_LINE (1<<5) ------------------ | Branch (5028:5): [True: 2.04k, False: 2.04k] ------------------ 5029| 4.08k| case ANCHOR_LOOK_BEHIND: /* just for (?<=x).* */ ------------------ | | 553| 4.08k|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ | Branch (5029:5): [True: 0, False: 4.08k] ------------------ 5030| 4.08k| case ANCHOR_PREC_READ_NOT: /* just for (?!x).* */ ------------------ | | 552| 4.08k|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (5030:5): [True: 0, False: 4.08k] ------------------ 5031| 4.08k| add_opt_anc_info(&opt->anc, NANCHOR(node)->type); ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 5032| 4.08k| break; 5033| | 5034| 0| case ANCHOR_PREC_READ: ------------------ | | 551| 0|#define ANCHOR_PREC_READ (1<<10) ------------------ | Branch (5034:5): [True: 0, False: 4.08k] ------------------ 5035| 0| { 5036| 0| NodeOptInfo nopt; 5037| | 5038| 0| r = optimize_node_left(NANCHOR(node)->target, &nopt, env); ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 5039| 0| if (r == 0) { ------------------ | Branch (5039:6): [True: 0, False: 0] ------------------ 5040| 0| if (nopt.exb.len > 0) ------------------ | Branch (5040:8): [True: 0, False: 0] ------------------ 5041| 0| copy_opt_exact_info(&opt->expr, &nopt.exb); 5042| 0| else if (nopt.exm.len > 0) ------------------ | Branch (5042:13): [True: 0, False: 0] ------------------ 5043| 0| copy_opt_exact_info(&opt->expr, &nopt.exm); 5044| | 5045| 0| opt->expr.reach_end = 0; 5046| | 5047| 0| if (nopt.map.value > 0) ------------------ | Branch (5047:8): [True: 0, False: 0] ------------------ 5048| 0| copy_opt_map_info(&opt->map, &nopt.map); 5049| 0| } 5050| 0| } 5051| 0| break; 5052| | 5053| 0| case ANCHOR_LOOK_BEHIND_NOT: ------------------ | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) ------------------ | Branch (5053:5): [True: 0, False: 4.08k] ------------------ 5054| 0| break; 5055| 4.08k| } 5056| 4.08k| break; 5057| | 5058| 4.08k| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (5058:3): [True: 0, False: 42.8k] ------------------ 5059| 0| { 5060| 0| int i; 5061| 0| int* backs; 5062| 0| OnigDistance min, max, tmin, tmax; 5063| 0| Node** nodes = SCANENV_MEM_NODES(env->scan_env); ------------------ | | 287| 0| (IS_NOT_NULL((senv)->mem_nodes_dynamic) ? \ | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 288| 0| (senv)->mem_nodes_dynamic : (senv)->mem_nodes_static) ------------------ 5064| 0| BRefNode* br = NBREF(node); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 5065| | 5066| 0| if (br->state & NST_RECURSION) { ------------------ | | 135| 0|#define NST_RECURSION (1<<7) ------------------ | Branch (5066:11): [True: 0, False: 0] ------------------ 5067| 0| set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE); ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 5068| 0| break; 5069| 0| } 5070| 0| backs = BACKREFS_P(br); ------------------ | | 120| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static); | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 5071| 0| r = get_min_match_length(nodes[backs[0]], &min, env->scan_env); 5072| 0| if (r != 0) break; ------------------ | Branch (5072:11): [True: 0, False: 0] ------------------ 5073| 0| r = get_max_match_length(nodes[backs[0]], &max, env->scan_env); 5074| 0| if (r != 0) break; ------------------ | Branch (5074:11): [True: 0, False: 0] ------------------ 5075| 0| for (i = 1; i < br->back_num; i++) { ------------------ | Branch (5075:19): [True: 0, False: 0] ------------------ 5076| 0| r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env); 5077| 0| if (r != 0) break; ------------------ | Branch (5077:6): [True: 0, False: 0] ------------------ 5078| 0| r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env); 5079| 0| if (r != 0) break; ------------------ | Branch (5079:6): [True: 0, False: 0] ------------------ 5080| 0| if (min > tmin) min = tmin; ------------------ | Branch (5080:6): [True: 0, False: 0] ------------------ 5081| 0| if (max < tmax) max = tmax; ------------------ | Branch (5081:6): [True: 0, False: 0] ------------------ 5082| 0| } 5083| 0| if (r == 0) set_mml(&opt->len, min, max); ------------------ | Branch (5083:11): [True: 0, False: 0] ------------------ 5084| 0| } 5085| 0| break; 5086| | 5087| 0|#ifdef USE_SUBEXP_CALL 5088| 0| case NT_CALL: ------------------ | | 48| 0|#define NT_CALL 10 ------------------ | Branch (5088:3): [True: 0, False: 42.8k] ------------------ 5089| 0| if (IS_CALL_RECURSION(NCALL(node))) ------------------ | | 161| 0|#define IS_CALL_RECURSION(cn) (((cn)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (161:40): [True: 0, False: 0] | | ------------------ ------------------ 5090| 0| set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE); ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 5091| 0| else { 5092| 0| OnigOptionType save = env->options; 5093| 0| env->options = NENCLOSE(NCALL(node)->target)->option; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5094| 0| r = optimize_node_left(NCALL(node)->target, opt, env); ------------------ | | 84| 0|#define NCALL(node) (&((node)->u.call)) ------------------ 5095| 0| env->options = save; 5096| 0| } 5097| 0| break; 5098| 0|#endif 5099| | 5100| 8.16k| case NT_QTFR: ------------------ | | 43| 8.16k|#define NT_QTFR 5 ------------------ | Branch (5100:3): [True: 8.16k, False: 34.6k] ------------------ 5101| 8.16k| { 5102| 8.16k| int i; 5103| 8.16k| OnigDistance min, max; 5104| 8.16k| NodeOptInfo nopt; 5105| 8.16k| QtfrNode* qn = NQTFR(node); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 5106| | 5107| 8.16k| r = optimize_node_left(qn->target, &nopt, env); 5108| 8.16k| if (r) break; ------------------ | Branch (5108:11): [True: 0, False: 8.16k] ------------------ 5109| | 5110| 8.16k| if (qn->lower == 0 && IS_REPEAT_INFINITE(qn->upper)) { ------------------ | | 422| 0|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 0|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5110:11): [True: 0, False: 8.16k] ------------------ 5111| 0| if (env->mmd.max == 0 && ------------------ | Branch (5111:6): [True: 0, False: 0] ------------------ 5112| 0| NTYPE(qn->target) == NT_CANY && qn->greedy) { ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ NTYPE(qn->target) == NT_CANY && qn->greedy) { ------------------ | | 41| 0|#define NT_CANY 3 ------------------ | Branch (5112:6): [True: 0, False: 0] | Branch (5112:38): [True: 0, False: 0] ------------------ 5113| 0| if (IS_MULTILINE(env->options)) ------------------ | | 395| 0|#define IS_MULTILINE(option) ((option) & ONIG_OPTION_MULTILINE) | | ------------------ | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (395:35): [True: 0, False: 0] | | ------------------ ------------------ 5114| | /* implicit anchor: /.*a/ ==> /\A.*a/ */ 5115| 0| add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_ML); ------------------ | | 557| 0|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ ------------------ 5116| 0| else 5117| 0| add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR); ------------------ | | 556| 0|#define ANCHOR_ANYCHAR_STAR (1<<14) /* ".*" optimize info */ ------------------ 5118| 0| } 5119| 0| } 5120| 8.16k| else { 5121| 8.16k| if (qn->lower > 0) { ------------------ | Branch (5121:6): [True: 8.16k, False: 0] ------------------ 5122| 8.16k| copy_node_opt_info(opt, &nopt); 5123| 8.16k| if (nopt.exb.len > 0) { ------------------ | Branch (5123:8): [True: 0, False: 8.16k] ------------------ 5124| 0| if (nopt.exb.reach_end) { ------------------ | Branch (5124:10): [True: 0, False: 0] ------------------ 5125| 0| for (i = 2; i <= qn->lower && ------------------ | Branch (5125:20): [True: 0, False: 0] ------------------ 5126| 0| ! is_full_opt_exact_info(&opt->exb); i++) { ------------------ | Branch (5126:6): [True: 0, False: 0] ------------------ 5127| 0| concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc); 5128| 0| } 5129| 0| if (i < qn->lower) { ------------------ | Branch (5129:12): [True: 0, False: 0] ------------------ 5130| 0| opt->exb.reach_end = 0; 5131| 0| } 5132| 0| } 5133| 0| } 5134| | 5135| 8.16k| if (qn->lower != qn->upper) { ------------------ | Branch (5135:8): [True: 8.16k, False: 0] ------------------ 5136| 8.16k| opt->exb.reach_end = 0; 5137| 8.16k| opt->exm.reach_end = 0; 5138| 8.16k| } 5139| 8.16k| if (qn->lower > 1) ------------------ | Branch (5139:8): [True: 0, False: 8.16k] ------------------ 5140| 0| opt->exm.reach_end = 0; 5141| 8.16k| } 5142| 8.16k| } 5143| | 5144| 8.16k| min = distance_multiply(nopt.len.min, qn->lower); 5145| 8.16k| if (IS_REPEAT_INFINITE(qn->upper)) ------------------ | | 422| 8.16k|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 8.16k|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 8.16k, False: 0] | | ------------------ ------------------ 5146| 8.16k| max = (nopt.len.max > 0 ? ONIG_INFINITE_DISTANCE : 0); ------------------ | | 85| 8.16k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (5146:9): [True: 8.16k, False: 0] ------------------ 5147| 0| else 5148| 0| max = distance_multiply(nopt.len.max, qn->upper); 5149| | 5150| 8.16k| set_mml(&opt->len, min, max); 5151| 8.16k| } 5152| 0| break; 5153| | 5154| 14.2k| case NT_ENCLOSE: ------------------ | | 44| 14.2k|#define NT_ENCLOSE 6 ------------------ | Branch (5154:3): [True: 14.2k, False: 28.5k] ------------------ 5155| 14.2k| { 5156| 14.2k| EncloseNode* en = NENCLOSE(node); ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5157| | 5158| 14.2k| switch (en->type) { ------------------ | Branch (5158:15): [True: 0, False: 14.2k] ------------------ 5159| 0| case ENCLOSE_OPTION: ------------------ | | 95| 0|#define ENCLOSE_OPTION (1<<1) ------------------ | Branch (5159:7): [True: 0, False: 14.2k] ------------------ 5160| 0| { 5161| 0| OnigOptionType save = env->options; 5162| | 5163| 0| env->options = en->option; 5164| 0| r = optimize_node_left(en->target, opt, env); 5165| 0| env->options = save; 5166| 0| } 5167| 0| break; 5168| | 5169| 8.16k| case ENCLOSE_MEMORY: ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (5169:7): [True: 8.16k, False: 6.12k] ------------------ 5170| 8.16k|#ifdef USE_SUBEXP_CALL 5171| 8.16k| en->opt_count++; 5172| 8.16k| if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) { ------------------ | | 4862| 8.16k|#define MAX_NODE_OPT_INFO_REF_COUNT 5 ------------------ | Branch (5172:6): [True: 0, False: 8.16k] ------------------ 5173| 0| OnigDistance min, max; 5174| | 5175| 0| min = 0; 5176| 0| max = ONIG_INFINITE_DISTANCE; ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 5177| 0| if (IS_ENCLOSE_MIN_FIXED(en)) min = en->min_len; ------------------ | | 152| 0|#define IS_ENCLOSE_MIN_FIXED(en) (((en)->state & NST_MIN_FIXED) != 0) | | ------------------ | | | | 128| 0|#define NST_MIN_FIXED (1<<0) | | ------------------ | | | Branch (152:40): [True: 0, False: 0] | | ------------------ ------------------ 5178| 0| if (IS_ENCLOSE_MAX_FIXED(en)) max = en->max_len; ------------------ | | 153| 0|#define IS_ENCLOSE_MAX_FIXED(en) (((en)->state & NST_MAX_FIXED) != 0) | | ------------------ | | | | 129| 0|#define NST_MAX_FIXED (1<<1) | | ------------------ | | | Branch (153:40): [True: 0, False: 0] | | ------------------ ------------------ 5179| 0| set_mml(&opt->len, min, max); 5180| 0| } 5181| 8.16k| else 5182| 8.16k|#endif 5183| 8.16k| { 5184| 8.16k| r = optimize_node_left(en->target, opt, env); 5185| | 5186| 8.16k| if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) { ------------------ | | 91| 8.16k|#define ANCHOR_ANYCHAR_STAR_MASK (ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML) | | ------------------ | | | | 556| 8.16k|#define ANCHOR_ANYCHAR_STAR (1<<14) /* ".*" optimize info */ | | ------------------ | | #define ANCHOR_ANYCHAR_STAR_MASK (ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML) | | ------------------ | | | | 557| 8.16k|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ | | ------------------ ------------------ | Branch (5186:8): [True: 0, False: 8.16k] ------------------ 5187| 0| if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 5188| 0| remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK); ------------------ | | 91| 0|#define ANCHOR_ANYCHAR_STAR_MASK (ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML) | | ------------------ | | | | 556| 0|#define ANCHOR_ANYCHAR_STAR (1<<14) /* ".*" optimize info */ | | ------------------ | | #define ANCHOR_ANYCHAR_STAR_MASK (ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML) | | ------------------ | | | | 557| 0|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ | | ------------------ ------------------ 5189| 0| } 5190| 8.16k| } 5191| 8.16k| break; 5192| | 5193| 6.12k| case ENCLOSE_STOP_BACKTRACK: ------------------ | | 96| 6.12k|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ | Branch (5193:7): [True: 6.12k, False: 8.16k] ------------------ 5194| 6.12k| case ENCLOSE_CONDITION: ------------------ | | 97| 6.12k|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (5194:7): [True: 0, False: 14.2k] ------------------ 5195| 6.12k| r = optimize_node_left(en->target, opt, env); 5196| 6.12k| break; 5197| | 5198| 0| case ENCLOSE_ABSENT: ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ | Branch (5198:7): [True: 0, False: 14.2k] ------------------ 5199| 0| set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE); ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ 5200| 0| break; 5201| 14.2k| } 5202| 14.2k| } 5203| 14.2k| break; 5204| | 5205| 14.2k| default: ------------------ | Branch (5205:3): [True: 0, False: 42.8k] ------------------ 5206| |#ifdef ONIG_DEBUG 5207| | fprintf(stderr, "optimize_node_left: undefined node type %d\n", 5208| | NTYPE(node)); 5209| |#endif 5210| 0| r = ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 5211| 0| break; 5212| 42.8k| } 5213| | 5214| 42.8k| return r; 5215| 42.8k|} regcomp.c:clear_node_opt_info: 4775| 42.8k|{ 4776| 42.8k| clear_mml(&opt->len); 4777| 42.8k| clear_opt_anc_info(&opt->anc); 4778| 42.8k| clear_opt_exact_info(&opt->exb); 4779| 42.8k| clear_opt_exact_info(&opt->exm); 4780| 42.8k| clear_opt_exact_info(&opt->expr); 4781| 42.8k| clear_opt_map_info(&opt->map); 4782| 42.8k|} regcomp.c:clear_opt_anc_info: 4427| 189k|{ 4428| 189k| anc->left_anchor = 0; 4429| 189k| anc->right_anchor = 0; 4430| 189k|} regcomp.c:clear_opt_exact_info: 4510| 128k|{ 4511| 128k| clear_mml(&ex->mmd); 4512| 128k| clear_opt_anc_info(&ex->anc); 4513| 128k| ex->reach_end = 0; 4514| 128k| ex->ignore_case = -1; /* unset */ 4515| 128k| ex->len = 0; 4516| 128k| ex->s[0] = '\0'; 4517| 128k|} regcomp.c:clear_opt_map_info: 4643| 42.8k|{ 4644| 42.8k| static const OptMapInfo clean_info = { 4645| 42.8k| {0, 0}, {0, 0}, 0, 4646| 42.8k| { 4647| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4648| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4649| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4650| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4651| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4652| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4653| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4654| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4655| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4656| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4657| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4658| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4659| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4660| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4661| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4662| 42.8k| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 4663| 42.8k| } 4664| 42.8k| }; 4665| | 4666| 42.8k| xmemcpy(map, &clean_info, sizeof(OptMapInfo)); ------------------ | | 215| 42.8k|#define xmemcpy memcpy ------------------ 4667| 42.8k|} regcomp.c:set_bound_node_opt_info: 4767| 42.8k|{ 4768| 42.8k| copy_mml(&(opt->exb.mmd), mmd); 4769| 42.8k| copy_mml(&(opt->expr.mmd), mmd); 4770| 42.8k| copy_mml(&(opt->map.mmd), mmd); 4771| 42.8k|} regcomp.c:copy_mml: 4391| 128k|{ 4392| 128k| to->min = from->min; 4393| 128k| to->max = from->max; 4394| 128k|} regcomp.c:copy_opt_env: 4421| 2.04k|{ 4422| 2.04k| *to = *from; 4423| 2.04k|} regcomp.c:add_mml: 4398| 36.7k|{ 4399| 36.7k| to->min = distance_add(to->min, from->min); 4400| 36.7k| to->max = distance_add(to->max, from->max); 4401| 36.7k|} regcomp.c:concat_left_node_opt_info: 4792| 18.3k|{ 4793| 18.3k| int exb_reach, exm_reach; 4794| 18.3k| OptAncInfo tanc; 4795| | 4796| 18.3k| concat_opt_anc_info(&tanc, &to->anc, &add->anc, to->len.max, add->len.max); 4797| 18.3k| copy_opt_anc_info(&to->anc, &tanc); 4798| | 4799| 18.3k| if (add->exb.len > 0 && to->len.max == 0) { ------------------ | Branch (4799:7): [True: 6.12k, False: 12.2k] | Branch (4799:27): [True: 0, False: 6.12k] ------------------ 4800| 0| concat_opt_anc_info(&tanc, &to->anc, &add->exb.anc, 4801| 0| to->len.max, add->len.max); 4802| 0| copy_opt_anc_info(&add->exb.anc, &tanc); 4803| 0| } 4804| | 4805| 18.3k| if (add->map.value > 0 && to->len.max == 0) { ------------------ | Branch (4805:7): [True: 6.12k, False: 12.2k] | Branch (4805:29): [True: 0, False: 6.12k] ------------------ 4806| 0| if (add->map.mmd.max == 0) ------------------ | Branch (4806:9): [True: 0, False: 0] ------------------ 4807| 0| add->map.anc.left_anchor |= to->anc.left_anchor; 4808| 0| } 4809| | 4810| 18.3k| exb_reach = to->exb.reach_end; 4811| 18.3k| exm_reach = to->exm.reach_end; 4812| | 4813| 18.3k| if (add->len.max != 0) ------------------ | Branch (4813:7): [True: 14.2k, False: 4.08k] ------------------ 4814| 14.2k| to->exb.reach_end = to->exm.reach_end = 0; 4815| | 4816| 18.3k| if (add->exb.len > 0) { ------------------ | Branch (4816:7): [True: 6.12k, False: 12.2k] ------------------ 4817| 6.12k| if (exb_reach) { ------------------ | Branch (4817:9): [True: 0, False: 6.12k] ------------------ 4818| 0| concat_opt_exact_info(&to->exb, &add->exb, enc); 4819| 0| clear_opt_exact_info(&add->exb); 4820| 0| } 4821| 6.12k| else if (exm_reach) { ------------------ | Branch (4821:14): [True: 0, False: 6.12k] ------------------ 4822| 0| concat_opt_exact_info(&to->exm, &add->exb, enc); 4823| 0| clear_opt_exact_info(&add->exb); 4824| 0| } 4825| 6.12k| } 4826| 18.3k| select_opt_exact_info(enc, &to->exm, &add->exb); 4827| 18.3k| select_opt_exact_info(enc, &to->exm, &add->exm); 4828| | 4829| 18.3k| if (to->expr.len > 0) { ------------------ | Branch (4829:7): [True: 0, False: 18.3k] ------------------ 4830| 0| if (add->len.max > 0) { ------------------ | Branch (4830:9): [True: 0, False: 0] ------------------ 4831| 0| if (to->expr.len > (int )add->len.max) ------------------ | Branch (4831:11): [True: 0, False: 0] ------------------ 4832| 0| to->expr.len = (int )add->len.max; 4833| | 4834| 0| if (to->expr.mmd.max == 0) ------------------ | Branch (4834:11): [True: 0, False: 0] ------------------ 4835| 0| select_opt_exact_info(enc, &to->exb, &to->expr); 4836| 0| else 4837| 0| select_opt_exact_info(enc, &to->exm, &to->expr); 4838| 0| } 4839| 0| } 4840| 18.3k| else if (add->expr.len > 0) { ------------------ | Branch (4840:12): [True: 0, False: 18.3k] ------------------ 4841| 0| copy_opt_exact_info(&to->expr, &add->expr); 4842| 0| } 4843| | 4844| 18.3k| select_opt_map_info(&to->map, &add->map); 4845| | 4846| 18.3k| add_mml(&to->len, &add->len); 4847| 18.3k|} regcomp.c:concat_opt_anc_info: 4441| 18.3k|{ 4442| 18.3k| clear_opt_anc_info(to); 4443| | 4444| 18.3k| to->left_anchor = left->left_anchor; 4445| 18.3k| if (left_len == 0) { ------------------ | Branch (4445:7): [True: 4.08k, False: 14.2k] ------------------ 4446| 4.08k| to->left_anchor |= right->left_anchor; 4447| 4.08k| } 4448| | 4449| 18.3k| to->right_anchor = right->right_anchor; 4450| 18.3k| if (right_len == 0) { ------------------ | Branch (4450:7): [True: 4.08k, False: 14.2k] ------------------ 4451| 4.08k| to->right_anchor |= left->right_anchor; 4452| 4.08k| } 4453| 14.2k| else { 4454| 14.2k| to->right_anchor |= (left->right_anchor & ANCHOR_PREC_READ_NOT); ------------------ | | 552| 14.2k|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ 4455| 14.2k| } 4456| 18.3k|} regcomp.c:copy_opt_anc_info: 4434| 18.3k|{ 4435| 18.3k| *to = *from; 4436| 18.3k|} regcomp.c:select_opt_map_info: 4708| 18.3k|{ 4709| 18.3k| const int z = 1<<15; /* 32768: something big value */ 4710| | 4711| 18.3k| int v1, v2; 4712| | 4713| 18.3k| if (alt->value == 0) return ; ------------------ | Branch (4713:7): [True: 12.2k, False: 6.12k] ------------------ 4714| 6.12k| if (now->value == 0) { ------------------ | Branch (4714:7): [True: 2.04k, False: 4.08k] ------------------ 4715| 2.04k| copy_opt_map_info(now, alt); 4716| 2.04k| return ; 4717| 2.04k| } 4718| | 4719| 4.08k| v1 = z / now->value; 4720| 4.08k| v2 = z / alt->value; 4721| 4.08k| if (comp_distance_value(&now->mmd, &alt->mmd, v1, v2) > 0) ------------------ | Branch (4721:7): [True: 0, False: 4.08k] ------------------ 4722| 0| copy_opt_map_info(now, alt); 4723| 4.08k|} regcomp.c:comp_distance_value: 4354| 10.2k|{ 4355| 10.2k| if (v2 <= 0) return -1; ------------------ | Branch (4355:7): [True: 0, False: 10.2k] ------------------ 4356| 10.2k| if (v1 <= 0) return 1; ------------------ | Branch (4356:7): [True: 0, False: 10.2k] ------------------ 4357| | 4358| 10.2k| v1 *= distance_value(d1); 4359| 10.2k| v2 *= distance_value(d2); 4360| | 4361| 10.2k| if (v2 > v1) return 1; ------------------ | Branch (4361:7): [True: 0, False: 10.2k] ------------------ 4362| 10.2k| if (v2 < v1) return -1; ------------------ | Branch (4362:7): [True: 0, False: 10.2k] ------------------ 4363| | 4364| 10.2k| if (d2->min < d1->min) return 1; ------------------ | Branch (4364:7): [True: 0, False: 10.2k] ------------------ 4365| 10.2k| if (d2->min > d1->min) return -1; ------------------ | Branch (4365:7): [True: 8.16k, False: 2.04k] ------------------ 4366| 2.04k| return 0; 4367| 10.2k|} regcomp.c:distance_value: 4325| 20.4k|{ 4326| | /* 1000 / (min-max-dist + 1) */ 4327| 20.4k| static const short int dist_vals[] = { 4328| 20.4k| 1000, 500, 333, 250, 200, 167, 143, 125, 111, 100, 4329| 20.4k| 91, 83, 77, 71, 67, 63, 59, 56, 53, 50, 4330| 20.4k| 48, 45, 43, 42, 40, 38, 37, 36, 34, 33, 4331| 20.4k| 32, 31, 30, 29, 29, 28, 27, 26, 26, 25, 4332| 20.4k| 24, 24, 23, 23, 22, 22, 21, 21, 20, 20, 4333| 20.4k| 20, 19, 19, 19, 18, 18, 18, 17, 17, 17, 4334| 20.4k| 16, 16, 16, 16, 15, 15, 15, 15, 14, 14, 4335| 20.4k| 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 4336| 20.4k| 12, 12, 12, 12, 12, 12, 11, 11, 11, 11, 4337| 20.4k| 11, 11, 11, 11, 11, 10, 10, 10, 10, 10 4338| 20.4k| }; 4339| | 4340| 20.4k| OnigDistance d; 4341| | 4342| 20.4k| if (mm->max == ONIG_INFINITE_DISTANCE) return 0; ------------------ | | 85| 20.4k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (4342:7): [True: 20.4k, False: 0] ------------------ 4343| | 4344| 0| d = mm->max - mm->min; 4345| 0| if (d < numberof(dist_vals)) ------------------ | | 129| 0|# define numberof(array) (int )(sizeof(array) / sizeof((array)[0])) ------------------ | Branch (4345:7): [True: 0, False: 0] ------------------ 4346| | /* return dist_vals[d] * 16 / (mm->min + 12); */ 4347| 0| return (int )dist_vals[d]; 4348| 0| else 4349| 0| return 1; 4350| 0|} regcomp.c:copy_node_opt_info: 4786| 8.16k|{ 4787| 8.16k| *to = *from; 4788| 8.16k|} regcomp.c:map_position_value: 4301| 14.2k|{ 4302| 14.2k| static const short int ByteValTable[] = { 4303| 14.2k| 5, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 10, 1, 1, 4304| 14.2k| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4305| 14.2k| 12, 4, 7, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 4306| 14.2k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 4307| 14.2k| 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4308| 14.2k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 5, 5, 5, 4309| 14.2k| 5, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 4310| 14.2k| 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1 4311| 14.2k| }; 4312| | 4313| 14.2k| if (i < numberof(ByteValTable)) { ------------------ | | 129| 14.2k|# define numberof(array) (int )(sizeof(array) / sizeof((array)[0])) ------------------ | Branch (4313:7): [True: 14.2k, False: 0] ------------------ 4314| 14.2k| if (i == 0 && ONIGENC_MBC_MINLEN(enc) > 1) ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (4314:9): [True: 0, False: 14.2k] | Branch (4314:19): [True: 0, False: 0] ------------------ 4315| 0| return 20; 4316| 14.2k| else 4317| 14.2k| return (int )ByteValTable[i]; 4318| 14.2k| } 4319| 0| else 4320| 0| return 4; /* Take it easy. */ 4321| 14.2k|} regcomp.c:concat_opt_exact_info_str: 4557| 6.12k|{ 4558| 6.12k| int i, j, len; 4559| 6.12k| UChar *p; ------------------ | | 76| 6.12k|# define UChar OnigUChar ------------------ 4560| | 4561| 12.2k| for (i = to->len, p = s; p < end && i < OPT_EXACT_MAXLEN; ) { ------------------ | | 89| 6.12k|#define OPT_EXACT_MAXLEN 24 /* This must be smaller than ONIG_CHAR_TABLE_SIZE. */ ------------------ | Branch (4561:28): [True: 6.12k, False: 6.12k] | Branch (4561:39): [True: 6.12k, False: 0] ------------------ 4562| 6.12k| len = enclen(enc, p, end); ------------------ | | 93| 6.12k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 6.12k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 6.12k] | | ------------------ ------------------ 4563| 6.12k| if (i + len > OPT_EXACT_MAXLEN) break; ------------------ | | 89| 6.12k|#define OPT_EXACT_MAXLEN 24 /* This must be smaller than ONIG_CHAR_TABLE_SIZE. */ ------------------ | Branch (4563:9): [True: 0, False: 6.12k] ------------------ 4564| 12.2k| for (j = 0; j < len && p < end; j++) ------------------ | Branch (4564:17): [True: 6.12k, False: 6.12k] | Branch (4564:28): [True: 6.12k, False: 0] ------------------ 4565| 6.12k| to->s[i++] = *p++; 4566| 6.12k| } 4567| | 4568| 6.12k| to->len = i; 4569| 6.12k|} regcomp.c:add_char_opt_map_info: 4677| 6.12k|{ 4678| 6.12k| if (map->map[c] == 0) { ------------------ | Branch (4678:7): [True: 6.12k, False: 0] ------------------ 4679| 6.12k| map->map[c] = 1; 4680| 6.12k| map->value += map_position_value(enc, c); 4681| 6.12k| } 4682| 6.12k|} regcomp.c:set_mml: 4378| 22.4k|{ 4379| 22.4k| mml->min = min; 4380| 22.4k| mml->max = max; 4381| 22.4k|} regcomp.c:add_opt_anc_info: 4479| 4.08k|{ 4480| 4.08k| if (is_left_anchor(anc)) ------------------ | Branch (4480:7): [True: 2.04k, False: 2.04k] ------------------ 4481| 2.04k| to->left_anchor |= anc; 4482| 2.04k| else 4483| 2.04k| to->right_anchor |= anc; 4484| 4.08k|} regcomp.c:is_left_anchor: 4460| 4.08k|{ 4461| 4.08k| if (anc == ANCHOR_END_BUF || anc == ANCHOR_SEMI_END_BUF || ------------------ | | 543| 8.16k|#define ANCHOR_END_BUF (1<<3) ------------------ if (anc == ANCHOR_END_BUF || anc == ANCHOR_SEMI_END_BUF || ------------------ | | 544| 8.16k|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ | Branch (4461:7): [True: 0, False: 4.08k] | Branch (4461:32): [True: 0, False: 4.08k] ------------------ 4462| 4.08k| anc == ANCHOR_END_LINE || anc == ANCHOR_PREC_READ || ------------------ | | 545| 8.16k|#define ANCHOR_END_LINE (1<<5) ------------------ anc == ANCHOR_END_LINE || anc == ANCHOR_PREC_READ || ------------------ | | 551| 6.12k|#define ANCHOR_PREC_READ (1<<10) ------------------ | Branch (4462:7): [True: 2.04k, False: 2.04k] | Branch (4462:33): [True: 0, False: 2.04k] ------------------ 4463| 4.08k| anc == ANCHOR_PREC_READ_NOT) ------------------ | | 552| 2.04k|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (4463:7): [True: 0, False: 2.04k] ------------------ 4464| 2.04k| return 0; 4465| | 4466| 2.04k| return 1; 4467| 4.08k|} regcomp.c:copy_opt_exact_info: 4521| 4.08k|{ 4522| 4.08k| *to = *from; 4523| 4.08k|} regcomp.c:copy_opt_map_info: 4671| 2.04k|{ 4672| 2.04k| *to = *from; 4673| 2.04k|} regcomp.c:is_set_opt_anc_info: 4471| 8.16k|{ 4472| 8.16k| if ((to->left_anchor & anc) != 0) return 1; ------------------ | Branch (4472:7): [True: 0, False: 8.16k] ------------------ 4473| | 4474| 8.16k| return ((to->right_anchor & anc) != 0 ? 1 : 0); ------------------ | Branch (4474:11): [True: 0, False: 8.16k] ------------------ 4475| 8.16k|} regcomp.c:select_opt_exact_info: 4612| 38.7k|{ 4613| 38.7k| int v1, v2; 4614| | 4615| 38.7k| v1 = now->len; 4616| 38.7k| v2 = alt->len; 4617| | 4618| 38.7k| if (v2 == 0) { ------------------ | Branch (4618:7): [True: 30.6k, False: 8.16k] ------------------ 4619| 30.6k| return ; 4620| 30.6k| } 4621| 8.16k| else if (v1 == 0) { ------------------ | Branch (4621:12): [True: 4.08k, False: 4.08k] ------------------ 4622| 4.08k| copy_opt_exact_info(now, alt); 4623| 4.08k| return ; 4624| 4.08k| } 4625| 4.08k| else if (v1 <= 2 && v2 <= 2) { ------------------ | Branch (4625:12): [True: 4.08k, False: 0] | Branch (4625:23): [True: 4.08k, False: 0] ------------------ 4626| | /* ByteValTable[x] is big value --> low price */ 4627| 4.08k| v2 = map_position_value(enc, now->s[0]); 4628| 4.08k| v1 = map_position_value(enc, alt->s[0]); 4629| | 4630| 4.08k| if (now->len > 1) v1 += 5; ------------------ | Branch (4630:9): [True: 0, False: 4.08k] ------------------ 4631| 4.08k| if (alt->len > 1) v2 += 5; ------------------ | Branch (4631:9): [True: 0, False: 4.08k] ------------------ 4632| 4.08k| } 4633| | 4634| 4.08k| if (now->ignore_case <= 0) v1 *= 2; ------------------ | Branch (4634:7): [True: 4.08k, False: 0] ------------------ 4635| 4.08k| if (alt->ignore_case <= 0) v2 *= 2; ------------------ | Branch (4635:7): [True: 4.08k, False: 0] ------------------ 4636| | 4637| 4.08k| if (comp_distance_value(&now->mmd, &alt->mmd, v1, v2) > 0) ------------------ | Branch (4637:7): [True: 0, False: 4.08k] ------------------ 4638| 0| copy_opt_exact_info(now, alt); 4639| 4.08k|} regcomp.c:comp_opt_exact_or_map_info: 4727| 2.04k|{ 4728| 2.04k|#define COMP_EM_BASE 20 4729| 2.04k| int ve, vm; 4730| | 4731| 2.04k| if (m->value <= 0) return -1; ------------------ | Branch (4731:7): [True: 0, False: 2.04k] ------------------ 4732| | 4733| 2.04k| ve = COMP_EM_BASE * e->len * (e->ignore_case > 0 ? 1 : 2); ------------------ | | 4728| 2.04k|#define COMP_EM_BASE 20 ------------------ | Branch (4733:33): [True: 0, False: 2.04k] ------------------ 4734| 2.04k| vm = COMP_EM_BASE * 5 * 2 / m->value; ------------------ | | 4728| 2.04k|#define COMP_EM_BASE 20 ------------------ 4735| 2.04k| return comp_distance_value(&e->mmd, &m->mmd, ve, vm); 4736| 2.04k|} regcomp.c:set_optimize_exact_info: 5219| 2.04k|{ 5220| 2.04k| int allow_reverse; 5221| | 5222| 2.04k| if (e->len == 0) return 0; ------------------ | Branch (5222:7): [True: 0, False: 2.04k] ------------------ 5223| | 5224| 2.04k| reg->exact = (UChar* )xmalloc(e->len); ------------------ | | 142| 2.04k|# define xmalloc malloc ------------------ 5225| 2.04k| CHECK_NULL_RETURN_MEMERR(reg->exact); ------------------ | | 314| 2.04k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 2.04k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5226| 2.04k| xmemcpy(reg->exact, e->s, e->len); ------------------ | | 215| 2.04k|#define xmemcpy memcpy ------------------ 5227| 2.04k| reg->exact_end = reg->exact + e->len; 5228| | 5229| 2.04k| allow_reverse = 5230| 2.04k| ONIGENC_IS_ALLOWED_REVERSE_MATCH(reg->enc, reg->exact, reg->exact_end); ------------------ | | 335| 2.04k| (enc)->is_allowed_reverse_match(s,end,enc) ------------------ 5231| | 5232| 2.04k| if (e->ignore_case > 0) { ------------------ | Branch (5232:7): [True: 0, False: 2.04k] ------------------ 5233| 0| if (e->len >= 3 || (e->len >= 2 && allow_reverse)) { ------------------ | Branch (5233:9): [True: 0, False: 0] | Branch (5233:25): [True: 0, False: 0] | Branch (5233:40): [True: 0, False: 0] ------------------ 5234| 0| e->len = set_bm_skip(reg->exact, reg->exact_end, reg, 5235| 0| reg->map, 1); 5236| 0| reg->exact_end = reg->exact + e->len; 5237| 0| if (e->len >= 3) { ------------------ | Branch (5237:11): [True: 0, False: 0] ------------------ 5238| 0| reg->optimize = (allow_reverse != 0 ------------------ | Branch (5238:19): [True: 0, False: 0] ------------------ 5239| 0| ? ONIG_OPTIMIZE_EXACT_BM_IC : ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC); ------------------ | | 361| 0|#define ONIG_OPTIMIZE_EXACT_BM_IC 6 /* BM (ignore case) */ ------------------ ? ONIG_OPTIMIZE_EXACT_BM_IC : ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC); ------------------ | | 362| 0|#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC 7 /* BM (applied to a multibyte string) (ignore case) */ ------------------ 5240| 0| } 5241| 0| else if (e->len > 0) { ------------------ | Branch (5241:16): [True: 0, False: 0] ------------------ 5242| 0| reg->optimize = ONIG_OPTIMIZE_EXACT_IC; ------------------ | | 359| 0|#define ONIG_OPTIMIZE_EXACT_IC 4 /* Slow Search (ignore case) */ ------------------ 5243| 0| } 5244| 0| else 5245| 0| return 0; 5246| 0| } 5247| 0| else { 5248| 0| reg->optimize = ONIG_OPTIMIZE_EXACT_IC; ------------------ | | 359| 0|#define ONIG_OPTIMIZE_EXACT_IC 4 /* Slow Search (ignore case) */ ------------------ 5249| 0| } 5250| 0| } 5251| 2.04k| else { 5252| 2.04k| if (e->len >= 3 || (e->len >= 2 && allow_reverse)) { ------------------ | Branch (5252:9): [True: 0, False: 2.04k] | Branch (5252:25): [True: 0, False: 2.04k] | Branch (5252:40): [True: 0, False: 0] ------------------ 5253| 0| set_bm_skip(reg->exact, reg->exact_end, reg, 5254| 0| reg->map, 0); 5255| 0| reg->optimize = (allow_reverse != 0 ------------------ | Branch (5255:24): [True: 0, False: 0] ------------------ 5256| 0| ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV); ------------------ | | 357| 0|#define ONIG_OPTIMIZE_EXACT_BM 2 /* Boyer Moore Search */ ------------------ ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV); ------------------ | | 358| 0|#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV 3 /* BM (applied to a multibyte string) */ ------------------ 5257| 0| } 5258| 2.04k| else { 5259| 2.04k| reg->optimize = ONIG_OPTIMIZE_EXACT; ------------------ | | 356| 2.04k|#define ONIG_OPTIMIZE_EXACT 1 /* Slow Search */ ------------------ 5260| 2.04k| } 5261| 2.04k| } 5262| | 5263| 2.04k| reg->dmin = e->mmd.min; 5264| 2.04k| reg->dmax = e->mmd.max; 5265| | 5266| 2.04k| if (reg->dmin != ONIG_INFINITE_DISTANCE) { ------------------ | | 85| 2.04k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (5266:7): [True: 2.04k, False: 0] ------------------ 5267| 2.04k| reg->threshold_len = (int )(reg->dmin + (reg->exact_end - reg->exact)); 5268| 2.04k| } 5269| | 5270| 2.04k| return 0; 5271| 2.04k|} regcomp.c:set_sub_anchor: 5292| 2.04k|{ 5293| 2.04k| reg->sub_anchor |= anc->left_anchor & ANCHOR_BEGIN_LINE; ------------------ | | 541| 2.04k|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ 5294| 2.04k| reg->sub_anchor |= anc->right_anchor & ANCHOR_END_LINE; ------------------ | | 545| 2.04k|#define ANCHOR_END_LINE (1<<5) ------------------ 5295| 2.04k|} regcomp.c:compile_tree: 1688| 42.8k|{ 1689| 42.8k| int n, type, len, pos, r = 0; 1690| | 1691| 42.8k| type = NTYPE(node); ------------------ | | 69| 42.8k|#define NTYPE(node) ((node)->u.base.type) ------------------ 1692| 42.8k| switch (type) { 1693| 2.04k| case NT_LIST: ------------------ | | 46| 2.04k|#define NT_LIST 8 ------------------ | Branch (1693:3): [True: 2.04k, False: 40.8k] ------------------ 1694| 18.3k| do { 1695| 18.3k| r = compile_tree(NCAR(node), reg); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1696| 18.3k| } while (r == 0 && IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 18.3k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 16.3k, False: 2.04k] | | ------------------ ------------------ | Branch (1696:14): [True: 18.3k, False: 0] ------------------ 1697| 2.04k| break; 1698| | 1699| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (1699:3): [True: 0, False: 42.8k] ------------------ 1700| 0| { 1701| 0| Node* x = node; 1702| 0| len = 0; 1703| 0| do { 1704| 0| len += compile_length_tree(NCAR(x), reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1705| 0| if (NCDR(x) != NULL) { ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ | Branch (1705:6): [True: 0, False: 0] ------------------ 1706| 0| len += SIZE_OP_PUSH + SIZE_OP_JUMP; ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ len += SIZE_OP_PUSH + SIZE_OP_JUMP; ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1707| 0| } 1708| 0| } while (IS_NOT_NULL(x = NCDR(x))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1709| 0| pos = reg->used + len; /* goal position */ 1710| | 1711| 0| do { 1712| 0| len = compile_length_tree(NCAR(node), reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1713| 0| if (IS_NOT_NULL(NCDR(node))) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1714| 0| r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1715| 0| if (r) break; ------------------ | Branch (1715:8): [True: 0, False: 0] ------------------ 1716| 0| } 1717| 0| r = compile_tree(NCAR(node), reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1718| 0| if (r) break; ------------------ | Branch (1718:6): [True: 0, False: 0] ------------------ 1719| 0| if (IS_NOT_NULL(NCDR(node))) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1720| 0| len = pos - (reg->used + SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1721| 0| r = add_opcode_rel_addr(reg, OP_JUMP, len); 1722| 0| if (r) break; ------------------ | Branch (1722:8): [True: 0, False: 0] ------------------ 1723| 0| } 1724| 0| } while (IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1725| 0| } 1726| 0| break; 1727| | 1728| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (1728:3): [True: 6.12k, False: 36.7k] ------------------ 1729| 6.12k| if (NSTRING_IS_RAW(node)) ------------------ | | 114| 6.12k|#define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) | | ------------------ | | | | 104| 6.12k|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ | | | Branch (114:39): [True: 0, False: 6.12k] | | ------------------ ------------------ 1730| 0| r = compile_string_raw_node(NSTR(node), reg); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1731| 6.12k| else 1732| 6.12k| r = compile_string_node(node, reg); 1733| 6.12k| break; 1734| | 1735| 12.2k| case NT_CCLASS: ------------------ | | 39| 12.2k|#define NT_CCLASS 1 ------------------ | Branch (1735:3): [True: 12.2k, False: 30.6k] ------------------ 1736| 12.2k| r = compile_cclass_node(NCCLASS(node), reg); ------------------ | | 77| 12.2k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 1737| 12.2k| break; 1738| | 1739| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (1739:3): [True: 0, False: 42.8k] ------------------ 1740| 0| { 1741| 0| int op; 1742| | 1743| 0| switch (NCTYPE(node)->ctype) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ 1744| 0| case ONIGENC_CTYPE_WORD: ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (1744:7): [True: 0, False: 0] ------------------ 1745| 0| if (NCTYPE(node)->ascii_range != 0) { ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (1745:6): [True: 0, False: 0] ------------------ 1746| 0| if (NCTYPE(node)->not != 0) op = OP_NOT_ASCII_WORD; ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (1746:8): [True: 0, False: 0] ------------------ 1747| 0| else op = OP_ASCII_WORD; 1748| 0| } 1749| 0| else { 1750| 0| if (NCTYPE(node)->not != 0) op = OP_NOT_WORD; ------------------ | | 78| 0|#define NCTYPE(node) (&((node)->u.ctype)) ------------------ | Branch (1750:8): [True: 0, False: 0] ------------------ 1751| 0| else op = OP_WORD; 1752| 0| } 1753| 0| break; 1754| 0| default: ------------------ | Branch (1754:7): [True: 0, False: 0] ------------------ 1755| 0| return ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1756| 0| break; 1757| 0| } 1758| 0| r = add_opcode(reg, op); 1759| 0| } 1760| 0| break; 1761| | 1762| 2.04k| case NT_CANY: ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (1762:3): [True: 2.04k, False: 40.8k] ------------------ 1763| 2.04k| if (IS_MULTILINE(reg->options)) ------------------ | | 395| 2.04k|#define IS_MULTILINE(option) ((option) & ONIG_OPTION_MULTILINE) | | ------------------ | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (395:35): [True: 0, False: 2.04k] | | ------------------ ------------------ 1764| 0| r = add_opcode(reg, OP_ANYCHAR_ML); 1765| 2.04k| else 1766| 2.04k| r = add_opcode(reg, OP_ANYCHAR); 1767| 2.04k| break; 1768| | 1769| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (1769:3): [True: 0, False: 42.8k] ------------------ 1770| 0| { 1771| 0| BRefNode* br = NBREF(node); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 1772| | 1773| 0|#ifdef USE_BACKREF_WITH_LEVEL 1774| 0| if (IS_BACKREF_NEST_LEVEL(br)) { ------------------ | | 164| 0|#define IS_BACKREF_NEST_LEVEL(bn) (((bn)->state & NST_NEST_LEVEL) != 0) | | ------------------ | | | | 141| 0|#define NST_NEST_LEVEL (1<<13) | | ------------------ | | | Branch (164:40): [True: 0, False: 0] | | ------------------ ------------------ 1775| 0| r = add_opcode(reg, OP_BACKREF_WITH_LEVEL); 1776| 0| if (r) return r; ------------------ | Branch (1776:6): [True: 0, False: 0] ------------------ 1777| 0| r = add_option(reg, (reg->options & ONIG_OPTION_IGNORECASE)); ------------------ | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U ------------------ 1778| 0| if (r) return r; ------------------ | Branch (1778:6): [True: 0, False: 0] ------------------ 1779| 0| r = add_length(reg, br->nest_level); 1780| 0| if (r) return r; ------------------ | Branch (1780:6): [True: 0, False: 0] ------------------ 1781| | 1782| 0| goto add_bacref_mems; 1783| 0| } 1784| 0| else 1785| 0|#endif 1786| 0| if (br->back_num == 1) { ------------------ | Branch (1786:11): [True: 0, False: 0] ------------------ 1787| 0| n = br->back_static[0]; 1788| 0| if (IS_IGNORECASE(reg->options)) { ------------------ | | 396| 0|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (396:35): [True: 0, False: 0] | | ------------------ ------------------ 1789| 0| r = add_opcode(reg, OP_BACKREFN_IC); 1790| 0| if (r) return r; ------------------ | Branch (1790:8): [True: 0, False: 0] ------------------ 1791| 0| r = add_mem_num(reg, n); 1792| 0| } 1793| 0| else { 1794| 0| switch (n) { 1795| 0| case 1: r = add_opcode(reg, OP_BACKREF1); break; ------------------ | Branch (1795:4): [True: 0, False: 0] ------------------ 1796| 0| case 2: r = add_opcode(reg, OP_BACKREF2); break; ------------------ | Branch (1796:4): [True: 0, False: 0] ------------------ 1797| 0| default: ------------------ | Branch (1797:4): [True: 0, False: 0] ------------------ 1798| 0| r = add_opcode(reg, OP_BACKREFN); 1799| 0| if (r) return r; ------------------ | Branch (1799:10): [True: 0, False: 0] ------------------ 1800| 0| r = add_mem_num(reg, n); 1801| 0| break; 1802| 0| } 1803| 0| } 1804| 0| } 1805| 0| else { 1806| 0| int i; 1807| 0| int* p; 1808| | 1809| 0| if (IS_IGNORECASE(reg->options)) { ------------------ | | 396| 0|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (396:35): [True: 0, False: 0] | | ------------------ ------------------ 1810| 0| r = add_opcode(reg, OP_BACKREF_MULTI_IC); 1811| 0| } 1812| 0| else { 1813| 0| r = add_opcode(reg, OP_BACKREF_MULTI); 1814| 0| } 1815| 0| if (r) return r; ------------------ | Branch (1815:6): [True: 0, False: 0] ------------------ 1816| | 1817| 0|#ifdef USE_BACKREF_WITH_LEVEL 1818| 0| add_bacref_mems: 1819| 0|#endif 1820| 0| r = add_length(reg, br->back_num); 1821| 0| if (r) return r; ------------------ | Branch (1821:6): [True: 0, False: 0] ------------------ 1822| 0| p = BACKREFS_P(br); ------------------ | | 120| 0| (IS_NOT_NULL((br)->back_dynamic) ? (br)->back_dynamic : (br)->back_static); | | ------------------ | | | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1823| 0| for (i = br->back_num - 1; i >= 0; i--) { ------------------ | Branch (1823:29): [True: 0, False: 0] ------------------ 1824| 0| r = add_mem_num(reg, p[i]); 1825| 0| if (r) return r; ------------------ | Branch (1825:8): [True: 0, False: 0] ------------------ 1826| 0| } 1827| 0| } 1828| 0| } 1829| 0| break; 1830| | 1831| 0|#ifdef USE_SUBEXP_CALL 1832| 0| case NT_CALL: ------------------ | | 48| 0|#define NT_CALL 10 ------------------ | Branch (1832:3): [True: 0, False: 42.8k] ------------------ 1833| 0| r = compile_call(NCALL(node), reg); ------------------ | | 84| 0|#define NCALL(node) (&((node)->u.call)) ------------------ 1834| 0| break; 1835| 0|#endif 1836| | 1837| 2.04k| case NT_QTFR: ------------------ | | 43| 2.04k|#define NT_QTFR 5 ------------------ | Branch (1837:3): [True: 2.04k, False: 40.8k] ------------------ 1838| 2.04k| r = compile_quantifier_node(NQTFR(node), reg); ------------------ | | 80| 2.04k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1839| 2.04k| break; 1840| | 1841| 14.2k| case NT_ENCLOSE: ------------------ | | 44| 14.2k|#define NT_ENCLOSE 6 ------------------ | Branch (1841:3): [True: 14.2k, False: 28.5k] ------------------ 1842| 14.2k| r = compile_enclose_node(NENCLOSE(node), reg); ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1843| 14.2k| break; 1844| | 1845| 4.08k| case NT_ANCHOR: ------------------ | | 45| 4.08k|#define NT_ANCHOR 7 ------------------ | Branch (1845:3): [True: 4.08k, False: 38.7k] ------------------ 1846| 4.08k| r = compile_anchor_node(NANCHOR(node), reg); ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1847| 4.08k| break; 1848| | 1849| 0| default: ------------------ | Branch (1849:3): [True: 0, False: 42.8k] ------------------ 1850| |#ifdef ONIG_DEBUG 1851| | fprintf(stderr, "compile_tree: undefined node type %d\n", NTYPE(node)); 1852| |#endif 1853| 0| break; 1854| 42.8k| } 1855| | 1856| 42.8k| return r; 1857| 42.8k|} regcomp.c:compile_length_tree: 1593| 8.16k|{ 1594| 8.16k| int len, type, r; 1595| | 1596| 8.16k| type = NTYPE(node); ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ 1597| 8.16k| switch (type) { 1598| 0| case NT_LIST: ------------------ | | 46| 0|#define NT_LIST 8 ------------------ | Branch (1598:3): [True: 0, False: 8.16k] ------------------ 1599| 0| len = 0; 1600| 0| do { 1601| 0| r = compile_length_tree(NCAR(node), reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1602| 0| if (r < 0) return r; ------------------ | Branch (1602:11): [True: 0, False: 0] ------------------ 1603| 0| len += r; 1604| 0| } while (IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1605| 0| r = len; 1606| 0| break; 1607| | 1608| 0| case NT_ALT: ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (1608:3): [True: 0, False: 8.16k] ------------------ 1609| 0| { 1610| 0| int n = 0; 1611| 0| len = 0; 1612| 0| do { 1613| 0| r = compile_length_tree(NCAR(node), reg); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1614| 0| if (r < 0) return r; ------------------ | Branch (1614:6): [True: 0, False: 0] ------------------ 1615| 0| len += r; 1616| 0| n++; 1617| 0| } while (IS_NOT_NULL(node = NCDR(node))); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1618| 0| r = len; 1619| 0| r += (SIZE_OP_PUSH + SIZE_OP_JUMP) * (n - 1); ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ r += (SIZE_OP_PUSH + SIZE_OP_JUMP) * (n - 1); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1620| 0| } 1621| 0| break; 1622| | 1623| 0| case NT_STR: ------------------ | | 38| 0|#define NT_STR 0 ------------------ | Branch (1623:3): [True: 0, False: 8.16k] ------------------ 1624| 0| if (NSTRING_IS_RAW(node)) ------------------ | | 114| 0|#define NSTRING_IS_RAW(node) (((node)->u.str.flag & NSTR_RAW) != 0) | | ------------------ | | | | 104| 0|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ | | | Branch (114:39): [True: 0, False: 0] | | ------------------ ------------------ 1625| 0| r = compile_length_string_raw_node(NSTR(node), reg); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1626| 0| else 1627| 0| r = compile_length_string_node(node, reg); 1628| 0| break; 1629| | 1630| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (1630:3): [True: 6.12k, False: 2.04k] ------------------ 1631| 6.12k| r = compile_length_cclass_node(NCCLASS(node), reg); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 1632| 6.12k| break; 1633| | 1634| 0| case NT_CTYPE: ------------------ | | 40| 0|#define NT_CTYPE 2 ------------------ | Branch (1634:3): [True: 0, False: 8.16k] ------------------ 1635| 2.04k| case NT_CANY: ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (1635:3): [True: 2.04k, False: 6.12k] ------------------ 1636| 2.04k| r = SIZE_OPCODE; ------------------ | | 688| 2.04k|#define SIZE_OPCODE 1 ------------------ 1637| 2.04k| break; 1638| | 1639| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (1639:3): [True: 0, False: 8.16k] ------------------ 1640| 0| { 1641| 0| BRefNode* br = NBREF(node); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 1642| | 1643| 0|#ifdef USE_BACKREF_WITH_LEVEL 1644| 0| if (IS_BACKREF_NEST_LEVEL(br)) { ------------------ | | 164| 0|#define IS_BACKREF_NEST_LEVEL(bn) (((bn)->state & NST_NEST_LEVEL) != 0) | | ------------------ | | | | 141| 0|#define NST_NEST_LEVEL (1<<13) | | ------------------ | | | Branch (164:40): [True: 0, False: 0] | | ------------------ ------------------ 1645| 0| r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH + ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH + ------------------ | | 695| 0|#define SIZE_OPTION (int )sizeof(OnigOptionType) ------------------ r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH + ------------------ | | 691| 0|#define SIZE_LENGTH (int )sizeof(LengthType) ------------------ 1646| 0| SIZE_LENGTH + (SIZE_MEMNUM * br->back_num); ------------------ | | 691| 0|#define SIZE_LENGTH (int )sizeof(LengthType) ------------------ SIZE_LENGTH + (SIZE_MEMNUM * br->back_num); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 1647| 0| } 1648| 0| else 1649| 0|#endif 1650| 0| if (br->back_num == 1) { ------------------ | Branch (1650:11): [True: 0, False: 0] ------------------ 1651| 0| r = ((!IS_IGNORECASE(reg->options) && br->back_static[0] <= 2) ------------------ | | 396| 0|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ ------------------ | Branch (1651:8): [True: 0, False: 0] | Branch (1651:40): [True: 0, False: 0] ------------------ 1652| 0| ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM)); ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM)); ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM)); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 1653| 0| } 1654| 0| else { 1655| 0| r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num); ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num); ------------------ | | 691| 0|#define SIZE_LENGTH (int )sizeof(LengthType) ------------------ r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 1656| 0| } 1657| 0| } 1658| 0| break; 1659| | 1660| 0|#ifdef USE_SUBEXP_CALL 1661| 0| case NT_CALL: ------------------ | | 48| 0|#define NT_CALL 10 ------------------ | Branch (1661:3): [True: 0, False: 8.16k] ------------------ 1662| 0| r = SIZE_OP_CALL; ------------------ | | 747| 0|#define SIZE_OP_CALL (SIZE_OPCODE + SIZE_ABSADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_CALL (SIZE_OPCODE + SIZE_ABSADDR) | | ------------------ | | | | 690| 0|#define SIZE_ABSADDR (int )sizeof(AbsAddrType) | | ------------------ ------------------ 1663| 0| break; 1664| 0|#endif 1665| | 1666| 0| case NT_QTFR: ------------------ | | 43| 0|#define NT_QTFR 5 ------------------ | Branch (1666:3): [True: 0, False: 8.16k] ------------------ 1667| 0| r = compile_length_quantifier_node(NQTFR(node), reg); ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1668| 0| break; 1669| | 1670| 0| case NT_ENCLOSE: ------------------ | | 44| 0|#define NT_ENCLOSE 6 ------------------ | Branch (1670:3): [True: 0, False: 8.16k] ------------------ 1671| 0| r = compile_length_enclose_node(NENCLOSE(node), reg); ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1672| 0| break; 1673| | 1674| 0| case NT_ANCHOR: ------------------ | | 45| 0|#define NT_ANCHOR 7 ------------------ | Branch (1674:3): [True: 0, False: 8.16k] ------------------ 1675| 0| r = compile_length_anchor_node(NANCHOR(node), reg); ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1676| 0| break; 1677| | 1678| 0| default: ------------------ | Branch (1678:3): [True: 0, False: 8.16k] ------------------ 1679| 0| return ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1680| 0| break; 1681| 8.16k| } 1682| | 1683| 8.16k| return r; 1684| 8.16k|} regcomp.c:select_str_opcode: 321| 6.12k|{ 322| 6.12k| int op; 323| 6.12k| OnigDistance str_len = (byte_len + mb_len - 1) / mb_len; 324| | 325| 6.12k| if (ignore_case) { ------------------ | Branch (325:7): [True: 0, False: 6.12k] ------------------ 326| 0| switch (str_len) { 327| 0| case 1: op = OP_EXACT1_IC; break; ------------------ | Branch (327:5): [True: 0, False: 0] ------------------ 328| 0| default: op = OP_EXACTN_IC; break; ------------------ | Branch (328:5): [True: 0, False: 0] ------------------ 329| 0| } 330| 0| } 331| 6.12k| else { 332| 6.12k| switch (mb_len) { 333| 6.12k| case 1: ------------------ | Branch (333:5): [True: 6.12k, False: 0] ------------------ 334| 6.12k| switch (str_len) { 335| 6.12k| case 1: op = OP_EXACT1; break; ------------------ | Branch (335:7): [True: 6.12k, False: 0] ------------------ 336| 0| case 2: op = OP_EXACT2; break; ------------------ | Branch (336:7): [True: 0, False: 6.12k] ------------------ 337| 0| case 3: op = OP_EXACT3; break; ------------------ | Branch (337:7): [True: 0, False: 6.12k] ------------------ 338| 0| case 4: op = OP_EXACT4; break; ------------------ | Branch (338:7): [True: 0, False: 6.12k] ------------------ 339| 0| case 5: op = OP_EXACT5; break; ------------------ | Branch (339:7): [True: 0, False: 6.12k] ------------------ 340| 0| default: op = OP_EXACTN; break; ------------------ | Branch (340:7): [True: 0, False: 6.12k] ------------------ 341| 6.12k| } 342| 6.12k| break; 343| | 344| 6.12k| case 2: ------------------ | Branch (344:5): [True: 0, False: 6.12k] ------------------ 345| 0| switch (str_len) { 346| 0| case 1: op = OP_EXACTMB2N1; break; ------------------ | Branch (346:7): [True: 0, False: 0] ------------------ 347| 0| case 2: op = OP_EXACTMB2N2; break; ------------------ | Branch (347:7): [True: 0, False: 0] ------------------ 348| 0| case 3: op = OP_EXACTMB2N3; break; ------------------ | Branch (348:7): [True: 0, False: 0] ------------------ 349| 0| default: op = OP_EXACTMB2N; break; ------------------ | Branch (349:7): [True: 0, False: 0] ------------------ 350| 0| } 351| 0| break; 352| | 353| 0| case 3: ------------------ | Branch (353:5): [True: 0, False: 6.12k] ------------------ 354| 0| op = OP_EXACTMB3N; 355| 0| break; 356| | 357| 0| default: ------------------ | Branch (357:5): [True: 0, False: 6.12k] ------------------ 358| 0| op = OP_EXACTMBN; 359| 0| break; 360| 6.12k| } 361| 6.12k| } 362| 6.12k| return op; 363| 6.12k|} regcomp.c:compile_length_cclass_node: 587| 6.12k|{ 588| 6.12k| int len; 589| | 590| 6.12k| if (IS_NULL(cc->mbuf)) { ------------------ | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 6.12k, False: 0] | | ------------------ ------------------ 591| 6.12k| len = SIZE_OPCODE + SIZE_BITSET; ------------------ | | 688| 6.12k|#define SIZE_OPCODE 1 ------------------ len = SIZE_OPCODE + SIZE_BITSET; ------------------ | | 438| 6.12k|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 592| 6.12k| } 593| 0| else { 594| 0| if (ONIGENC_MBC_MINLEN(reg->enc) > 1 || bitset_is_empty(cc->bs)) { ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (594:9): [True: 0, False: 0] | Branch (594:45): [True: 0, False: 0] ------------------ 595| 0| len = SIZE_OPCODE; ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ 596| 0| } 597| 0| else { 598| 0| len = SIZE_OPCODE + SIZE_BITSET; ------------------ | | 688| 0|#define SIZE_OPCODE 1 ------------------ len = SIZE_OPCODE + SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 599| 0| } 600| 0|#ifdef PLATFORM_UNALIGNED_WORD_ACCESS 601| 0| len += SIZE_LENGTH + cc->mbuf->used; ------------------ | | 691| 0|#define SIZE_LENGTH (int )sizeof(LengthType) ------------------ 602| |#else 603| | len += SIZE_LENGTH + cc->mbuf->used + (WORD_ALIGNMENT_SIZE - 1); 604| |#endif 605| 0| } 606| | 607| 6.12k| return len; 608| 6.12k|} regcomp.c:add_opcode_rel_addr: 277| 12.2k|{ 278| 12.2k| int r; 279| | 280| 12.2k| r = add_opcode(reg, opcode); 281| 12.2k| if (r) return r; ------------------ | Branch (281:7): [True: 0, False: 12.2k] ------------------ 282| 12.2k| r = add_rel_addr(reg, addr); 283| 12.2k| return r; 284| 12.2k|} regcomp.c:add_rel_addr: 223| 12.2k|{ 224| 12.2k| RelAddrType ra = (RelAddrType )addr; 225| | 226| 12.2k| BBUF_ADD(reg, &ra, SIZE_RELADDR); ------------------ | | 504| 12.2k|#define BBUF_ADD(buf,bytes,n) BBUF_WRITE((buf),(buf)->used,(bytes),(n)) | | ------------------ | | | | 490| 12.2k|#define BBUF_WRITE(buf,pos,bytes,n) do{\ | | | | 491| 12.2k| int used = (pos) + (int )(n);\ | | | | 492| 12.2k| if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\ | | | | ------------------ | | | | | | 470| 0|#define BBUF_EXPAND(buf,low) do{\ | | | | | | 471| 0| UChar *tmp;\ | | | | | | ------------------ | | | | | | | | 76| 0|# define UChar OnigUChar | | | | | | ------------------ | | | | | | 472| 0| do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\ | | | | | | ------------------ | | | | | | | Branch (472:36): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 473| 0| tmp = (UChar* )xrealloc((buf)->p, (buf)->alloc);\ | | | | | | ------------------ | | | | | | | | 143| 0|# define xrealloc realloc | | | | | | ------------------ | | | | | | 474| 0| if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | | | ------------------ | | | | | | | | | Branch (311:39): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 632| 0|#define ONIGERR_MEMORY -5 | | | | | | ------------------ | | | | | | 475| 0| (buf)->p = tmp;\ | | | | | | 476| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (476:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (492:7): [True: 0, False: 12.2k] | | | | ------------------ | | | | 493| 12.2k| xmemcpy((buf)->p + (pos), (bytes), (n));\ | | | | ------------------ | | | | | | 215| 12.2k|#define xmemcpy memcpy | | | | ------------------ | | | | 494| 12.2k| if ((buf)->used < (unsigned int )used) (buf)->used = used;\ | | | | ------------------ | | | | | Branch (494:7): [True: 12.2k, False: 0] | | | | ------------------ | | | | 495| 12.2k|} while (0) | | | | ------------------ | | | | | Branch (495:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 12.2k| return 0; 228| 12.2k|} regcomp.c:add_compile_string: 444| 6.12k|{ 445| 6.12k| int op = select_str_opcode(mb_len, byte_len, ignore_case); 446| 6.12k| add_opcode(reg, op); 447| | 448| 6.12k| if (op == OP_EXACTMBN) ------------------ | Branch (448:7): [True: 0, False: 6.12k] ------------------ 449| 0| add_length(reg, mb_len); 450| | 451| 6.12k| if (IS_NEED_STR_LEN_OP_EXACT(op)) { ------------------ | | 316| 6.12k| ((op) == OP_EXACTN || (op) == OP_EXACTMB2N ||\ | | ------------------ | | | Branch (316:5): [True: 0, False: 6.12k] | | | Branch (316:29): [True: 0, False: 6.12k] | | ------------------ | | 317| 6.12k| (op) == OP_EXACTMB3N || (op) == OP_EXACTMBN || (op) == OP_EXACTN_IC) | | ------------------ | | | Branch (317:5): [True: 0, False: 6.12k] | | | Branch (317:29): [True: 0, False: 6.12k] | | | Branch (317:53): [True: 0, False: 6.12k] | | ------------------ ------------------ 452| 0| if (op == OP_EXACTN_IC) ------------------ | Branch (452:9): [True: 0, False: 0] ------------------ 453| 0| add_length(reg, byte_len); 454| 0| else 455| 0| add_length(reg, byte_len / mb_len); 456| 0| } 457| | 458| 6.12k| add_bytes(reg, s, byte_len); 459| 6.12k| return 0; 460| 6.12k|} regcomp.c:add_bytes: 288| 6.12k|{ 289| 6.12k| BBUF_ADD(reg, bytes, len); ------------------ | | 504| 6.12k|#define BBUF_ADD(buf,bytes,n) BBUF_WRITE((buf),(buf)->used,(bytes),(n)) | | ------------------ | | | | 490| 6.12k|#define BBUF_WRITE(buf,pos,bytes,n) do{\ | | | | 491| 6.12k| int used = (pos) + (int )(n);\ | | | | 492| 6.12k| if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\ | | | | ------------------ | | | | | | 470| 0|#define BBUF_EXPAND(buf,low) do{\ | | | | | | 471| 0| UChar *tmp;\ | | | | | | ------------------ | | | | | | | | 76| 0|# define UChar OnigUChar | | | | | | ------------------ | | | | | | 472| 0| do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\ | | | | | | ------------------ | | | | | | | Branch (472:36): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 473| 0| tmp = (UChar* )xrealloc((buf)->p, (buf)->alloc);\ | | | | | | ------------------ | | | | | | | | 143| 0|# define xrealloc realloc | | | | | | ------------------ | | | | | | 474| 0| if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | | | ------------------ | | | | | | | | | Branch (311:39): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 632| 0|#define ONIGERR_MEMORY -5 | | | | | | ------------------ | | | | | | 475| 0| (buf)->p = tmp;\ | | | | | | 476| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (476:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (492:7): [True: 0, False: 6.12k] | | | | ------------------ | | | | 493| 6.12k| xmemcpy((buf)->p + (pos), (bytes), (n));\ | | | | ------------------ | | | | | | 215| 6.12k|#define xmemcpy memcpy | | | | ------------------ | | | | 494| 6.12k| if ((buf)->used < (unsigned int )used) (buf)->used = used;\ | | | | ------------------ | | | | | Branch (494:7): [True: 6.12k, False: 0] | | | | ------------------ | | | | 495| 6.12k|} while (0) | | | | ------------------ | | | | | Branch (495:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 290| 6.12k| return 0; 291| 6.12k|} regcomp.c:compile_string_node: 513| 6.12k|{ 514| 6.12k| int r, len, prev_len, blen, ambig; 515| 6.12k| OnigEncoding enc = reg->enc; 516| 6.12k| UChar *p, *prev, *end; ------------------ | | 76| 6.12k|# define UChar OnigUChar ------------------ 517| 6.12k| StrNode* sn; 518| | 519| 6.12k| sn = NSTR(node); ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 520| 6.12k| if (sn->end <= sn->s) ------------------ | Branch (520:7): [True: 0, False: 6.12k] ------------------ 521| 0| return 0; 522| | 523| 6.12k| end = sn->end; 524| 6.12k| ambig = NSTRING_IS_AMBIG(node); ------------------ | | 115| 6.12k|#define NSTRING_IS_AMBIG(node) (((node)->u.str.flag & NSTR_AMBIG) != 0) | | ------------------ | | | | 105| 6.12k|#define NSTR_AMBIG (1<<1) | | ------------------ ------------------ 525| | 526| 6.12k| p = prev = sn->s; 527| 6.12k| prev_len = enclen(enc, p, end); ------------------ | | 93| 6.12k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 6.12k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 6.12k] | | ------------------ ------------------ 528| 6.12k| p += prev_len; 529| 6.12k| blen = prev_len; 530| | 531| 6.12k| for (; p < end; ) { ------------------ | Branch (531:10): [True: 0, False: 6.12k] ------------------ 532| 0| len = enclen(enc, p, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 533| 0| if (len == prev_len || ambig) { ------------------ | Branch (533:9): [True: 0, False: 0] | Branch (533:28): [True: 0, False: 0] ------------------ 534| 0| blen += len; 535| 0| } 536| 0| else { 537| 0| r = add_compile_string(prev, prev_len, blen, reg, ambig); 538| 0| if (p + len > end) { ------------------ | Branch (538:11): [True: 0, False: 0] ------------------ 539| 0| return 0; 540| 0| } 541| 0| if (r) return r; ------------------ | Branch (541:11): [True: 0, False: 0] ------------------ 542| | 543| 0| prev = p; 544| 0| blen = len; 545| 0| prev_len = len; 546| 0| } 547| | 548| 0| p += len; 549| 0| } 550| 6.12k| return add_compile_string(prev, prev_len, blen, reg, ambig); 551| 6.12k|} regcomp.c:compile_cclass_node: 612| 12.2k|{ 613| 12.2k| int r; 614| | 615| 12.2k| if (IS_NULL(cc->mbuf)) { ------------------ | | 311| 12.2k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 12.2k, False: 0] | | ------------------ ------------------ 616| 12.2k| if (IS_NCCLASS_NOT(cc)) ------------------ | | 809| 12.2k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 12.2k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 12.2k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 12.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 617| 12.2k| add_opcode(reg, OP_CCLASS_NOT); 618| 0| else 619| 0| add_opcode(reg, OP_CCLASS); 620| | 621| 12.2k| r = add_bitset(reg, cc->bs); 622| 12.2k| } 623| 0| else { 624| 0| if (ONIGENC_MBC_MINLEN(reg->enc) > 1 || bitset_is_empty(cc->bs)) { ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (624:9): [True: 0, False: 0] | Branch (624:45): [True: 0, False: 0] ------------------ 625| 0| if (IS_NCCLASS_NOT(cc)) ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 626| 0| add_opcode(reg, OP_CCLASS_MB_NOT); 627| 0| else 628| 0| add_opcode(reg, OP_CCLASS_MB); 629| | 630| 0| r = add_multi_byte_cclass(cc->mbuf, reg); 631| 0| } 632| 0| else { 633| 0| if (IS_NCCLASS_NOT(cc)) ------------------ | | 809| 0|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 0|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 634| 0| add_opcode(reg, OP_CCLASS_MIX_NOT); 635| 0| else 636| 0| add_opcode(reg, OP_CCLASS_MIX); 637| | 638| 0| r = add_bitset(reg, cc->bs); 639| 0| if (r) return r; ------------------ | Branch (639:11): [True: 0, False: 0] ------------------ 640| 0| r = add_multi_byte_cclass(cc->mbuf, reg); 641| 0| } 642| 0| } 643| | 644| 12.2k| return r; 645| 12.2k|} regcomp.c:add_bitset: 295| 12.2k|{ 296| 12.2k| BBUF_ADD(reg, bs, SIZE_BITSET); ------------------ | | 504| 12.2k|#define BBUF_ADD(buf,bytes,n) BBUF_WRITE((buf),(buf)->used,(bytes),(n)) | | ------------------ | | | | 490| 12.2k|#define BBUF_WRITE(buf,pos,bytes,n) do{\ | | | | 491| 12.2k| int used = (pos) + (int )(n);\ | | | | 492| 12.2k| if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\ | | | | ------------------ | | | | | | 470| 4.08k|#define BBUF_EXPAND(buf,low) do{\ | | | | | | 471| 4.08k| UChar *tmp;\ | | | | | | ------------------ | | | | | | | | 76| 4.08k|# define UChar OnigUChar | | | | | | ------------------ | | | | | | 472| 4.08k| do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\ | | | | | | ------------------ | | | | | | | Branch (472:36): [True: 0, False: 4.08k] | | | | | | ------------------ | | | | | | 473| 4.08k| tmp = (UChar* )xrealloc((buf)->p, (buf)->alloc);\ | | | | | | ------------------ | | | | | | | | 143| 4.08k|# define xrealloc realloc | | | | | | ------------------ | | | | | | 474| 4.08k| if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 311| 4.08k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | | | ------------------ | | | | | | | | | Branch (311:39): [True: 0, False: 4.08k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 632| 0|#define ONIGERR_MEMORY -5 | | | | | | ------------------ | | | | | | 475| 4.08k| (buf)->p = tmp;\ | | | | | | 476| 4.08k|} while (0) | | | | | | ------------------ | | | | | | | Branch (476:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (492:7): [True: 4.08k, False: 8.16k] | | | | ------------------ | | | | 493| 12.2k| xmemcpy((buf)->p + (pos), (bytes), (n));\ | | | | ------------------ | | | | | | 215| 12.2k|#define xmemcpy memcpy | | | | ------------------ | | | | 494| 12.2k| if ((buf)->used < (unsigned int )used) (buf)->used = used;\ | | | | ------------------ | | | | | Branch (494:7): [True: 12.2k, False: 0] | | | | ------------------ | | | | 495| 12.2k|} while (0) | | | | ------------------ | | | | | Branch (495:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 297| 12.2k| return 0; 298| 12.2k|} regcomp.c:add_mem_num: 250| 16.3k|{ 251| 16.3k| MemNumType n = (MemNumType )num; 252| | 253| 16.3k| BBUF_ADD(reg, &n, SIZE_MEMNUM); ------------------ | | 504| 16.3k|#define BBUF_ADD(buf,bytes,n) BBUF_WRITE((buf),(buf)->used,(bytes),(n)) | | ------------------ | | | | 490| 16.3k|#define BBUF_WRITE(buf,pos,bytes,n) do{\ | | | | 491| 16.3k| int used = (pos) + (int )(n);\ | | | | 492| 16.3k| if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\ | | | | ------------------ | | | | | | 470| 0|#define BBUF_EXPAND(buf,low) do{\ | | | | | | 471| 0| UChar *tmp;\ | | | | | | ------------------ | | | | | | | | 76| 0|# define UChar OnigUChar | | | | | | ------------------ | | | | | | 472| 0| do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\ | | | | | | ------------------ | | | | | | | Branch (472:36): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 473| 0| tmp = (UChar* )xrealloc((buf)->p, (buf)->alloc);\ | | | | | | ------------------ | | | | | | | | 143| 0|# define xrealloc realloc | | | | | | ------------------ | | | | | | 474| 0| if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | | | ------------------ | | | | | | | | | Branch (311:39): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 632| 0|#define ONIGERR_MEMORY -5 | | | | | | ------------------ | | | | | | 475| 0| (buf)->p = tmp;\ | | | | | | 476| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (476:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (492:7): [True: 0, False: 16.3k] | | | | ------------------ | | | | 493| 16.3k| xmemcpy((buf)->p + (pos), (bytes), (n));\ | | | | ------------------ | | | | | | 215| 16.3k|#define xmemcpy memcpy | | | | ------------------ | | | | 494| 16.3k| if ((buf)->used < (unsigned int )used) (buf)->used = used;\ | | | | ------------------ | | | | | Branch (494:7): [True: 16.3k, False: 0] | | | | ------------------ | | | | 495| 16.3k|} while (0) | | | | ------------------ | | | | | Branch (495:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 254| 16.3k| return 0; 255| 16.3k|} regcomp.c:compile_quantifier_node: 1033| 2.04k|{ 1034| 2.04k| int i, r, mod_tlen; 1035| 2.04k| int infinite = IS_REPEAT_INFINITE(qn->upper); ------------------ | | 422| 2.04k|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 2.04k|#define REPEAT_INFINITE -1 | | ------------------ ------------------ 1036| 2.04k| int empty_info = qn->target_empty_info; 1037| 2.04k| int tlen = compile_length_tree(qn->target, reg); 1038| | 1039| 2.04k| if (tlen < 0) return tlen; ------------------ | Branch (1039:7): [True: 0, False: 2.04k] ------------------ 1040| | 1041| 2.04k| if (is_anychar_star_quantifier(qn)) { ------------------ | Branch (1041:7): [True: 2.04k, False: 0] ------------------ 1042| 2.04k| r = compile_tree_n_times(qn->target, qn->lower, reg); 1043| 2.04k| if (r) return r; ------------------ | Branch (1043:9): [True: 0, False: 2.04k] ------------------ 1044| 2.04k| if (IS_NOT_NULL(qn->next_head_exact)) { ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 2.04k] | | ------------------ ------------------ 1045| 0| if (IS_MULTILINE(reg->options)) ------------------ | | 395| 0|#define IS_MULTILINE(option) ((option) & ONIG_OPTION_MULTILINE) | | ------------------ | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (395:35): [True: 0, False: 0] | | ------------------ ------------------ 1046| 0| r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT); 1047| 0| else 1048| 0| r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT); 1049| 0| if (r) return r; ------------------ | Branch (1049:11): [True: 0, False: 0] ------------------ 1050| 0| return add_bytes(reg, NSTR(qn->next_head_exact)->s, 1); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1051| 0| } 1052| 2.04k| else { 1053| 2.04k| if (IS_MULTILINE(reg->options)) ------------------ | | 395| 2.04k|#define IS_MULTILINE(option) ((option) & ONIG_OPTION_MULTILINE) | | ------------------ | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | ------------------ | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | ------------------ | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (395:35): [True: 0, False: 2.04k] | | ------------------ ------------------ 1054| 0| return add_opcode(reg, OP_ANYCHAR_ML_STAR); 1055| 2.04k| else 1056| 2.04k| return add_opcode(reg, OP_ANYCHAR_STAR); 1057| 2.04k| } 1058| 2.04k| } 1059| | 1060| 0| if (empty_info != 0) ------------------ | Branch (1060:7): [True: 0, False: 0] ------------------ 1061| 0| mod_tlen = tlen + (SIZE_OP_NULL_CHECK_START + SIZE_OP_NULL_CHECK_END); ------------------ | | 742| 0|#define SIZE_OP_NULL_CHECK_START (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_NULL_CHECK_START (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ mod_tlen = tlen + (SIZE_OP_NULL_CHECK_START + SIZE_OP_NULL_CHECK_END); ------------------ | | 743| 0|#define SIZE_OP_NULL_CHECK_END (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_NULL_CHECK_END (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ 1062| 0| else 1063| 0| mod_tlen = tlen; 1064| | 1065| 0| if (infinite && ------------------ | Branch (1065:7): [True: 0, False: 0] ------------------ 1066| 0| (qn->lower <= 1 || tlen * qn->lower <= QUANTIFIER_EXPAND_LIMIT_SIZE)) { ------------------ | | 724| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 50 ------------------ | Branch (1066:8): [True: 0, False: 0] | Branch (1066:26): [True: 0, False: 0] ------------------ 1067| 0| if (qn->lower == 1 && tlen > QUANTIFIER_EXPAND_LIMIT_SIZE) { ------------------ | | 724| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 50 ------------------ | Branch (1067:9): [True: 0, False: 0] | Branch (1067:27): [True: 0, False: 0] ------------------ 1068| 0| if (qn->greedy) { ------------------ | Branch (1068:11): [True: 0, False: 0] ------------------ 1069| |#ifdef USE_OP_PUSH_OR_JUMP_EXACT 1070| | if (IS_NOT_NULL(qn->head_exact)) 1071| | r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1); 1072| | else 1073| |#endif 1074| 0| if (IS_NOT_NULL(qn->next_head_exact)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1075| 0| r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT); ------------------ | | 724| 0|#define SIZE_OP_PUSH_IF_PEEK_NEXT (SIZE_OPCODE + SIZE_RELADDR + 1) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH_IF_PEEK_NEXT (SIZE_OPCODE + SIZE_RELADDR + 1) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1076| 0| else 1077| 0| r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH); ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1078| 0| } 1079| 0| else { 1080| 0| r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1081| 0| } 1082| 0| if (r) return r; ------------------ | Branch (1082:11): [True: 0, False: 0] ------------------ 1083| 0| } 1084| 0| else { 1085| 0| r = compile_tree_n_times(qn->target, qn->lower, reg); 1086| 0| if (r) return r; ------------------ | Branch (1086:11): [True: 0, False: 0] ------------------ 1087| 0| } 1088| | 1089| 0| if (qn->greedy) { ------------------ | Branch (1089:9): [True: 0, False: 0] ------------------ 1090| |#ifdef USE_OP_PUSH_OR_JUMP_EXACT 1091| | if (IS_NOT_NULL(qn->head_exact)) { 1092| | r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1, 1093| | mod_tlen + SIZE_OP_JUMP); 1094| | if (r) return r; 1095| | add_bytes(reg, NSTR(qn->head_exact)->s, 1); 1096| | r = compile_tree_empty_check(qn->target, reg, empty_info); 1097| | if (r) return r; 1098| | r = add_opcode_rel_addr(reg, OP_JUMP, 1099| | -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1)); 1100| | } 1101| | else 1102| |#endif 1103| 0| if (IS_NOT_NULL(qn->next_head_exact)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1104| 0| r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT, 1105| 0| mod_tlen + SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1106| 0| if (r) return r; ------------------ | Branch (1106:6): [True: 0, False: 0] ------------------ 1107| 0| add_bytes(reg, NSTR(qn->next_head_exact)->s, 1); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1108| 0| r = compile_tree_empty_check(qn->target, reg, empty_info); 1109| 0| if (r) return r; ------------------ | Branch (1109:6): [True: 0, False: 0] ------------------ 1110| 0| r = add_opcode_rel_addr(reg, OP_JUMP, 1111| 0| -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_IF_PEEK_NEXT)); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_IF_PEEK_NEXT)); ------------------ | | 724| 0|#define SIZE_OP_PUSH_IF_PEEK_NEXT (SIZE_OPCODE + SIZE_RELADDR + 1) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH_IF_PEEK_NEXT (SIZE_OPCODE + SIZE_RELADDR + 1) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1112| 0| } 1113| 0| else { 1114| 0| r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1115| 0| if (r) return r; ------------------ | Branch (1115:6): [True: 0, False: 0] ------------------ 1116| 0| r = compile_tree_empty_check(qn->target, reg, empty_info); 1117| 0| if (r) return r; ------------------ | Branch (1117:6): [True: 0, False: 0] ------------------ 1118| 0| r = add_opcode_rel_addr(reg, OP_JUMP, 1119| 0| -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH)); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH)); ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1120| 0| } 1121| 0| } 1122| 0| else { 1123| 0| r = add_opcode_rel_addr(reg, OP_JUMP, mod_tlen); 1124| 0| if (r) return r; ------------------ | Branch (1124:11): [True: 0, False: 0] ------------------ 1125| 0| r = compile_tree_empty_check(qn->target, reg, empty_info); 1126| 0| if (r) return r; ------------------ | Branch (1126:11): [True: 0, False: 0] ------------------ 1127| 0| r = add_opcode_rel_addr(reg, OP_PUSH, -(mod_tlen + (int )SIZE_OP_PUSH)); ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1128| 0| } 1129| 0| } 1130| 0| else if (qn->upper == 0 && qn->is_referred != 0) { /* /(?..){0}/ */ ------------------ | Branch (1130:12): [True: 0, False: 0] | Branch (1130:30): [True: 0, False: 0] ------------------ 1131| 0| r = add_opcode_rel_addr(reg, OP_JUMP, tlen); 1132| 0| if (r) return r; ------------------ | Branch (1132:9): [True: 0, False: 0] ------------------ 1133| 0| r = compile_tree(qn->target, reg); 1134| 0| } 1135| 0| else if (!infinite && qn->greedy && ------------------ | Branch (1135:12): [True: 0, False: 0] | Branch (1135:25): [True: 0, False: 0] ------------------ 1136| 0| (qn->upper == 1 || (tlen + SIZE_OP_PUSH) * qn->upper ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ | Branch (1136:13): [True: 0, False: 0] | Branch (1136:31): [True: 0, False: 0] ------------------ 1137| 0| <= QUANTIFIER_EXPAND_LIMIT_SIZE)) { ------------------ | | 724| 0|#define QUANTIFIER_EXPAND_LIMIT_SIZE 50 ------------------ 1138| 0| int n = qn->upper - qn->lower; 1139| | 1140| 0| r = compile_tree_n_times(qn->target, qn->lower, reg); 1141| 0| if (r) return r; ------------------ | Branch (1141:9): [True: 0, False: 0] ------------------ 1142| | 1143| 0| for (i = 0; i < n; i++) { ------------------ | Branch (1143:17): [True: 0, False: 0] ------------------ 1144| 0| r = add_opcode_rel_addr(reg, OP_PUSH, 1145| 0| (n - i) * tlen + (n - i - 1) * SIZE_OP_PUSH); ------------------ | | 721| 0|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1146| 0| if (r) return r; ------------------ | Branch (1146:11): [True: 0, False: 0] ------------------ 1147| 0| r = compile_tree(qn->target, reg); 1148| 0| if (r) return r; ------------------ | Branch (1148:11): [True: 0, False: 0] ------------------ 1149| 0| } 1150| 0| } 1151| 0| else if (!qn->greedy && qn->upper == 1 && qn->lower == 0) { /* '??' */ ------------------ | Branch (1151:12): [True: 0, False: 0] | Branch (1151:27): [True: 0, False: 0] | Branch (1151:45): [True: 0, False: 0] ------------------ 1152| 0| r = add_opcode_rel_addr(reg, OP_PUSH, SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1153| 0| if (r) return r; ------------------ | Branch (1153:9): [True: 0, False: 0] ------------------ 1154| 0| r = add_opcode_rel_addr(reg, OP_JUMP, tlen); 1155| 0| if (r) return r; ------------------ | Branch (1155:9): [True: 0, False: 0] ------------------ 1156| 0| r = compile_tree(qn->target, reg); 1157| 0| } 1158| 0| else { 1159| 0| r = compile_range_repeat_node(qn, mod_tlen, empty_info, reg); 1160| 0| } 1161| 0| return r; 1162| 0|} regcomp.c:is_anychar_star_quantifier: 716| 2.04k|{ 717| 2.04k| if (qn->greedy && IS_REPEAT_INFINITE(qn->upper) && ------------------ | | 422| 4.08k|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 2.04k|#define REPEAT_INFINITE -1 | | ------------------ | | | Branch (422:33): [True: 2.04k, False: 0] | | ------------------ ------------------ | Branch (717:7): [True: 2.04k, False: 0] ------------------ 718| 2.04k| NTYPE(qn->target) == NT_CANY) ------------------ | | 69| 2.04k|#define NTYPE(node) ((node)->u.base.type) ------------------ NTYPE(qn->target) == NT_CANY) ------------------ | | 41| 2.04k|#define NT_CANY 3 ------------------ | Branch (718:7): [True: 2.04k, False: 0] ------------------ 719| 2.04k| return 1; 720| 0| else 721| 0| return 0; 722| 2.04k|} regcomp.c:compile_tree_n_times: 414| 8.16k|{ 415| 8.16k| int i, r; 416| | 417| 16.3k| for (i = 0; i < n; i++) { ------------------ | Branch (417:15): [True: 8.16k, False: 8.16k] ------------------ 418| 8.16k| r = compile_tree(node, reg); 419| 8.16k| if (r) return r; ------------------ | Branch (419:9): [True: 0, False: 8.16k] ------------------ 420| 8.16k| } 421| 8.16k| return 0; 422| 8.16k|} regcomp.c:compile_enclose_node: 1308| 14.2k|{ 1309| 14.2k| int r, len; 1310| | 1311| 14.2k| if (node->type == ENCLOSE_OPTION) ------------------ | | 95| 14.2k|#define ENCLOSE_OPTION (1<<1) ------------------ | Branch (1311:7): [True: 0, False: 14.2k] ------------------ 1312| 0| return compile_option_node(node, reg); 1313| | 1314| 14.2k| switch (node->type) { 1315| 8.16k| case ENCLOSE_MEMORY: ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (1315:3): [True: 8.16k, False: 6.12k] ------------------ 1316| 8.16k|#ifdef USE_SUBEXP_CALL 1317| 8.16k| if (IS_ENCLOSE_CALLED(node)) { ------------------ | | 147| 8.16k|#define IS_ENCLOSE_CALLED(en) (((en)->state & NST_CALLED) != 0) | | ------------------ | | | | 136| 8.16k|#define NST_CALLED (1<<8) | | ------------------ | | | Branch (147:40): [True: 0, False: 8.16k] | | ------------------ ------------------ 1318| 0| r = add_opcode(reg, OP_CALL); 1319| 0| if (r) return r; ------------------ | Branch (1319:11): [True: 0, False: 0] ------------------ 1320| 0| node->call_addr = BBUF_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP; ------------------ | | 507| 0|#define BBUF_GET_OFFSET_POS(buf) ((buf)->used) ------------------ node->call_addr = BBUF_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP; ------------------ | | 690| 0|#define SIZE_ABSADDR (int )sizeof(AbsAddrType) ------------------ node->call_addr = BBUF_GET_OFFSET_POS(reg) + SIZE_ABSADDR + SIZE_OP_JUMP; ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1321| 0| node->state |= NST_ADDR_FIXED; ------------------ | | 137| 0|#define NST_ADDR_FIXED (1<<9) ------------------ 1322| 0| r = add_abs_addr(reg, (int )node->call_addr); 1323| 0| if (r) return r; ------------------ | Branch (1323:11): [True: 0, False: 0] ------------------ 1324| 0| len = compile_length_tree(node->target, reg); 1325| 0| len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN); ------------------ | | 735| 0|#define SIZE_OP_MEMORY_START_PUSH (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_MEMORY_START_PUSH (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN); ------------------ | | 748| 0|#define SIZE_OP_RETURN SIZE_OPCODE | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ ------------------ 1326| 0| if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 1327| 0| len += (IS_ENCLOSE_RECURSION(node) ------------------ | | 149| 0|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 0] | | ------------------ ------------------ 1328| 0| ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH); ------------------ | | 737| 0|#define SIZE_OP_MEMORY_END_PUSH_REC (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_MEMORY_END_PUSH_REC (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH); ------------------ | | 736| 0|#define SIZE_OP_MEMORY_END_PUSH (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_MEMORY_END_PUSH (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ 1329| 0| else 1330| 0| len += (IS_ENCLOSE_RECURSION(node) ------------------ | | 149| 0|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 0] | | ------------------ ------------------ 1331| 0| ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END); ------------------ | | 739| 0|#define SIZE_OP_MEMORY_END_REC (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_MEMORY_END_REC (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END); ------------------ | | 738| 0|#define SIZE_OP_MEMORY_END (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_MEMORY_END (SIZE_OPCODE + SIZE_MEMNUM) | | ------------------ | | | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) | | ------------------ ------------------ 1332| | 1333| 0| r = add_opcode_rel_addr(reg, OP_JUMP, len); 1334| 0| if (r) return r; ------------------ | Branch (1334:11): [True: 0, False: 0] ------------------ 1335| 0| } 1336| 8.16k|#endif 1337| 8.16k| if (BIT_STATUS_AT(reg->bt_mem_start, node->regnum)) ------------------ | | 371| 8.16k| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 8.16k|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 8.16k] | | | Branch (371:4): [True: 8.16k, False: 0] | | ------------------ ------------------ 1338| 0| r = add_opcode(reg, OP_MEMORY_START_PUSH); 1339| 8.16k| else 1340| 8.16k| r = add_opcode(reg, OP_MEMORY_START); 1341| 8.16k| if (r) return r; ------------------ | Branch (1341:9): [True: 0, False: 8.16k] ------------------ 1342| 8.16k| r = add_mem_num(reg, node->regnum); 1343| 8.16k| if (r) return r; ------------------ | Branch (1343:9): [True: 0, False: 8.16k] ------------------ 1344| 8.16k| r = compile_tree(node->target, reg); 1345| 8.16k| if (r) return r; ------------------ | Branch (1345:9): [True: 0, False: 8.16k] ------------------ 1346| 8.16k|#ifdef USE_SUBEXP_CALL 1347| 8.16k| if (IS_ENCLOSE_CALLED(node)) { ------------------ | | 147| 8.16k|#define IS_ENCLOSE_CALLED(en) (((en)->state & NST_CALLED) != 0) | | ------------------ | | | | 136| 8.16k|#define NST_CALLED (1<<8) | | ------------------ | | | Branch (147:40): [True: 0, False: 8.16k] | | ------------------ ------------------ 1348| 0| if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 1349| 0| r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node) ------------------ | | 149| 0|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 0] | | ------------------ ------------------ 1350| 0| ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH)); 1351| 0| else 1352| 0| r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node) ------------------ | | 149| 0|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 0|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 0] | | ------------------ ------------------ 1353| 0| ? OP_MEMORY_END_REC : OP_MEMORY_END)); 1354| | 1355| 0| if (r) return r; ------------------ | Branch (1355:11): [True: 0, False: 0] ------------------ 1356| 0| r = add_mem_num(reg, node->regnum); 1357| 0| if (r) return r; ------------------ | Branch (1357:11): [True: 0, False: 0] ------------------ 1358| 0| r = add_opcode(reg, OP_RETURN); 1359| 0| } 1360| 8.16k| else if (IS_ENCLOSE_RECURSION(node)) { ------------------ | | 149| 8.16k|#define IS_ENCLOSE_RECURSION(en) (((en)->state & NST_RECURSION) != 0) | | ------------------ | | | | 135| 8.16k|#define NST_RECURSION (1<<7) | | ------------------ | | | Branch (149:40): [True: 0, False: 8.16k] | | ------------------ ------------------ 1361| 0| if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 1362| 0| r = add_opcode(reg, OP_MEMORY_END_PUSH_REC); 1363| 0| else 1364| 0| r = add_opcode(reg, OP_MEMORY_END_REC); 1365| 0| if (r) return r; ------------------ | Branch (1365:11): [True: 0, False: 0] ------------------ 1366| 0| r = add_mem_num(reg, node->regnum); 1367| 0| } 1368| 8.16k| else 1369| 8.16k|#endif 1370| 8.16k| { 1371| 8.16k| if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)) ------------------ | | 371| 8.16k| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 8.16k|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 8.16k] | | | Branch (371:4): [True: 8.16k, False: 0] | | ------------------ ------------------ 1372| 0| r = add_opcode(reg, OP_MEMORY_END_PUSH); 1373| 8.16k| else 1374| 8.16k| r = add_opcode(reg, OP_MEMORY_END); 1375| 8.16k| if (r) return r; ------------------ | Branch (1375:11): [True: 0, False: 8.16k] ------------------ 1376| 8.16k| r = add_mem_num(reg, node->regnum); 1377| 8.16k| } 1378| 8.16k| break; 1379| | 1380| 8.16k| case ENCLOSE_STOP_BACKTRACK: ------------------ | | 96| 6.12k|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ | Branch (1380:3): [True: 6.12k, False: 8.16k] ------------------ 1381| 6.12k| if (IS_ENCLOSE_STOP_BT_SIMPLE_REPEAT(node)) { ------------------ | | 156| 6.12k| (((en)->state & NST_STOP_BT_SIMPLE_REPEAT) != 0) | | ------------------ | | | | 134| 6.12k|#define NST_STOP_BT_SIMPLE_REPEAT (1<<6) | | ------------------ | | | Branch (156:5): [True: 6.12k, False: 0] | | ------------------ ------------------ 1382| 6.12k| QtfrNode* qn = NQTFR(node->target); ------------------ | | 80| 6.12k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1383| 6.12k| r = compile_tree_n_times(qn->target, qn->lower, reg); 1384| 6.12k| if (r) return r; ------------------ | Branch (1384:11): [True: 0, False: 6.12k] ------------------ 1385| | 1386| 6.12k| len = compile_length_tree(qn->target, reg); 1387| 6.12k| if (len < 0) return len; ------------------ | Branch (1387:11): [True: 0, False: 6.12k] ------------------ 1388| | 1389| 6.12k| r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_POP + SIZE_OP_JUMP); ------------------ | | 722| 6.12k|#define SIZE_OP_POP SIZE_OPCODE | | ------------------ | | | | 688| 6.12k|#define SIZE_OPCODE 1 | | ------------------ ------------------ r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_POP + SIZE_OP_JUMP); ------------------ | | 720| 6.12k|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 6.12k|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 6.12k|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1390| 6.12k| if (r) return r; ------------------ | Branch (1390:11): [True: 0, False: 6.12k] ------------------ 1391| 6.12k| r = compile_tree(qn->target, reg); 1392| 6.12k| if (r) return r; ------------------ | Branch (1392:11): [True: 0, False: 6.12k] ------------------ 1393| 6.12k| r = add_opcode(reg, OP_POP); 1394| 6.12k| if (r) return r; ------------------ | Branch (1394:11): [True: 0, False: 6.12k] ------------------ 1395| 6.12k| r = add_opcode_rel_addr(reg, OP_JUMP, 1396| 6.12k| -((int )SIZE_OP_PUSH + len + (int )SIZE_OP_POP + (int )SIZE_OP_JUMP)); ------------------ | | 721| 6.12k|#define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 6.12k|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_PUSH (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 6.12k|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ -((int )SIZE_OP_PUSH + len + (int )SIZE_OP_POP + (int )SIZE_OP_JUMP)); ------------------ | | 722| 6.12k|#define SIZE_OP_POP SIZE_OPCODE | | ------------------ | | | | 688| 6.12k|#define SIZE_OPCODE 1 | | ------------------ ------------------ -((int )SIZE_OP_PUSH + len + (int )SIZE_OP_POP + (int )SIZE_OP_JUMP)); ------------------ | | 720| 6.12k|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 6.12k|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 6.12k|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1397| 6.12k| } 1398| 0| else { 1399| 0| r = add_opcode(reg, OP_PUSH_STOP_BT); 1400| 0| if (r) return r; ------------------ | Branch (1400:11): [True: 0, False: 0] ------------------ 1401| 0| r = compile_tree(node->target, reg); 1402| 0| if (r) return r; ------------------ | Branch (1402:11): [True: 0, False: 0] ------------------ 1403| 0| r = add_opcode(reg, OP_POP_STOP_BT); 1404| 0| } 1405| 6.12k| break; 1406| | 1407| 6.12k| case ENCLOSE_CONDITION: ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (1407:3): [True: 0, False: 14.2k] ------------------ 1408| 0| r = add_opcode(reg, OP_CONDITION); 1409| 0| if (r) return r; ------------------ | Branch (1409:9): [True: 0, False: 0] ------------------ 1410| 0| r = add_mem_num(reg, node->regnum); 1411| 0| if (r) return r; ------------------ | Branch (1411:9): [True: 0, False: 0] ------------------ 1412| | 1413| 0| if (NTYPE(node->target) == NT_ALT) { ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(node->target) == NT_ALT) { ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (1413:9): [True: 0, False: 0] ------------------ 1414| 0| Node* x = node->target; 1415| 0| int len2; 1416| | 1417| 0| len = compile_length_tree(NCAR(x), reg); /* yes-node */ ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1418| 0| if (len < 0) return len; ------------------ | Branch (1418:11): [True: 0, False: 0] ------------------ 1419| 0| if (NCDR(x) == NULL) return ONIGERR_PARSER_BUG; ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ if (NCDR(x) == NULL) return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ | Branch (1419:11): [True: 0, False: 0] ------------------ 1420| 0| x = NCDR(x); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1421| 0| len2 = compile_length_tree(NCAR(x), reg); /* no-node */ ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1422| 0| if (len2 < 0) return len2; ------------------ | Branch (1422:11): [True: 0, False: 0] ------------------ 1423| 0| if (NCDR(x) != NULL) return ONIGERR_INVALID_CONDITION_PATTERN; ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ if (NCDR(x) != NULL) return ONIGERR_INVALID_CONDITION_PATTERN; ------------------ | | 667| 0|#define ONIGERR_INVALID_CONDITION_PATTERN -124 ------------------ | Branch (1423:11): [True: 0, False: 0] ------------------ 1424| | 1425| 0| x = node->target; 1426| 0| r = add_rel_addr(reg, len + SIZE_OP_JUMP); ------------------ | | 720| 0|#define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ | | #define SIZE_OP_JUMP (SIZE_OPCODE + SIZE_RELADDR) | | ------------------ | | | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) | | ------------------ ------------------ 1427| 0| if (r) return r; ------------------ | Branch (1427:11): [True: 0, False: 0] ------------------ 1428| 0| r = compile_tree(NCAR(x), reg); /* yes-node */ ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1429| 0| if (r) return r; ------------------ | Branch (1429:11): [True: 0, False: 0] ------------------ 1430| 0| r = add_opcode_rel_addr(reg, OP_JUMP, len2); 1431| 0| if (r) return r; ------------------ | Branch (1431:11): [True: 0, False: 0] ------------------ 1432| 0| x = NCDR(x); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1433| 0| r = compile_tree(NCAR(x), reg); /* no-node */ ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1434| 0| } 1435| 0| else { 1436| 0| return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 1437| 0| } 1438| 0| break; 1439| | 1440| 0| case ENCLOSE_ABSENT: ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ | Branch (1440:3): [True: 0, False: 14.2k] ------------------ 1441| 0| len = compile_length_tree(node->target, reg); 1442| 0| if (len < 0) return len; ------------------ | Branch (1442:9): [True: 0, False: 0] ------------------ 1443| | 1444| 0| r = add_opcode(reg, OP_PUSH_ABSENT_POS); 1445| 0| if (r) return r; ------------------ | Branch (1445:9): [True: 0, False: 0] ------------------ 1446| 0| r = add_opcode_rel_addr(reg, OP_ABSENT, len + SIZE_OP_ABSENT_END); ------------------ | | 752| 0|#define SIZE_OP_ABSENT_END SIZE_OPCODE | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ ------------------ 1447| 0| if (r) return r; ------------------ | Branch (1447:9): [True: 0, False: 0] ------------------ 1448| 0| r = compile_tree(node->target, reg); 1449| 0| if (r) return r; ------------------ | Branch (1449:9): [True: 0, False: 0] ------------------ 1450| 0| r = add_opcode(reg, OP_ABSENT_END); 1451| 0| break; 1452| | 1453| 0| default: ------------------ | Branch (1453:3): [True: 0, False: 14.2k] ------------------ 1454| 0| return ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1455| 0| break; 1456| 14.2k| } 1457| | 1458| 14.2k| return r; 1459| 14.2k|} regcomp.c:compile_anchor_node: 1496| 4.08k|{ 1497| 4.08k| int r, len; 1498| | 1499| 4.08k| switch (node->type) { 1500| 0| case ANCHOR_BEGIN_BUF: r = add_opcode(reg, OP_BEGIN_BUF); break; ------------------ | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ | Branch (1500:3): [True: 0, False: 4.08k] ------------------ 1501| 0| case ANCHOR_END_BUF: r = add_opcode(reg, OP_END_BUF); break; ------------------ | | 543| 0|#define ANCHOR_END_BUF (1<<3) ------------------ | Branch (1501:3): [True: 0, False: 4.08k] ------------------ 1502| 2.04k| case ANCHOR_BEGIN_LINE: r = add_opcode(reg, OP_BEGIN_LINE); break; ------------------ | | 541| 2.04k|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ | Branch (1502:3): [True: 2.04k, False: 2.04k] ------------------ 1503| 2.04k| case ANCHOR_END_LINE: r = add_opcode(reg, OP_END_LINE); break; ------------------ | | 545| 2.04k|#define ANCHOR_END_LINE (1<<5) ------------------ | Branch (1503:3): [True: 2.04k, False: 2.04k] ------------------ 1504| 0| case ANCHOR_SEMI_END_BUF: r = add_opcode(reg, OP_SEMI_END_BUF); break; ------------------ | | 544| 0|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ | Branch (1504:3): [True: 0, False: 4.08k] ------------------ 1505| 0| case ANCHOR_BEGIN_POSITION: r = add_opcode(reg, OP_BEGIN_POSITION); break; ------------------ | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) ------------------ | Branch (1505:3): [True: 0, False: 4.08k] ------------------ 1506| | 1507| 0| case ANCHOR_WORD_BOUND: ------------------ | | 547| 0|#define ANCHOR_WORD_BOUND (1<<6) ------------------ | Branch (1507:3): [True: 0, False: 4.08k] ------------------ 1508| 0| if (node->ascii_range) r = add_opcode(reg, OP_ASCII_WORD_BOUND); ------------------ | Branch (1508:9): [True: 0, False: 0] ------------------ 1509| 0| else r = add_opcode(reg, OP_WORD_BOUND); 1510| 0| break; 1511| 0| case ANCHOR_NOT_WORD_BOUND: ------------------ | | 548| 0|#define ANCHOR_NOT_WORD_BOUND (1<<7) ------------------ | Branch (1511:3): [True: 0, False: 4.08k] ------------------ 1512| 0| if (node->ascii_range) r = add_opcode(reg, OP_NOT_ASCII_WORD_BOUND); ------------------ | Branch (1512:9): [True: 0, False: 0] ------------------ 1513| 0| else r = add_opcode(reg, OP_NOT_WORD_BOUND); 1514| 0| break; 1515| 0|#ifdef USE_WORD_BEGIN_END 1516| 0| case ANCHOR_WORD_BEGIN: ------------------ | | 549| 0|#define ANCHOR_WORD_BEGIN (1<<8) ------------------ | Branch (1516:3): [True: 0, False: 4.08k] ------------------ 1517| 0| if (node->ascii_range) r = add_opcode(reg, OP_ASCII_WORD_BEGIN); ------------------ | Branch (1517:9): [True: 0, False: 0] ------------------ 1518| 0| else r = add_opcode(reg, OP_WORD_BEGIN); 1519| 0| break; 1520| 0| case ANCHOR_WORD_END: ------------------ | | 550| 0|#define ANCHOR_WORD_END (1<<9) ------------------ | Branch (1520:3): [True: 0, False: 4.08k] ------------------ 1521| 0| if (node->ascii_range) r = add_opcode(reg, OP_ASCII_WORD_END); ------------------ | Branch (1521:9): [True: 0, False: 0] ------------------ 1522| 0| else r = add_opcode(reg, OP_WORD_END); 1523| 0| break; 1524| 0|#endif 1525| 0| case ANCHOR_KEEP: r = add_opcode(reg, OP_KEEP); break; ------------------ | | 559| 0|#define ANCHOR_KEEP (1<<16) ------------------ | Branch (1525:3): [True: 0, False: 4.08k] ------------------ 1526| | 1527| 0| case ANCHOR_PREC_READ: ------------------ | | 551| 0|#define ANCHOR_PREC_READ (1<<10) ------------------ | Branch (1527:3): [True: 0, False: 4.08k] ------------------ 1528| 0| r = add_opcode(reg, OP_PUSH_POS); 1529| 0| if (r) return r; ------------------ | Branch (1529:9): [True: 0, False: 0] ------------------ 1530| 0| r = compile_tree(node->target, reg); 1531| 0| if (r) return r; ------------------ | Branch (1531:9): [True: 0, False: 0] ------------------ 1532| 0| r = add_opcode(reg, OP_POP_POS); 1533| 0| break; 1534| | 1535| 0| case ANCHOR_PREC_READ_NOT: ------------------ | | 552| 0|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (1535:3): [True: 0, False: 4.08k] ------------------ 1536| 0| len = compile_length_tree(node->target, reg); 1537| 0| if (len < 0) return len; ------------------ | Branch (1537:9): [True: 0, False: 0] ------------------ 1538| 0| r = add_opcode_rel_addr(reg, OP_PUSH_POS_NOT, len + SIZE_OP_FAIL_POS); ------------------ | | 730| 0|#define SIZE_OP_FAIL_POS SIZE_OPCODE | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ ------------------ 1539| 0| if (r) return r; ------------------ | Branch (1539:9): [True: 0, False: 0] ------------------ 1540| 0| r = compile_tree(node->target, reg); 1541| 0| if (r) return r; ------------------ | Branch (1541:9): [True: 0, False: 0] ------------------ 1542| 0| r = add_opcode(reg, OP_FAIL_POS); 1543| 0| break; 1544| | 1545| 0| case ANCHOR_LOOK_BEHIND: ------------------ | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ | Branch (1545:3): [True: 0, False: 4.08k] ------------------ 1546| 0| { 1547| 0| int n; 1548| 0| r = add_opcode(reg, OP_LOOK_BEHIND); 1549| 0| if (r) return r; ------------------ | Branch (1549:11): [True: 0, False: 0] ------------------ 1550| 0| if (node->char_len < 0) { ------------------ | Branch (1550:11): [True: 0, False: 0] ------------------ 1551| 0| r = get_char_length_tree(node->target, reg, &n); 1552| 0| if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; ------------------ | | 665| 0|#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN -122 ------------------ | Branch (1552:6): [True: 0, False: 0] ------------------ 1553| 0| } 1554| 0| else 1555| 0| n = node->char_len; 1556| 0| r = add_length(reg, n); 1557| 0| if (r) return r; ------------------ | Branch (1557:11): [True: 0, False: 0] ------------------ 1558| 0| r = compile_tree(node->target, reg); 1559| 0| } 1560| 0| break; 1561| | 1562| 0| case ANCHOR_LOOK_BEHIND_NOT: ------------------ | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) ------------------ | Branch (1562:3): [True: 0, False: 4.08k] ------------------ 1563| 0| { 1564| 0| int n; 1565| 0| len = compile_length_tree(node->target, reg); 1566| 0| r = add_opcode_rel_addr(reg, OP_PUSH_LOOK_BEHIND_NOT, 1567| 0| len + SIZE_OP_FAIL_LOOK_BEHIND_NOT); ------------------ | | 746| 0|#define SIZE_OP_FAIL_LOOK_BEHIND_NOT SIZE_OPCODE | | ------------------ | | | | 688| 0|#define SIZE_OPCODE 1 | | ------------------ ------------------ 1568| 0| if (r) return r; ------------------ | Branch (1568:11): [True: 0, False: 0] ------------------ 1569| 0| if (node->char_len < 0) { ------------------ | Branch (1569:11): [True: 0, False: 0] ------------------ 1570| 0| r = get_char_length_tree(node->target, reg, &n); 1571| 0| if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN; ------------------ | | 665| 0|#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN -122 ------------------ | Branch (1571:6): [True: 0, False: 0] ------------------ 1572| 0| } 1573| 0| else 1574| 0| n = node->char_len; 1575| 0| r = add_length(reg, n); 1576| 0| if (r) return r; ------------------ | Branch (1576:11): [True: 0, False: 0] ------------------ 1577| 0| r = compile_tree(node->target, reg); 1578| 0| if (r) return r; ------------------ | Branch (1578:11): [True: 0, False: 0] ------------------ 1579| 0| r = add_opcode(reg, OP_FAIL_LOOK_BEHIND_NOT); 1580| 0| } 1581| 0| break; 1582| | 1583| 0| default: ------------------ | Branch (1583:3): [True: 0, False: 4.08k] ------------------ 1584| 0| return ONIGERR_TYPE_BUG; ------------------ | | 633| 0|#define ONIGERR_TYPE_BUG -6 ------------------ 1585| 0| break; 1586| 4.08k| } 1587| | 1588| 4.08k| return r; 1589| 4.08k|} regcomp.c:add_opcode: 205| 63.2k|{ 206| 63.2k| BBUF_ADD1(reg, opcode); ------------------ | | 505| 63.2k|#define BBUF_ADD1(buf,byte) BBUF_WRITE1((buf),(buf)->used,(byte)) | | ------------------ | | | | 497| 63.2k|#define BBUF_WRITE1(buf,pos,byte) do{\ | | | | 498| 63.2k| int used = (pos) + 1;\ | | | | 499| 63.2k| if ((buf)->alloc < (unsigned int )used) BBUF_EXPAND((buf),used);\ | | | | ------------------ | | | | | | 470| 0|#define BBUF_EXPAND(buf,low) do{\ | | | | | | 471| 0| UChar *tmp;\ | | | | | | ------------------ | | | | | | | | 76| 0|# define UChar OnigUChar | | | | | | ------------------ | | | | | | 472| 0| do { (buf)->alloc *= 2; } while ((buf)->alloc < (unsigned int )low);\ | | | | | | ------------------ | | | | | | | Branch (472:36): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 473| 0| tmp = (UChar* )xrealloc((buf)->p, (buf)->alloc);\ | | | | | | ------------------ | | | | | | | | 143| 0|# define xrealloc realloc | | | | | | ------------------ | | | | | | 474| 0| if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | | | | | ------------------ | | | | | | | | | Branch (311:39): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (IS_NULL(tmp)) return(ONIGERR_MEMORY);\ | | | | | | ------------------ | | | | | | | | 632| 0|#define ONIGERR_MEMORY -5 | | | | | | ------------------ | | | | | | 475| 0| (buf)->p = tmp;\ | | | | | | 476| 0|} while (0) | | | | | | ------------------ | | | | | | | Branch (476:10): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (499:7): [True: 0, False: 63.2k] | | | | ------------------ | | | | 500| 63.2k| (buf)->p[(pos)] = (UChar )(byte);\ | | | | 501| 63.2k| if ((buf)->used < (unsigned int )used) (buf)->used = used;\ | | | | ------------------ | | | | | Branch (501:7): [True: 63.2k, False: 0] | | | | ------------------ | | | | 502| 63.2k|} while (0) | | | | ------------------ | | | | | Branch (502:10): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 207| 63.2k| return 0; 208| 63.2k|} regcomp.c:exec_end_call_list: 5943| 2.04k|{ 5944| 2.04k| OnigEndCallListItemType* prev; 5945| 2.04k| void (*func)(void); 5946| | 5947| 2.04k| while (EndCallTop != 0) { ------------------ | Branch (5947:10): [True: 0, False: 2.04k] ------------------ 5948| 0| func = EndCallTop->func; 5949| 0| (*func)(); 5950| | 5951| 0| prev = EndCallTop; 5952| 0| EndCallTop = EndCallTop->next; 5953| 0| xfree(prev); ------------------ | | 145| 0|# define xfree free ------------------ 5954| 0| } 5955| 2.04k|} onigenc_init: 37| 2.04k|{ 38| 2.04k| return 0; 39| 2.04k|} onigenc_mbclen: 56| 11.2M|{ 57| 11.2M| int ret = ONIGENC_PRECISE_MBC_ENC_LEN(enc, p, e); ------------------ | | 356| 11.2M|#define ONIGENC_PRECISE_MBC_ENC_LEN(enc,p,e) (enc)->precise_mbc_enc_len(p,e,enc) ------------------ 58| 11.2M| if (ONIGENC_MBCLEN_CHARFOUND_P(ret)) { ------------------ | | 346| 11.2M|#define ONIGENC_MBCLEN_CHARFOUND_P(r) (0 < (r)) | | ------------------ | | | Branch (346:49): [True: 8.43M, False: 2.80M] | | ------------------ ------------------ 59| 8.43M| ret = ONIGENC_MBCLEN_CHARFOUND_LEN(ret); ------------------ | | 347| 8.43M|#define ONIGENC_MBCLEN_CHARFOUND_LEN(r) (r) ------------------ 60| 8.43M| if (ret > (int)(e - p)) ret = (int)(e - p); // just for case ------------------ | Branch (60:9): [True: 0, False: 8.43M] ------------------ 61| 8.43M| return ret; 62| 8.43M| } 63| 2.80M| else if (ONIGENC_MBCLEN_NEEDMORE_P(ret)) { ------------------ | | 353| 2.80M|#define ONIGENC_MBCLEN_NEEDMORE_P(r) ((r) < -1) | | ------------------ | | | Branch (353:49): [True: 2.55k, False: 2.80M] | | ------------------ ------------------ 64| 2.55k| return (int)(e - p); 65| 2.55k| } 66| 2.80M| return p < e ? 1 : 0; ------------------ | Branch (66:10): [True: 2.80M, False: 0] ------------------ 67| 11.2M|} onigenc_always_true_is_allowed_reverse_match: 677| 2.04k|{ 678| 2.04k| return TRUE; ------------------ | | 73| 2.04k|# define TRUE 1 ------------------ 679| 2.04k|} onig_search: 3795| 2.04k|{ 3796| 2.04k| return onig_search_gpos(reg, str, end, start, start, range, region, option); 3797| 2.04k|} onig_search_gpos: 3803| 2.04k|{ 3804| 2.04k| ptrdiff_t r; 3805| 2.04k| UChar *s, *prev; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 3806| 2.04k| OnigMatchArg msa; 3807| 2.04k|#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE 3808| 2.04k| const UChar *orig_start = start; 3809| 2.04k| const UChar *orig_range = range; 3810| 2.04k|#endif 3811| | 3812| |#ifdef ONIG_DEBUG_SEARCH 3813| | fprintf(stderr, 3814| | "onig_search (entry point): str: %"PRIuPTR" (%p), end: %"PRIuPTR", start: %"PRIuPTR", range: %"PRIuPTR"\n", 3815| | (uintptr_t )str, str, end - str, start - str, range - str); 3816| |#endif 3817| | 3818| 2.04k| if (region) { ------------------ | Branch (3818:7): [True: 0, False: 2.04k] ------------------ 3819| 0| r = onig_region_resize_clear(region, reg->num_mem + 1); 3820| 0| if (r) goto finish_no_msa; ------------------ | Branch (3820:9): [True: 0, False: 0] ------------------ 3821| 0| } 3822| | 3823| 2.04k| if (start > end || start < str) goto mismatch_no_msa; ------------------ | Branch (3823:7): [True: 0, False: 2.04k] | Branch (3823:22): [True: 0, False: 2.04k] ------------------ 3824| | 3825| | 3826| 2.04k|#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE 3827| 2.04k|# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 3828| 2.04k|# define MATCH_AND_RETURN_CHECK(upper_range) \ 3829| 2.04k| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ 3830| 2.04k| if (r != ONIG_MISMATCH) {\ 3831| 2.04k| if (r >= 0) {\ 3832| 2.04k| if (! IS_FIND_LONGEST(reg->options)) {\ 3833| 2.04k| goto match;\ 3834| 2.04k| }\ 3835| 2.04k| }\ 3836| 2.04k| else goto finish; /* error */ \ 3837| 2.04k| } 3838| |# else 3839| |# define MATCH_AND_RETURN_CHECK(upper_range) \ 3840| | r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ 3841| | if (r != ONIG_MISMATCH) {\ 3842| | if (r >= 0) {\ 3843| | goto match;\ 3844| | }\ 3845| | else goto finish; /* error */ \ 3846| | } 3847| |# endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */ 3848| |#else 3849| |# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 3850| |# define MATCH_AND_RETURN_CHECK(none) \ 3851| | r = match_at(reg, str, end, s, prev, &msa);\ 3852| | if (r != ONIG_MISMATCH) {\ 3853| | if (r >= 0) {\ 3854| | if (! IS_FIND_LONGEST(reg->options)) {\ 3855| | goto match;\ 3856| | }\ 3857| | }\ 3858| | else goto finish; /* error */ \ 3859| | } 3860| |# else 3861| |# define MATCH_AND_RETURN_CHECK(none) \ 3862| | r = match_at(reg, str, end, s, prev, &msa);\ 3863| | if (r != ONIG_MISMATCH) {\ 3864| | if (r >= 0) {\ 3865| | goto match;\ 3866| | }\ 3867| | else goto finish; /* error */ \ 3868| | } 3869| |# endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */ 3870| |#endif /* USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE */ 3871| | 3872| | 3873| | /* anchor optimize: resume search range */ 3874| 2.04k| if (reg->anchor != 0 && str < end) { ------------------ | Branch (3874:7): [True: 0, False: 2.04k] | Branch (3874:27): [True: 0, False: 0] ------------------ 3875| 0| UChar *min_semi_end, *max_semi_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3876| | 3877| 0| if (reg->anchor & ANCHOR_BEGIN_POSITION) { ------------------ | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) ------------------ | Branch (3877:9): [True: 0, False: 0] ------------------ 3878| | /* search start-position only */ 3879| 0| begin_position: 3880| 0| if (range > start) ------------------ | Branch (3880:11): [True: 0, False: 0] ------------------ 3881| 0| { 3882| 0| if (global_pos > start) ------------------ | Branch (3882:6): [True: 0, False: 0] ------------------ 3883| 0| { 3884| 0| if (global_pos < range) ------------------ | Branch (3884:8): [True: 0, False: 0] ------------------ 3885| 0| range = global_pos + 1; 3886| 0| } 3887| 0| else 3888| 0| range = start + 1; 3889| 0| } 3890| 0| else 3891| 0| range = start; 3892| 0| } 3893| 0| else if (reg->anchor & ANCHOR_BEGIN_BUF) { ------------------ | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ | Branch (3893:14): [True: 0, False: 0] ------------------ 3894| | /* search str-position only */ 3895| 0| if (range > start) { ------------------ | Branch (3895:11): [True: 0, False: 0] ------------------ 3896| 0| if (start != str) goto mismatch_no_msa; ------------------ | Branch (3896:6): [True: 0, False: 0] ------------------ 3897| 0| range = str + 1; 3898| 0| } 3899| 0| else { 3900| 0| if (range <= str) { ------------------ | Branch (3900:6): [True: 0, False: 0] ------------------ 3901| 0| start = str; 3902| 0| range = str; 3903| 0| } 3904| 0| else 3905| 0| goto mismatch_no_msa; 3906| 0| } 3907| 0| } 3908| 0| else if (reg->anchor & ANCHOR_END_BUF) { ------------------ | | 543| 0|#define ANCHOR_END_BUF (1<<3) ------------------ | Branch (3908:14): [True: 0, False: 0] ------------------ 3909| 0| min_semi_end = max_semi_end = (UChar* )end; 3910| | 3911| 0| end_buf: 3912| 0| if ((OnigDistance )(max_semi_end - str) < reg->anchor_dmin) ------------------ | Branch (3912:11): [True: 0, False: 0] ------------------ 3913| 0| goto mismatch_no_msa; 3914| | 3915| 0| if (range > start) { ------------------ | Branch (3915:11): [True: 0, False: 0] ------------------ 3916| 0| if ((OnigDistance )(min_semi_end - start) > reg->anchor_dmax) { ------------------ | Branch (3916:6): [True: 0, False: 0] ------------------ 3917| 0| start = min_semi_end - reg->anchor_dmax; 3918| 0| if (start < end) ------------------ | Branch (3918:8): [True: 0, False: 0] ------------------ 3919| 0| start = onigenc_get_right_adjust_char_head(reg->enc, str, start, end); 3920| 0| } 3921| 0| if ((OnigDistance )(max_semi_end - (range - 1)) < reg->anchor_dmin) { ------------------ | Branch (3921:6): [True: 0, False: 0] ------------------ 3922| 0| range = max_semi_end - reg->anchor_dmin + 1; 3923| 0| } 3924| | 3925| 0| if (start > range) goto mismatch_no_msa; ------------------ | Branch (3925:6): [True: 0, False: 0] ------------------ 3926| | /* If start == range, match with empty at end. 3927| | Backward search is used. */ 3928| 0| } 3929| 0| else { 3930| 0| if ((OnigDistance )(min_semi_end - range) > reg->anchor_dmax) { ------------------ | Branch (3930:6): [True: 0, False: 0] ------------------ 3931| 0| range = min_semi_end - reg->anchor_dmax; 3932| 0| } 3933| 0| if ((OnigDistance )(max_semi_end - start) < reg->anchor_dmin) { ------------------ | Branch (3933:6): [True: 0, False: 0] ------------------ 3934| 0| start = max_semi_end - reg->anchor_dmin; 3935| 0| start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start, end); ------------------ | | 337| 0| (enc)->left_adjust_char_head(start, s, end, enc) ------------------ 3936| 0| } 3937| 0| if (range > start) goto mismatch_no_msa; ------------------ | Branch (3937:6): [True: 0, False: 0] ------------------ 3938| 0| } 3939| 0| } 3940| 0| else if (reg->anchor & ANCHOR_SEMI_END_BUF) { ------------------ | | 544| 0|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ | Branch (3940:14): [True: 0, False: 0] ------------------ 3941| 0| UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, end, 1); ------------------ | | 76| 0|# define UChar OnigUChar ------------------ UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, end, 1); ------------------ | | 343| 0| onigenc_step_back((enc),(start),(s),(end),(n)) ------------------ 3942| | 3943| 0| max_semi_end = (UChar* )end; 3944| 0| if (ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) { ------------------ | | 368| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end),enc) | | ------------------ | | | Branch (368:48): [True: 0, False: 0] | | ------------------ ------------------ 3945| 0| min_semi_end = pre_end; 3946| | 3947| 0|#ifdef USE_CRNL_AS_LINE_TERMINATOR 3948| 0| pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, end, 1); ------------------ | | 343| 0| onigenc_step_back((enc),(start),(s),(end),(n)) ------------------ 3949| 0| if (IS_NOT_NULL(pre_end) && ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 3950| 0| IS_NEWLINE_CRLF(reg->options) && ------------------ | | 409| 0|#define IS_NEWLINE_CRLF(option) ((option) & ONIG_OPTION_NEWLINE_CRLF) | | ------------------ | | | | 474| 0|#define ONIG_OPTION_NEWLINE_CRLF (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1) | | | | ------------------ | | | | | | 472| 0|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | | | ------------------ | | | | | | | | 471| 0|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | | | ------------------ | | | | | | | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:35): [True: 0, False: 0] | | ------------------ ------------------ 3951| 0| ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) { ------------------ | | 63| 0| (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (63:4): [True: 0, False: 0] | | ------------------ | | 64| 0| ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p,end)),end) == 10) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | | Branch (369:68): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | ------------------ ------------------ 3952| 0| min_semi_end = pre_end; 3953| 0| } 3954| 0|#endif 3955| 0| if (min_semi_end > str && start <= min_semi_end) { ------------------ | Branch (3955:6): [True: 0, False: 0] | Branch (3955:28): [True: 0, False: 0] ------------------ 3956| 0| goto end_buf; 3957| 0| } 3958| 0| } 3959| 0| else { 3960| 0| min_semi_end = (UChar* )end; 3961| 0| goto end_buf; 3962| 0| } 3963| 0| } 3964| 0| else if ((reg->anchor & ANCHOR_ANYCHAR_STAR_ML)) { ------------------ | | 557| 0|#define ANCHOR_ANYCHAR_STAR_ML (1<<15) /* ".*" optimize info (multi-line) */ ------------------ | Branch (3964:14): [True: 0, False: 0] ------------------ 3965| 0| goto begin_position; 3966| 0| } 3967| 0| } 3968| 2.04k| else if (str == end) { /* empty string */ ------------------ | Branch (3968:12): [True: 0, False: 2.04k] ------------------ 3969| 0| static const UChar address_for_empty_string[] = ""; 3970| | 3971| |#ifdef ONIG_DEBUG_SEARCH 3972| | fprintf(stderr, "onig_search: empty string.\n"); 3973| |#endif 3974| | 3975| 0| if (reg->threshold_len == 0) { ------------------ | Branch (3975:9): [True: 0, False: 0] ------------------ 3976| 0| start = end = str = address_for_empty_string; 3977| 0| s = (UChar* )start; 3978| 0| prev = (UChar* )NULL; 3979| | 3980| 0| MATCH_ARG_INIT(msa, option, region, start, start); ------------------ | | 417| 0|# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\ | | 418| 0| (msa).stack_p = (void* )0;\ | | 419| 0| (msa).options = (arg_option);\ | | 420| 0| (msa).region = (arg_region);\ | | 421| 0| (msa).start = (arg_start);\ | | 422| 0| (msa).gpos = (arg_gpos);\ | | 423| 0| (msa).best_len = ONIG_MISMATCH;\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | 424| 0| (msa).counter = 0;\ | | 425| 0|} while(0) | | ------------------ | | | Branch (425:9): [Folded - Ignored] | | ------------------ ------------------ 3981| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 3982| | msa.state_check_buff = (void* )0; 3983| | msa.state_check_buff_size = 0; /* NO NEED, for valgrind */ 3984| |#endif 3985| 0| MATCH_AND_RETURN_CHECK(end); ------------------ | | 3829| 0| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 0] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 3986| 0| goto mismatch; 3987| 0| } 3988| 0| goto mismatch_no_msa; 3989| 0| } 3990| | 3991| |#ifdef ONIG_DEBUG_SEARCH 3992| | fprintf(stderr, "onig_search(apply anchor): end: %d, start: %d, range: %d\n", 3993| | (int )(end - str), (int )(start - str), (int )(range - str)); 3994| |#endif 3995| | 3996| 2.04k| MATCH_ARG_INIT(msa, option, region, start, global_pos); ------------------ | | 417| 2.04k|# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\ | | 418| 2.04k| (msa).stack_p = (void* )0;\ | | 419| 2.04k| (msa).options = (arg_option);\ | | 420| 2.04k| (msa).region = (arg_region);\ | | 421| 2.04k| (msa).start = (arg_start);\ | | 422| 2.04k| (msa).gpos = (arg_gpos);\ | | 423| 2.04k| (msa).best_len = ONIG_MISMATCH;\ | | ------------------ | | | | 628| 2.04k|#define ONIG_MISMATCH -1 | | ------------------ | | 424| 2.04k| (msa).counter = 0;\ | | 425| 2.04k|} while(0) | | ------------------ | | | Branch (425:9): [Folded - Ignored] | | ------------------ ------------------ 3997| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 3998| | { 3999| | ptrdiff_t offset = (MIN(start, range) - str); 4000| | STATE_CHECK_BUFF_INIT(msa, end - str, offset, reg->num_comb_exp_check); 4001| | } 4002| |#endif 4003| | 4004| 2.04k| s = (UChar* )start; 4005| 2.04k| if (range > start) { /* forward search */ ------------------ | Branch (4005:7): [True: 2.04k, False: 0] ------------------ 4006| 2.04k| if (s > str) ------------------ | Branch (4006:9): [True: 0, False: 2.04k] ------------------ 4007| 0| prev = onigenc_get_prev_char_head(reg->enc, str, s, end); 4008| 2.04k| else 4009| 2.04k| prev = (UChar* )NULL; 4010| | 4011| 2.04k| if (reg->optimize != ONIG_OPTIMIZE_NONE) { ------------------ | | 355| 2.04k|#define ONIG_OPTIMIZE_NONE 0 ------------------ | Branch (4011:9): [True: 2.04k, False: 0] ------------------ 4012| 2.04k| UChar *sch_range, *low, *high, *low_prev; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 4013| | 4014| 2.04k| sch_range = (UChar* )range; 4015| 2.04k| if (reg->dmax != 0) { ------------------ | Branch (4015:11): [True: 2.04k, False: 0] ------------------ 4016| 2.04k| if (reg->dmax == ONIG_INFINITE_DISTANCE) ------------------ | | 85| 2.04k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (4016:6): [True: 2.04k, False: 0] ------------------ 4017| 2.04k| sch_range = (UChar* )end; 4018| 0| else { 4019| 0| sch_range += reg->dmax; 4020| 0| if (sch_range > end) sch_range = (UChar* )end; ------------------ | Branch (4020:8): [True: 0, False: 0] ------------------ 4021| 0| } 4022| 2.04k| } 4023| | 4024| 2.04k| if ((end - start) < reg->threshold_len) ------------------ | Branch (4024:11): [True: 0, False: 2.04k] ------------------ 4025| 0| goto mismatch; 4026| | 4027| 2.04k| if (reg->dmax != ONIG_INFINITE_DISTANCE) { ------------------ | | 85| 2.04k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (4027:11): [True: 0, False: 2.04k] ------------------ 4028| 0| do { 4029| 0| if (! forward_search_range(reg, str, end, s, sch_range, ------------------ | Branch (4029:8): [True: 0, False: 0] ------------------ 4030| 0| &low, &high, &low_prev)) goto mismatch; 4031| 0| if (s < low) { ------------------ | Branch (4031:8): [True: 0, False: 0] ------------------ 4032| 0| s = low; 4033| 0| prev = low_prev; 4034| 0| } 4035| 0| while (s <= high) { ------------------ | Branch (4035:11): [True: 0, False: 0] ------------------ 4036| 0| MATCH_AND_RETURN_CHECK(orig_range); ------------------ | | 3829| 0| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 0] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 4037| 0| prev = s; 4038| 0| s += enclen(reg->enc, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 4039| 0| } 4040| 0| } while (s < range); ------------------ | Branch (4040:11): [True: 0, False: 0] ------------------ 4041| 0| goto mismatch; 4042| 0| } 4043| 2.04k| else { /* check only. */ 4044| 2.04k| if (! forward_search_range(reg, str, end, s, sch_range, ------------------ | Branch (4044:6): [True: 659, False: 1.38k] ------------------ 4045| 2.04k| &low, &high, (UChar** )NULL)) goto mismatch; 4046| | 4047| 1.38k| if ((reg->anchor & ANCHOR_ANYCHAR_STAR) != 0) { ------------------ | | 556| 1.38k|#define ANCHOR_ANYCHAR_STAR (1<<14) /* ".*" optimize info */ ------------------ | Branch (4047:6): [True: 0, False: 1.38k] ------------------ 4048| 0| do { 4049| 0| MATCH_AND_RETURN_CHECK(orig_range); ------------------ | | 3829| 0| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 0] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 4050| 0| prev = s; 4051| 0| s += enclen(reg->enc, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 4052| | 4053| 0| if ((reg->anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) == 0) { ------------------ | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ if ((reg->anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) == 0) { ------------------ | | 552| 0|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ | Branch (4053:10): [True: 0, False: 0] ------------------ 4054| 0| while (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0) ------------------ | | 66| 0| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) ------------------ | Branch (4054:15): [True: 0, False: 0] ------------------ 4055| 0| && s < range) { ------------------ | Branch (4055:8): [True: 0, False: 0] ------------------ 4056| 0| prev = s; 4057| 0| s += enclen(reg->enc, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 4058| 0| } 4059| 0| } 4060| 0| } while (s < range); ------------------ | Branch (4060:13): [True: 0, False: 0] ------------------ 4061| 0| goto mismatch; 4062| 0| } 4063| 1.38k| } 4064| 2.04k| } 4065| | 4066| 1.43M| do { 4067| 1.43M| MATCH_AND_RETURN_CHECK(orig_range); ------------------ | | 3829| 1.43M| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 1.43M| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 1.43M|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 630, False: 1.43M] | | ------------------ | | 3831| 630| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 630, False: 0] | | ------------------ | | 3832| 630| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 630|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 630|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 630|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 630|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 630|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 630|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 630, False: 0] | | ------------------ | | 3833| 630| goto match;\ | | 3834| 630| }\ | | 3835| 630| }\ | | 3836| 630| else goto finish; /* error */ \ | | 3837| 630| } ------------------ 4068| 1.43M| prev = s; 4069| 1.43M| s += enclen(reg->enc, s, end); ------------------ | | 93| 1.43M|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 1.43M|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 1.43M] | | ------------------ ------------------ 4070| 1.43M| } while (s < range); ------------------ | Branch (4070:14): [True: 1.43M, False: 752] ------------------ 4071| | 4072| 752| if (s == range) { /* because empty match with /$/. */ ------------------ | Branch (4072:9): [True: 752, False: 0] ------------------ 4073| 752| MATCH_AND_RETURN_CHECK(orig_range); ------------------ | | 3829| 752| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 752| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 752|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 752] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 4074| 752| } 4075| 752| } 4076| 0| else { /* backward search */ 4077| 0| if (reg->optimize != ONIG_OPTIMIZE_NONE) { ------------------ | | 355| 0|#define ONIG_OPTIMIZE_NONE 0 ------------------ | Branch (4077:9): [True: 0, False: 0] ------------------ 4078| 0| UChar *low, *high, *adjrange, *sch_start; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 4079| | 4080| 0| if (range < end) ------------------ | Branch (4080:11): [True: 0, False: 0] ------------------ 4081| 0| adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range, end); ------------------ | | 337| 0| (enc)->left_adjust_char_head(start, s, end, enc) ------------------ 4082| 0| else 4083| 0| adjrange = (UChar* )end; 4084| | 4085| 0| if (reg->dmax != ONIG_INFINITE_DISTANCE && ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (4085:11): [True: 0, False: 0] ------------------ 4086| 0| (end - range) >= reg->threshold_len) { ------------------ | Branch (4086:4): [True: 0, False: 0] ------------------ 4087| 0| do { 4088| 0| sch_start = s + reg->dmax; 4089| 0| if (sch_start > end) sch_start = (UChar* )end; ------------------ | Branch (4089:8): [True: 0, False: 0] ------------------ 4090| 0| if (backward_search_range(reg, str, end, sch_start, range, adjrange, ------------------ | Branch (4090:8): [True: 0, False: 0] ------------------ 4091| 0| &low, &high) <= 0) 4092| 0| goto mismatch; 4093| | 4094| 0| if (s > high) ------------------ | Branch (4094:8): [True: 0, False: 0] ------------------ 4095| 0| s = high; 4096| | 4097| 0| while (s >= low) { ------------------ | Branch (4097:11): [True: 0, False: 0] ------------------ 4098| 0| prev = onigenc_get_prev_char_head(reg->enc, str, s, end); 4099| 0| MATCH_AND_RETURN_CHECK(orig_start); ------------------ | | 3829| 0| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 0] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 4100| 0| s = prev; 4101| 0| } 4102| 0| } while (s >= range); ------------------ | Branch (4102:11): [True: 0, False: 0] ------------------ 4103| 0| goto mismatch; 4104| 0| } 4105| 0| else { /* check only. */ 4106| 0| if ((end - range) < reg->threshold_len) goto mismatch; ------------------ | Branch (4106:6): [True: 0, False: 0] ------------------ 4107| | 4108| 0| sch_start = s; 4109| 0| if (reg->dmax != 0) { ------------------ | Branch (4109:6): [True: 0, False: 0] ------------------ 4110| 0| if (reg->dmax == ONIG_INFINITE_DISTANCE) ------------------ | | 85| 0|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (4110:8): [True: 0, False: 0] ------------------ 4111| 0| sch_start = (UChar* )end; 4112| 0| else { 4113| 0| sch_start += reg->dmax; 4114| 0| if (sch_start > end) sch_start = (UChar* )end; ------------------ | Branch (4114:10): [True: 0, False: 0] ------------------ 4115| 0| else 4116| 0| sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, ------------------ | | 337| 0| (enc)->left_adjust_char_head(start, s, end, enc) ------------------ 4117| 0| start, sch_start, end); 4118| 0| } 4119| 0| } 4120| 0| if (backward_search_range(reg, str, end, sch_start, range, adjrange, ------------------ | Branch (4120:6): [True: 0, False: 0] ------------------ 4121| 0| &low, &high) <= 0) goto mismatch; 4122| 0| } 4123| 0| } 4124| | 4125| 0| do { 4126| 0| prev = onigenc_get_prev_char_head(reg->enc, str, s, end); 4127| 0| MATCH_AND_RETURN_CHECK(orig_start); ------------------ | | 3829| 0| r = match_at(reg, str, end, (upper_range), s, prev, &msa); \ | | 3830| 0| if (r != ONIG_MISMATCH) {\ | | ------------------ | | | | 628| 0|#define ONIG_MISMATCH -1 | | ------------------ | | | Branch (3830:7): [True: 0, False: 0] | | ------------------ | | 3831| 0| if (r >= 0) {\ | | ------------------ | | | Branch (3831:9): [True: 0, False: 0] | | ------------------ | | 3832| 0| if (! IS_FIND_LONGEST(reg->options)) {\ | | ------------------ | | | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (3832:11): [True: 0, False: 0] | | ------------------ | | 3833| 0| goto match;\ | | 3834| 0| }\ | | 3835| 0| }\ | | 3836| 0| else goto finish; /* error */ \ | | 3837| 0| } ------------------ 4128| 0| s = prev; 4129| 0| } while (s >= range); ------------------ | Branch (4129:14): [True: 0, False: 0] ------------------ 4130| 0| } 4131| | 4132| 1.41k| mismatch: 4133| 1.41k|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 4134| 1.41k| if (IS_FIND_LONGEST(reg->options)) { ------------------ | | 398| 1.41k|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 459| 1.41k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 458| 1.41k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 456| 1.41k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 455| 1.41k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 454| 1.41k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (398:35): [True: 0, False: 1.41k] | | ------------------ ------------------ 4135| 0| if (msa.best_len >= 0) { ------------------ | Branch (4135:9): [True: 0, False: 0] ------------------ 4136| 0| s = msa.best_s; 4137| 0| goto match; 4138| 0| } 4139| 0| } 4140| 1.41k|#endif 4141| 1.41k| r = ONIG_MISMATCH; ------------------ | | 628| 1.41k|#define ONIG_MISMATCH -1 ------------------ 4142| | 4143| 1.41k| finish: 4144| 1.41k| MATCH_ARG_FREE(msa); ------------------ | | 474| 1.41k|# define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p) | | ------------------ | | | | 145| 0|# define xfree free | | ------------------ | | | Branch (474:35): [True: 0, False: 1.41k] | | ------------------ ------------------ 4145| | 4146| | /* If result is mismatch and no FIND_NOT_EMPTY option, 4147| | then the region is not set in match_at(). */ 4148| 1.41k| if (IS_FIND_NOT_EMPTY(reg->options) && region) { ------------------ | | 399| 2.82k|#define IS_FIND_NOT_EMPTY(option) ((option) & ONIG_OPTION_FIND_NOT_EMPTY) | | ------------------ | | | | 460| 1.41k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 459| 1.41k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 1.41k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 1.41k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 1.41k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 1.41k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (399:35): [True: 0, False: 1.41k] | | ------------------ ------------------ | Branch (4148:42): [True: 0, False: 0] ------------------ 4149| 0| onig_region_clear(region); 4150| 0| } 4151| | 4152| |#ifdef ONIG_DEBUG 4153| | if (r != ONIG_MISMATCH) 4154| | fprintf(stderr, "onig_search: error %"PRIdPTRDIFF"\n", r); 4155| |#endif 4156| 1.41k| return r; 4157| | 4158| 0| mismatch_no_msa: 4159| 0| r = ONIG_MISMATCH; ------------------ | | 628| 0|#define ONIG_MISMATCH -1 ------------------ 4160| 0| finish_no_msa: 4161| |#ifdef ONIG_DEBUG 4162| | if (r != ONIG_MISMATCH) 4163| | fprintf(stderr, "onig_search: error %"PRIdPTRDIFF"\n", r); 4164| |#endif 4165| 0| return r; 4166| | 4167| 630| match: 4168| 630| MATCH_ARG_FREE(msa); ------------------ | | 474| 630|# define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p) | | ------------------ | | | | 145| 286|# define xfree free | | ------------------ | | | Branch (474:35): [True: 286, False: 344] | | ------------------ ------------------ 4169| 630| return s - str; 4170| 0|} regexec.c:match_at: 1436| 1.43M|{ 1437| 1.43M| static const UChar FinishCode[] = { OP_FINISH }; 1438| | 1439| 1.43M| int i, num_mem, pop_level; 1440| 1.43M| ptrdiff_t n, best_len; 1441| 1.43M| LengthType tlen, tlen2; 1442| 1.43M| MemNumType mem; 1443| 1.43M| RelAddrType addr; 1444| 1.43M| OnigOptionType option = reg->options; 1445| 1.43M| OnigEncoding encode = reg->enc; 1446| 1.43M| OnigCaseFoldType case_fold_flag = reg->case_fold_flag; 1447| 1.43M| UChar *s, *q, *sbegin; ------------------ | | 76| 1.43M|# define UChar OnigUChar ------------------ 1448| 1.43M| UChar *p = reg->p; ------------------ | | 76| 1.43M|# define UChar OnigUChar ------------------ 1449| 1.43M| UChar *pkeep; ------------------ | | 76| 1.43M|# define UChar OnigUChar ------------------ 1450| 1.43M| char *alloca_base; 1451| 1.43M| char *xmalloc_base = NULL; 1452| 1.43M| OnigStackType *stk_alloc, *stk_base, *stk, *stk_end; 1453| 1.43M| OnigStackType *stkp; /* used as any purpose. */ 1454| 1.43M| OnigStackIndex si; 1455| 1.43M| OnigStackIndex *repeat_stk; 1456| 1.43M| OnigStackIndex *mem_start_stk, *mem_end_stk; 1457| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 1458| | int scv; 1459| | unsigned char* state_check_buff = msa->state_check_buff; 1460| | int num_comb_exp_check = reg->num_comb_exp_check; 1461| |#endif 1462| | 1463| 1.43M|#if USE_TOKEN_THREADED_VM 1464| 1.43M|# define OP_OFFSET 1 1465| 1.43M|# define VM_LOOP JUMP; 1466| 1.43M|# define VM_LOOP_END 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; 1468| 1.43M|# define DEFAULT L_DEFAULT: 1469| 1.43M|# define NEXT sprev = sbegin; JUMP 1470| 1.43M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) 1471| | 1472| 1.43M| RB_GNUC_EXTENSION static const void *oplabels[] = { 1473| 1.43M| &&L_OP_FINISH, /* matching process terminator (no more alternative) */ 1474| 1.43M| &&L_OP_END, /* pattern code terminator (success end) */ 1475| | 1476| 1.43M| &&L_OP_EXACT1, /* single byte, N = 1 */ 1477| 1.43M| &&L_OP_EXACT2, /* single byte, N = 2 */ 1478| 1.43M| &&L_OP_EXACT3, /* single byte, N = 3 */ 1479| 1.43M| &&L_OP_EXACT4, /* single byte, N = 4 */ 1480| 1.43M| &&L_OP_EXACT5, /* single byte, N = 5 */ 1481| 1.43M| &&L_OP_EXACTN, /* single byte */ 1482| 1.43M| &&L_OP_EXACTMB2N1, /* mb-length = 2 N = 1 */ 1483| 1.43M| &&L_OP_EXACTMB2N2, /* mb-length = 2 N = 2 */ 1484| 1.43M| &&L_OP_EXACTMB2N3, /* mb-length = 2 N = 3 */ 1485| 1.43M| &&L_OP_EXACTMB2N, /* mb-length = 2 */ 1486| 1.43M| &&L_OP_EXACTMB3N, /* mb-length = 3 */ 1487| 1.43M| &&L_OP_EXACTMBN, /* other length */ 1488| | 1489| 1.43M| &&L_OP_EXACT1_IC, /* single byte, N = 1, ignore case */ 1490| 1.43M| &&L_OP_EXACTN_IC, /* single byte, ignore case */ 1491| | 1492| 1.43M| &&L_OP_CCLASS, 1493| 1.43M| &&L_OP_CCLASS_MB, 1494| 1.43M| &&L_OP_CCLASS_MIX, 1495| 1.43M| &&L_OP_CCLASS_NOT, 1496| 1.43M| &&L_OP_CCLASS_MB_NOT, 1497| 1.43M| &&L_OP_CCLASS_MIX_NOT, 1498| | 1499| 1.43M| &&L_OP_ANYCHAR, /* "." */ 1500| 1.43M| &&L_OP_ANYCHAR_ML, /* "." multi-line */ 1501| 1.43M| &&L_OP_ANYCHAR_STAR, /* ".*" */ 1502| 1.43M| &&L_OP_ANYCHAR_ML_STAR, /* ".*" multi-line */ 1503| 1.43M| &&L_OP_ANYCHAR_STAR_PEEK_NEXT, 1504| 1.43M| &&L_OP_ANYCHAR_ML_STAR_PEEK_NEXT, 1505| | 1506| 1.43M| &&L_OP_WORD, 1507| 1.43M| &&L_OP_NOT_WORD, 1508| 1.43M| &&L_OP_WORD_BOUND, 1509| 1.43M| &&L_OP_NOT_WORD_BOUND, 1510| 1.43M|# ifdef USE_WORD_BEGIN_END 1511| 1.43M| &&L_OP_WORD_BEGIN, 1512| 1.43M| &&L_OP_WORD_END, 1513| |# else 1514| | &&L_DEFAULT, 1515| | &&L_DEFAULT, 1516| |# endif 1517| 1.43M| &&L_OP_ASCII_WORD, 1518| 1.43M| &&L_OP_NOT_ASCII_WORD, 1519| 1.43M| &&L_OP_ASCII_WORD_BOUND, 1520| 1.43M| &&L_OP_NOT_ASCII_WORD_BOUND, 1521| 1.43M|# ifdef USE_WORD_BEGIN_END 1522| 1.43M| &&L_OP_ASCII_WORD_BEGIN, 1523| 1.43M| &&L_OP_ASCII_WORD_END, 1524| |# else 1525| | &&L_DEFAULT, 1526| | &&L_DEFAULT, 1527| |# endif 1528| | 1529| 1.43M| &&L_OP_BEGIN_BUF, 1530| 1.43M| &&L_OP_END_BUF, 1531| 1.43M| &&L_OP_BEGIN_LINE, 1532| 1.43M| &&L_OP_END_LINE, 1533| 1.43M| &&L_OP_SEMI_END_BUF, 1534| 1.43M| &&L_OP_BEGIN_POSITION, 1535| | 1536| 1.43M| &&L_OP_BACKREF1, 1537| 1.43M| &&L_OP_BACKREF2, 1538| 1.43M| &&L_OP_BACKREFN, 1539| 1.43M| &&L_OP_BACKREFN_IC, 1540| 1.43M| &&L_OP_BACKREF_MULTI, 1541| 1.43M| &&L_OP_BACKREF_MULTI_IC, 1542| 1.43M|# ifdef USE_BACKREF_WITH_LEVEL 1543| 1.43M| &&L_OP_BACKREF_WITH_LEVEL, /* \k, \k */ 1544| |# else 1545| | &&L_DEFAULT, 1546| |# endif 1547| 1.43M| &&L_OP_MEMORY_START, 1548| 1.43M| &&L_OP_MEMORY_START_PUSH, /* push back-tracker to stack */ 1549| 1.43M| &&L_OP_MEMORY_END_PUSH, /* push back-tracker to stack */ 1550| 1.43M|# ifdef USE_SUBEXP_CALL 1551| 1.43M| &&L_OP_MEMORY_END_PUSH_REC, /* push back-tracker to stack */ 1552| |# else 1553| | &&L_DEFAULT, 1554| |# endif 1555| 1.43M| &&L_OP_MEMORY_END, 1556| 1.43M|# ifdef USE_SUBEXP_CALL 1557| 1.43M| &&L_OP_MEMORY_END_REC, /* push marker to stack */ 1558| |# else 1559| | &&L_DEFAULT, 1560| |# endif 1561| | 1562| 1.43M| &&L_OP_KEEP, 1563| | 1564| 1.43M| &&L_OP_FAIL, /* pop stack and move */ 1565| 1.43M| &&L_OP_JUMP, 1566| 1.43M| &&L_OP_PUSH, 1567| 1.43M| &&L_OP_POP, 1568| |# ifdef USE_OP_PUSH_OR_JUMP_EXACT 1569| | &&L_OP_PUSH_OR_JUMP_EXACT1, /* if match exact then push, else jump. */ 1570| |# else 1571| 1.43M| &&L_DEFAULT, 1572| 1.43M|# endif 1573| 1.43M| &&L_OP_PUSH_IF_PEEK_NEXT, /* if match exact then push, else none. */ 1574| 1.43M| &&L_OP_REPEAT, /* {n,m} */ 1575| 1.43M| &&L_OP_REPEAT_NG, /* {n,m}? (non greedy) */ 1576| 1.43M| &&L_OP_REPEAT_INC, 1577| 1.43M| &&L_OP_REPEAT_INC_NG, /* non greedy */ 1578| 1.43M| &&L_OP_REPEAT_INC_SG, /* search and get in stack */ 1579| 1.43M| &&L_OP_REPEAT_INC_NG_SG, /* search and get in stack (non greedy) */ 1580| 1.43M| &&L_OP_NULL_CHECK_START, /* null loop checker start */ 1581| 1.43M| &&L_OP_NULL_CHECK_END, /* null loop checker end */ 1582| 1.43M|# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 1583| 1.43M| &&L_OP_NULL_CHECK_END_MEMST, /* null loop checker end (with capture status) */ 1584| |# else 1585| | &&L_DEFAULT, 1586| |# endif 1587| 1.43M|# ifdef USE_SUBEXP_CALL 1588| 1.43M| &&L_OP_NULL_CHECK_END_MEMST_PUSH, /* with capture status and push check-end */ 1589| |# else 1590| | &&L_DEFAULT, 1591| |# endif 1592| | 1593| 1.43M| &&L_OP_PUSH_POS, /* (?=...) start */ 1594| 1.43M| &&L_OP_POP_POS, /* (?=...) end */ 1595| 1.43M| &&L_OP_PUSH_POS_NOT, /* (?!...) start */ 1596| 1.43M| &&L_OP_FAIL_POS, /* (?!...) end */ 1597| 1.43M| &&L_OP_PUSH_STOP_BT, /* (?>...) start */ 1598| 1.43M| &&L_OP_POP_STOP_BT, /* (?>...) end */ 1599| 1.43M| &&L_OP_LOOK_BEHIND, /* (?<=...) start (no needs end opcode) */ 1600| 1.43M| &&L_OP_PUSH_LOOK_BEHIND_NOT, /* (? */ 1608| 1.43M| &&L_OP_RETURN, 1609| |# else 1610| | &&L_DEFAULT, 1611| | &&L_DEFAULT, 1612| |# endif 1613| 1.43M| &&L_OP_CONDITION, 1614| | 1615| |# ifdef USE_COMBINATION_EXPLOSION_CHECK 1616| | &&L_OP_STATE_CHECK_PUSH, /* combination explosion check and push */ 1617| | &&L_OP_STATE_CHECK_PUSH_OR_JUMP, /* check ok -> push, else jump */ 1618| | &&L_OP_STATE_CHECK, /* check only */ 1619| |# else 1620| 1.43M| &&L_DEFAULT, 1621| 1.43M| &&L_DEFAULT, 1622| 1.43M| &&L_DEFAULT, 1623| 1.43M|# endif 1624| |# ifdef USE_COMBINATION_EXPLOSION_CHECK 1625| | &&L_OP_STATE_CHECK_ANYCHAR_STAR, 1626| | &&L_OP_STATE_CHECK_ANYCHAR_ML_STAR, 1627| |# else 1628| 1.43M| &&L_DEFAULT, 1629| 1.43M| &&L_DEFAULT, 1630| 1.43M|# endif 1631| | /* no need: IS_DYNAMIC_OPTION() == 0 */ 1632| |# if 0 /* no need: IS_DYNAMIC_OPTION() == 0 */ 1633| | &&L_OP_SET_OPTION_PUSH, /* set option and push recover option */ 1634| | &&L_OP_SET_OPTION /* set option */ 1635| |# else 1636| 1.43M| &&L_DEFAULT, 1637| 1.43M| &&L_DEFAULT 1638| 1.43M|# endif 1639| 1.43M| }; 1640| |#else /* USE_TOKEN_THREADED_VM */ 1641| | 1642| |# define OP_OFFSET 0 1643| |# define VM_LOOP \ 1644| | while (1) { \ 1645| | OPCODE_EXEC_HOOK; \ 1646| | sbegin = s; \ 1647| | switch (*p++) { 1648| |# define VM_LOOP_END } sprev = sbegin; } 1649| |# define CASE(x) case x: 1650| |# define DEFAULT default: 1651| |# define NEXT break 1652| |# define JUMP continue; break 1653| |#endif /* USE_TOKEN_THREADED_VM */ 1654| | 1655| | 1656| 1.43M|#ifdef USE_SUBEXP_CALL 1657| |/* Stack #0 is used to store the pattern itself and used for (?R), \g<0>, 1658| | etc. Additional space is required. */ 1659| 1.43M|# define ADD_NUMMEM 1 1660| |#else 1661| |/* Stack #0 not is used. */ 1662| |# define ADD_NUMMEM 0 1663| |#endif 1664| | 1665| 1.43M| n = reg->num_repeat + (reg->num_mem + ADD_NUMMEM) * 2; ------------------ | | 1659| 1.43M|# define ADD_NUMMEM 1 ------------------ 1666| | 1667| 1.43M| STACK_INIT(alloca_base, xmalloc_base, n, INIT_MATCH_STACK_SIZE); ------------------ | | 481| 1.43M|#define STACK_INIT(alloc_addr, heap_addr, ptr_num, stack_num) do {\ | | 482| 1.43M| if (ptr_num > MAX_PTR_NUM) {\ | | ------------------ | | | | 479| 2.87M|#define MAX_PTR_NUM 100 | | ------------------ | | | Branch (482:7): [True: 0, False: 1.43M] | | ------------------ | | 483| 0| alloc_addr = (char* )xmalloc(sizeof(OnigStackIndex) * (ptr_num));\ | | ------------------ | | | | 142| 0|# define xmalloc malloc | | ------------------ | | 484| 0| heap_addr = alloc_addr;\ | | 485| 0| if (msa->stack_p) {\ | | ------------------ | | | Branch (485:9): [True: 0, False: 0] | | ------------------ | | 486| 0| stk_alloc = (OnigStackType* )(msa->stack_p);\ | | 487| 0| stk_base = stk_alloc;\ | | 488| 0| stk = stk_base;\ | | 489| 0| stk_end = stk_base + msa->stack_n;\ | | 490| 0| } else {\ | | 491| 0| stk_alloc = (OnigStackType* )xalloca(sizeof(OnigStackType) * (stack_num));\ | | ------------------ | | | | 226| 0|# define xalloca alloca | | ------------------ | | 492| 0| stk_base = stk_alloc;\ | | 493| 0| stk = stk_base;\ | | 494| 0| stk_end = stk_base + (stack_num);\ | | 495| 0| }\ | | 496| 1.43M| } else if (msa->stack_p) {\ | | ------------------ | | | Branch (496:14): [True: 0, False: 1.43M] | | ------------------ | | 497| 0| alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num));\ | | ------------------ | | | | 226| 0|# define xalloca alloca | | ------------------ | | 498| 0| heap_addr = NULL;\ | | 499| 0| stk_alloc = (OnigStackType* )(msa->stack_p);\ | | 500| 0| stk_base = stk_alloc;\ | | 501| 0| stk = stk_base;\ | | 502| 0| stk_end = stk_base + msa->stack_n;\ | | 503| 0| }\ | | 504| 1.43M| else {\ | | 505| 1.43M| alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num)\ | | ------------------ | | | | 226| 1.43M|# define xalloca alloca | | ------------------ | | 506| 1.43M| + sizeof(OnigStackType) * (stack_num));\ | | 507| 1.43M| heap_addr = NULL;\ | | 508| 1.43M| stk_alloc = (OnigStackType* )(alloc_addr + sizeof(OnigStackIndex) * (ptr_num));\ | | 509| 1.43M| stk_base = stk_alloc;\ | | 510| 1.43M| stk = stk_base;\ | | 511| 1.43M| stk_end = stk_base + (stack_num);\ | | 512| 1.43M| }\ | | 513| 1.43M|} while(0) | | ------------------ | | | Branch (513:9): [Folded - Ignored] | | ------------------ ------------------ 1668| 1.43M| pop_level = reg->stack_pop_level; 1669| 1.43M| num_mem = reg->num_mem; 1670| 1.43M| repeat_stk = (OnigStackIndex* )alloca_base; 1671| | 1672| 1.43M| mem_start_stk = (OnigStackIndex* )(repeat_stk + reg->num_repeat); 1673| 1.43M| mem_end_stk = mem_start_stk + (num_mem + ADD_NUMMEM); ------------------ | | 1659| 1.43M|# define ADD_NUMMEM 1 ------------------ 1674| 1.43M| { 1675| 1.43M| OnigStackIndex *pp = mem_start_stk; 1676| 8.63M| for (; pp < repeat_stk + n; pp += 2) { ------------------ | Branch (1676:12): [True: 7.19M, False: 1.43M] ------------------ 1677| 7.19M| pp[0] = INVALID_STACK_INDEX; ------------------ | | 386| 7.19M|#define INVALID_STACK_INDEX -1 ------------------ 1678| 7.19M| pp[1] = INVALID_STACK_INDEX; ------------------ | | 386| 7.19M|#define INVALID_STACK_INDEX -1 ------------------ 1679| 7.19M| } 1680| 1.43M| } 1681| |#ifndef USE_SUBEXP_CALL 1682| | mem_start_stk--; /* for index start from 1, 1683| | mem_start_stk[1]..mem_start_stk[num_mem] */ 1684| | mem_end_stk--; /* for index start from 1, 1685| | mem_end_stk[1]..mem_end_stk[num_mem] */ 1686| |#endif 1687| | 1688| |#ifdef ONIG_DEBUG_MATCH 1689| | fprintf(stderr, "match_at: str: %"PRIuPTR" (%p), end: %"PRIuPTR" (%p), start: %"PRIuPTR" (%p), sprev: %"PRIuPTR" (%p)\n", 1690| | (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )sstart, sstart, (uintptr_t )sprev, sprev); 1691| | fprintf(stderr, "size: %d, start offset: %d\n", 1692| | (int )(end - str), (int )(sstart - str)); 1693| | fprintf(stderr, "\n ofs> str stk:type addr:opcode\n"); 1694| |#endif 1695| | 1696| 1.43M| STACK_PUSH_ENSURED(STK_ALT, (UChar* )FinishCode); /* bottom stack */ ------------------ | | 672| 1.43M|# define STACK_PUSH_ENSURED(stack_type,pat) do {\ | | 673| 1.43M| stk->type = (stack_type);\ | | 674| 1.43M| stk->u.state.pcode = (pat);\ | | 675| 1.43M| STACK_INC;\ | | ------------------ | | | | 1393| 1.43M|# define STACK_INC stk++ | | ------------------ | | 676| 1.43M|} while(0) | | ------------------ | | | Branch (676:9): [Folded - Ignored] | | ------------------ ------------------ 1697| 1.43M| best_len = ONIG_MISMATCH; ------------------ | | 628| 1.43M|#define ONIG_MISMATCH -1 ------------------ 1698| 1.43M| s = (UChar* )sstart; 1699| 1.43M| pkeep = (UChar* )sstart; 1700| | 1701| | 1702| |#ifdef ONIG_DEBUG_MATCH 1703| |# define OPCODE_EXEC_HOOK \ 1704| | if (s) { \ 1705| | UChar *op, *q, *bp, buf[50]; \ 1706| | int len; \ 1707| | op = p - OP_OFFSET; \ 1708| | fprintf(stderr, "%4"PRIdPTR"> \"", (*op == OP_FINISH) ? (ptrdiff_t )-1 : s - str); \ 1709| | bp = buf; \ 1710| | q = s; \ 1711| | if (*op != OP_FINISH) { /* s may not be a valid pointer if OP_FINISH. */ \ 1712| | for (i = 0; i < 7 && q < end; i++) { \ 1713| | len = enclen(encode, q, end); \ 1714| | while (len-- > 0) *bp++ = *q++; \ 1715| | } \ 1716| | if (q < end) { xmemcpy(bp, "...", 3); bp += 3; } \ 1717| | } \ 1718| | xmemcpy(bp, "\"", 1); bp += 1; \ 1719| | *bp = 0; \ 1720| | fputs((char* )buf, stderr); \ 1721| | for (i = 0; i < 20 - (bp - buf); i++) fputc(' ', stderr); \ 1722| | fprintf(stderr, "%4"PRIdPTR":%s %4"PRIdPTR":", \ 1723| | stk - stk_base - 1, \ 1724| | (stk > stk_base) ? stack_type_str(stk[-1].type) : " ", \ 1725| | (op == FinishCode) ? (ptrdiff_t )-1 : op - reg->p); \ 1726| | onig_print_compiled_byte_code(stderr, op, reg->p+reg->used, NULL, encode); \ 1727| | fprintf(stderr, "\n"); \ 1728| | } 1729| |#else 1730| 1.43M|# define OPCODE_EXEC_HOOK ((void) 0) 1731| 1.43M|#endif 1732| | 1733| | 1734| 1.43M| VM_LOOP { ------------------ | | 1465| 1.43M|# define VM_LOOP JUMP; | | ------------------ | | | | 1470| 1.43M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 1.43M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 1735| 1.43M| CASE(OP_END) MOP_IN(OP_END); ------------------ | | 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 1.43M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1736| 630| n = s - sstart; 1737| 630| if (n > best_len) { ------------------ | Branch (1737:11): [True: 630, False: 0] ------------------ 1738| 630| OnigRegion* region; 1739| 630|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 1740| 630| if (IS_FIND_LONGEST(option)) { ------------------ | | 398| 630|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 459| 630|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 458| 630|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 456| 630|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 455| 630|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 454| 630|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (398:35): [True: 0, False: 630] | | ------------------ ------------------ 1741| 0| if (n > msa->best_len) { ------------------ | Branch (1741:8): [True: 0, False: 0] ------------------ 1742| 0| msa->best_len = n; 1743| 0| msa->best_s = (UChar* )sstart; 1744| 0| } 1745| 0| else 1746| 0| goto end_best_len; 1747| 0| } 1748| 630|#endif 1749| 630| best_len = n; 1750| 630| region = msa->region; 1751| 630| if (region) { ------------------ | Branch (1751:6): [True: 0, False: 630] ------------------ 1752| 0| region->beg[0] = ((pkeep > s) ? s : pkeep) - str; ------------------ | Branch (1752:22): [True: 0, False: 0] ------------------ 1753| 0| region->end[0] = s - str; 1754| 0| for (i = 1; i <= num_mem; i++) { ------------------ | Branch (1754:16): [True: 0, False: 0] ------------------ 1755| 0| if (mem_end_stk[i] != INVALID_STACK_INDEX) { ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (1755:10): [True: 0, False: 0] ------------------ 1756| 0| if (BIT_STATUS_AT(reg->bt_mem_start, i)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 1757| 0| region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str; ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 1758| 0| else 1759| 0| region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str; 1760| | 1761| 0| region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 1762| 0| ? STACK_AT(mem_end_stk[i])->u.mem.pstr ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 1763| 0| : (UChar* )((void* )mem_end_stk[i])) - str; 1764| 0| } 1765| 0| else { 1766| 0| region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS; ------------------ | | 737| 0|#define ONIG_REGION_NOTPOS -1 ------------------ 1767| 0| } 1768| 0| } 1769| | 1770| 0|#ifdef USE_CAPTURE_HISTORY 1771| 0| if (reg->capture_history != 0) { ------------------ | Branch (1771:8): [True: 0, False: 0] ------------------ 1772| 0| int r; 1773| 0| OnigCaptureTreeNode* node; 1774| | 1775| 0| if (IS_NULL(region->history_root)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 1776| 0| region->history_root = node = history_node_new(); 1777| 0| CHECK_NULL_RETURN_MEMERR(node); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1778| 0| } 1779| 0| else { 1780| 0| node = region->history_root; 1781| 0| history_tree_clear(node); 1782| 0| } 1783| | 1784| 0| node->group = 0; 1785| 0| node->beg = ((pkeep > s) ? s : pkeep) - str; ------------------ | Branch (1785:21): [True: 0, False: 0] ------------------ 1786| 0| node->end = s - str; 1787| | 1788| 0| stkp = stk_base; 1789| 0| r = make_capture_history_tree(region->history_root, &stkp, 1790| 0| stk, (UChar* )str, reg); 1791| 0| if (r < 0) { ------------------ | Branch (1791:10): [True: 0, False: 0] ------------------ 1792| 0| best_len = r; /* error code */ 1793| 0| goto finish; 1794| 0| } 1795| 0| } 1796| 0|#endif /* USE_CAPTURE_HISTORY */ 1797| 0| } /* if (region) */ 1798| 630| } /* n > best_len */ 1799| | 1800| 630|#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE 1801| 630| end_best_len: 1802| 630|#endif 1803| 630| MOP_OUT; 1804| | 1805| 630| if (IS_FIND_CONDITION(option)) { ------------------ | | 400| 630|#define IS_FIND_CONDITION(option) ((option) & \ | | ------------------ | | | Branch (400:35): [True: 0, False: 630] | | ------------------ | | 401| 630| (ONIG_OPTION_FIND_LONGEST | ONIG_OPTION_FIND_NOT_EMPTY)) | | ------------------ | | | | 459| 630|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 458| 630|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 456| 630|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 455| 630|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 454| 630|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ONIG_OPTION_FIND_LONGEST | ONIG_OPTION_FIND_NOT_EMPTY)) | | ------------------ | | | | 460| 630|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 459| 630|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 630|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 630|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 630|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 630|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1806| 0| if (IS_FIND_NOT_EMPTY(option) && s == sstart) { ------------------ | | 399| 0|#define IS_FIND_NOT_EMPTY(option) ((option) & ONIG_OPTION_FIND_NOT_EMPTY) | | ------------------ | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | ------------------ | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | ------------------ | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (399:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1806:35): [True: 0, False: 0] ------------------ 1807| 0| best_len = ONIG_MISMATCH; ------------------ | | 628| 0|#define ONIG_MISMATCH -1 ------------------ 1808| 0| goto fail; /* for retry */ 1809| 0| } 1810| 0| if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) { ------------------ | | 398| 0|#define IS_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST) | | ------------------ | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | ------------------ | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | ------------------ | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | ------------------ | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (398:35): [True: 0, False: 0] | | ------------------ ------------------ if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ 1811| 0| goto fail; /* for retry */ 1812| 0| } 1813| 0| } 1814| | 1815| | /* default behavior: return first-matching result. */ 1816| 630| goto finish; 1817| | 1818| 18.6k| CASE(OP_EXACT1) MOP_IN(OP_EXACT1); ------------------ | | 1467| 18.6k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 630|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1819| 18.6k| DATA_ENSURE(1); ------------------ | | 1180| 18.6k|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 5.79k, False: 12.8k] | | ------------------ ------------------ 1820| 12.8k| if (*p != *s) goto fail; ------------------ | Branch (1820:11): [True: 0, False: 12.8k] ------------------ 1821| 12.8k| p++; s++; 1822| 12.8k| MOP_OUT; 1823| 12.8k| NEXT; ------------------ | | 1469| 12.8k|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 12.8k|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 12.8k|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 1824| | 1825| 12.8k| CASE(OP_EXACT1_IC) MOP_IN(OP_EXACT1_IC); ------------------ | | 1467| 12.8k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 12.8k|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1826| 0| { 1827| 0| int len; 1828| 0| UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN]; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 1829| | 1830| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1831| 0| len = ONIGENC_MBC_CASE_FOLD(encode, ------------------ | | 333| 0| (enc)->mbc_case_fold(flag,(const OnigUChar** )pp,end,buf,enc) ------------------ 1832| | /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */ 1833| 0| case_fold_flag, 1834| 0| &s, end, lowbuf); 1835| 0| DATA_ENSURE(0); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1836| 0| q = lowbuf; 1837| 0| while (len-- > 0) { ------------------ | Branch (1837:9): [True: 0, False: 0] ------------------ 1838| 0| if (*p != *q) { ------------------ | Branch (1838:8): [True: 0, False: 0] ------------------ 1839| 0| goto fail; 1840| 0| } 1841| 0| p++; q++; 1842| 0| } 1843| 0| } 1844| 0| MOP_OUT; 1845| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 1846| | 1847| 0| CASE(OP_EXACT2) MOP_IN(OP_EXACT2); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1848| 0| DATA_ENSURE(2); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1849| 0| if (*p != *s) goto fail; ------------------ | Branch (1849:11): [True: 0, False: 0] ------------------ 1850| 0| p++; s++; 1851| 0| if (*p != *s) goto fail; ------------------ | Branch (1851:11): [True: 0, False: 0] ------------------ 1852| 0| sprev = s; 1853| 0| p++; s++; 1854| 0| MOP_OUT; 1855| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1856| | 1857| 0| CASE(OP_EXACT3) MOP_IN(OP_EXACT3); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1858| 0| DATA_ENSURE(3); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1859| 0| if (*p != *s) goto fail; ------------------ | Branch (1859:11): [True: 0, False: 0] ------------------ 1860| 0| p++; s++; 1861| 0| if (*p != *s) goto fail; ------------------ | Branch (1861:11): [True: 0, False: 0] ------------------ 1862| 0| p++; s++; 1863| 0| if (*p != *s) goto fail; ------------------ | Branch (1863:11): [True: 0, False: 0] ------------------ 1864| 0| sprev = s; 1865| 0| p++; s++; 1866| 0| MOP_OUT; 1867| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1868| | 1869| 0| CASE(OP_EXACT4) MOP_IN(OP_EXACT4); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1870| 0| DATA_ENSURE(4); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1871| 0| if (*p != *s) goto fail; ------------------ | Branch (1871:11): [True: 0, False: 0] ------------------ 1872| 0| p++; s++; 1873| 0| if (*p != *s) goto fail; ------------------ | Branch (1873:11): [True: 0, False: 0] ------------------ 1874| 0| p++; s++; 1875| 0| if (*p != *s) goto fail; ------------------ | Branch (1875:11): [True: 0, False: 0] ------------------ 1876| 0| p++; s++; 1877| 0| if (*p != *s) goto fail; ------------------ | Branch (1877:11): [True: 0, False: 0] ------------------ 1878| 0| sprev = s; 1879| 0| p++; s++; 1880| 0| MOP_OUT; 1881| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1882| | 1883| 0| CASE(OP_EXACT5) MOP_IN(OP_EXACT5); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1884| 0| DATA_ENSURE(5); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1885| 0| if (*p != *s) goto fail; ------------------ | Branch (1885:11): [True: 0, False: 0] ------------------ 1886| 0| p++; s++; 1887| 0| if (*p != *s) goto fail; ------------------ | Branch (1887:11): [True: 0, False: 0] ------------------ 1888| 0| p++; s++; 1889| 0| if (*p != *s) goto fail; ------------------ | Branch (1889:11): [True: 0, False: 0] ------------------ 1890| 0| p++; s++; 1891| 0| if (*p != *s) goto fail; ------------------ | Branch (1891:11): [True: 0, False: 0] ------------------ 1892| 0| p++; s++; 1893| 0| if (*p != *s) goto fail; ------------------ | Branch (1893:11): [True: 0, False: 0] ------------------ 1894| 0| sprev = s; 1895| 0| p++; s++; 1896| 0| MOP_OUT; 1897| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1898| | 1899| 0| CASE(OP_EXACTN) MOP_IN(OP_EXACTN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1900| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1901| 0| DATA_ENSURE(tlen); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1902| 0| while (tlen-- > 0) { ------------------ | Branch (1902:14): [True: 0, False: 0] ------------------ 1903| 0| if (*p++ != *s++) goto fail; ------------------ | Branch (1903:6): [True: 0, False: 0] ------------------ 1904| 0| } 1905| 0| sprev = s - 1; 1906| 0| MOP_OUT; 1907| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1908| | 1909| 0| CASE(OP_EXACTN_IC) MOP_IN(OP_EXACTN_IC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1910| 0| { 1911| 0| int len; 1912| 0| UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN]; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 1913| | 1914| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1915| 0| endp = p + tlen; 1916| | 1917| 0| while (p < endp) { ------------------ | Branch (1917:9): [True: 0, False: 0] ------------------ 1918| 0| sprev = s; 1919| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1920| 0| len = ONIGENC_MBC_CASE_FOLD(encode, ------------------ | | 333| 0| (enc)->mbc_case_fold(flag,(const OnigUChar** )pp,end,buf,enc) ------------------ 1921| | /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */ 1922| 0| case_fold_flag, 1923| 0| &s, end, lowbuf); 1924| 0| DATA_ENSURE(0); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1925| 0| q = lowbuf; 1926| 0| while (len-- > 0) { ------------------ | Branch (1926:11): [True: 0, False: 0] ------------------ 1927| 0| if (*p != *q) goto fail; ------------------ | Branch (1927:10): [True: 0, False: 0] ------------------ 1928| 0| p++; q++; 1929| 0| } 1930| 0| } 1931| 0| } 1932| | 1933| 0| MOP_OUT; 1934| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1935| | 1936| 0| CASE(OP_EXACTMB2N1) MOP_IN(OP_EXACTMB2N1); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1937| 0| DATA_ENSURE(2); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1938| 0| if (*p != *s) goto fail; ------------------ | Branch (1938:11): [True: 0, False: 0] ------------------ 1939| 0| p++; s++; 1940| 0| if (*p != *s) goto fail; ------------------ | Branch (1940:11): [True: 0, False: 0] ------------------ 1941| 0| p++; s++; 1942| 0| MOP_OUT; 1943| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 1944| | 1945| 0| CASE(OP_EXACTMB2N2) MOP_IN(OP_EXACTMB2N2); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1946| 0| DATA_ENSURE(4); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1947| 0| if (*p != *s) goto fail; ------------------ | Branch (1947:11): [True: 0, False: 0] ------------------ 1948| 0| p++; s++; 1949| 0| if (*p != *s) goto fail; ------------------ | Branch (1949:11): [True: 0, False: 0] ------------------ 1950| 0| p++; s++; 1951| 0| sprev = s; 1952| 0| if (*p != *s) goto fail; ------------------ | Branch (1952:11): [True: 0, False: 0] ------------------ 1953| 0| p++; s++; 1954| 0| if (*p != *s) goto fail; ------------------ | Branch (1954:11): [True: 0, False: 0] ------------------ 1955| 0| p++; s++; 1956| 0| MOP_OUT; 1957| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1958| | 1959| 0| CASE(OP_EXACTMB2N3) MOP_IN(OP_EXACTMB2N3); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1960| 0| DATA_ENSURE(6); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1961| 0| if (*p != *s) goto fail; ------------------ | Branch (1961:11): [True: 0, False: 0] ------------------ 1962| 0| p++; s++; 1963| 0| if (*p != *s) goto fail; ------------------ | Branch (1963:11): [True: 0, False: 0] ------------------ 1964| 0| p++; s++; 1965| 0| if (*p != *s) goto fail; ------------------ | Branch (1965:11): [True: 0, False: 0] ------------------ 1966| 0| p++; s++; 1967| 0| if (*p != *s) goto fail; ------------------ | Branch (1967:11): [True: 0, False: 0] ------------------ 1968| 0| p++; s++; 1969| 0| sprev = s; 1970| 0| if (*p != *s) goto fail; ------------------ | Branch (1970:11): [True: 0, False: 0] ------------------ 1971| 0| p++; s++; 1972| 0| if (*p != *s) goto fail; ------------------ | Branch (1972:11): [True: 0, False: 0] ------------------ 1973| 0| p++; s++; 1974| 0| MOP_OUT; 1975| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1976| | 1977| 0| CASE(OP_EXACTMB2N) MOP_IN(OP_EXACTMB2N); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1978| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1979| 0| DATA_ENSURE(tlen * 2); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1980| 0| while (tlen-- > 0) { ------------------ | Branch (1980:14): [True: 0, False: 0] ------------------ 1981| 0| if (*p != *s) goto fail; ------------------ | Branch (1981:6): [True: 0, False: 0] ------------------ 1982| 0| p++; s++; 1983| 0| if (*p != *s) goto fail; ------------------ | Branch (1983:6): [True: 0, False: 0] ------------------ 1984| 0| p++; s++; 1985| 0| } 1986| 0| sprev = s - 2; 1987| 0| MOP_OUT; 1988| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 1989| | 1990| 0| CASE(OP_EXACTMB3N) MOP_IN(OP_EXACTMB3N); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 1991| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1992| 0| DATA_ENSURE(tlen * 3); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 1993| 0| while (tlen-- > 0) { ------------------ | Branch (1993:14): [True: 0, False: 0] ------------------ 1994| 0| if (*p != *s) goto fail; ------------------ | Branch (1994:6): [True: 0, False: 0] ------------------ 1995| 0| p++; s++; 1996| 0| if (*p != *s) goto fail; ------------------ | Branch (1996:6): [True: 0, False: 0] ------------------ 1997| 0| p++; s++; 1998| 0| if (*p != *s) goto fail; ------------------ | Branch (1998:6): [True: 0, False: 0] ------------------ 1999| 0| p++; s++; 2000| 0| } 2001| 0| sprev = s - 3; 2002| 0| MOP_OUT; 2003| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2004| | 2005| 0| CASE(OP_EXACTMBN) MOP_IN(OP_EXACTMBN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2006| 0| GET_LENGTH_INC(tlen, p); /* mb-len */ ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2007| 0| GET_LENGTH_INC(tlen2, p); /* string len */ ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2008| 0| tlen2 *= tlen; 2009| 0| DATA_ENSURE(tlen2); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2010| 0| while (tlen2-- > 0) { ------------------ | Branch (2010:14): [True: 0, False: 0] ------------------ 2011| 0| if (*p != *s) goto fail; ------------------ | Branch (2011:6): [True: 0, False: 0] ------------------ 2012| 0| p++; s++; 2013| 0| } 2014| 0| sprev = s - tlen; 2015| 0| MOP_OUT; 2016| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2017| | 2018| 0| CASE(OP_CCLASS) MOP_IN(OP_CCLASS); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2019| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2020| 0| if (BITSET_AT(((BitSetRef )p), *s) == 0) goto fail; ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2020:11): [True: 0, False: 0] ------------------ 2021| 0| p += SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2022| 0| s += enclen(encode, s, end); /* OP_CCLASS can match mb-code. \D, \S */ ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2023| 0| MOP_OUT; 2024| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2025| | 2026| 0| CASE(OP_CCLASS_MB) MOP_IN(OP_CCLASS_MB); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2027| 0| if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) goto fail; ------------------ | | 319| 0|#define ONIGENC_IS_MBC_HEAD(enc,p,e) (ONIGENC_MBC_ENC_LEN(enc,p,e) != 1) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ ------------------ | Branch (2027:11): [True: 0, False: 0] ------------------ 2028| | 2029| 0| cclass_mb: 2030| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2031| 0| { 2032| 0| OnigCodePoint code; 2033| 0| UChar *ss; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2034| 0| int mb_len; 2035| | 2036| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2037| 0| mb_len = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2038| 0| DATA_ENSURE(mb_len); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2039| 0| ss = s; 2040| 0| s += mb_len; 2041| 0| code = ONIGENC_MBC_TO_CODE(encode, ss, s); ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ 2042| | 2043| 0|#ifdef PLATFORM_UNALIGNED_WORD_ACCESS 2044| 0| if (! onig_is_in_code_range(p, code)) goto fail; ------------------ | Branch (2044:6): [True: 0, False: 0] ------------------ 2045| |#else 2046| | q = p; 2047| | ALIGNMENT_RIGHT(q); 2048| | if (! onig_is_in_code_range(q, code)) goto fail; 2049| |#endif 2050| 0| } 2051| 0| p += tlen; 2052| 0| MOP_OUT; 2053| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2054| | 2055| 0| CASE(OP_CCLASS_MIX) MOP_IN(OP_CCLASS_MIX); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2056| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2057| 0| if (ONIGENC_IS_MBC_HEAD(encode, s, end)) { ------------------ | | 319| 0|#define ONIGENC_IS_MBC_HEAD(enc,p,e) (ONIGENC_MBC_ENC_LEN(enc,p,e) != 1) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (319:40): [True: 0, False: 0] | | ------------------ ------------------ 2058| 0| p += SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2059| 0| goto cclass_mb; 2060| 0| } 2061| 0| else { 2062| 0| if (BITSET_AT(((BitSetRef )p), *s) == 0) ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2062:6): [True: 0, False: 0] ------------------ 2063| 0| goto fail; 2064| | 2065| 0| p += SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2066| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2067| 0| p += tlen; 2068| 0| s++; 2069| 0| } 2070| 0| MOP_OUT; 2071| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2072| | 2073| 5.97M| CASE(OP_CCLASS_NOT) MOP_IN(OP_CCLASS_NOT); ------------------ | | 1467| 5.97M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2074| 5.97M| DATA_ENSURE(1); ------------------ | | 1180| 5.97M|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 6.10k, False: 5.96M] | | ------------------ ------------------ 2075| 5.96M| if (BITSET_AT(((BitSetRef )p), *s) != 0) goto fail; ------------------ | | 448| 5.96M|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 5.96M|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 5.96M|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 5.96M|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 5.96M|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 5.96M|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 5.96M|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2075:11): [True: 13.7k, False: 5.95M] ------------------ 2076| 5.95M| p += SIZE_BITSET; ------------------ | | 438| 5.95M|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2077| 5.95M| s += enclen(encode, s, end); ------------------ | | 93| 5.95M|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 5.95M|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 5.95M] | | ------------------ ------------------ 2078| 5.95M| MOP_OUT; 2079| 5.95M| NEXT; ------------------ | | 1469| 5.95M|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 5.95M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 5.95M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2080| | 2081| 5.95M| CASE(OP_CCLASS_MB_NOT) MOP_IN(OP_CCLASS_MB_NOT); ------------------ | | 1467| 5.95M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 5.95M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2082| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2083| 0| if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) { ------------------ | | 319| 0|#define ONIGENC_IS_MBC_HEAD(enc,p,e) (ONIGENC_MBC_ENC_LEN(enc,p,e) != 1) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ ------------------ | Branch (2083:11): [True: 0, False: 0] ------------------ 2084| 0| s++; 2085| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2086| 0| p += tlen; 2087| 0| goto cc_mb_not_success; 2088| 0| } 2089| | 2090| 0| cclass_mb_not: 2091| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2092| 0| { 2093| 0| OnigCodePoint code; 2094| 0| UChar *ss; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2095| 0| int mb_len = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2096| | 2097| 0| if (! DATA_ENSURE_CHECK(mb_len)) { ------------------ | | 1179| 0|# define DATA_ENSURE_CHECK(n) (s + (n) <= right_range) ------------------ | Branch (2097:6): [True: 0, False: 0] ------------------ 2098| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2099| 0| s = (UChar* )end; 2100| 0| p += tlen; 2101| 0| goto cc_mb_not_success; 2102| 0| } 2103| | 2104| 0| ss = s; 2105| 0| s += mb_len; 2106| 0| code = ONIGENC_MBC_TO_CODE(encode, ss, s); ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ 2107| | 2108| 0|#ifdef PLATFORM_UNALIGNED_WORD_ACCESS 2109| 0| if (onig_is_in_code_range(p, code)) goto fail; ------------------ | Branch (2109:6): [True: 0, False: 0] ------------------ 2110| |#else 2111| | q = p; 2112| | ALIGNMENT_RIGHT(q); 2113| | if (onig_is_in_code_range(q, code)) goto fail; 2114| |#endif 2115| 0| } 2116| 0| p += tlen; 2117| | 2118| 0| cc_mb_not_success: 2119| 0| MOP_OUT; 2120| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2121| | 2122| 0| CASE(OP_CCLASS_MIX_NOT) MOP_IN(OP_CCLASS_MIX_NOT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2123| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2124| 0| if (ONIGENC_IS_MBC_HEAD(encode, s, end)) { ------------------ | | 319| 0|#define ONIGENC_IS_MBC_HEAD(enc,p,e) (ONIGENC_MBC_ENC_LEN(enc,p,e) != 1) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (319:40): [True: 0, False: 0] | | ------------------ ------------------ 2125| 0| p += SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2126| 0| goto cclass_mb_not; 2127| 0| } 2128| 0| else { 2129| 0| if (BITSET_AT(((BitSetRef )p), *s) != 0) ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2129:6): [True: 0, False: 0] ------------------ 2130| 0| goto fail; 2131| | 2132| 0| p += SIZE_BITSET; ------------------ | | 438| 0|#define SIZE_BITSET (int )sizeof(BitSet) ------------------ 2133| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2134| 0| p += tlen; 2135| 0| s++; 2136| 0| } 2137| 0| MOP_OUT; 2138| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2139| | 2140| 2.08k| CASE(OP_ANYCHAR) MOP_IN(OP_ANYCHAR); ------------------ | | 1467| 2.08k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2141| 2.08k| DATA_ENSURE(1); ------------------ | | 1180| 2.08k|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 914, False: 1.16k] | | ------------------ ------------------ 2142| 1.16k| n = enclen(encode, s, end); ------------------ | | 93| 1.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 1.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 1.16k] | | ------------------ ------------------ 2143| 1.16k| DATA_ENSURE(n); ------------------ | | 1180| 1.16k|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 1.16k] | | ------------------ ------------------ 2144| 1.16k| if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0)) goto fail; ------------------ | | 66| 1.16k| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) | | ------------------ | | | Branch (66:3): [True: 537, False: 630] | | ------------------ ------------------ 2145| 630| s += n; 2146| 630| MOP_OUT; 2147| 630| NEXT; ------------------ | | 1469| 630|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 630|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 630|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2148| | 2149| 630| CASE(OP_ANYCHAR_ML) MOP_IN(OP_ANYCHAR_ML); ------------------ | | 1467| 630|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 630|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2150| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2151| 0| n = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2152| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2153| 0| s += n; 2154| 0| MOP_OUT; 2155| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2156| | 2157| 630| CASE(OP_ANYCHAR_STAR) MOP_IN(OP_ANYCHAR_STAR); ------------------ | | 1467| 630|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2158| 733k| while (DATA_ENSURE_CHECK1) { ------------------ | | 1178| 733k|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 733k, False: 208] | | ------------------ ------------------ 2159| 733k| STACK_PUSH_ALT(p, s, sprev, pkeep); ------------------ | | 679| 733k|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 733k|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 733k| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 733k|#define STACK_ENSURE(n) do {\ | | | | | | 580| 733k| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 809, False: 732k] | | | | | | ------------------ | | | | | | 581| 809| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 809| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 809] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 809| }\ | | | | | | 588| 733k|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 733k| stk->type = (stack_type);\ | | | | 665| 733k| stk->u.state.pcode = (pat);\ | | | | 666| 733k| stk->u.state.pstr = (s);\ | | | | 667| 733k| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 733k| stk->u.state.pkeep = (keep);\ | | | | 669| 733k| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 733k|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 733k|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2160| 733k| n = enclen(encode, s, end); ------------------ | | 93| 733k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 733k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 733k] | | ------------------ ------------------ 2161| 733k| DATA_ENSURE(n); ------------------ | | 1180| 733k|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 733k] | | ------------------ ------------------ 2162| 733k| if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0)) goto fail; ------------------ | | 66| 733k| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) | | ------------------ | | | Branch (66:3): [True: 422, False: 732k] | | ------------------ ------------------ 2163| 732k| sprev = s; 2164| 732k| s += n; 2165| 732k| } 2166| 208| MOP_OUT; 2167| 208| JUMP; ------------------ | | 1470| 208|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 208|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2168| | 2169| 208| CASE(OP_ANYCHAR_ML_STAR) MOP_IN(OP_ANYCHAR_ML_STAR); ------------------ | | 1467| 208|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 208|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2170| 0| while (DATA_ENSURE_CHECK1) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ 2171| 0| STACK_PUSH_ALT(p, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2172| 0| n = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2173| 0| if (n > 1) { ------------------ | Branch (2173:6): [True: 0, False: 0] ------------------ 2174| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2175| 0| sprev = s; 2176| 0| s += n; 2177| 0| } 2178| 0| else { 2179| 0| sprev = s; 2180| 0| s++; 2181| 0| } 2182| 0| } 2183| 0| MOP_OUT; 2184| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2185| | 2186| 0| CASE(OP_ANYCHAR_STAR_PEEK_NEXT) MOP_IN(OP_ANYCHAR_STAR_PEEK_NEXT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2187| 0| while (DATA_ENSURE_CHECK1) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ 2188| 0| if (*p == *s) { ------------------ | Branch (2188:6): [True: 0, False: 0] ------------------ 2189| 0| STACK_PUSH_ALT(p + 1, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2190| 0| } 2191| 0| n = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2192| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2193| 0| if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0)) goto fail; ------------------ | | 66| 0| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) | | ------------------ | | | Branch (66:3): [True: 0, False: 0] | | ------------------ ------------------ 2194| 0| sprev = s; 2195| 0| s += n; 2196| 0| } 2197| 0| p++; 2198| 0| MOP_OUT; 2199| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2200| | 2201| 0| CASE(OP_ANYCHAR_ML_STAR_PEEK_NEXT)MOP_IN(OP_ANYCHAR_ML_STAR_PEEK_NEXT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2202| 0| while (DATA_ENSURE_CHECK1) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ 2203| 0| if (*p == *s) { ------------------ | Branch (2203:6): [True: 0, False: 0] ------------------ 2204| 0| STACK_PUSH_ALT(p + 1, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2205| 0| } 2206| 0| n = enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2207| 0| if (n > 1) { ------------------ | Branch (2207:6): [True: 0, False: 0] ------------------ 2208| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2209| 0| sprev = s; 2210| 0| s += n; 2211| 0| } 2212| 0| else { 2213| 0| sprev = s; 2214| 0| s++; 2215| 0| } 2216| 0| } 2217| 0| p++; 2218| 0| MOP_OUT; 2219| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2220| | 2221| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 2222| | CASE(OP_STATE_CHECK_ANYCHAR_STAR) MOP_IN(OP_STATE_CHECK_ANYCHAR_STAR); 2223| | GET_STATE_CHECK_NUM_INC(mem, p); 2224| | while (DATA_ENSURE_CHECK1) { 2225| | STATE_CHECK_VAL(scv, mem); 2226| | if (scv) goto fail; 2227| | 2228| | STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep); 2229| | n = enclen(encode, s, end); 2230| | DATA_ENSURE(n); 2231| | if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0)) goto fail; 2232| | sprev = s; 2233| | s += n; 2234| | } 2235| | MOP_OUT; 2236| | NEXT; 2237| | 2238| | CASE(OP_STATE_CHECK_ANYCHAR_ML_STAR) 2239| | MOP_IN(OP_STATE_CHECK_ANYCHAR_ML_STAR); 2240| | 2241| | GET_STATE_CHECK_NUM_INC(mem, p); 2242| | while (DATA_ENSURE_CHECK1) { 2243| | STATE_CHECK_VAL(scv, mem); 2244| | if (scv) goto fail; 2245| | 2246| | STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep); 2247| | n = enclen(encode, s, end); 2248| | if (n > 1) { 2249| | DATA_ENSURE(n); 2250| | sprev = s; 2251| | s += n; 2252| | } 2253| | else { 2254| | sprev = s; 2255| | s++; 2256| | } 2257| | } 2258| | MOP_OUT; 2259| | NEXT; 2260| |#endif /* USE_COMBINATION_EXPLOSION_CHECK */ 2261| | 2262| 0| CASE(OP_WORD) MOP_IN(OP_WORD); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2263| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2264| 0| if (! ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2264:11): [True: 0, False: 0] ------------------ 2265| 0| goto fail; 2266| | 2267| 0| s += enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2268| 0| MOP_OUT; 2269| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2270| | 2271| 0| CASE(OP_ASCII_WORD) MOP_IN(OP_ASCII_WORD); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2272| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2273| 0| if (! ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2273:11): [True: 0, False: 0] ------------------ 2274| 0| goto fail; 2275| | 2276| 0| s += enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2277| 0| MOP_OUT; 2278| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2279| | 2280| 0| CASE(OP_NOT_WORD) MOP_IN(OP_NOT_WORD); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2281| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2282| 0| if (ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2283| 0| goto fail; 2284| | 2285| 0| s += enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2286| 0| MOP_OUT; 2287| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2288| | 2289| 0| CASE(OP_NOT_ASCII_WORD) MOP_IN(OP_NOT_ASCII_WORD); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2290| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2291| 0| if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2292| 0| goto fail; 2293| | 2294| 0| s += enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2295| 0| MOP_OUT; 2296| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2297| | 2298| 0| CASE(OP_WORD_BOUND) MOP_IN(OP_WORD_BOUND); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2299| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ 2300| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2301| 0| if (! ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2301:6): [True: 0, False: 0] ------------------ 2302| 0| goto fail; 2303| 0| } 2304| 0| else if (ON_STR_END(s)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2305| 0| if (! ONIGENC_IS_MBC_WORD(encode, sprev, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2305:6): [True: 0, False: 0] ------------------ 2306| 0| goto fail; 2307| 0| } 2308| 0| else { 2309| 0| if (ONIGENC_IS_MBC_WORD(encode, s, end) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2309:6): [True: 0, False: 0] ------------------ 2310| 0| == ONIGENC_IS_MBC_WORD(encode, sprev, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ 2311| 0| goto fail; 2312| 0| } 2313| 0| MOP_OUT; 2314| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2315| | 2316| 0| CASE(OP_ASCII_WORD_BOUND) MOP_IN(OP_ASCII_WORD_BOUND); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2317| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ 2318| 0| DATA_ENSURE(1); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2319| 0| if (! ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2319:6): [True: 0, False: 0] ------------------ 2320| 0| goto fail; 2321| 0| } 2322| 0| else if (ON_STR_END(s)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2323| 0| if (! ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2323:6): [True: 0, False: 0] ------------------ 2324| 0| goto fail; 2325| 0| } 2326| 0| else { 2327| 0| if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2327:6): [True: 0, False: 0] ------------------ 2328| 0| == ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2329| 0| goto fail; 2330| 0| } 2331| 0| MOP_OUT; 2332| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2333| | 2334| 0| CASE(OP_NOT_WORD_BOUND) MOP_IN(OP_NOT_WORD_BOUND); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2335| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ 2336| 0| if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2337| 0| goto fail; 2338| 0| } 2339| 0| else if (ON_STR_END(s)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2340| 0| if (ONIGENC_IS_MBC_WORD(encode, sprev, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2341| 0| goto fail; 2342| 0| } 2343| 0| else { 2344| 0| if (ONIGENC_IS_MBC_WORD(encode, s, end) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2344:6): [True: 0, False: 0] ------------------ 2345| 0| != ONIGENC_IS_MBC_WORD(encode, sprev, end)) ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ 2346| 0| goto fail; 2347| 0| } 2348| 0| MOP_OUT; 2349| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2350| | 2351| 0| CASE(OP_NOT_ASCII_WORD_BOUND) MOP_IN(OP_NOT_ASCII_WORD_BOUND); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2352| 0| if (ON_STR_BEGIN(s)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ 2353| 0| if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2354| 0| goto fail; 2355| 0| } 2356| 0| else if (ON_STR_END(s)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2357| 0| if (ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2358| 0| goto fail; 2359| 0| } 2360| 0| else { 2361| 0| if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2361:6): [True: 0, False: 0] ------------------ 2362| 0| != ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2363| 0| goto fail; 2364| 0| } 2365| 0| MOP_OUT; 2366| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2367| | 2368| 0|#ifdef USE_WORD_BEGIN_END 2369| 0| CASE(OP_WORD_BEGIN) MOP_IN(OP_WORD_BEGIN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2370| 0| if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) { ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2371| 0| if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) { ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2371:25): [True: 0, False: 0] ------------------ 2372| 0| MOP_OUT; 2373| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2374| 0| } 2375| 0| } 2376| 0| goto fail; 2377| | 2378| 0| CASE(OP_ASCII_WORD_BEGIN) MOP_IN(OP_ASCII_WORD_BEGIN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2379| 0| if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) { ------------------ | | 1178| 0|# define DATA_ENSURE_CHECK1 (s < right_range) | | ------------------ | | | Branch (1178:32): [True: 0, False: 0] | | ------------------ ------------------ if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) { ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ 2380| 0| if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 0, False: 0] | | ------------------ ------------------ if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) { ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2380:25): [True: 0, False: 0] ------------------ 2381| 0| MOP_OUT; 2382| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2383| 0| } 2384| 0| } 2385| 0| goto fail; 2386| | 2387| 0| CASE(OP_WORD_END) MOP_IN(OP_WORD_END); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2388| 0| if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_WORD(encode, sprev, end)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_WORD(encode, sprev, end)) { ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | | | ------------------ | | | | | | | Branch (375:48): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2388:11): [True: 0, False: 0] ------------------ 2389| 0| if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) { ------------------ | | 323| 0| ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) | | ------------------ | | | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2389:23): [True: 0, False: 0] ------------------ 2390| 0| MOP_OUT; 2391| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2392| 0| } 2393| 0| } 2394| 0| goto fail; 2395| | 2396| 0| CASE(OP_ASCII_WORD_END) MOP_IN(OP_ASCII_WORD_END); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2397| 0| if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) { ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | ------------------ | | | Branch (325:4): [True: 0, False: 0] | | ------------------ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2397:11): [True: 0, False: 0] ------------------ 2398| 0| if (ON_STR_END(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ if (ON_STR_END(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) { ------------------ | | 325| 0| onigenc_ascii_is_code_ctype( \ | | 326| 0| ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) | | ------------------ | | | | 306| 0|#define ONIGENC_CTYPE_WORD 12 | | ------------------ ------------------ | Branch (2398:23): [True: 0, False: 0] ------------------ 2399| 0| MOP_OUT; 2400| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2401| 0| } 2402| 0| } 2403| 0| goto fail; 2404| 0|#endif 2405| | 2406| 0| CASE(OP_BEGIN_BUF) MOP_IN(OP_BEGIN_BUF); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2407| 0| if (! ON_STR_BEGIN(s)) goto fail; ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ | Branch (2407:11): [True: 0, False: 0] ------------------ 2408| 0| if (IS_NOTBOS(msa->options)) goto fail; ------------------ | | 404| 0|#define IS_NOTBOS(option) ((option) & ONIG_OPTION_NOTBOS) | | ------------------ | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | ------------------ | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | ------------------ | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (404:35): [True: 0, False: 0] | | ------------------ ------------------ 2409| | 2410| 0| MOP_OUT; 2411| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2412| | 2413| 0| CASE(OP_END_BUF) MOP_IN(OP_END_BUF); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2414| 0| if (! ON_STR_END(s)) goto fail; ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) ------------------ | Branch (2414:11): [True: 0, False: 0] ------------------ 2415| 0| if (IS_NOTEOS(msa->options)) goto fail; ------------------ | | 405| 0|#define IS_NOTEOS(option) ((option) & ONIG_OPTION_NOTEOS) | | ------------------ | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | ------------------ | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | ------------------ | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (405:35): [True: 0, False: 0] | | ------------------ ------------------ 2416| | 2417| 0| MOP_OUT; 2418| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2419| | 2420| 1.43M| CASE(OP_BEGIN_LINE) MOP_IN(OP_BEGIN_LINE); ------------------ | | 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2421| 1.43M| if (ON_STR_BEGIN(s)) { ------------------ | | 1175| 1.43M|#define ON_STR_BEGIN(s) ((s) == str) | | ------------------ | | | Branch (1175:32): [True: 1.38k, False: 1.43M] | | ------------------ ------------------ 2422| 1.38k| if (IS_NOTBOL(msa->options)) goto fail; ------------------ | | 402| 1.38k|#define IS_NOTBOL(option) ((option) & ONIG_OPTION_NOTBOL) | | ------------------ | | | | 465| 1.38k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | ------------------ | | | | | | 463| 1.38k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 462| 1.38k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | ------------------ | | | | | | | | | | 461| 1.38k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 460| 1.38k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 459| 1.38k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 458| 1.38k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 456| 1.38k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 455| 1.38k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 454| 1.38k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (402:35): [True: 0, False: 1.38k] | | ------------------ ------------------ 2423| 1.38k| MOP_OUT; 2424| 1.38k| JUMP; ------------------ | | 1470| 1.38k|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 1.38k|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2425| 1.38k| } 2426| 1.43M| else if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end) ------------------ | | 368| 2.87M|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end),enc) | | ------------------ | | | Branch (368:48): [True: 7.64k, False: 1.42M] | | ------------------ ------------------ 2427| 1.43M|#ifdef USE_CRNL_AS_LINE_TERMINATOR 2428| 1.43M| && !(IS_NEWLINE_CRLF(option) ------------------ | | 409| 15.2k|#define IS_NEWLINE_CRLF(option) ((option) & ONIG_OPTION_NEWLINE_CRLF) | | ------------------ | | | | 474| 7.64k|#define ONIG_OPTION_NEWLINE_CRLF (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1) | | | | ------------------ | | | | | | 472| 7.64k|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | | | ------------------ | | | | | | | | 471| 7.64k|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | | | ------------------ | | | | | | | | | | 470| 7.64k|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 468| 7.64k|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 467| 7.64k|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 466| 7.64k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 465| 7.64k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 463| 7.64k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 462| 7.64k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 461| 7.64k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 460| 7.64k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 7.64k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 7.64k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 7.64k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 7.64k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 7.64k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:35): [True: 0, False: 7.64k] | | ------------------ ------------------ 2429| 7.64k| && ONIGENC_IS_MBC_CRNL(encode, sprev, end)) ------------------ | | 63| 0| (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (63:4): [True: 0, False: 0] | | ------------------ | | 64| 0| ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p,end)),end) == 10) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | | Branch (369:68): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | ------------------ ------------------ 2430| 1.43M|#endif 2431| 1.43M| && !ON_STR_END(s)) { ------------------ | | 1176| 7.64k|#define ON_STR_END(s) ((s) == end) ------------------ | Branch (2431:6): [True: 7.63k, False: 6] ------------------ 2432| 7.63k| MOP_OUT; 2433| 7.63k| JUMP; ------------------ | | 1470| 7.63k|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 7.63k|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2434| 7.63k| } 2435| 1.43M| goto fail; 2436| | 2437| 1.43M| CASE(OP_END_LINE) MOP_IN(OP_END_LINE); ------------------ | | 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 1.43M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2438| 630| if (ON_STR_END(s)) { ------------------ | | 1176| 630|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 208, False: 422] | | ------------------ ------------------ 2439| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 2440| | if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE_EX(encode, sprev, str, end, option, 1)) { 2441| |#endif 2442| 208| if (IS_NOTEOL(msa->options)) goto fail; ------------------ | | 403| 208|#define IS_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 466| 208|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 465| 208|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 463| 208|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 462| 208|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 461| 208|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 460| 208|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 459| 208|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 458| 208|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 456| 208|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 455| 208|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 454| 208|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (403:35): [True: 0, False: 208] | | ------------------ ------------------ 2443| 208| MOP_OUT; 2444| 208| JUMP; ------------------ | | 1470| 208|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 208|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2445| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 2446| | } 2447| |#endif 2448| 208| } 2449| 422| else if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 1)) { ------------------ | | 66| 422| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) | | ------------------ | | | Branch (66:3): [True: 422, False: 0] | | ------------------ ------------------ 2450| 422| MOP_OUT; 2451| 422| JUMP; ------------------ | | 1470| 422|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 422|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2452| 422| } 2453| 630| goto fail; 2454| | 2455| 630| CASE(OP_SEMI_END_BUF) MOP_IN(OP_SEMI_END_BUF); ------------------ | | 1467| 630|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 630|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2456| 0| if (ON_STR_END(s)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2457| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 2458| | if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE_EX(encode, sprev, str, end, option, 1)) { 2459| |#endif 2460| 0| if (IS_NOTEOL(msa->options)) goto fail; ------------------ | | 403| 0|#define IS_NOTEOL(option) ((option) & ONIG_OPTION_NOTEOL) | | ------------------ | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | ------------------ | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | ------------------ | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | ------------------ | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (403:35): [True: 0, False: 0] | | ------------------ ------------------ 2461| 0| MOP_OUT; 2462| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2463| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 2464| | } 2465| |#endif 2466| 0| } 2467| 0| else if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 1)) { ------------------ | | 66| 0| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) | | ------------------ | | | Branch (66:3): [True: 0, False: 0] | | ------------------ ------------------ 2468| 0| UChar* ss = s + enclen(encode, s, end); ------------------ | | 76| 0|# define UChar OnigUChar ------------------ UChar* ss = s + enclen(encode, s, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2469| 0| if (ON_STR_END(ss)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2470| 0| MOP_OUT; 2471| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2472| 0| } 2473| 0|#ifdef USE_CRNL_AS_LINE_TERMINATOR 2474| 0| else if (IS_NEWLINE_CRLF(option) ------------------ | | 409| 0|#define IS_NEWLINE_CRLF(option) ((option) & ONIG_OPTION_NEWLINE_CRLF) | | ------------------ | | | | 474| 0|#define ONIG_OPTION_NEWLINE_CRLF (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1) | | | | ------------------ | | | | | | 472| 0|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | | | ------------------ | | | | | | | | 471| 0|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | | | ------------------ | | | | | | | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:35): [True: 0, False: 0] | | ------------------ ------------------ 2475| 0| && ONIGENC_IS_MBC_CRNL(encode, s, end)) { ------------------ | | 63| 0| (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (63:4): [True: 0, False: 0] | | ------------------ | | 64| 0| ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p,end)),end) == 10) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | | Branch (369:68): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | ------------------ ------------------ 2476| 0| ss += enclen(encode, ss, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 2477| 0| if (ON_STR_END(ss)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 2478| 0| MOP_OUT; 2479| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2480| 0| } 2481| 0| } 2482| 0|#endif 2483| 0| } 2484| 0| goto fail; 2485| | 2486| 0| CASE(OP_BEGIN_POSITION) MOP_IN(OP_BEGIN_POSITION); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2487| 0| if (s != msa->gpos) ------------------ | Branch (2487:11): [True: 0, False: 0] ------------------ 2488| 0| goto fail; 2489| | 2490| 0| MOP_OUT; 2491| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2492| | 2493| 0| CASE(OP_MEMORY_START_PUSH) MOP_IN(OP_MEMORY_START_PUSH); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2494| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2495| 0| STACK_PUSH_MEM_START(mem, s); ------------------ | | 703| 0|#define STACK_PUSH_MEM_START(mnum, s) do {\ | | 704| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 705| 0| stk->type = STK_MEM_START;\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | 706| 0| stk->u.mem.num = (mnum);\ | | 707| 0| stk->u.mem.pstr = (s);\ | | 708| 0| stk->u.mem.start = mem_start_stk[mnum];\ | | 709| 0| stk->u.mem.end = mem_end_stk[mnum];\ | | 710| 0| mem_start_stk[mnum] = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 711| 0| mem_end_stk[mnum] = INVALID_STACK_INDEX;\ | | ------------------ | | | | 386| 0|#define INVALID_STACK_INDEX -1 | | ------------------ | | 712| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 713| 0|} while(0) | | ------------------ | | | Branch (713:9): [Folded - Ignored] | | ------------------ ------------------ 2496| 0| MOP_OUT; 2497| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2498| | 2499| 21.9k| CASE(OP_MEMORY_START) MOP_IN(OP_MEMORY_START); ------------------ | | 1467| 21.9k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2500| 21.9k| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 21.9k|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 21.9k|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 21.9k| val = *(type* )p;\ | | | | 323| 21.9k| (p) += sizeof(type);\ | | | | 324| 21.9k|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2501| 21.9k| mem_start_stk[mem] = (OnigStackIndex )((void* )s); 2502| 21.9k| mem_end_stk[mem] = INVALID_STACK_INDEX; ------------------ | | 386| 21.9k|#define INVALID_STACK_INDEX -1 ------------------ 2503| 21.9k| MOP_OUT; 2504| 21.9k| JUMP; ------------------ | | 1470| 21.9k|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 21.9k|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2505| | 2506| 21.9k| CASE(OP_MEMORY_END_PUSH) MOP_IN(OP_MEMORY_END_PUSH); ------------------ | | 1467| 21.9k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 21.9k|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2507| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2508| 0| STACK_PUSH_MEM_END(mem, s); ------------------ | | 715| 0|#define STACK_PUSH_MEM_END(mnum, s) do {\ | | 716| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 717| 0| stk->type = STK_MEM_END;\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | 718| 0| stk->u.mem.num = (mnum);\ | | 719| 0| stk->u.mem.pstr = (s);\ | | 720| 0| stk->u.mem.start = mem_start_stk[mnum];\ | | 721| 0| stk->u.mem.end = mem_end_stk[mnum];\ | | 722| 0| mem_end_stk[mnum] = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 723| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 724| 0|} while(0) | | ------------------ | | | Branch (724:9): [Folded - Ignored] | | ------------------ ------------------ 2509| 0| MOP_OUT; 2510| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2511| | 2512| 19.3k| CASE(OP_MEMORY_END) MOP_IN(OP_MEMORY_END); ------------------ | | 1467| 19.3k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2513| 19.3k| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 19.3k|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 19.3k|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 19.3k| val = *(type* )p;\ | | | | 323| 19.3k| (p) += sizeof(type);\ | | | | 324| 19.3k|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2514| 19.3k| mem_end_stk[mem] = (OnigStackIndex )((void* )s); 2515| 19.3k| MOP_OUT; 2516| 19.3k| JUMP; ------------------ | | 1470| 19.3k|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 19.3k|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2517| | 2518| 19.3k| CASE(OP_KEEP) MOP_IN(OP_KEEP); ------------------ | | 1467| 19.3k|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 19.3k|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2519| 0| pkeep = s; 2520| 0| MOP_OUT; 2521| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2522| | 2523| 0|#ifdef USE_SUBEXP_CALL 2524| 0| CASE(OP_MEMORY_END_PUSH_REC) MOP_IN(OP_MEMORY_END_PUSH_REC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2525| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2526| 0| STACK_GET_MEM_START(mem, stkp); /* should be before push mem-end. */ ------------------ | | 733| 0|#define STACK_GET_MEM_START(mnum, k) do {\ | | 734| 0| int level = 0;\ | | 735| 0| k = stk;\ | | 736| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (736:10): [True: 0, False: 0] | | ------------------ | | 737| 0| k--;\ | | 738| 0| if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \ | | ------------------ | | | | 414| 0|#define STK_MASK_MEM_END_OR_MARK 0x8000 /* MEM_END or MEM_END_MARK */ | | ------------------ | | | Branch (738:9): [True: 0, False: 0] | | ------------------ | | 739| 0| && k->u.mem.num == (mnum)) {\ | | ------------------ | | | Branch (739:10): [True: 0, False: 0] | | ------------------ | | 740| 0| level++;\ | | 741| 0| }\ | | 742| 0| else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (742:14): [True: 0, False: 0] | | | Branch (742:42): [True: 0, False: 0] | | ------------------ | | 743| 0| if (level == 0) break;\ | | ------------------ | | | Branch (743:11): [True: 0, False: 0] | | ------------------ | | 744| 0| level--;\ | | 745| 0| }\ | | 746| 0| }\ | | 747| 0|} while(0) | | ------------------ | | | Branch (747:9): [Folded - Ignored] | | ------------------ ------------------ 2527| 0| STACK_PUSH_MEM_END(mem, s); ------------------ | | 715| 0|#define STACK_PUSH_MEM_END(mnum, s) do {\ | | 716| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 717| 0| stk->type = STK_MEM_END;\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | 718| 0| stk->u.mem.num = (mnum);\ | | 719| 0| stk->u.mem.pstr = (s);\ | | 720| 0| stk->u.mem.start = mem_start_stk[mnum];\ | | 721| 0| stk->u.mem.end = mem_end_stk[mnum];\ | | 722| 0| mem_end_stk[mnum] = GET_STACK_INDEX(stk);\ | | ------------------ | | | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) | | ------------------ | | 723| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 724| 0|} while(0) | | ------------------ | | | Branch (724:9): [Folded - Ignored] | | ------------------ ------------------ 2528| 0| mem_start_stk[mem] = GET_STACK_INDEX(stkp); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2529| 0| MOP_OUT; 2530| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2531| | 2532| 0| CASE(OP_MEMORY_END_REC) MOP_IN(OP_MEMORY_END_REC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2533| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2534| 0| mem_end_stk[mem] = (OnigStackIndex )((void* )s); 2535| 0| STACK_GET_MEM_START(mem, stkp); ------------------ | | 733| 0|#define STACK_GET_MEM_START(mnum, k) do {\ | | 734| 0| int level = 0;\ | | 735| 0| k = stk;\ | | 736| 0| while (k > stk_base) {\ | | ------------------ | | | Branch (736:10): [True: 0, False: 0] | | ------------------ | | 737| 0| k--;\ | | 738| 0| if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \ | | ------------------ | | | | 414| 0|#define STK_MASK_MEM_END_OR_MARK 0x8000 /* MEM_END or MEM_END_MARK */ | | ------------------ | | | Branch (738:9): [True: 0, False: 0] | | ------------------ | | 739| 0| && k->u.mem.num == (mnum)) {\ | | ------------------ | | | Branch (739:10): [True: 0, False: 0] | | ------------------ | | 740| 0| level++;\ | | 741| 0| }\ | | 742| 0| else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (742:14): [True: 0, False: 0] | | | Branch (742:42): [True: 0, False: 0] | | ------------------ | | 743| 0| if (level == 0) break;\ | | ------------------ | | | Branch (743:11): [True: 0, False: 0] | | ------------------ | | 744| 0| level--;\ | | 745| 0| }\ | | 746| 0| }\ | | 747| 0|} while(0) | | ------------------ | | | Branch (747:9): [Folded - Ignored] | | ------------------ ------------------ 2536| | 2537| 0| if (BIT_STATUS_AT(reg->bt_mem_start, mem)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2538| 0| mem_start_stk[mem] = GET_STACK_INDEX(stkp); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2539| 0| else 2540| 0| mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr); 2541| | 2542| 0| STACK_PUSH_MEM_END_MARK(mem); ------------------ | | 726| 0|#define STACK_PUSH_MEM_END_MARK(mnum) do {\ | | 727| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 728| 0| stk->type = STK_MEM_END_MARK;\ | | ------------------ | | | | 401| 0|#define STK_MEM_END_MARK 0x8400 | | ------------------ | | 729| 0| stk->u.mem.num = (mnum);\ | | 730| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 731| 0|} while(0) | | ------------------ | | | Branch (731:9): [Folded - Ignored] | | ------------------ ------------------ 2543| 0| MOP_OUT; 2544| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2545| 0|#endif 2546| | 2547| 0| CASE(OP_BACKREF1) MOP_IN(OP_BACKREF1); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2548| 0| mem = 1; 2549| 0| goto backref; 2550| | 2551| 0| CASE(OP_BACKREF2) MOP_IN(OP_BACKREF2); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2552| 0| mem = 2; 2553| 0| goto backref; 2554| | 2555| 0| CASE(OP_BACKREFN) MOP_IN(OP_BACKREFN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2556| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2557| 0| backref: 2558| 0| { 2559| 0| int len; 2560| 0| UChar *pstart, *pend; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2561| | 2562| | /* if you want to remove following line, 2563| | you should check in parse and compile time. */ 2564| 0| if (mem > num_mem) goto fail; ------------------ | Branch (2564:6): [True: 0, False: 0] ------------------ 2565| 0| if (mem_end_stk[mem] == INVALID_STACK_INDEX) goto fail; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2565:6): [True: 0, False: 0] ------------------ 2566| 0| if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2566:6): [True: 0, False: 0] ------------------ 2567| | 2568| 0| if (BIT_STATUS_AT(reg->bt_mem_start, mem)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2569| 0| pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr; ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2570| 0| else 2571| 0| pstart = (UChar* )((void* )mem_start_stk[mem]); 2572| | 2573| 0| pend = (BIT_STATUS_AT(reg->bt_mem_end, mem) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2574| 0| ? STACK_AT(mem_end_stk[mem])->u.mem.pstr ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2575| 0| : (UChar* )((void* )mem_end_stk[mem])); 2576| 0| n = pend - pstart; 2577| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2578| 0| sprev = s; 2579| 0| STRING_CMP(pstart, s, n); ------------------ | | 1119| 0|#define STRING_CMP(s1,s2,len) do {\ | | 1120| 0| while (len-- > 0) {\ | | ------------------ | | | Branch (1120:10): [True: 0, False: 0] | | ------------------ | | 1121| 0| if (*s1++ != *s2++) goto fail;\ | | ------------------ | | | Branch (1121:9): [True: 0, False: 0] | | ------------------ | | 1122| 0| }\ | | 1123| 0|} while(0) | | ------------------ | | | Branch (1123:9): [Folded - Ignored] | | ------------------ ------------------ 2580| 0| while (sprev + (len = enclen(encode, sprev, end)) < s) ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2580:9): [True: 0, False: 0] ------------------ 2581| 0| sprev += len; 2582| | 2583| 0| MOP_OUT; 2584| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2585| 0| } 2586| | 2587| 0| CASE(OP_BACKREFN_IC) MOP_IN(OP_BACKREFN_IC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2588| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2589| 0| { 2590| 0| int len; 2591| 0| UChar *pstart, *pend; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2592| | 2593| | /* if you want to remove following line, 2594| | you should check in parse and compile time. */ 2595| 0| if (mem > num_mem) goto fail; ------------------ | Branch (2595:6): [True: 0, False: 0] ------------------ 2596| 0| if (mem_end_stk[mem] == INVALID_STACK_INDEX) goto fail; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2596:6): [True: 0, False: 0] ------------------ 2597| 0| if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2597:6): [True: 0, False: 0] ------------------ 2598| | 2599| 0| if (BIT_STATUS_AT(reg->bt_mem_start, mem)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2600| 0| pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr; ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2601| 0| else 2602| 0| pstart = (UChar* )((void* )mem_start_stk[mem]); 2603| | 2604| 0| pend = (BIT_STATUS_AT(reg->bt_mem_end, mem) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2605| 0| ? STACK_AT(mem_end_stk[mem])->u.mem.pstr ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2606| 0| : (UChar* )((void* )mem_end_stk[mem])); 2607| 0| n = pend - pstart; 2608| 0| DATA_ENSURE(n); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 2609| 0| sprev = s; 2610| 0| STRING_CMP_IC(case_fold_flag, pstart, &s, (int)n, end); ------------------ | | 1125| 0|#define STRING_CMP_IC(case_fold_flag,s1,ps2,len,text_end) do {\ | | 1126| 0| if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \ | | ------------------ | | | Branch (1126:7): [True: 0, False: 0] | | ------------------ | | 1127| 0| goto fail; \ | | 1128| 0|} while(0) | | ------------------ | | | Branch (1128:9): [Folded - Ignored] | | ------------------ ------------------ 2611| 0| while (sprev + (len = enclen(encode, sprev, end)) < s) ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2611:9): [True: 0, False: 0] ------------------ 2612| 0| sprev += len; 2613| | 2614| 0| MOP_OUT; 2615| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2616| 0| } 2617| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2618| | 2619| 0| CASE(OP_BACKREF_MULTI) MOP_IN(OP_BACKREF_MULTI); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2620| 0| { 2621| 0| int len, is_fail; 2622| 0| UChar *pstart, *pend, *swork; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2623| | 2624| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2625| 0| for (i = 0; i < tlen; i++) { ------------------ | Branch (2625:14): [True: 0, False: 0] ------------------ 2626| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2627| | 2628| 0| if (mem_end_stk[mem] == INVALID_STACK_INDEX) continue; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2628:8): [True: 0, False: 0] ------------------ 2629| 0| if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2629:8): [True: 0, False: 0] ------------------ 2630| | 2631| 0| if (BIT_STATUS_AT(reg->bt_mem_start, mem)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2632| 0| pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr; ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2633| 0| else 2634| 0| pstart = (UChar* )((void* )mem_start_stk[mem]); 2635| | 2636| 0| pend = (BIT_STATUS_AT(reg->bt_mem_end, mem) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2637| 0| ? STACK_AT(mem_end_stk[mem])->u.mem.pstr ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2638| 0| : (UChar* )((void* )mem_end_stk[mem])); 2639| 0| n = pend - pstart; 2640| 0| DATA_ENSURE_CONTINUE(n); ------------------ | | 1181| 0|# define DATA_ENSURE_CONTINUE(n) if (s + (n) > right_range) continue | | ------------------ | | | Branch (1181:38): [True: 0, False: 0] | | ------------------ ------------------ 2641| 0| sprev = s; 2642| 0| swork = s; 2643| 0| STRING_CMP_VALUE(pstart, swork, n, is_fail); ------------------ | | 1157| 0|#define STRING_CMP_VALUE(s1,s2,len,is_fail) do {\ | | 1158| 0| is_fail = 0;\ | | 1159| 0| while (len-- > 0) {\ | | ------------------ | | | Branch (1159:10): [True: 0, False: 0] | | ------------------ | | 1160| 0| if (*s1++ != *s2++) {\ | | ------------------ | | | Branch (1160:9): [True: 0, False: 0] | | ------------------ | | 1161| 0| is_fail = 1; break;\ | | 1162| 0| }\ | | 1163| 0| }\ | | 1164| 0|} while(0) | | ------------------ | | | Branch (1164:9): [Folded - Ignored] | | ------------------ ------------------ 2644| 0| if (is_fail) continue; ------------------ | Branch (2644:8): [True: 0, False: 0] ------------------ 2645| 0| s = swork; 2646| 0| while (sprev + (len = enclen(encode, sprev, end)) < s) ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2646:11): [True: 0, False: 0] ------------------ 2647| 0| sprev += len; 2648| | 2649| 0| p += (SIZE_MEMNUM * (tlen - i - 1)); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 2650| 0| break; /* success */ 2651| 0| } 2652| 0| if (i == tlen) goto fail; ------------------ | Branch (2652:6): [True: 0, False: 0] ------------------ 2653| 0| MOP_OUT; 2654| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2655| 0| } 2656| 0| NEXT; ------------------ | | 1469| 0|# define NEXT sprev = sbegin; JUMP | | ------------------ | | | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | | | ------------------ | | | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | | | ------------------ | | ------------------ ------------------ 2657| | 2658| 0| CASE(OP_BACKREF_MULTI_IC) MOP_IN(OP_BACKREF_MULTI_IC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2659| 0| { 2660| 0| int len, is_fail; 2661| 0| UChar *pstart, *pend, *swork; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2662| | 2663| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2664| 0| for (i = 0; i < tlen; i++) { ------------------ | Branch (2664:14): [True: 0, False: 0] ------------------ 2665| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2666| | 2667| 0| if (mem_end_stk[mem] == INVALID_STACK_INDEX) continue; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2667:8): [True: 0, False: 0] ------------------ 2668| 0| if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue; ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (2668:8): [True: 0, False: 0] ------------------ 2669| | 2670| 0| if (BIT_STATUS_AT(reg->bt_mem_start, mem)) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2671| 0| pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr; ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2672| 0| else 2673| 0| pstart = (UChar* )((void* )mem_start_stk[mem]); 2674| | 2675| 0| pend = (BIT_STATUS_AT(reg->bt_mem_end, mem) ------------------ | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (371:3): [True: 0, False: 0] | | | Branch (371:4): [True: 0, False: 0] | | ------------------ ------------------ 2676| 0| ? STACK_AT(mem_end_stk[mem])->u.mem.pstr ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2677| 0| : (UChar* )((void* )mem_end_stk[mem])); 2678| 0| n = pend - pstart; 2679| 0| DATA_ENSURE_CONTINUE(n); ------------------ | | 1181| 0|# define DATA_ENSURE_CONTINUE(n) if (s + (n) > right_range) continue | | ------------------ | | | Branch (1181:38): [True: 0, False: 0] | | ------------------ ------------------ 2680| 0| sprev = s; 2681| 0| swork = s; 2682| 0| STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, end, is_fail); ------------------ | | 1166| 0|#define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,text_end,is_fail) do {\ | | 1167| 0| if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \ | | ------------------ | | | Branch (1167:7): [True: 0, False: 0] | | ------------------ | | 1168| 0| is_fail = 1; \ | | 1169| 0| else \ | | 1170| 0| is_fail = 0; \ | | 1171| 0|} while(0) | | ------------------ | | | Branch (1171:9): [Folded - Ignored] | | ------------------ ------------------ 2683| 0| if (is_fail) continue; ------------------ | Branch (2683:8): [True: 0, False: 0] ------------------ 2684| 0| s = swork; 2685| 0| while (sprev + (len = enclen(encode, sprev, end)) < s) ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2685:11): [True: 0, False: 0] ------------------ 2686| 0| sprev += len; 2687| | 2688| 0| p += (SIZE_MEMNUM * (tlen - i - 1)); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 2689| 0| break; /* success */ 2690| 0| } 2691| 0| if (i == tlen) goto fail; ------------------ | Branch (2691:6): [True: 0, False: 0] ------------------ 2692| 0| MOP_OUT; 2693| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2694| 0| } 2695| | 2696| 0|#ifdef USE_BACKREF_WITH_LEVEL 2697| 0| CASE(OP_BACKREF_WITH_LEVEL) ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2698| 0| { 2699| 0| int len; 2700| 0| OnigOptionType ic; 2701| 0| LengthType level; 2702| | 2703| 0| GET_OPTION_INC(ic, p); ------------------ | | 705| 0|#define GET_OPTION_INC(option,p) PLATFORM_GET_INC(option, p, OnigOptionType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2704| 0| GET_LENGTH_INC(level, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2705| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2706| | 2707| 0| sprev = s; 2708| 0| if (backref_match_at_nested_level(reg, stk, stk_base, ic, ------------------ | Branch (2708:6): [True: 0, False: 0] ------------------ 2709| 0| case_fold_flag, (int )level, (int )tlen, p, &s, end)) { 2710| 0| while (sprev + (len = enclen(encode, sprev, end)) < s) ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2710:11): [True: 0, False: 0] ------------------ 2711| 0| sprev += len; 2712| | 2713| 0| p += (SIZE_MEMNUM * tlen); ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 2714| 0| } 2715| 0| else 2716| 0| goto fail; 2717| | 2718| 0| MOP_OUT; 2719| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2720| 0| } 2721| | 2722| 0|#endif 2723| | 2724| |#if 0 /* no need: IS_DYNAMIC_OPTION() == 0 */ 2725| | CASE(OP_SET_OPTION_PUSH) MOP_IN(OP_SET_OPTION_PUSH); 2726| | GET_OPTION_INC(option, p); 2727| | STACK_PUSH_ALT(p, s, sprev, pkeep); 2728| | p += SIZE_OP_SET_OPTION + SIZE_OP_FAIL; 2729| | MOP_OUT; 2730| | JUMP; 2731| | 2732| | CASE(OP_SET_OPTION) MOP_IN(OP_SET_OPTION); 2733| | GET_OPTION_INC(option, p); 2734| | MOP_OUT; 2735| | JUMP; 2736| |#endif 2737| | 2738| 0| CASE(OP_NULL_CHECK_START) MOP_IN(OP_NULL_CHECK_START); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2739| 0| GET_MEMNUM_INC(mem, p); /* mem: null check id */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2740| 0| STACK_PUSH_NULL_CHECK_START(mem, s); ------------------ | | 767| 0|#define STACK_PUSH_NULL_CHECK_START(cnum, s) do {\ | | 768| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 769| 0| stk->type = STK_NULL_CHECK_START;\ | | ------------------ | | | | 399| 0|#define STK_NULL_CHECK_START 0x3000 | | ------------------ | | 770| 0| stk->u.null_check.num = (cnum);\ | | 771| 0| stk->u.null_check.pstr = (s);\ | | 772| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 773| 0|} while(0) | | ------------------ | | | Branch (773:9): [Folded - Ignored] | | ------------------ ------------------ 2741| 0| MOP_OUT; 2742| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2743| | 2744| 0| CASE(OP_NULL_CHECK_END) MOP_IN(OP_NULL_CHECK_END); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2745| 0| { 2746| 0| int isnull; 2747| | 2748| 0| GET_MEMNUM_INC(mem, p); /* mem: null check id */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2749| 0| STACK_NULL_CHECK(isnull, mem, s); ------------------ | | 960| 0|#define STACK_NULL_CHECK(isnull,id,s) do {\ | | 961| 0| OnigStackType* k = stk;\ | | 962| 0| while (1) {\ | | ------------------ | | | Branch (962:10): [Folded - Ignored] | | ------------------ | | 963| 0| k--;\ | | 964| 0| STACK_BASE_CHECK(k, "STACK_NULL_CHECK"); \ | | 965| 0| if (k->type == STK_NULL_CHECK_START) {\ | | ------------------ | | | | 399| 0|#define STK_NULL_CHECK_START 0x3000 | | ------------------ | | | Branch (965:9): [True: 0, False: 0] | | ------------------ | | 966| 0| if (k->u.null_check.num == (id)) {\ | | ------------------ | | | Branch (966:11): [True: 0, False: 0] | | ------------------ | | 967| 0| (isnull) = (k->u.null_check.pstr == (s));\ | | 968| 0| break;\ | | 969| 0| }\ | | 970| 0| }\ | | 971| 0| }\ | | 972| 0|} while(0) | | ------------------ | | | Branch (972:9): [Folded - Ignored] | | ------------------ ------------------ 2750| 0| if (isnull) { ------------------ | Branch (2750:6): [True: 0, False: 0] ------------------ 2751| |#ifdef ONIG_DEBUG_MATCH 2752| | fprintf(stderr, "NULL_CHECK_END: skip id:%d, s:%"PRIuPTR" (%p)\n", 2753| | (int )mem, (uintptr_t )s, s); 2754| |#endif 2755| 0| null_check_found: 2756| | /* empty loop founded, skip next instruction */ 2757| 0| switch (*p++) { 2758| 0| case OP_JUMP: ------------------ | Branch (2758:4): [True: 0, False: 0] ------------------ 2759| 0| case OP_PUSH: ------------------ | Branch (2759:4): [True: 0, False: 0] ------------------ 2760| 0| p += SIZE_RELADDR; ------------------ | | 689| 0|#define SIZE_RELADDR (int )sizeof(RelAddrType) ------------------ 2761| 0| break; 2762| 0| case OP_REPEAT_INC: ------------------ | Branch (2762:4): [True: 0, False: 0] ------------------ 2763| 0| case OP_REPEAT_INC_NG: ------------------ | Branch (2763:4): [True: 0, False: 0] ------------------ 2764| 0| case OP_REPEAT_INC_SG: ------------------ | Branch (2764:4): [True: 0, False: 0] ------------------ 2765| 0| case OP_REPEAT_INC_NG_SG: ------------------ | Branch (2765:4): [True: 0, False: 0] ------------------ 2766| 0| p += SIZE_MEMNUM; ------------------ | | 692| 0|#define SIZE_MEMNUM (int )sizeof(MemNumType) ------------------ 2767| 0| break; 2768| 0| default: ------------------ | Branch (2768:4): [True: 0, False: 0] ------------------ 2769| 0| goto unexpected_bytecode_error; 2770| 0| break; 2771| 0| } 2772| 0| } 2773| 0| } 2774| 0| MOP_OUT; 2775| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2776| | 2777| 0|#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 2778| 0| CASE(OP_NULL_CHECK_END_MEMST) MOP_IN(OP_NULL_CHECK_END_MEMST); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2779| 0| { 2780| 0| int isnull; 2781| | 2782| 0| GET_MEMNUM_INC(mem, p); /* mem: null check id */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2783| 0| STACK_NULL_CHECK_MEMST(isnull, mem, s, reg); ------------------ | | 995| 0|#define STACK_NULL_CHECK_MEMST(isnull,id,s,reg) do {\ | | 996| 0| OnigStackType* k = stk;\ | | 997| 0| while (1) {\ | | ------------------ | | | Branch (997:10): [Folded - Ignored] | | ------------------ | | 998| 0| k--;\ | | 999| 0| STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST"); \ | | 1000| 0| if (k->type == STK_NULL_CHECK_START) {\ | | ------------------ | | | | 399| 0|#define STK_NULL_CHECK_START 0x3000 | | ------------------ | | | Branch (1000:9): [True: 0, False: 0] | | ------------------ | | 1001| 0| if (k->u.null_check.num == (id)) {\ | | ------------------ | | | Branch (1001:11): [True: 0, False: 0] | | ------------------ | | 1002| 0| if (k->u.null_check.pstr != (s)) {\ | | ------------------ | | | Branch (1002:13): [True: 0, False: 0] | | ------------------ | | 1003| 0| (isnull) = 0;\ | | 1004| 0| break;\ | | 1005| 0| }\ | | 1006| 0| else {\ | | 1007| 0| UChar* endp;\ | | ------------------ | | | | 76| 0|# define UChar OnigUChar | | ------------------ | | 1008| 0| (isnull) = 1;\ | | 1009| 0| while (k < stk) {\ | | ------------------ | | | Branch (1009:18): [True: 0, False: 0] | | ------------------ | | 1010| 0| if (k->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (1010:17): [True: 0, False: 0] | | ------------------ | | 1011| 0| if (k->u.mem.end == INVALID_STACK_INDEX) {\ | | ------------------ | | | | 386| 0|#define INVALID_STACK_INDEX -1 | | ------------------ | | | Branch (1011:19): [True: 0, False: 0] | | ------------------ | | 1012| 0| (isnull) = 0; break;\ | | 1013| 0| }\ | | 1014| 0| if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\ | | ------------------ | | | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | | | ------------------ | | | | | Branch (371:3): [True: 0, False: 0] | | | | | Branch (371:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1015| 0| endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 1016| 0| else\ | | 1017| 0| endp = (UChar* )k->u.mem.end;\ | | 1018| 0| if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | | Branch (1018:19): [True: 0, False: 0] | | ------------------ | | 1019| 0| (isnull) = 0; break;\ | | 1020| 0| }\ | | 1021| 0| else if (endp != s) {\ | | ------------------ | | | Branch (1021:24): [True: 0, False: 0] | | ------------------ | | 1022| 0| (isnull) = -1; /* empty, but position changed */ \ | | 1023| 0| }\ | | 1024| 0| }\ | | 1025| 0| k++;\ | | 1026| 0| }\ | | 1027| 0| break;\ | | 1028| 0| }\ | | 1029| 0| }\ | | 1030| 0| }\ | | 1031| 0| }\ | | 1032| 0|} while(0) | | ------------------ | | | Branch (1032:9): [Folded - Ignored] | | ------------------ ------------------ 2784| 0| if (isnull) { ------------------ | Branch (2784:6): [True: 0, False: 0] ------------------ 2785| |# ifdef ONIG_DEBUG_MATCH 2786| | fprintf(stderr, "NULL_CHECK_END_MEMST: skip id:%d, s:%"PRIuPTR" (%p)\n", 2787| | (int )mem, (uintptr_t )s, s); 2788| |# endif 2789| 0| if (isnull == -1) goto fail; ------------------ | Branch (2789:8): [True: 0, False: 0] ------------------ 2790| 0| goto null_check_found; 2791| 0| } 2792| 0| } 2793| 0| MOP_OUT; 2794| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2795| 0|#endif 2796| | 2797| 0|#ifdef USE_SUBEXP_CALL 2798| 0| CASE(OP_NULL_CHECK_END_MEMST_PUSH) ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2799| 0| MOP_IN(OP_NULL_CHECK_END_MEMST_PUSH); 2800| 0| { 2801| 0| int isnull; 2802| | 2803| 0| GET_MEMNUM_INC(mem, p); /* mem: null check id */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2804| 0|# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT 2805| 0| STACK_NULL_CHECK_MEMST_REC(isnull, mem, s, reg); ------------------ | | 1034| 0|#define STACK_NULL_CHECK_MEMST_REC(isnull,id,s,reg) do {\ | | 1035| 0| int level = 0;\ | | 1036| 0| OnigStackType* k = stk;\ | | 1037| 0| while (1) {\ | | ------------------ | | | Branch (1037:10): [Folded - Ignored] | | ------------------ | | 1038| 0| k--;\ | | 1039| 0| STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST_REC"); \ | | 1040| 0| if (k->type == STK_NULL_CHECK_START) {\ | | ------------------ | | | | 399| 0|#define STK_NULL_CHECK_START 0x3000 | | ------------------ | | | Branch (1040:9): [True: 0, False: 0] | | ------------------ | | 1041| 0| if (k->u.null_check.num == (id)) {\ | | ------------------ | | | Branch (1041:11): [True: 0, False: 0] | | ------------------ | | 1042| 0| if (level == 0) {\ | | ------------------ | | | Branch (1042:13): [True: 0, False: 0] | | ------------------ | | 1043| 0| if (k->u.null_check.pstr != (s)) {\ | | ------------------ | | | Branch (1043:15): [True: 0, False: 0] | | ------------------ | | 1044| 0| (isnull) = 0;\ | | 1045| 0| break;\ | | 1046| 0| }\ | | 1047| 0| else {\ | | 1048| 0| UChar* endp;\ | | ------------------ | | | | 76| 0|# define UChar OnigUChar | | ------------------ | | 1049| 0| (isnull) = 1;\ | | 1050| 0| while (k < stk) {\ | | ------------------ | | | Branch (1050:20): [True: 0, False: 0] | | ------------------ | | 1051| 0| if (k->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (1051:19): [True: 0, False: 0] | | ------------------ | | 1052| 0| if (k->u.mem.end == INVALID_STACK_INDEX) {\ | | ------------------ | | | | 386| 0|#define INVALID_STACK_INDEX -1 | | ------------------ | | | Branch (1052:21): [True: 0, False: 0] | | ------------------ | | 1053| 0| (isnull) = 0; break;\ | | 1054| 0| }\ | | 1055| 0| if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\ | | ------------------ | | | | 371| 0| ((n) < (int )BIT_STATUS_BITS_NUM ? ((stats) & ((BitStatusType )1 << n)) : ((stats) & 1)) | | | | ------------------ | | | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | | | ------------------ | | | | | Branch (371:3): [True: 0, False: 0] | | | | | Branch (371:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1056| 0| endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 1057| 0| else\ | | 1058| 0| endp = (UChar* )k->u.mem.end;\ | | 1059| 0| if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | | Branch (1059:21): [True: 0, False: 0] | | ------------------ | | 1060| 0| (isnull) = 0; break;\ | | 1061| 0| }\ | | 1062| 0| else if (endp != s) {\ | | ------------------ | | | Branch (1062:26): [True: 0, False: 0] | | ------------------ | | 1063| 0| (isnull) = -1; /* empty, but position changed */ \ | | 1064| 0| }\ | | 1065| 0| }\ | | 1066| 0| k++;\ | | 1067| 0| }\ | | 1068| 0| break;\ | | 1069| 0| }\ | | 1070| 0| }\ | | 1071| 0| else {\ | | 1072| 0| level--;\ | | 1073| 0| }\ | | 1074| 0| }\ | | 1075| 0| }\ | | 1076| 0| else if (k->type == STK_NULL_CHECK_END) {\ | | ------------------ | | | | 400| 0|#define STK_NULL_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | | Branch (1076:14): [True: 0, False: 0] | | ------------------ | | 1077| 0| if (k->u.null_check.num == (id)) level++;\ | | ------------------ | | | Branch (1077:11): [True: 0, False: 0] | | ------------------ | | 1078| 0| }\ | | 1079| 0| }\ | | 1080| 0|} while(0) | | ------------------ | | | Branch (1080:9): [Folded - Ignored] | | ------------------ ------------------ 2806| |# else 2807| | STACK_NULL_CHECK_REC(isnull, mem, s); 2808| |# endif 2809| 0| if (isnull) { ------------------ | Branch (2809:6): [True: 0, False: 0] ------------------ 2810| |# ifdef ONIG_DEBUG_MATCH 2811| | fprintf(stderr, "NULL_CHECK_END_MEMST_PUSH: skip id:%d, s:%"PRIuPTR" (%p)\n", 2812| | (int )mem, (uintptr_t )s, s); 2813| |# endif 2814| 0| if (isnull == -1) goto fail; ------------------ | Branch (2814:8): [True: 0, False: 0] ------------------ 2815| 0| goto null_check_found; 2816| 0| } 2817| 0| else { 2818| 0| STACK_PUSH_NULL_CHECK_END(mem); ------------------ | | 775| 0|#define STACK_PUSH_NULL_CHECK_END(cnum) do {\ | | 776| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 777| 0| stk->type = STK_NULL_CHECK_END;\ | | ------------------ | | | | 400| 0|#define STK_NULL_CHECK_END 0x5000 /* for recursive call */ | | ------------------ | | 778| 0| stk->u.null_check.num = (cnum);\ | | 779| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 780| 0|} while(0) | | ------------------ | | | Branch (780:9): [Folded - Ignored] | | ------------------ ------------------ 2819| 0| } 2820| 0| } 2821| 0| MOP_OUT; 2822| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2823| 0|#endif 2824| | 2825| 5.93M| CASE(OP_JUMP) MOP_IN(OP_JUMP); ------------------ | | 1467| 5.93M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2826| 5.93M| GET_RELADDR_INC(addr, p); ------------------ | | 700| 5.93M|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 5.93M|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 5.93M| val = *(type* )p;\ | | | | 323| 5.93M| (p) += sizeof(type);\ | | | | 324| 5.93M|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2827| 5.93M| p += addr; 2828| 5.93M| MOP_OUT; 2829| 5.93M| CHECK_INTERRUPT_IN_MATCH_AT; 2830| 5.93M| JUMP; ------------------ | | 1470| 5.93M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 5.93M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2831| | 2832| 5.95M| CASE(OP_PUSH) MOP_IN(OP_PUSH); ------------------ | | 1467| 5.95M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 5.93M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2833| 5.95M| GET_RELADDR_INC(addr, p); ------------------ | | 700| 5.95M|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 5.95M|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 5.95M| val = *(type* )p;\ | | | | 323| 5.95M| (p) += sizeof(type);\ | | | | 324| 5.95M|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2834| 5.95M| STACK_PUSH_ALT(p + addr, s, sprev, pkeep); ------------------ | | 679| 5.95M|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 5.95M|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 5.95M| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 5.95M|#define STACK_ENSURE(n) do {\ | | | | | | 580| 5.95M| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 5.95M] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 5.95M|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 5.95M| stk->type = (stack_type);\ | | | | 665| 5.95M| stk->u.state.pcode = (pat);\ | | | | 666| 5.95M| stk->u.state.pstr = (s);\ | | | | 667| 5.95M| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 5.95M| stk->u.state.pkeep = (keep);\ | | | | 669| 5.95M| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 5.95M|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 5.95M|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2835| 5.95M| MOP_OUT; 2836| 5.95M| JUMP; ------------------ | | 1470| 5.95M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 5.95M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2837| | 2838| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 2839| | CASE(OP_STATE_CHECK_PUSH) MOP_IN(OP_STATE_CHECK_PUSH); 2840| | GET_STATE_CHECK_NUM_INC(mem, p); 2841| | STATE_CHECK_VAL(scv, mem); 2842| | if (scv) goto fail; 2843| | 2844| | GET_RELADDR_INC(addr, p); 2845| | STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep); 2846| | MOP_OUT; 2847| | JUMP; 2848| | 2849| | CASE(OP_STATE_CHECK_PUSH_OR_JUMP) MOP_IN(OP_STATE_CHECK_PUSH_OR_JUMP); 2850| | GET_STATE_CHECK_NUM_INC(mem, p); 2851| | GET_RELADDR_INC(addr, p); 2852| | STATE_CHECK_VAL(scv, mem); 2853| | if (scv) { 2854| | p += addr; 2855| | } 2856| | else { 2857| | STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep); 2858| | } 2859| | MOP_OUT; 2860| | JUMP; 2861| | 2862| | CASE(OP_STATE_CHECK) MOP_IN(OP_STATE_CHECK); 2863| | GET_STATE_CHECK_NUM_INC(mem, p); 2864| | STATE_CHECK_VAL(scv, mem); 2865| | if (scv) goto fail; 2866| | 2867| | STACK_PUSH_STATE_CHECK(s, mem); 2868| | MOP_OUT; 2869| | JUMP; 2870| |#endif /* USE_COMBINATION_EXPLOSION_CHECK */ 2871| | 2872| 5.95M| CASE(OP_POP) MOP_IN(OP_POP); ------------------ | | 1467| 5.95M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 5.95M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2873| 5.93M| STACK_POP_ONE; ------------------ | | 814| 5.93M|#define STACK_POP_ONE do {\ | | 815| 5.93M| stk--;\ | | 816| 5.93M| STACK_BASE_CHECK(stk, "STACK_POP_ONE"); \ | | 817| 5.93M|} while(0) | | ------------------ | | | Branch (817:9): [Folded - Ignored] | | ------------------ ------------------ 2874| 5.93M| MOP_OUT; 2875| 5.93M| JUMP; ------------------ | | 1470| 5.93M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 5.93M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2876| | 2877| |#ifdef USE_OP_PUSH_OR_JUMP_EXACT 2878| | CASE(OP_PUSH_OR_JUMP_EXACT1) MOP_IN(OP_PUSH_OR_JUMP_EXACT1); 2879| | GET_RELADDR_INC(addr, p); 2880| | if (*p == *s && DATA_ENSURE_CHECK1) { 2881| | p++; 2882| | STACK_PUSH_ALT(p + addr, s, sprev, pkeep); 2883| | MOP_OUT; 2884| | JUMP; 2885| | } 2886| | p += (addr + 1); 2887| | MOP_OUT; 2888| | JUMP; 2889| |#endif 2890| | 2891| 5.93M| CASE(OP_PUSH_IF_PEEK_NEXT) MOP_IN(OP_PUSH_IF_PEEK_NEXT); ------------------ | | 1467| 5.93M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 5.93M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2892| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2893| 0| if (*p == *s) { ------------------ | Branch (2893:11): [True: 0, False: 0] ------------------ 2894| 0| p++; 2895| 0| STACK_PUSH_ALT(p + addr, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2896| 0| MOP_OUT; 2897| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2898| 0| } 2899| 0| p++; 2900| 0| MOP_OUT; 2901| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2902| | 2903| 0| CASE(OP_REPEAT) MOP_IN(OP_REPEAT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2904| 0| { 2905| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2906| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2907| | 2908| 0| STACK_ENSURE(1); ------------------ | | 579| 0|#define STACK_ENSURE(n) do {\ | | 580| 0| if (stk_end - stk < (n)) {\ | | ------------------ | | | Branch (580:7): [True: 0, False: 0] | | ------------------ | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | 582| 0| if (r != 0) {\ | | ------------------ | | | Branch (582:9): [True: 0, False: 0] | | ------------------ | | 583| 0| STACK_SAVE;\ | | ------------------ | | | | 515| 0|#define STACK_SAVE do{\ | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | ------------------ | | | | | Branch (516:7): [True: 0, False: 0] | | | | ------------------ | | | | 517| 0| msa->stack_p = stk_base;\ | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | 519| 0| };\ | | | | 520| 0|} while(0) | | | | ------------------ | | | | | Branch (520:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | ------------------ | | | | 145| 0|# define xfree free | | ------------------ | | | Branch (584:11): [True: 0, False: 0] | | ------------------ | | 585| 0| return r;\ | | 586| 0| }\ | | 587| 0| }\ | | 588| 0|} while(0) | | ------------------ | | | Branch (588:9): [Folded - Ignored] | | ------------------ ------------------ 2909| 0| repeat_stk[mem] = GET_STACK_INDEX(stk); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2910| 0| STACK_PUSH_REPEAT(mem, p); ------------------ | | 687| 0|#define STACK_PUSH_REPEAT(id, pat) do {\ | | 688| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| stk->type = STK_REPEAT;\ | | ------------------ | | | | 404| 0|#define STK_REPEAT 0x0700 | | ------------------ | | 690| 0| stk->u.repeat.num = (id);\ | | 691| 0| stk->u.repeat.pcode = (pat);\ | | 692| 0| stk->u.repeat.count = 0;\ | | 693| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 694| 0|} while(0) | | ------------------ | | | Branch (694:9): [Folded - Ignored] | | ------------------ ------------------ 2911| | 2912| 0| if (reg->repeat_range[mem].lower == 0) { ------------------ | Branch (2912:6): [True: 0, False: 0] ------------------ 2913| 0| STACK_PUSH_ALT(p + addr, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2914| 0| } 2915| 0| } 2916| 0| MOP_OUT; 2917| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2918| | 2919| 0| CASE(OP_REPEAT_NG) MOP_IN(OP_REPEAT_NG); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2920| 0| { 2921| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2922| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2923| | 2924| 0| STACK_ENSURE(1); ------------------ | | 579| 0|#define STACK_ENSURE(n) do {\ | | 580| 0| if (stk_end - stk < (n)) {\ | | ------------------ | | | Branch (580:7): [True: 0, False: 0] | | ------------------ | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | 582| 0| if (r != 0) {\ | | ------------------ | | | Branch (582:9): [True: 0, False: 0] | | ------------------ | | 583| 0| STACK_SAVE;\ | | ------------------ | | | | 515| 0|#define STACK_SAVE do{\ | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | ------------------ | | | | | Branch (516:7): [True: 0, False: 0] | | | | ------------------ | | | | 517| 0| msa->stack_p = stk_base;\ | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | 519| 0| };\ | | | | 520| 0|} while(0) | | | | ------------------ | | | | | Branch (520:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | ------------------ | | | | 145| 0|# define xfree free | | ------------------ | | | Branch (584:11): [True: 0, False: 0] | | ------------------ | | 585| 0| return r;\ | | 586| 0| }\ | | 587| 0| }\ | | 588| 0|} while(0) | | ------------------ | | | Branch (588:9): [Folded - Ignored] | | ------------------ ------------------ 2925| 0| repeat_stk[mem] = GET_STACK_INDEX(stk); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2926| 0| STACK_PUSH_REPEAT(mem, p); ------------------ | | 687| 0|#define STACK_PUSH_REPEAT(id, pat) do {\ | | 688| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 689| 0| stk->type = STK_REPEAT;\ | | ------------------ | | | | 404| 0|#define STK_REPEAT 0x0700 | | ------------------ | | 690| 0| stk->u.repeat.num = (id);\ | | 691| 0| stk->u.repeat.pcode = (pat);\ | | 692| 0| stk->u.repeat.count = 0;\ | | 693| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 694| 0|} while(0) | | ------------------ | | | Branch (694:9): [Folded - Ignored] | | ------------------ ------------------ 2927| | 2928| 0| if (reg->repeat_range[mem].lower == 0) { ------------------ | Branch (2928:6): [True: 0, False: 0] ------------------ 2929| 0| STACK_PUSH_ALT(p, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2930| 0| p += addr; 2931| 0| } 2932| 0| } 2933| 0| MOP_OUT; 2934| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2935| | 2936| 0| CASE(OP_REPEAT_INC) MOP_IN(OP_REPEAT_INC); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2937| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2938| 0| si = repeat_stk[mem]; 2939| 0| stkp = STACK_AT(si); ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2940| | 2941| 0| repeat_inc: 2942| 0| stkp->u.repeat.count++; 2943| 0| if (stkp->u.repeat.count >= reg->repeat_range[mem].upper) { ------------------ | Branch (2943:11): [True: 0, False: 0] ------------------ 2944| | /* end of repeat. Nothing to do. */ 2945| 0| } 2946| 0| else if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) { ------------------ | Branch (2946:16): [True: 0, False: 0] ------------------ 2947| 0| STACK_PUSH_ALT(p, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2948| 0| p = STACK_AT(si)->u.repeat.pcode; /* Don't use stkp after PUSH. */ ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2949| 0| } 2950| 0| else { 2951| 0| p = stkp->u.repeat.pcode; 2952| 0| } 2953| 0| STACK_PUSH_REPEAT_INC(si); ------------------ | | 696| 0|#define STACK_PUSH_REPEAT_INC(sindex) do {\ | | 697| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 698| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | 699| 0| stk->u.repeat_inc.si = (sindex);\ | | 700| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 701| 0|} while(0) | | ------------------ | | | Branch (701:9): [Folded - Ignored] | | ------------------ ------------------ 2954| 0| MOP_OUT; 2955| 0| CHECK_INTERRUPT_IN_MATCH_AT; 2956| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2957| | 2958| 0| CASE(OP_REPEAT_INC_SG) MOP_IN(OP_REPEAT_INC_SG); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2959| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2960| 0| STACK_GET_REPEAT(mem, stkp); ------------------ | | 1082| 0|#define STACK_GET_REPEAT(id, k) do {\ | | 1083| 0| int level = 0;\ | | 1084| 0| k = stk;\ | | 1085| 0| while (1) {\ | | ------------------ | | | Branch (1085:10): [Folded - Ignored] | | ------------------ | | 1086| 0| k--;\ | | 1087| 0| STACK_BASE_CHECK(k, "STACK_GET_REPEAT"); \ | | 1088| 0| if (k->type == STK_REPEAT) {\ | | ------------------ | | | | 404| 0|#define STK_REPEAT 0x0700 | | ------------------ | | | Branch (1088:9): [True: 0, False: 0] | | ------------------ | | 1089| 0| if (level == 0) {\ | | ------------------ | | | Branch (1089:11): [True: 0, False: 0] | | ------------------ | | 1090| 0| if (k->u.repeat.num == (id)) {\ | | ------------------ | | | Branch (1090:13): [True: 0, False: 0] | | ------------------ | | 1091| 0| break;\ | | 1092| 0| }\ | | 1093| 0| }\ | | 1094| 0| }\ | | 1095| 0| else if (k->type == STK_CALL_FRAME) level--;\ | | ------------------ | | | | 405| 0|#define STK_CALL_FRAME 0x0800 | | ------------------ | | | Branch (1095:14): [True: 0, False: 0] | | ------------------ | | 1096| 0| else if (k->type == STK_RETURN) level++;\ | | ------------------ | | | | 406| 0|#define STK_RETURN 0x0900 | | ------------------ | | | Branch (1096:14): [True: 0, False: 0] | | ------------------ | | 1097| 0| }\ | | 1098| 0|} while(0) | | ------------------ | | | Branch (1098:9): [Folded - Ignored] | | ------------------ ------------------ 2961| 0| si = GET_STACK_INDEX(stkp); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2962| 0| goto repeat_inc; 2963| | 2964| 0| CASE(OP_REPEAT_INC_NG) MOP_IN(OP_REPEAT_INC_NG); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2965| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2966| 0| si = repeat_stk[mem]; 2967| 0| stkp = STACK_AT(si); ------------------ | | 590| 0|#define STACK_AT(index) (stk_base + (index)) ------------------ 2968| | 2969| 0| repeat_inc_ng: 2970| 0| stkp->u.repeat.count++; 2971| 0| if (stkp->u.repeat.count < reg->repeat_range[mem].upper) { ------------------ | Branch (2971:11): [True: 0, False: 0] ------------------ 2972| 0| if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) { ------------------ | Branch (2972:6): [True: 0, False: 0] ------------------ 2973| 0| UChar* pcode = stkp->u.repeat.pcode; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 2974| | 2975| 0| STACK_PUSH_REPEAT_INC(si); ------------------ | | 696| 0|#define STACK_PUSH_REPEAT_INC(sindex) do {\ | | 697| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 698| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | 699| 0| stk->u.repeat_inc.si = (sindex);\ | | 700| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 701| 0|} while(0) | | ------------------ | | | Branch (701:9): [Folded - Ignored] | | ------------------ ------------------ 2976| 0| STACK_PUSH_ALT(pcode, s, sprev, pkeep); ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2977| 0| } 2978| 0| else { 2979| 0| p = stkp->u.repeat.pcode; 2980| 0| STACK_PUSH_REPEAT_INC(si); ------------------ | | 696| 0|#define STACK_PUSH_REPEAT_INC(sindex) do {\ | | 697| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 698| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | 699| 0| stk->u.repeat_inc.si = (sindex);\ | | 700| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 701| 0|} while(0) | | ------------------ | | | Branch (701:9): [Folded - Ignored] | | ------------------ ------------------ 2981| 0| } 2982| 0| } 2983| 0| else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) { ------------------ | Branch (2983:16): [True: 0, False: 0] ------------------ 2984| 0| STACK_PUSH_REPEAT_INC(si); ------------------ | | 696| 0|#define STACK_PUSH_REPEAT_INC(sindex) do {\ | | 697| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 698| 0| stk->type = STK_REPEAT_INC;\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | 699| 0| stk->u.repeat_inc.si = (sindex);\ | | 700| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 701| 0|} while(0) | | ------------------ | | | Branch (701:9): [Folded - Ignored] | | ------------------ ------------------ 2985| 0| } 2986| 0| MOP_OUT; 2987| 0| CHECK_INTERRUPT_IN_MATCH_AT; 2988| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 2989| | 2990| 0| CASE(OP_REPEAT_INC_NG_SG) MOP_IN(OP_REPEAT_INC_NG_SG); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2991| 0| GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */ ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2992| 0| STACK_GET_REPEAT(mem, stkp); ------------------ | | 1082| 0|#define STACK_GET_REPEAT(id, k) do {\ | | 1083| 0| int level = 0;\ | | 1084| 0| k = stk;\ | | 1085| 0| while (1) {\ | | ------------------ | | | Branch (1085:10): [Folded - Ignored] | | ------------------ | | 1086| 0| k--;\ | | 1087| 0| STACK_BASE_CHECK(k, "STACK_GET_REPEAT"); \ | | 1088| 0| if (k->type == STK_REPEAT) {\ | | ------------------ | | | | 404| 0|#define STK_REPEAT 0x0700 | | ------------------ | | | Branch (1088:9): [True: 0, False: 0] | | ------------------ | | 1089| 0| if (level == 0) {\ | | ------------------ | | | Branch (1089:11): [True: 0, False: 0] | | ------------------ | | 1090| 0| if (k->u.repeat.num == (id)) {\ | | ------------------ | | | Branch (1090:13): [True: 0, False: 0] | | ------------------ | | 1091| 0| break;\ | | 1092| 0| }\ | | 1093| 0| }\ | | 1094| 0| }\ | | 1095| 0| else if (k->type == STK_CALL_FRAME) level--;\ | | ------------------ | | | | 405| 0|#define STK_CALL_FRAME 0x0800 | | ------------------ | | | Branch (1095:14): [True: 0, False: 0] | | ------------------ | | 1096| 0| else if (k->type == STK_RETURN) level++;\ | | ------------------ | | | | 406| 0|#define STK_RETURN 0x0900 | | ------------------ | | | Branch (1096:14): [True: 0, False: 0] | | ------------------ | | 1097| 0| }\ | | 1098| 0|} while(0) | | ------------------ | | | Branch (1098:9): [Folded - Ignored] | | ------------------ ------------------ 2993| 0| si = GET_STACK_INDEX(stkp); ------------------ | | 591| 0|#define GET_STACK_INDEX(stk) ((stk) - stk_base) ------------------ 2994| 0| goto repeat_inc_ng; 2995| | 2996| 0| CASE(OP_PUSH_POS) MOP_IN(OP_PUSH_POS); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 2997| 0| STACK_PUSH_POS(s, sprev, pkeep); ------------------ | | 680| 0|#define STACK_PUSH_POS(s,sprev,keep) STACK_PUSH(STK_POS,NULL_UCHARP,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2998| 0| MOP_OUT; 2999| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3000| | 3001| 0| CASE(OP_POP_POS) MOP_IN(OP_POP_POS); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3002| 0| { 3003| 0| STACK_POS_END(stkp); ------------------ | | 930| 0|#define STACK_POS_END(k) do {\ | | 931| 0| k = stk;\ | | 932| 0| while (1) {\ | | ------------------ | | | Branch (932:10): [Folded - Ignored] | | ------------------ | | 933| 0| k--;\ | | 934| 0| STACK_BASE_CHECK(k, "STACK_POS_END"); \ | | 935| 0| if (IS_TO_VOID_TARGET(k)) {\ | | ------------------ | | | | 599| 0|#define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0) | | | | ------------------ | | | | | | 413| 0|#define STK_MASK_TO_VOID_TARGET 0x10ff | | | | ------------------ | | | | | Branch (599:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 936| 0| k->type = STK_VOID;\ | | ------------------ | | | | 407| 0|#define STK_VOID 0x0a00 /* for fill a blank */ | | ------------------ | | 937| 0| }\ | | 938| 0| else if (k->type == STK_POS) {\ | | ------------------ | | | | 402| 0|#define STK_POS 0x0500 /* used when POP-POS */ | | ------------------ | | | Branch (938:14): [True: 0, False: 0] | | ------------------ | | 939| 0| k->type = STK_VOID;\ | | ------------------ | | | | 407| 0|#define STK_VOID 0x0a00 /* for fill a blank */ | | ------------------ | | 940| 0| break;\ | | 941| 0| }\ | | 942| 0| }\ | | 943| 0|} while(0) | | ------------------ | | | Branch (943:9): [Folded - Ignored] | | ------------------ ------------------ 3004| 0| s = stkp->u.state.pstr; 3005| 0| sprev = stkp->u.state.pstr_prev; 3006| 0| } 3007| 0| MOP_OUT; 3008| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3009| | 3010| 0| CASE(OP_PUSH_POS_NOT) MOP_IN(OP_PUSH_POS_NOT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3011| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3012| 0| STACK_PUSH_POS_NOT(p + addr, s, sprev, pkeep); ------------------ | | 681| 0|#define STACK_PUSH_POS_NOT(pat,s,sprev,keep) STACK_PUSH(STK_POS_NOT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3013| 0| MOP_OUT; 3014| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3015| | 3016| 0| CASE(OP_FAIL_POS) MOP_IN(OP_FAIL_POS); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3017| 0| STACK_POP_TIL_POS_NOT; ------------------ | | 863| 0|#define STACK_POP_TIL_POS_NOT do {\ | | 864| 0| while (1) {\ | | ------------------ | | | Branch (864:10): [Folded - Ignored] | | ------------------ | | 865| 0| stk--;\ | | 866| 0| STACK_BASE_CHECK(stk, "STACK_POP_TIL_POS_NOT"); \ | | 867| 0| if (stk->type == STK_POS_NOT) break;\ | | ------------------ | | | | 392| 0|#define STK_POS_NOT 0x0003 | | ------------------ | | | Branch (867:9): [True: 0, False: 0] | | ------------------ | | 868| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (868:14): [True: 0, False: 0] | | ------------------ | | 869| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 870| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 871| 0| }\ | | 872| 0| else if (stk->type == STK_REPEAT_INC) {\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | | Branch (872:14): [True: 0, False: 0] | | ------------------ | | 873| 0| STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 874| 0| }\ | | 875| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | | Branch (875:14): [True: 0, False: 0] | | ------------------ | | 876| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 877| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 878| 0| }\ | | 879| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 880| 0| }\ | | 881| 0|} while(0) | | ------------------ | | | Branch (881:9): [Folded - Ignored] | | ------------------ ------------------ 3018| 0| goto fail; 3019| | 3020| 0| CASE(OP_PUSH_STOP_BT) MOP_IN(OP_PUSH_STOP_BT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3021| 0| STACK_PUSH_STOP_BT; ------------------ | | 683| 0|#define STACK_PUSH_STOP_BT STACK_PUSH_TYPE(STK_STOP_BT) | | ------------------ | | | | 593| 0|#define STACK_PUSH_TYPE(stack_type) do {\ | | | | 594| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 595| 0| stk->type = (stack_type);\ | | | | 596| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 597| 0|} while(0) | | | | ------------------ | | | | | Branch (597:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3022| 0| MOP_OUT; 3023| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3024| | 3025| 0| CASE(OP_POP_STOP_BT) MOP_IN(OP_POP_STOP_BT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3026| 0| STACK_STOP_BT_END; ------------------ | | 945| 0|#define STACK_STOP_BT_END do {\ | | 946| 0| OnigStackType *k = stk;\ | | 947| 0| while (1) {\ | | ------------------ | | | Branch (947:10): [Folded - Ignored] | | ------------------ | | 948| 0| k--;\ | | 949| 0| STACK_BASE_CHECK(k, "STACK_STOP_BT_END"); \ | | 950| 0| if (IS_TO_VOID_TARGET(k)) {\ | | ------------------ | | | | 599| 0|#define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0) | | | | ------------------ | | | | | | 413| 0|#define STK_MASK_TO_VOID_TARGET 0x10ff | | | | ------------------ | | | | | Branch (599:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 951| 0| k->type = STK_VOID;\ | | ------------------ | | | | 407| 0|#define STK_VOID 0x0a00 /* for fill a blank */ | | ------------------ | | 952| 0| }\ | | 953| 0| else if (k->type == STK_STOP_BT) {\ | | ------------------ | | | | 403| 0|#define STK_STOP_BT 0x0600 /* mark for "(?>...)" */ | | ------------------ | | | Branch (953:14): [True: 0, False: 0] | | ------------------ | | 954| 0| k->type = STK_VOID;\ | | ------------------ | | | | 407| 0|#define STK_VOID 0x0a00 /* for fill a blank */ | | ------------------ | | 955| 0| break;\ | | 956| 0| }\ | | 957| 0| }\ | | 958| 0|} while(0) | | ------------------ | | | Branch (958:9): [Folded - Ignored] | | ------------------ ------------------ 3027| 0| MOP_OUT; 3028| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3029| | 3030| 0| CASE(OP_LOOK_BEHIND) MOP_IN(OP_LOOK_BEHIND); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3031| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3032| 0| s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (int )tlen); ------------------ | | 343| 0| onigenc_step_back((enc),(start),(s),(end),(n)) ------------------ 3033| 0| if (IS_NULL(s)) goto fail; ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 3034| 0| sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end); 3035| 0| MOP_OUT; 3036| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3037| | 3038| 0| CASE(OP_PUSH_LOOK_BEHIND_NOT) MOP_IN(OP_PUSH_LOOK_BEHIND_NOT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3039| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3040| 0| GET_LENGTH_INC(tlen, p); ------------------ | | 702| 0|#define GET_LENGTH_INC(len,p) PLATFORM_GET_INC(len, p, LengthType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3041| 0| q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (int )tlen); ------------------ | | 343| 0| onigenc_step_back((enc),(start),(s),(end),(n)) ------------------ 3042| 0| if (IS_NULL(q)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 3043| | /* too short case -> success. ex. /(?stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3050| 0| s = q; 3051| 0| sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end); 3052| 0| } 3053| 0| MOP_OUT; 3054| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3055| | 3056| 0| CASE(OP_FAIL_LOOK_BEHIND_NOT) MOP_IN(OP_FAIL_LOOK_BEHIND_NOT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3057| 0| STACK_POP_TIL_LOOK_BEHIND_NOT; ------------------ | | 883| 0|#define STACK_POP_TIL_LOOK_BEHIND_NOT do {\ | | 884| 0| while (1) {\ | | ------------------ | | | Branch (884:10): [Folded - Ignored] | | ------------------ | | 885| 0| stk--;\ | | 886| 0| STACK_BASE_CHECK(stk, "STACK_POP_TIL_LOOK_BEHIND_NOT"); \ | | 887| 0| if (stk->type == STK_LOOK_BEHIND_NOT) break;\ | | ------------------ | | | | 391| 0|#define STK_LOOK_BEHIND_NOT 0x0002 | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (888:14): [True: 0, False: 0] | | ------------------ | | 889| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 890| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 891| 0| }\ | | 892| 0| else if (stk->type == STK_REPEAT_INC) {\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | | Branch (892:14): [True: 0, False: 0] | | ------------------ | | 893| 0| STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 894| 0| }\ | | 895| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | | Branch (895:14): [True: 0, False: 0] | | ------------------ | | 896| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 897| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 898| 0| }\ | | 899| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 900| 0| }\ | | 901| 0|} while(0) | | ------------------ | | | Branch (901:9): [Folded - Ignored] | | ------------------ ------------------ 3058| 0| goto fail; 3059| | 3060| 0| CASE(OP_PUSH_ABSENT_POS) MOP_IN(OP_PUSH_ABSENT_POS); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3061| | /* Save the absent-start-pos and the original end-pos. */ 3062| 0| STACK_PUSH_ABSENT_POS(s, ABSENT_END_POS); ------------------ | | 795| 0|#define STACK_PUSH_ABSENT_POS(start, end) do {\ | | 796| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 797| 0| stk->type = STK_ABSENT_POS;\ | | ------------------ | | | | 408| 0|#define STK_ABSENT_POS 0x0b00 /* for absent */ | | ------------------ | | 798| 0| stk->u.absent_pos.abs_pstr = (start);\ | | 799| 0| stk->u.absent_pos.end_pstr = (end);\ | | 800| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 801| 0|} while(0) | | ------------------ | | | Branch (801:9): [Folded - Ignored] | | ------------------ ------------------ 3063| 0| MOP_OUT; 3064| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3065| | 3066| 0| CASE(OP_ABSENT) MOP_IN(OP_ABSENT); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3067| 0| { 3068| 0| const UChar* aend = ABSENT_END_POS; ------------------ | | 1182| 0|# define ABSENT_END_POS right_range ------------------ 3069| 0| UChar* absent; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3070| 0| UChar* selfp = p - 1; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3071| | 3072| 0| STACK_POP_ABSENT_POS(absent, ABSENT_END_POS); /* Restore end-pos. */ ------------------ | | 923| 0|#define STACK_POP_ABSENT_POS(start, end) do {\ | | 924| 0| stk--;\ | | 925| 0| STACK_BASE_CHECK(stk, "STACK_POP_ABSENT_POS"); \ | | 926| 0| (start) = stk->u.absent_pos.abs_pstr;\ | | 927| 0| (end) = stk->u.absent_pos.end_pstr;\ | | 928| 0|} while(0) | | ------------------ | | | Branch (928:9): [Folded - Ignored] | | ------------------ ------------------ 3073| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3074| |#ifdef ONIG_DEBUG_MATCH 3075| | fprintf(stderr, "ABSENT: s:%p, end:%p, absent:%p, aend:%p\n", s, end, absent, aend); 3076| |#endif 3077| 0| if ((absent > aend) && (s > absent)) { ------------------ | Branch (3077:6): [True: 0, False: 0] | Branch (3077:25): [True: 0, False: 0] ------------------ 3078| | /* An empty match occurred in (?~...) at the start point. 3079| | * Never match. */ 3080| 0| STACK_POP; ------------------ | | 819| 0|#define STACK_POP do {\ | | 820| 0| switch (pop_level) {\ | | 821| 0| case STACK_POP_LEVEL_FREE:\ | | ------------------ | | | | 350| 0|#define STACK_POP_LEVEL_FREE 0 | | ------------------ | | | Branch (821:3): [True: 0, False: 0] | | ------------------ | | 822| 0| while (1) {\ | | ------------------ | | | Branch (822:12): [Folded - Ignored] | | ------------------ | | 823| 0| stk--;\ | | 824| 0| STACK_BASE_CHECK(stk, "STACK_POP"); \ | | 825| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 0|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (825:11): [True: 0, False: 0] | | ------------------ | | 826| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 827| 0| }\ | | 828| 0| break;\ | | 829| 0| case STACK_POP_LEVEL_MEM_START:\ | | ------------------ | | | | 351| 0|#define STACK_POP_LEVEL_MEM_START 1 | | ------------------ | | | Branch (829:3): [True: 0, False: 0] | | ------------------ | | 830| 0| while (1) {\ | | ------------------ | | | Branch (830:12): [Folded - Ignored] | | ------------------ | | 831| 0| stk--;\ | | 832| 0| STACK_BASE_CHECK(stk, "STACK_POP 2"); \ | | 833| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 0|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (833:11): [True: 0, False: 0] | | ------------------ | | 834| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (834:16): [True: 0, False: 0] | | ------------------ | | 835| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 836| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 837| 0| }\ | | 838| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 839| 0| }\ | | 840| 0| break;\ | | 841| 0| default:\ | | ------------------ | | | Branch (841:3): [True: 0, False: 0] | | ------------------ | | 842| 0| while (1) {\ | | ------------------ | | | Branch (842:12): [Folded - Ignored] | | ------------------ | | 843| 0| stk--;\ | | 844| 0| STACK_BASE_CHECK(stk, "STACK_POP 3"); \ | | 845| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 0|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (845:11): [True: 0, False: 0] | | ------------------ | | 846| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (846:16): [True: 0, False: 0] | | ------------------ | | 847| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 848| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 849| 0| }\ | | 850| 0| else if (stk->type == STK_REPEAT_INC) {\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | | Branch (850:16): [True: 0, False: 0] | | ------------------ | | 851| 0| STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 852| 0| }\ | | 853| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | | Branch (853:16): [True: 0, False: 0] | | ------------------ | | 854| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 855| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 856| 0| }\ | | 857| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 858| 0| }\ | | 859| 0| break;\ | | 860| 0| }\ | | 861| 0|} while(0) | | ------------------ | | | Branch (861:9): [Folded - Ignored] | | ------------------ ------------------ 3081| 0| goto fail; 3082| 0| } 3083| 0| else if ((s >= aend) && (s > absent)) { ------------------ | Branch (3083:11): [True: 0, False: 0] | Branch (3083:26): [True: 0, False: 0] ------------------ 3084| 0| if (s > aend) { ------------------ | Branch (3084:8): [True: 0, False: 0] ------------------ 3085| | /* Only one (or less) character matched in the last iteration. 3086| | * This is not a possible point. */ 3087| 0| goto fail; 3088| 0| } 3089| | /* All possible points were found. Try matching after (?~...). */ 3090| 0| DATA_ENSURE(0); ------------------ | | 1180| 0|# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail | | ------------------ | | | Branch (1180:36): [True: 0, False: 0] | | ------------------ ------------------ 3091| 0| p += addr; 3092| 0| } 3093| 0| else { 3094| 0| STACK_PUSH_ALT(p + addr, s, sprev, pkeep); /* Push possible point. */ ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3095| | /* For approximating enclen. Strict version of enclen does not work here. */ 3096| 0| n = enclen_approximate(encode, s, end); ------------------ | | 94| 0|#define enclen_approximate(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN_APPROX(enc,p,e)) | | ------------------ | | | | 363| 0|#define ONIGENC_MBC_ENC_LEN_APPROX(enc,p,e) onigenc_mbclen_approximate(p,e,enc) | | ------------------ | | | Branch (94:38): [True: 0, False: 0] | | ------------------ ------------------ 3097| 0| STACK_PUSH_ABSENT_POS(absent, ABSENT_END_POS); /* Save the original pos. */ ------------------ | | 795| 0|#define STACK_PUSH_ABSENT_POS(start, end) do {\ | | 796| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 797| 0| stk->type = STK_ABSENT_POS;\ | | ------------------ | | | | 408| 0|#define STK_ABSENT_POS 0x0b00 /* for absent */ | | ------------------ | | 798| 0| stk->u.absent_pos.abs_pstr = (start);\ | | 799| 0| stk->u.absent_pos.end_pstr = (end);\ | | 800| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 801| 0|} while(0) | | ------------------ | | | Branch (801:9): [Folded - Ignored] | | ------------------ ------------------ 3098| 0| STACK_PUSH_ALT(selfp, s + n, s, pkeep); /* Next iteration. */ ------------------ | | 679| 0|#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep) | | ------------------ | | | | 662| 0|# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\ | | | | 663| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 664| 0| stk->type = (stack_type);\ | | | | 665| 0| stk->u.state.pcode = (pat);\ | | | | 666| 0| stk->u.state.pstr = (s);\ | | | | 667| 0| stk->u.state.pstr_prev = (sprev);\ | | | | 668| 0| stk->u.state.pkeep = (keep);\ | | | | 669| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 670| 0|} while(0) | | | | ------------------ | | | | | Branch (670:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3099| 0| STACK_PUSH_ABSENT; ------------------ | | 682| 0|#define STACK_PUSH_ABSENT STACK_PUSH_TYPE(STK_ABSENT) | | ------------------ | | | | 593| 0|#define STACK_PUSH_TYPE(stack_type) do {\ | | | | 594| 0| STACK_ENSURE(1);\ | | | | ------------------ | | | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | | | ------------------ | | | | | | | Branch (580:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | | | 582| 0| if (r != 0) {\ | | | | | | ------------------ | | | | | | | Branch (582:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 583| 0| STACK_SAVE;\ | | | | | | ------------------ | | | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | | | ------------------ | | | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | | | 519| 0| };\ | | | | | | | | 520| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | | | ------------------ | | | | | | | | 145| 0|# define xfree free | | | | | | ------------------ | | | | | | | Branch (584:11): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 585| 0| return r;\ | | | | | | 586| 0| }\ | | | | | | 587| 0| }\ | | | | | | 588| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (588:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 595| 0| stk->type = (stack_type);\ | | | | 596| 0| STACK_INC;\ | | | | ------------------ | | | | | | 1393| 0|# define STACK_INC stk++ | | | | ------------------ | | | | 597| 0|} while(0) | | | | ------------------ | | | | | Branch (597:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3100| 0| ABSENT_END_POS = aend; ------------------ | | 1182| 0|# define ABSENT_END_POS right_range ------------------ 3101| 0| } 3102| 0| } 3103| 0| MOP_OUT; 3104| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3105| | 3106| 0| CASE(OP_ABSENT_END) MOP_IN(OP_ABSENT_END); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3107| | /* The pattern inside (?~...) was matched. 3108| | * Set the end-pos temporary and go to next iteration. */ 3109| 0| if (sprev < ABSENT_END_POS) ------------------ | | 1182| 0|# define ABSENT_END_POS right_range ------------------ | Branch (3109:11): [True: 0, False: 0] ------------------ 3110| 0| ABSENT_END_POS = sprev; ------------------ | | 1182| 0|# define ABSENT_END_POS right_range ------------------ 3111| |#ifdef ONIG_DEBUG_MATCH 3112| | fprintf(stderr, "ABSENT_END: end:%p\n", ABSENT_END_POS); 3113| |#endif 3114| 0| STACK_POP_TIL_ABSENT; ------------------ | | 903| 0|#define STACK_POP_TIL_ABSENT do {\ | | 904| 0| while (1) {\ | | ------------------ | | | Branch (904:10): [Folded - Ignored] | | ------------------ | | 905| 0| stk--;\ | | 906| 0| STACK_BASE_CHECK(stk, "STACK_POP_TIL_ABSENT"); \ | | 907| 0| if (stk->type == STK_ABSENT) break;\ | | ------------------ | | | | 409| 0|#define STK_ABSENT 0x0c00 /* absent inner loop marker */ | | ------------------ | | | Branch (907:9): [True: 0, False: 0] | | ------------------ | | 908| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (908:14): [True: 0, False: 0] | | ------------------ | | 909| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 910| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 911| 0| }\ | | 912| 0| else if (stk->type == STK_REPEAT_INC) {\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | | Branch (912:14): [True: 0, False: 0] | | ------------------ | | 913| 0| STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 914| 0| }\ | | 915| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | | Branch (915:14): [True: 0, False: 0] | | ------------------ | | 916| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 917| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 918| 0| }\ | | 919| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 920| 0| }\ | | 921| 0|} while(0) | | ------------------ | | | Branch (921:9): [Folded - Ignored] | | ------------------ ------------------ 3115| 0| goto fail; 3116| | 3117| 0|#ifdef USE_SUBEXP_CALL 3118| 0| CASE(OP_CALL) MOP_IN(OP_CALL); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3119| 0| GET_ABSADDR_INC(addr, p); ------------------ | | 701| 0|#define GET_ABSADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, AbsAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3120| 0| STACK_PUSH_CALL_FRAME(p); ------------------ | | 782| 0|#define STACK_PUSH_CALL_FRAME(pat) do {\ | | 783| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 784| 0| stk->type = STK_CALL_FRAME;\ | | ------------------ | | | | 405| 0|#define STK_CALL_FRAME 0x0800 | | ------------------ | | 785| 0| stk->u.call_frame.ret_addr = (pat);\ | | 786| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 787| 0|} while(0) | | ------------------ | | | Branch (787:9): [Folded - Ignored] | | ------------------ ------------------ 3121| 0| p = reg->p + addr; 3122| 0| MOP_OUT; 3123| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3124| | 3125| 0| CASE(OP_RETURN) MOP_IN(OP_RETURN); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3126| 0| STACK_RETURN(p); ------------------ | | 1100| 0|#define STACK_RETURN(addr) do {\ | | 1101| 0| int level = 0;\ | | 1102| 0| OnigStackType* k = stk;\ | | 1103| 0| while (1) {\ | | ------------------ | | | Branch (1103:10): [Folded - Ignored] | | ------------------ | | 1104| 0| k--;\ | | 1105| 0| STACK_BASE_CHECK(k, "STACK_RETURN"); \ | | 1106| 0| if (k->type == STK_CALL_FRAME) {\ | | ------------------ | | | | 405| 0|#define STK_CALL_FRAME 0x0800 | | ------------------ | | | Branch (1106:9): [True: 0, False: 0] | | ------------------ | | 1107| 0| if (level == 0) {\ | | ------------------ | | | Branch (1107:11): [True: 0, False: 0] | | ------------------ | | 1108| 0| (addr) = k->u.call_frame.ret_addr;\ | | 1109| 0| break;\ | | 1110| 0| }\ | | 1111| 0| else level--;\ | | 1112| 0| }\ | | 1113| 0| else if (k->type == STK_RETURN)\ | | ------------------ | | | | 406| 0|#define STK_RETURN 0x0900 | | ------------------ | | | Branch (1113:14): [True: 0, False: 0] | | ------------------ | | 1114| 0| level++;\ | | 1115| 0| }\ | | 1116| 0|} while(0) | | ------------------ | | | Branch (1116:9): [Folded - Ignored] | | ------------------ ------------------ 3127| 0| STACK_PUSH_RETURN; ------------------ | | 789| 0|#define STACK_PUSH_RETURN do {\ | | 790| 0| STACK_ENSURE(1);\ | | ------------------ | | | | 579| 0|#define STACK_ENSURE(n) do {\ | | | | 580| 0| if (stk_end - stk < (n)) {\ | | | | ------------------ | | | | | Branch (580:7): [True: 0, False: 0] | | | | ------------------ | | | | 581| 0| int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\ | | | | 582| 0| if (r != 0) {\ | | | | ------------------ | | | | | Branch (582:9): [True: 0, False: 0] | | | | ------------------ | | | | 583| 0| STACK_SAVE;\ | | | | ------------------ | | | | | | 515| 0|#define STACK_SAVE do{\ | | | | | | 516| 0| if (stk_base != stk_alloc) {\ | | | | | | ------------------ | | | | | | | Branch (516:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 517| 0| msa->stack_p = stk_base;\ | | | | | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | | | | | 519| 0| };\ | | | | | | 520| 0|} while(0) | | | | | | ------------------ | | | | | | | Branch (520:9): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 584| 0| if (xmalloc_base) xfree(xmalloc_base);\ | | | | ------------------ | | | | | | 145| 0|# define xfree free | | | | ------------------ | | | | | Branch (584:11): [True: 0, False: 0] | | | | ------------------ | | | | 585| 0| return r;\ | | | | 586| 0| }\ | | | | 587| 0| }\ | | | | 588| 0|} while(0) | | | | ------------------ | | | | | Branch (588:9): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 791| 0| stk->type = STK_RETURN;\ | | ------------------ | | | | 406| 0|#define STK_RETURN 0x0900 | | ------------------ | | 792| 0| STACK_INC;\ | | ------------------ | | | | 1393| 0|# define STACK_INC stk++ | | ------------------ | | 793| 0|} while(0) | | ------------------ | | | Branch (793:9): [Folded - Ignored] | | ------------------ ------------------ 3128| 0| MOP_OUT; 3129| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3130| 0|#endif 3131| | 3132| 0| CASE(OP_CONDITION) MOP_IN(OP_CONDITION); ------------------ | | 1467| 0|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3133| 0| GET_MEMNUM_INC(mem, p); ------------------ | | 703| 0|#define GET_MEMNUM_INC(num,p) PLATFORM_GET_INC(num, p, MemNumType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3134| 0| GET_RELADDR_INC(addr, p); ------------------ | | 700| 0|#define GET_RELADDR_INC(addr,p) PLATFORM_GET_INC(addr, p, RelAddrType) | | ------------------ | | | | 321| 0|# define PLATFORM_GET_INC(val,p,type) do{\ | | | | 322| 0| val = *(type* )p;\ | | | | 323| 0| (p) += sizeof(type);\ | | | | 324| 0|} while(0) | | | | ------------------ | | | | | Branch (324:9): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3135| 0| if ((mem > num_mem) || ------------------ | Branch (3135:11): [True: 0, False: 0] ------------------ 3136| 0| (mem_end_stk[mem] == INVALID_STACK_INDEX) || ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (3136:4): [True: 0, False: 0] ------------------ 3137| 0| (mem_start_stk[mem] == INVALID_STACK_INDEX)) { ------------------ | | 386| 0|#define INVALID_STACK_INDEX -1 ------------------ | Branch (3137:4): [True: 0, False: 0] ------------------ 3138| 0| p += addr; 3139| 0| } 3140| 0| MOP_OUT; 3141| 0| JUMP; ------------------ | | 1470| 0|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 0|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3142| | 3143| 1.43M| CASE(OP_FINISH) ------------------ | | 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 0|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3144| 1.43M| goto finish; 3145| | 3146| 1.43M| CASE(OP_FAIL) ------------------ | | 1467| 1.43M|# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK; | | ------------------ | | | | 1730| 1.43M|# define OPCODE_EXEC_HOOK ((void) 0) | | ------------------ ------------------ 3147| 0| if (0) { ------------------ | Branch (3147:11): [Folded - Ignored] ------------------ 3148| | /* fall */ 3149| 1.45M| fail: 3150| 1.45M| MOP_OUT; 3151| 1.45M| } 3152| 1.45M| MOP_IN(OP_FAIL); 3153| 1.45M| STACK_POP; ------------------ | | 819| 1.45M|#define STACK_POP do {\ | | 820| 1.45M| switch (pop_level) {\ | | 821| 1.45M| case STACK_POP_LEVEL_FREE:\ | | ------------------ | | | | 350| 1.45M|#define STACK_POP_LEVEL_FREE 0 | | ------------------ | | | Branch (821:3): [True: 1.45M, False: 0] | | ------------------ | | 822| 1.45M| while (1) {\ | | ------------------ | | | Branch (822:12): [Folded - Ignored] | | ------------------ | | 823| 1.45M| stk--;\ | | 824| 1.45M| STACK_BASE_CHECK(stk, "STACK_POP"); \ | | 825| 1.45M| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 1.45M|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (825:11): [True: 1.45M, False: 0] | | ------------------ | | 826| 1.45M| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 827| 0| }\ | | 828| 1.45M| break;\ | | 829| 0| case STACK_POP_LEVEL_MEM_START:\ | | ------------------ | | | | 351| 0|#define STACK_POP_LEVEL_MEM_START 1 | | ------------------ | | | Branch (829:3): [True: 0, False: 1.45M] | | ------------------ | | 830| 0| while (1) {\ | | ------------------ | | | Branch (830:12): [Folded - Ignored] | | ------------------ | | 831| 0| stk--;\ | | 832| 0| STACK_BASE_CHECK(stk, "STACK_POP 2"); \ | | 833| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 0|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (833:11): [True: 0, False: 0] | | ------------------ | | 834| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (834:16): [True: 0, False: 0] | | ------------------ | | 835| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 836| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 837| 0| }\ | | 838| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 839| 0| }\ | | 840| 0| break;\ | | 841| 0| default:\ | | ------------------ | | | Branch (841:3): [True: 0, False: 1.45M] | | ------------------ | | 842| 0| while (1) {\ | | ------------------ | | | Branch (842:12): [Folded - Ignored] | | ------------------ | | 843| 0| stk--;\ | | 844| 0| STACK_BASE_CHECK(stk, "STACK_POP 3"); \ | | 845| 0| if ((stk->type & STK_MASK_POP_USED) != 0) break;\ | | ------------------ | | | | 412| 0|#define STK_MASK_POP_USED 0x00ff | | ------------------ | | | Branch (845:11): [True: 0, False: 0] | | ------------------ | | 846| 0| else if (stk->type == STK_MEM_START) {\ | | ------------------ | | | | 394| 0|#define STK_MEM_START 0x0100 | | ------------------ | | | Branch (846:16): [True: 0, False: 0] | | ------------------ | | 847| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 848| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 849| 0| }\ | | 850| 0| else if (stk->type == STK_REPEAT_INC) {\ | | ------------------ | | | | 396| 0|#define STK_REPEAT_INC 0x0300 | | ------------------ | | | Branch (850:16): [True: 0, False: 0] | | ------------------ | | 851| 0| STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\ | | ------------------ | | | | 590| 0|#define STACK_AT(index) (stk_base + (index)) | | ------------------ | | 852| 0| }\ | | 853| 0| else if (stk->type == STK_MEM_END) {\ | | ------------------ | | | | 395| 0|#define STK_MEM_END 0x8200 | | ------------------ | | | Branch (853:16): [True: 0, False: 0] | | ------------------ | | 854| 0| mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\ | | 855| 0| mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\ | | 856| 0| }\ | | 857| 0| ELSE_IF_STATE_CHECK_MARK(stk);\ | | 858| 0| }\ | | 859| 0| break;\ | | 860| 1.45M| }\ | | 861| 1.45M|} while(0) | | ------------------ | | | Branch (861:9): [Folded - Ignored] | | ------------------ ------------------ 3154| 1.45M| p = stk->u.state.pcode; 3155| 1.45M| s = stk->u.state.pstr; 3156| 1.45M| sprev = stk->u.state.pstr_prev; 3157| 1.45M| pkeep = stk->u.state.pkeep; 3158| | 3159| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 3160| | if (stk->u.state.state_check != 0) { 3161| | stk->type = STK_STATE_CHECK_MARK; 3162| | stk++; 3163| | } 3164| |#endif 3165| | 3166| 1.45M| MOP_OUT; 3167| 1.45M| CHECK_INTERRUPT_IN_MATCH_AT; 3168| 1.45M| JUMP; ------------------ | | 1470| 1.45M|# define JUMP RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++]) | | ------------------ | | | | 203| 1.45M|# define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; }) | | ------------------ ------------------ 3169| | 3170| 1.45M| DEFAULT ------------------ | | 1468| 0|# define DEFAULT L_DEFAULT: ------------------ 3171| 0| goto bytecode_error; 3172| 1.45M| } VM_LOOP_END 3173| | 3174| 1.43M| finish: 3175| 1.43M| STACK_SAVE; ------------------ | | 515| 1.43M|#define STACK_SAVE do{\ | | 516| 1.43M| if (stk_base != stk_alloc) {\ | | ------------------ | | | Branch (516:7): [True: 286, False: 1.43M] | | ------------------ | | 517| 286| msa->stack_p = stk_base;\ | | 518| 286| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | 519| 286| };\ | | 520| 1.43M|} while(0) | | ------------------ | | | Branch (520:9): [Folded - Ignored] | | ------------------ ------------------ 3176| 1.43M| if (xmalloc_base) xfree(xmalloc_base); ------------------ | | 145| 0|# define xfree free ------------------ | Branch (3176:7): [True: 0, False: 1.43M] ------------------ 3177| 1.43M| return best_len; 3178| | 3179| |#ifdef ONIG_DEBUG 3180| | stack_error: 3181| | STACK_SAVE; 3182| | if (xmalloc_base) xfree(xmalloc_base); 3183| | return ONIGERR_STACK_BUG; 3184| |#endif 3185| | 3186| 0| bytecode_error: 3187| 0| STACK_SAVE; ------------------ | | 515| 0|#define STACK_SAVE do{\ | | 516| 0| if (stk_base != stk_alloc) {\ | | ------------------ | | | Branch (516:7): [True: 0, False: 0] | | ------------------ | | 517| 0| msa->stack_p = stk_base;\ | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | 519| 0| };\ | | 520| 0|} while(0) | | ------------------ | | | Branch (520:9): [Folded - Ignored] | | ------------------ ------------------ 3188| 0| if (xmalloc_base) xfree(xmalloc_base); ------------------ | | 145| 0|# define xfree free ------------------ | Branch (3188:7): [True: 0, False: 0] ------------------ 3189| 0| return ONIGERR_UNDEFINED_BYTECODE; ------------------ | | 636| 0|#define ONIGERR_UNDEFINED_BYTECODE -13 ------------------ 3190| | 3191| 0| unexpected_bytecode_error: 3192| 0| STACK_SAVE; ------------------ | | 515| 0|#define STACK_SAVE do{\ | | 516| 0| if (stk_base != stk_alloc) {\ | | ------------------ | | | Branch (516:7): [True: 0, False: 0] | | ------------------ | | 517| 0| msa->stack_p = stk_base;\ | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | 519| 0| };\ | | 520| 0|} while(0) | | ------------------ | | | Branch (520:9): [Folded - Ignored] | | ------------------ ------------------ 3193| 0| if (xmalloc_base) xfree(xmalloc_base); ------------------ | | 145| 0|# define xfree free ------------------ | Branch (3193:7): [True: 0, False: 0] ------------------ 3194| 0| return ONIGERR_UNEXPECTED_BYTECODE; ------------------ | | 637| 0|#define ONIGERR_UNEXPECTED_BYTECODE -14 ------------------ 3195| 1.45M|} regexec.c:stack_double: 540| 809|{ 541| 809| size_t n; 542| 809| OnigStackType *x, *stk_base, *stk_end, *stk; 543| | 544| 809| stk_base = *arg_stk_base; 545| 809| stk_end = *arg_stk_end; 546| 809| stk = *arg_stk; 547| | 548| 809| n = stk_end - stk_base; 549| 809| if (stk_base == stk_alloc && IS_NULL(msa->stack_p)) { ------------------ | | 311| 286|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 286, False: 0] | | ------------------ ------------------ | Branch (549:7): [True: 286, False: 523] ------------------ 550| 286| x = (OnigStackType* )xmalloc(sizeof(OnigStackType) * n * 2); ------------------ | | 142| 286|# define xmalloc malloc ------------------ 551| 286| if (IS_NULL(x)) { ------------------ | | 311| 286|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 286] | | ------------------ ------------------ 552| 0| STACK_SAVE; ------------------ | | 515| 0|#define STACK_SAVE do{\ | | 516| 0| if (stk_base != stk_alloc) {\ | | ------------------ | | | Branch (516:7): [True: 0, False: 0] | | ------------------ | | 517| 0| msa->stack_p = stk_base;\ | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | 519| 0| };\ | | 520| 0|} while(0) | | ------------------ | | | Branch (520:9): [Folded - Ignored] | | ------------------ ------------------ 553| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 554| 0| } 555| 286| xmemcpy(x, stk_base, n * sizeof(OnigStackType)); ------------------ | | 215| 286|#define xmemcpy memcpy ------------------ 556| 286| n *= 2; 557| 286| } 558| 523| else { 559| 523| unsigned int limit_size = MatchStackLimitSize; 560| 523| n *= 2; 561| 523| if (limit_size != 0 && n > limit_size) { ------------------ | Branch (561:9): [True: 0, False: 523] | Branch (561:28): [True: 0, False: 0] ------------------ 562| 0| if ((unsigned int )(stk_end - stk_base) == limit_size) ------------------ | Branch (562:11): [True: 0, False: 0] ------------------ 563| 0| return ONIGERR_MATCH_STACK_LIMIT_OVER; ------------------ | | 638| 0|#define ONIGERR_MATCH_STACK_LIMIT_OVER -15 ------------------ 564| 0| else 565| 0| n = limit_size; 566| 0| } 567| 523| x = (OnigStackType* )xrealloc(stk_base, sizeof(OnigStackType) * n); ------------------ | | 143| 523|# define xrealloc realloc ------------------ 568| 523| if (IS_NULL(x)) { ------------------ | | 311| 523|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 523] | | ------------------ ------------------ 569| 0| STACK_SAVE; ------------------ | | 515| 0|#define STACK_SAVE do{\ | | 516| 0| if (stk_base != stk_alloc) {\ | | ------------------ | | | Branch (516:7): [True: 0, False: 0] | | ------------------ | | 517| 0| msa->stack_p = stk_base;\ | | 518| 0| msa->stack_n = stk_end - stk_base; /* TODO: check overflow */\ | | 519| 0| };\ | | 520| 0|} while(0) | | ------------------ | | | Branch (520:9): [Folded - Ignored] | | ------------------ ------------------ 570| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 571| 0| } 572| 523| } 573| 809| *arg_stk = x + (stk - stk_base); 574| 809| *arg_stk_base = x; 575| 809| *arg_stk_end = x + n; 576| 809| return 0; 577| 809|} regexec.c:forward_search_range: 3561| 2.04k|{ 3562| 2.04k| UChar *p, *pprev = (UChar* )NULL; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 3563| | 3564| |#ifdef ONIG_DEBUG_SEARCH 3565| | fprintf(stderr, "forward_search_range: str: %"PRIuPTR" (%p), end: %"PRIuPTR" (%p), s: %"PRIuPTR" (%p), range: %"PRIuPTR" (%p)\n", 3566| | (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )s, s, (uintptr_t )range, range); 3567| |#endif 3568| | 3569| 2.04k| p = s; 3570| 2.04k| if (reg->dmin > 0) { ------------------ | Branch (3570:7): [True: 2.04k, False: 0] ------------------ 3571| 2.04k| if (ONIGENC_IS_SINGLEBYTE(reg->enc)) { ------------------ | | 318| 2.04k|#define ONIGENC_IS_SINGLEBYTE(enc) (ONIGENC_MBC_MAXLEN(enc) == 1) | | ------------------ | | | | 365| 2.04k|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ | | | Branch (318:40): [True: 0, False: 2.04k] | | ------------------ ------------------ 3572| 0| p += reg->dmin; 3573| 0| } 3574| 2.04k| else { 3575| 2.04k| UChar *q = p + reg->dmin; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 3576| | 3577| 2.04k| if (q >= end) return 0; /* fail */ ------------------ | Branch (3577:11): [True: 0, False: 2.04k] ------------------ 3578| 4.08k| while (p < q) p += enclen(reg->enc, p, end); ------------------ | | 93| 4.08k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 2.04k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 2.04k] | | ------------------ ------------------ | Branch (3578:14): [True: 2.04k, False: 2.04k] ------------------ 3579| 2.04k| } 3580| 2.04k| } 3581| | 3582| 2.04k| retry: 3583| 2.04k| switch (reg->optimize) { ------------------ | Branch (3583:11): [True: 0, False: 2.04k] ------------------ 3584| 2.04k| case ONIG_OPTIMIZE_EXACT: ------------------ | | 356| 2.04k|#define ONIG_OPTIMIZE_EXACT 1 /* Slow Search */ ------------------ | Branch (3584:3): [True: 2.04k, False: 0] ------------------ 3585| 2.04k| p = slow_search(reg->enc, reg->exact, reg->exact_end, p, end, range); 3586| 2.04k| break; 3587| 0| case ONIG_OPTIMIZE_EXACT_IC: ------------------ | | 359| 0|#define ONIG_OPTIMIZE_EXACT_IC 4 /* Slow Search (ignore case) */ ------------------ | Branch (3587:3): [True: 0, False: 2.04k] ------------------ 3588| 0| p = slow_search_ic(reg->enc, reg->case_fold_flag, 3589| 0| reg->exact, reg->exact_end, p, end, range); 3590| 0| break; 3591| | 3592| 0| case ONIG_OPTIMIZE_EXACT_BM: ------------------ | | 357| 0|#define ONIG_OPTIMIZE_EXACT_BM 2 /* Boyer Moore Search */ ------------------ | Branch (3592:3): [True: 0, False: 2.04k] ------------------ 3593| 0| p = bm_search(reg, reg->exact, reg->exact_end, p, end, range); 3594| 0| break; 3595| | 3596| 0| case ONIG_OPTIMIZE_EXACT_BM_NOT_REV: ------------------ | | 358| 0|#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV 3 /* BM (applied to a multibyte string) */ ------------------ | Branch (3596:3): [True: 0, False: 2.04k] ------------------ 3597| 0| p = bm_search_notrev(reg, reg->exact, reg->exact_end, p, end, range); 3598| 0| break; 3599| | 3600| 0| case ONIG_OPTIMIZE_EXACT_BM_IC: ------------------ | | 361| 0|#define ONIG_OPTIMIZE_EXACT_BM_IC 6 /* BM (ignore case) */ ------------------ | Branch (3600:3): [True: 0, False: 2.04k] ------------------ 3601| 0| p = bm_search_ic(reg, reg->exact, reg->exact_end, p, end, range); 3602| 0| break; 3603| | 3604| 0| case ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC: ------------------ | | 362| 0|#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC 7 /* BM (applied to a multibyte string) (ignore case) */ ------------------ | Branch (3604:3): [True: 0, False: 2.04k] ------------------ 3605| 0| p = bm_search_notrev_ic(reg, reg->exact, reg->exact_end, p, end, range); 3606| 0| break; 3607| | 3608| 0| case ONIG_OPTIMIZE_MAP: ------------------ | | 360| 0|#define ONIG_OPTIMIZE_MAP 5 /* char map */ ------------------ | Branch (3608:3): [True: 0, False: 2.04k] ------------------ 3609| 0| p = map_search(reg->enc, reg->map, p, range, end); 3610| 0| break; 3611| 2.04k| } 3612| | 3613| 2.04k| if (p && p < range) { ------------------ | Branch (3613:7): [True: 1.38k, False: 659] | Branch (3613:12): [True: 1.38k, False: 0] ------------------ 3614| 1.38k| if (p - reg->dmin < s) { ------------------ | Branch (3614:9): [True: 0, False: 1.38k] ------------------ 3615| 0| retry_gate: 3616| 0| pprev = p; 3617| 0| p += enclen(reg->enc, p, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 3618| 0| goto retry; 3619| 0| } 3620| | 3621| 1.38k| if (reg->sub_anchor) { ------------------ | Branch (3621:9): [True: 0, False: 1.38k] ------------------ 3622| 0| UChar* prev; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3623| | 3624| 0| switch (reg->sub_anchor) { ------------------ | Branch (3624:15): [True: 0, False: 0] ------------------ 3625| 0| case ANCHOR_BEGIN_LINE: ------------------ | | 541| 0|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ | Branch (3625:7): [True: 0, False: 0] ------------------ 3626| 0| if (!ON_STR_BEGIN(p)) { ------------------ | | 1175| 0|#define ON_STR_BEGIN(s) ((s) == str) ------------------ | Branch (3626:6): [True: 0, False: 0] ------------------ 3627| 0| prev = onigenc_get_prev_char_head(reg->enc, 3628| 0| (pprev ? pprev : str), p, end); ------------------ | Branch (3628:11): [True: 0, False: 0] ------------------ 3629| 0| if (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)) ------------------ | | 66| 0| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) ------------------ | Branch (3629:8): [True: 0, False: 0] ------------------ 3630| 0| goto retry_gate; 3631| 0| } 3632| 0| break; 3633| | 3634| 0| case ANCHOR_END_LINE: ------------------ | | 545| 0|#define ANCHOR_END_LINE (1<<5) ------------------ | Branch (3634:7): [True: 0, False: 0] ------------------ 3635| 0| if (ON_STR_END(p)) { ------------------ | | 1176| 0|#define ON_STR_END(s) ((s) == end) | | ------------------ | | | Branch (1176:32): [True: 0, False: 0] | | ------------------ ------------------ 3636| |#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE 3637| | prev = (UChar* )onigenc_get_prev_char_head(reg->enc, 3638| | (pprev ? pprev : str), p); 3639| | if (prev && ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 1)) 3640| | goto retry_gate; 3641| |#endif 3642| 0| } 3643| 0| else if (! ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, p, str, end, reg->options, 1)) ------------------ | | 66| 0| is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev)) ------------------ | Branch (3643:11): [True: 0, False: 0] ------------------ 3644| 0| goto retry_gate; 3645| 0| break; 3646| 0| } 3647| 0| } 3648| | 3649| 1.38k| if (reg->dmax == 0) { ------------------ | Branch (3649:9): [True: 0, False: 1.38k] ------------------ 3650| 0| *low = p; 3651| 0| if (low_prev) { ------------------ | Branch (3651:11): [True: 0, False: 0] ------------------ 3652| 0| if (*low > s) ------------------ | Branch (3652:6): [True: 0, False: 0] ------------------ 3653| 0| *low_prev = onigenc_get_prev_char_head(reg->enc, s, p, end); 3654| 0| else 3655| 0| *low_prev = onigenc_get_prev_char_head(reg->enc, 3656| 0| (pprev ? pprev : str), p, end); ------------------ | Branch (3656:9): [True: 0, False: 0] ------------------ 3657| 0| } 3658| 0| } 3659| 1.38k| else { 3660| 1.38k| if (reg->dmax != ONIG_INFINITE_DISTANCE) { ------------------ | | 85| 1.38k|#define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) ------------------ | Branch (3660:11): [True: 0, False: 1.38k] ------------------ 3661| 0| if (p < str + reg->dmax) { ------------------ | Branch (3661:6): [True: 0, False: 0] ------------------ 3662| 0| *low = (UChar* )str; 3663| 0| if (low_prev) ------------------ | Branch (3663:8): [True: 0, False: 0] ------------------ 3664| 0| *low_prev = onigenc_get_prev_char_head(reg->enc, str, *low, end); 3665| 0| } 3666| 0| else { 3667| 0| *low = p - reg->dmax; 3668| 0| if (*low > s) { ------------------ | Branch (3668:8): [True: 0, False: 0] ------------------ 3669| 0| *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s, 3670| 0| *low, end, (const UChar** )low_prev); 3671| 0| if (low_prev && IS_NULL(*low_prev)) ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3671:10): [True: 0, False: 0] ------------------ 3672| 0| *low_prev = onigenc_get_prev_char_head(reg->enc, 3673| 0| (pprev ? pprev : s), *low, end); ------------------ | Branch (3673:13): [True: 0, False: 0] ------------------ 3674| 0| } 3675| 0| else { 3676| 0| if (low_prev) ------------------ | Branch (3676:10): [True: 0, False: 0] ------------------ 3677| 0| *low_prev = onigenc_get_prev_char_head(reg->enc, 3678| 0| (pprev ? pprev : str), *low, end); ------------------ | Branch (3678:9): [True: 0, False: 0] ------------------ 3679| 0| } 3680| 0| } 3681| 0| } 3682| 1.38k| } 3683| | /* no needs to adjust *high, *high is used as range check only */ 3684| 1.38k| *high = p - reg->dmin; 3685| | 3686| |#ifdef ONIG_DEBUG_SEARCH 3687| | fprintf(stderr, 3688| | "forward_search_range success: low: %"PRIdPTR", high: %"PRIdPTR", dmin: %"PRIdPTR", dmax: %"PRIdPTR"\n", 3689| | *low - str, *high - str, reg->dmin, reg->dmax); 3690| |#endif 3691| 1.38k| return 1; /* success */ 3692| 1.38k| } 3693| | 3694| 659| return 0; /* fail */ 3695| 2.04k|} regexec.c:slow_search: 3201| 2.04k|{ 3202| 2.04k| UChar *t, *p, *s, *end; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 3203| | 3204| 2.04k| end = (UChar* )text_end; 3205| 2.04k| end -= target_end - target - 1; 3206| 2.04k| if (end > text_range) ------------------ | Branch (3206:7): [True: 0, False: 2.04k] ------------------ 3207| 0| end = text_range; 3208| | 3209| 2.04k| s = (UChar* )text; 3210| | 3211| 2.04k| if (enc->max_enc_len == enc->min_enc_len) { ------------------ | Branch (3211:7): [True: 0, False: 2.04k] ------------------ 3212| 0| int n = enc->max_enc_len; 3213| | 3214| 0| while (s < end) { ------------------ | Branch (3214:12): [True: 0, False: 0] ------------------ 3215| 0| if (*s == *target) { ------------------ | Branch (3215:11): [True: 0, False: 0] ------------------ 3216| 0| p = s + 1; 3217| 0| t = target + 1; 3218| 0| if (target_end == t || memcmp(t, p, target_end - t) == 0) ------------------ | Branch (3218:6): [True: 0, False: 0] | Branch (3218:25): [True: 0, False: 0] ------------------ 3219| 0| return s; 3220| 0| } 3221| 0| s += n; 3222| 0| } 3223| 0| return (UChar* )NULL; 3224| 0| } 3225| 2.96M| while (s < end) { ------------------ | Branch (3225:10): [True: 2.96M, False: 659] ------------------ 3226| 2.96M| if (*s == *target) { ------------------ | Branch (3226:9): [True: 1.38k, False: 2.95M] ------------------ 3227| 1.38k| p = s + 1; 3228| 1.38k| t = target + 1; 3229| 1.38k| if (target_end == t || memcmp(t, p, target_end - t) == 0) ------------------ | Branch (3229:11): [True: 1.38k, False: 0] | Branch (3229:30): [True: 0, False: 0] ------------------ 3230| 1.38k| return s; 3231| 1.38k| } 3232| 2.95M| s += enclen(enc, s, text_end); ------------------ | | 93| 2.95M|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 2.95M|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 2.95M] | | ------------------ ------------------ 3233| 2.95M| } 3234| | 3235| 659| return (UChar* )NULL; 3236| 2.04k|} regexec.c:is_mbc_newline_ex: 70| 734k|{ 71| 734k| if (IS_NEWLINE_CRLF(option)) { ------------------ | | 409| 734k|#define IS_NEWLINE_CRLF(option) ((option) & ONIG_OPTION_NEWLINE_CRLF) | | ------------------ | | | | 474| 734k|#define ONIG_OPTION_NEWLINE_CRLF (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1) | | | | ------------------ | | | | | | 472| 734k|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | | | ------------------ | | | | | | | | 471| 734k|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | | | ------------------ | | | | | | | | | | 470| 734k|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 468| 734k|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 467| 734k|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 466| 734k|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 465| 734k|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 463| 734k|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 462| 734k|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 461| 734k|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 460| 734k|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 734k|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 734k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 734k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 734k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 734k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (409:35): [True: 0, False: 734k] | | ------------------ ------------------ 72| 0| if (ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0a) { ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ | Branch (72:9): [True: 0, False: 0] ------------------ 73| 0| if (check_prev) { ------------------ | Branch (73:11): [True: 0, False: 0] ------------------ 74| 0| const UChar *prev = onigenc_get_prev_char_head(enc, start, p, end); 75| 0| if ((prev != NULL) && ONIGENC_MBC_TO_CODE(enc, prev, end) == 0x0d) ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ | Branch (75:6): [True: 0, False: 0] | Branch (75:24): [True: 0, False: 0] ------------------ 76| 0| return 0; 77| 0| else 78| 0| return 1; 79| 0| } 80| 0| else 81| 0| return 1; 82| 0| } 83| 0| else { 84| 0| const UChar *pnext = p + enclen(enc, p, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 85| 0| if (pnext < end && ------------------ | Branch (85:11): [True: 0, False: 0] ------------------ 86| 0| ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0d && ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ | Branch (86:4): [True: 0, False: 0] ------------------ 87| 0| ONIGENC_MBC_TO_CODE(enc, pnext, end) == 0x0a) ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ | Branch (87:4): [True: 0, False: 0] ------------------ 88| 0| return 1; 89| 0| if (ONIGENC_IS_MBC_NEWLINE(enc, p, end)) ------------------ | | 368| 0|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end),enc) | | ------------------ | | | Branch (368:48): [True: 0, False: 0] | | ------------------ ------------------ 90| 0| return 1; 91| 0| return 0; 92| 0| } 93| 0| } 94| 734k| else { 95| 734k| return ONIGENC_IS_MBC_NEWLINE(enc, p, end); ------------------ | | 368| 734k|#define ONIGENC_IS_MBC_NEWLINE(enc,p,end) (enc)->is_mbc_newline((p),(end),enc) ------------------ 96| 734k| } 97| 734k|} onig_strcpy: 260| 6.12k|{ 261| 6.12k| ptrdiff_t len = end - src; 262| 6.12k| if (len > 0) { ------------------ | Branch (262:7): [True: 6.12k, False: 0] ------------------ 263| 6.12k| xmemcpy(dest, src, len); ------------------ | | 215| 6.12k|#define xmemcpy memcpy ------------------ 264| 6.12k| dest[len] = (UChar )0; 265| 6.12k| } 266| 6.12k|} onig_st_init_strend_table_with_size: 407| 2.04k|{ 408| 2.04k| static const struct st_hash_type hashType = { 409| 2.04k| str_end_cmp, 410| 2.04k| str_end_hash, 411| 2.04k| }; 412| | 413| 2.04k| return (hash_table_type* ) 414| 2.04k| onig_st_init_table_with_size(&hashType, size); 415| 2.04k|} onig_st_lookup_strend: 420| 6.12k|{ 421| 6.12k| st_str_end_key key; 422| | 423| 6.12k| key.s = (UChar* )str_key; 424| 6.12k| key.end = (UChar* )end_key; 425| | 426| 6.12k| return onig_st_lookup(table, (st_data_t )(&key), value); 427| 6.12k|} onig_st_insert_strend: 432| 8.16k|{ 433| 8.16k| st_str_end_key* key; 434| 8.16k| int result; 435| | 436| 8.16k| key = (st_str_end_key* )xmalloc(sizeof(st_str_end_key)); ------------------ | | 142| 8.16k|# define xmalloc malloc ------------------ 437| 8.16k| key->s = (UChar* )str_key; 438| 8.16k| key->end = (UChar* )end_key; 439| 8.16k| result = onig_st_insert(table, (st_data_t )key, value); 440| 8.16k| if (result) { ------------------ | Branch (440:7): [True: 0, False: 8.16k] ------------------ 441| 0| xfree(key); ------------------ | | 145| 0|# define xfree free ------------------ 442| 0| } 443| 8.16k| return result; 444| 8.16k|} onig_names_free: 526| 2.04k|{ 527| 2.04k| int r; 528| 2.04k| NameTable* t; 529| | 530| 2.04k| r = names_clear(reg); 531| 2.04k| if (r) return r; ------------------ | Branch (531:7): [True: 0, False: 2.04k] ------------------ 532| | 533| 2.04k| t = (NameTable* )reg->name_table; 534| 2.04k| if (IS_NOT_NULL(t)) onig_st_free_table(t); ------------------ | | 312| 2.04k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 0] | | ------------------ ------------------ 535| 2.04k| reg->name_table = (void* )NULL; 536| 2.04k| return 0; 537| 2.04k|} onig_node_free: 1063| 48.9k|{ 1064| 67.3k| start: 1065| 67.3k| if (IS_NULL(node)) return ; ------------------ | | 311| 67.3k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 8.16k, False: 59.1k] | | ------------------ ------------------ 1066| | 1067| 59.1k| switch (NTYPE(node)) { ------------------ | | 69| 59.1k|#define NTYPE(node) ((node)->u.base.type) | | ------------------ | | | Branch (69:33): [True: 2.04k, False: 57.1k] | | ------------------ ------------------ 1068| 6.12k| case NT_STR: ------------------ | | 38| 6.12k|#define NT_STR 0 ------------------ | Branch (1068:3): [True: 6.12k, False: 53.0k] ------------------ 1069| 6.12k| if (NSTR(node)->capa != 0 && ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ | Branch (1069:9): [True: 0, False: 6.12k] ------------------ 1070| 6.12k| IS_NOT_NULL(NSTR(node)->s) && NSTR(node)->s != NSTR(node)->buf) { ------------------ | | 312| 6.12k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ IS_NOT_NULL(NSTR(node)->s) && NSTR(node)->s != NSTR(node)->buf) { ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ IS_NOT_NULL(NSTR(node)->s) && NSTR(node)->s != NSTR(node)->buf) { ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ | Branch (1070:32): [True: 0, False: 0] ------------------ 1071| 0| xfree(NSTR(node)->s); ------------------ | | 145| 0|# define xfree free ------------------ xfree(NSTR(node)->s); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1072| 0| } 1073| 6.12k| break; 1074| | 1075| 18.3k| case NT_LIST: ------------------ | | 46| 18.3k|#define NT_LIST 8 ------------------ | Branch (1075:3): [True: 18.3k, False: 40.8k] ------------------ 1076| 18.3k| case NT_ALT: ------------------ | | 47| 18.3k|#define NT_ALT 9 ------------------ | Branch (1076:3): [True: 0, False: 59.1k] ------------------ 1077| 18.3k| onig_node_free(NCAR(node)); ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1078| 18.3k| { 1079| 18.3k| Node* next_node = NCDR(node); ------------------ | | 87| 18.3k|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1080| | 1081| 18.3k| xfree(node); ------------------ | | 145| 18.3k|# define xfree free ------------------ 1082| 18.3k| node = next_node; 1083| 18.3k| goto start; 1084| 18.3k| } 1085| 0| break; 1086| | 1087| 6.12k| case NT_CCLASS: ------------------ | | 39| 6.12k|#define NT_CCLASS 1 ------------------ | Branch (1087:3): [True: 6.12k, False: 53.0k] ------------------ 1088| 6.12k| { 1089| 6.12k| CClassNode* cc = NCCLASS(node); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 1090| | 1091| 6.12k| if (cc->mbuf) ------------------ | Branch (1091:11): [True: 0, False: 6.12k] ------------------ 1092| 0| bbuf_free(cc->mbuf); 1093| 6.12k| } 1094| 6.12k| break; 1095| | 1096| 8.16k| case NT_QTFR: ------------------ | | 43| 8.16k|#define NT_QTFR 5 ------------------ | Branch (1096:3): [True: 8.16k, False: 51.0k] ------------------ 1097| 8.16k| if (NQTFR(node)->target) ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ | Branch (1097:9): [True: 8.16k, False: 0] ------------------ 1098| 8.16k| onig_node_free(NQTFR(node)->target); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1099| 8.16k| break; 1100| | 1101| 14.2k| case NT_ENCLOSE: ------------------ | | 44| 14.2k|#define NT_ENCLOSE 6 ------------------ | Branch (1101:3): [True: 14.2k, False: 44.9k] ------------------ 1102| 14.2k| if (NENCLOSE(node)->target) ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ | Branch (1102:9): [True: 14.2k, False: 0] ------------------ 1103| 14.2k| onig_node_free(NENCLOSE(node)->target); ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1104| 14.2k| break; 1105| | 1106| 0| case NT_BREF: ------------------ | | 42| 0|#define NT_BREF 4 ------------------ | Branch (1106:3): [True: 0, False: 59.1k] ------------------ 1107| 0| if (IS_NOT_NULL(NBREF(node)->back_dynamic)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 1108| 0| xfree(NBREF(node)->back_dynamic); ------------------ | | 145| 0|# define xfree free ------------------ xfree(NBREF(node)->back_dynamic); ------------------ | | 79| 0|#define NBREF(node) (&((node)->u.bref)) ------------------ 1109| 0| break; 1110| | 1111| 4.08k| case NT_ANCHOR: ------------------ | | 45| 4.08k|#define NT_ANCHOR 7 ------------------ | Branch (1111:3): [True: 4.08k, False: 55.1k] ------------------ 1112| 4.08k| if (NANCHOR(node)->target) ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ | Branch (1112:9): [True: 0, False: 4.08k] ------------------ 1113| 0| onig_node_free(NANCHOR(node)->target); ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1114| 4.08k| break; 1115| 59.1k| } 1116| | 1117| 40.8k| xfree(node); ------------------ | | 145| 40.8k|# define xfree free ------------------ 1118| 40.8k|} onig_node_new_anchor: 1223| 4.08k|{ 1224| 4.08k| Node* node = node_new(); 1225| 4.08k| CHECK_NULL_RETURN(node); ------------------ | | 313| 4.08k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 4.08k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 4.08k] | | | | ------------------ | | ------------------ ------------------ 1226| | 1227| 4.08k| SET_NTYPE(node, NT_ANCHOR); ------------------ | | 71| 4.08k| do { \ | | 72| 4.08k| int value = ntype; \ | | 73| 4.08k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 4.08k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1228| 4.08k| NANCHOR(node)->type = type; ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1229| 4.08k| NANCHOR(node)->target = NULL; ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1230| 4.08k| NANCHOR(node)->char_len = -1; ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1231| 4.08k| NANCHOR(node)->ascii_range = 0; ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 1232| 4.08k| return node; 1233| 4.08k|} onig_node_new_enclose: 1348| 6.12k|{ 1349| 6.12k| return node_new_enclose(type); 1350| 6.12k|} onig_node_str_cat: 1377| 6.12k|{ 1378| 6.12k| ptrdiff_t addlen = end - s; 1379| | 1380| 6.12k| if (addlen > 0) { ------------------ | Branch (1380:7): [True: 6.12k, False: 0] ------------------ 1381| 6.12k| ptrdiff_t len = NSTR(node)->end - NSTR(node)->s; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ ptrdiff_t len = NSTR(node)->end - NSTR(node)->s; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1382| | 1383| 6.12k| if (NSTR(node)->capa > 0 || (len + addlen > NODE_STR_BUF_SIZE - 1)) { ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ if (NSTR(node)->capa > 0 || (len + addlen > NODE_STR_BUF_SIZE - 1)) { ------------------ | | 101| 6.12k|#define NODE_STR_BUF_SIZE 24 /* sizeof(CClassNode) - sizeof(int)*4 */ ------------------ | Branch (1383:9): [True: 0, False: 6.12k] | Branch (1383:33): [True: 0, False: 6.12k] ------------------ 1384| 0| UChar* p; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 1385| 0| ptrdiff_t capa = len + addlen + NODE_STR_MARGIN; ------------------ | | 100| 0|#define NODE_STR_MARGIN 16 ------------------ 1386| | 1387| 0| if (capa <= NSTR(node)->capa) { ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ | Branch (1387:11): [True: 0, False: 0] ------------------ 1388| 0| onig_strcpy(NSTR(node)->s + len, s, end); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1389| 0| } 1390| 0| else { 1391| 0| if (NSTR(node)->s == NSTR(node)->buf) ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ if (NSTR(node)->s == NSTR(node)->buf) ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ | Branch (1391:6): [True: 0, False: 0] ------------------ 1392| 0| p = strcat_capa_from_static(NSTR(node)->s, NSTR(node)->end, ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ p = strcat_capa_from_static(NSTR(node)->s, NSTR(node)->end, ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1393| 0| s, end, capa); 1394| 0| else 1395| 0| p = strcat_capa(NSTR(node)->s, NSTR(node)->end, s, end, capa); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ p = strcat_capa(NSTR(node)->s, NSTR(node)->end, s, end, capa); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1396| | 1397| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1398| 0| NSTR(node)->s = p; ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1399| 0| NSTR(node)->capa = (int )capa; ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 1400| 0| } 1401| 0| } 1402| 6.12k| else { 1403| 6.12k| onig_strcpy(NSTR(node)->s + len, s, end); ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1404| 6.12k| } 1405| 6.12k| NSTR(node)->end = NSTR(node)->s + len + addlen; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ NSTR(node)->end = NSTR(node)->s + len + addlen; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1406| 6.12k| } 1407| | 1408| 6.12k| return 0; 1409| 6.12k|} onig_parse_make_tree: 6633| 2.04k|{ 6634| 2.04k| int r; 6635| 2.04k| UChar* p; ------------------ | | 76| 2.04k|# define UChar OnigUChar ------------------ 6636| | 6637| 2.04k|#ifdef USE_NAMED_GROUP 6638| 2.04k| names_clear(reg); 6639| 2.04k|#endif 6640| | 6641| 2.04k| scan_env_clear(env); 6642| 2.04k| env->option = reg->options; 6643| 2.04k| env->case_fold_flag = reg->case_fold_flag; 6644| 2.04k| env->enc = reg->enc; 6645| 2.04k| env->syntax = reg->syntax; 6646| 2.04k| env->pattern = (UChar* )pattern; 6647| 2.04k| env->pattern_end = (UChar* )end; 6648| 2.04k| env->reg = reg; 6649| | 6650| 2.04k| *root = NULL; 6651| 2.04k| p = (UChar* )pattern; 6652| 2.04k| r = parse_regexp(root, &p, (UChar* )end, env); 6653| 2.04k| reg->num_mem = env->num_mem; 6654| 2.04k| return r; 6655| 2.04k|} regparse.c:str_end_hash: 392| 14.2k|{ 393| 14.2k| const st_str_end_key *x = (const st_str_end_key *)xp; 394| 14.2k| const UChar *p; 395| 14.2k| st_index_t val = 0; 396| | 397| 14.2k| p = x->s; 398| 81.6k| while (p < x->end) { ------------------ | Branch (398:10): [True: 67.3k, False: 14.2k] ------------------ 399| 67.3k| val = val * 997 + (int )*p++; 400| 67.3k| } 401| | 402| 14.2k| return val + (val >> 5); 403| 14.2k|} regparse.c:names_clear: 515| 4.08k|{ 516| 4.08k| NameTable* t = (NameTable* )reg->name_table; 517| | 518| 4.08k| if (IS_NOT_NULL(t)) { ------------------ | | 312| 4.08k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 2.04k, False: 2.04k] | | ------------------ ------------------ 519| 2.04k| onig_st_foreach(t, i_free_name_entry, 0); 520| 2.04k| } 521| 4.08k| return 0; 522| 4.08k|} regparse.c:i_free_name_entry: 505| 8.16k|{ 506| 8.16k| xfree(e->name); ------------------ | | 145| 8.16k|# define xfree free ------------------ 507| 8.16k| if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs); ------------------ | | 312| 8.16k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 8.16k] | | ------------------ ------------------ if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs); ------------------ | | 145| 0|# define xfree free ------------------ 508| 8.16k| xfree(key); ------------------ | | 145| 8.16k|# define xfree free ------------------ 509| 8.16k| xfree(e); ------------------ | | 145| 8.16k|# define xfree free ------------------ 510| 8.16k| return ST_DELETE; 511| 8.16k|} regparse.c:name_find: 541| 8.16k|{ 542| 8.16k| NameEntry* e; 543| 8.16k| NameTable* t = (NameTable* )reg->name_table; 544| | 545| 8.16k| e = (NameEntry* )NULL; 546| 8.16k| if (IS_NOT_NULL(t)) { ------------------ | | 312| 8.16k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 6.12k, False: 2.04k] | | ------------------ ------------------ 547| 6.12k| onig_st_lookup_strend(t, name, name_end, (HashDataType* )((void* )(&e))); 548| 6.12k| } 549| 8.16k| return e; 550| 8.16k|} regparse.c:node_new_list: 1175| 18.3k|{ 1176| 18.3k| Node* node = node_new(); 1177| 18.3k| CHECK_NULL_RETURN(node); ------------------ | | 313| 18.3k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 18.3k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 18.3k] | | | | ------------------ | | ------------------ ------------------ 1178| | 1179| 18.3k| SET_NTYPE(node, NT_LIST); ------------------ | | 71| 18.3k| do { \ | | 72| 18.3k| int value = ntype; \ | | 73| 18.3k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 18.3k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1180| 18.3k| NCAR(node) = left; ------------------ | | 86| 18.3k|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1181| 18.3k| NCDR(node) = right; ------------------ | | 87| 18.3k|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 18.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 1182| 18.3k| return node; 1183| 18.3k|} regparse.c:node_new: 1122| 59.1k|{ 1123| 59.1k| Node* node; 1124| | 1125| 59.1k| node = (Node* )xmalloc(sizeof(Node)); ------------------ | | 142| 59.1k|# define xmalloc malloc ------------------ 1126| | /* xmemset(node, 0, sizeof(Node)); */ 1127| 59.1k| return node; 1128| 59.1k|} regparse.c:node_new_enclose: 1331| 14.2k|{ 1332| 14.2k| Node* node = node_new(); 1333| 14.2k| CHECK_NULL_RETURN(node); ------------------ | | 313| 14.2k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 14.2k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 14.2k] | | | | ------------------ | | ------------------ ------------------ 1334| | 1335| 14.2k| SET_NTYPE(node, NT_ENCLOSE); ------------------ | | 71| 14.2k| do { \ | | 72| 14.2k| int value = ntype; \ | | 73| 14.2k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 14.2k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1336| 14.2k| NENCLOSE(node)->type = type; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1337| 14.2k| NENCLOSE(node)->state = 0; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1338| 14.2k| NENCLOSE(node)->regnum = 0; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1339| 14.2k| NENCLOSE(node)->option = 0; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1340| 14.2k| NENCLOSE(node)->target = NULL; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1341| 14.2k| NENCLOSE(node)->call_addr = -1; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1342| 14.2k| NENCLOSE(node)->opt_count = 0; ------------------ | | 81| 14.2k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1343| 14.2k| return node; 1344| 14.2k|} regparse.c:node_new_str: 1464| 6.12k|{ 1465| 6.12k| Node* node = node_new(); 1466| 6.12k| CHECK_NULL_RETURN(node); ------------------ | | 313| 6.12k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ ------------------ 1467| | 1468| 6.12k| SET_NTYPE(node, NT_STR); ------------------ | | 71| 6.12k| do { \ | | 72| 6.12k| int value = ntype; \ | | 73| 6.12k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 6.12k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1469| 6.12k| NSTR(node)->capa = 0; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1470| 6.12k| NSTR(node)->flag = 0; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1471| 6.12k| NSTR(node)->s = NSTR(node)->buf; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ NSTR(node)->s = NSTR(node)->buf; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1472| 6.12k| NSTR(node)->end = NSTR(node)->buf; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ NSTR(node)->end = NSTR(node)->buf; ------------------ | | 76| 6.12k|#define NSTR(node) (&((node)->u.str)) ------------------ 1473| 6.12k| if (onig_node_str_cat(node, s, end)) { ------------------ | Branch (1473:7): [True: 0, False: 6.12k] ------------------ 1474| 0| onig_node_free(node); 1475| 0| return NULL; 1476| 0| } 1477| 6.12k| return node; 1478| 6.12k|} regparse.c:scan_env_clear: 984| 2.04k|{ 985| 2.04k| int i; 986| | 987| 2.04k| BIT_STATUS_CLEAR(env->capture_history); ------------------ | | 368| 2.04k|#define BIT_STATUS_CLEAR(stats) (stats) = 0 ------------------ 988| 2.04k| BIT_STATUS_CLEAR(env->bt_mem_start); ------------------ | | 368| 2.04k|#define BIT_STATUS_CLEAR(stats) (stats) = 0 ------------------ 989| 2.04k| BIT_STATUS_CLEAR(env->bt_mem_end); ------------------ | | 368| 2.04k|#define BIT_STATUS_CLEAR(stats) (stats) = 0 ------------------ 990| 2.04k| BIT_STATUS_CLEAR(env->backrefed_mem); ------------------ | | 368| 2.04k|#define BIT_STATUS_CLEAR(stats) (stats) = 0 ------------------ 991| 2.04k| env->error = (UChar* )NULL; 992| 2.04k| env->error_end = (UChar* )NULL; 993| 2.04k| env->num_call = 0; 994| 2.04k| env->num_mem = 0; 995| 2.04k|#ifdef USE_NAMED_GROUP 996| 2.04k| env->num_named = 0; 997| 2.04k|#endif 998| 2.04k| env->mem_alloc = 0; 999| 2.04k| env->mem_nodes_dynamic = (Node** )NULL; 1000| | 1001| 18.3k| for (i = 0; i < SCANENV_MEMNODES_SIZE; i++) ------------------ | | 285| 18.3k|#define SCANENV_MEMNODES_SIZE 8 ------------------ | Branch (1001:15): [True: 16.3k, False: 2.04k] ------------------ 1002| 16.3k| env->mem_nodes_static[i] = NULL_NODE; ------------------ | | 283| 16.3k|#define NULL_NODE ((Node* )0) ------------------ 1003| | 1004| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 1005| | env->num_comb_exp_check = 0; 1006| | env->comb_exp_max_regnum = 0; 1007| | env->curr_max_regnum = 0; 1008| | env->has_recursion = 0; 1009| |#endif 1010| 2.04k| env->parse_depth = 0; 1011| 2.04k| env->warnings_flag = 0; 1012| 2.04k|} regparse.c:parse_regexp: 6601| 2.04k|{ 6602| 2.04k| int r; 6603| 2.04k| OnigToken tok; 6604| | 6605| 2.04k| r = fetch_token(&tok, src, end, env); 6606| 2.04k| if (r < 0) return r; ------------------ | Branch (6606:7): [True: 0, False: 2.04k] ------------------ 6607| 2.04k| r = parse_subexp(top, &tok, TK_EOT, src, end, env); 6608| 2.04k| if (r < 0) return r; ------------------ | Branch (6608:7): [True: 0, False: 2.04k] ------------------ 6609| | 6610| 2.04k|#ifdef USE_SUBEXP_CALL 6611| 2.04k| if (env->num_call > 0) { ------------------ | Branch (6611:7): [True: 0, False: 2.04k] ------------------ 6612| | /* Capture the pattern itself. It is used for (?R), (?0) and \g<0>. */ 6613| 0| const int num = 0; 6614| 0| Node* np; 6615| 0| np = node_new_enclose_memory(env->option, 0); 6616| 0| CHECK_NULL_RETURN_MEMERR(np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6617| 0| NENCLOSE(np)->regnum = num; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 6618| 0| NENCLOSE(np)->target = *top; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 6619| 0| r = scan_env_set_mem_node(env, num, np); 6620| 0| if (r != 0) { ------------------ | Branch (6620:9): [True: 0, False: 0] ------------------ 6621| 0| onig_node_free(np); 6622| 0| return r; 6623| 0| } 6624| 0| *top = np; 6625| 0| } 6626| 2.04k|#endif 6627| 2.04k| return 0; 6628| 2.04k|} regparse.c:fetch_token: 3306| 44.9k|{ 3307| 44.9k| int r, num; 3308| 44.9k| OnigCodePoint c; 3309| 44.9k| OnigEncoding enc = env->enc; 3310| 44.9k| const OnigSyntaxType* syn = env->syntax; 3311| 44.9k| UChar* prev; ------------------ | | 76| 44.9k|# define UChar OnigUChar ------------------ 3312| 44.9k| UChar* p = *src; ------------------ | | 76| 44.9k|# define UChar OnigUChar ------------------ 3313| 44.9k| PFETCH_READY; ------------------ | | 295| 44.9k|# define PFETCH_READY UChar* pfetch_prev = NULL; (void)pfetch_prev | | ------------------ | | | | 76| 44.9k|# define UChar OnigUChar | | ------------------ ------------------ 3314| | 3315| 44.9k| start: 3316| 44.9k| if (PEND) { ------------------ | | 299| 44.9k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 2.04k, False: 42.8k] | | | Branch (299:23): [True: 42.8k, False: 2.04k] | | ------------------ ------------------ 3317| 2.04k| tok->type = TK_EOT; 3318| 2.04k| return tok->type; 3319| 2.04k| } 3320| | 3321| 42.8k| tok->type = TK_STRING; 3322| 42.8k| tok->base = 0; 3323| 42.8k| tok->backp = p; 3324| | 3325| 42.8k| PFETCH(c); ------------------ | | 305| 42.8k|#define PFETCH(c) do { \ | | 306| 42.8k| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 42.8k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 42.8k] | | ------------------ | | 307| 42.8k| pfetch_prev = p; \ | | 308| 42.8k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 42.8k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 42.8k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 42.8k] | | | | ------------------ | | ------------------ | | 309| 42.8k|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3326| 42.8k| if (p > end) return ONIGERR_PREMATURE_END_OF_CHAR_CLASS; ------------------ | | 648| 0|#define ONIGERR_PREMATURE_END_OF_CHAR_CLASS -103 ------------------ | Branch (3326:6): [True: 0, False: 42.8k] ------------------ 3327| 42.8k| if (IS_MC_ESC_CODE(c, syn)) { ------------------ | | 769| 42.8k| ((code) == MC_ESC(syn) && \ | | ------------------ | | | | 761| 85.7k|#define MC_ESC(syn) (syn)->meta_char_table.esc | | ------------------ | | | Branch (769:4): [True: 0, False: 42.8k] | | ------------------ | | 770| 42.8k| !IS_SYNTAX_OP2((syn), ONIG_SYN_OP2_INEFFECTIVE_ESCAPE)) | | ------------------ | | | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (770:4): [True: 0, False: 0] | | ------------------ ------------------ 3328| 0| if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 649| 0|#define ONIGERR_END_PATTERN_AT_ESCAPE -104 ------------------ 3329| | 3330| 0| tok->backp = p; 3331| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3332| | 3333| 0| tok->u.c = c; 3334| 0| tok->escaped = 1; 3335| 0| switch (c) { 3336| 0| case '*': ------------------ | Branch (3336:5): [True: 0, False: 0] ------------------ 3337| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3337:11): [True: 0, False: 0] ------------------ 3338| 0| tok->type = TK_OP_REPEAT; 3339| 0| tok->u.repeat.lower = 0; 3340| 0| tok->u.repeat.upper = REPEAT_INFINITE; ------------------ | | 421| 0|#define REPEAT_INFINITE -1 ------------------ 3341| 0| goto greedy_check; 3342| 0| break; 3343| | 3344| 0| case '+': ------------------ | Branch (3344:5): [True: 0, False: 0] ------------------ 3345| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_PLUS_ONE_INF)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3345:11): [True: 0, False: 0] ------------------ 3346| 0| tok->type = TK_OP_REPEAT; 3347| 0| tok->u.repeat.lower = 1; 3348| 0| tok->u.repeat.upper = REPEAT_INFINITE; ------------------ | | 421| 0|#define REPEAT_INFINITE -1 ------------------ 3349| 0| goto greedy_check; 3350| 0| break; 3351| | 3352| 0| case '?': ------------------ | Branch (3352:5): [True: 0, False: 0] ------------------ 3353| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3353:11): [True: 0, False: 0] ------------------ 3354| 0| tok->type = TK_OP_REPEAT; 3355| 0| tok->u.repeat.lower = 0; 3356| 0| tok->u.repeat.upper = 1; 3357| 8.16k| greedy_check: 3358| 8.16k| if (!PEND && PPEEK_IS('?') && ------------------ | | 299| 16.3k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 8.16k, False: 0] | | ------------------ ------------------ if (!PEND && PPEEK_IS('?') && ------------------ | | 320| 16.3k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 8.16k] | | ------------------ ------------------ | Branch (3358:11): [True: 8.16k, False: 0] ------------------ 3359| 8.16k| IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_NON_GREEDY)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3360| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3361| 0| tok->u.repeat.greedy = 0; 3362| 0| tok->u.repeat.possessive = 0; 3363| 0| } 3364| 8.16k| else { 3365| 8.16k| possessive_check: 3366| 8.16k| if (!PEND && PPEEK_IS('+') && ------------------ | | 299| 16.3k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 8.16k, False: 0] | | ------------------ ------------------ if (!PEND && PPEEK_IS('+') && ------------------ | | 320| 16.3k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 8.16k] | | ------------------ ------------------ | Branch (3366:6): [True: 8.16k, False: 0] ------------------ 3367| 8.16k| ((IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3368| 0| tok->type != TK_INTERVAL) || ------------------ | Branch (3368:8): [True: 0, False: 0] ------------------ 3369| 0| (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3370| 0| tok->type == TK_INTERVAL))) { ------------------ | Branch (3370:8): [True: 0, False: 0] ------------------ 3371| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3372| 0| tok->u.repeat.greedy = 1; 3373| 0| tok->u.repeat.possessive = 1; 3374| 0| } 3375| 8.16k| else { 3376| 8.16k| tok->u.repeat.greedy = 1; 3377| 8.16k| tok->u.repeat.possessive = 0; 3378| 8.16k| } 3379| 8.16k| } 3380| 8.16k| break; 3381| | 3382| 8.16k| case '{': ------------------ | Branch (3382:5): [True: 0, False: 0] ------------------ 3383| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3383:11): [True: 0, False: 0] ------------------ 3384| 0| r = fetch_range_quantifier(&p, end, tok, env); 3385| 0| if (r < 0) return r; /* error */ ------------------ | Branch (3385:11): [True: 0, False: 0] ------------------ 3386| 0| if (r == 0) goto greedy_check; ------------------ | Branch (3386:11): [True: 0, False: 0] ------------------ 3387| 0| else if (r == 2) { /* {n} */ ------------------ | Branch (3387:16): [True: 0, False: 0] ------------------ 3388| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 3389| 0| goto possessive_check; 3390| | 3391| 0| goto greedy_check; 3392| 0| } 3393| | /* r == 1 : normal char */ 3394| 0| break; 3395| | 3396| 0| case '|': ------------------ | Branch (3396:5): [True: 0, False: 0] ------------------ 3397| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_VBAR_ALT)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3397:11): [True: 0, False: 0] ------------------ 3398| 0| tok->type = TK_ALT; 3399| 0| break; 3400| | 3401| 0| case '(': ------------------ | Branch (3401:5): [True: 0, False: 0] ------------------ 3402| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3402:11): [True: 0, False: 0] ------------------ 3403| 0| tok->type = TK_SUBEXP_OPEN; 3404| 0| break; 3405| | 3406| 0| case ')': ------------------ | Branch (3406:5): [True: 0, False: 0] ------------------ 3407| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3407:11): [True: 0, False: 0] ------------------ 3408| 0| tok->type = TK_SUBEXP_CLOSE; 3409| 0| break; 3410| | 3411| 0| case 'w': ------------------ | Branch (3411:5): [True: 0, False: 0] ------------------ 3412| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3412:11): [True: 0, False: 0] ------------------ 3413| 0| tok->type = TK_CHAR_TYPE; 3414| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ 3415| 0| tok->u.prop.not = 0; 3416| 0| break; 3417| | 3418| 0| case 'W': ------------------ | Branch (3418:5): [True: 0, False: 0] ------------------ 3419| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3419:11): [True: 0, False: 0] ------------------ 3420| 0| tok->type = TK_CHAR_TYPE; 3421| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ 3422| 0| tok->u.prop.not = 1; 3423| 0| break; 3424| | 3425| 0| case 'b': ------------------ | Branch (3425:5): [True: 0, False: 0] ------------------ 3426| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3426:11): [True: 0, False: 0] ------------------ 3427| 0| tok->type = TK_ANCHOR; 3428| 0| tok->u.anchor.subtype = ANCHOR_WORD_BOUND; ------------------ | | 547| 0|#define ANCHOR_WORD_BOUND (1<<6) ------------------ 3429| 0| tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option) ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 3430| 0| && ! IS_WORD_BOUND_ALL_RANGE(env->option); ------------------ | | 408| 0|#define IS_WORD_BOUND_ALL_RANGE(option) ((option) & ONIG_OPTION_WORD_BOUND_ALL_RANGE) | | ------------------ | | | | 472| 0|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | ------------------ | | | | | | 471| 0|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | ------------------ | | | | | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | ------------------ | | | | | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (3430:6): [True: 0, False: 0] ------------------ 3431| 0| break; 3432| | 3433| 0| case 'B': ------------------ | Branch (3433:5): [True: 0, False: 0] ------------------ 3434| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3434:11): [True: 0, False: 0] ------------------ 3435| 0| tok->type = TK_ANCHOR; 3436| 0| tok->u.anchor.subtype = ANCHOR_NOT_WORD_BOUND; ------------------ | | 548| 0|#define ANCHOR_NOT_WORD_BOUND (1<<7) ------------------ 3437| 0| tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option) ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (406:35): [True: 0, False: 0] | | ------------------ ------------------ 3438| 0| && ! IS_WORD_BOUND_ALL_RANGE(env->option); ------------------ | | 408| 0|#define IS_WORD_BOUND_ALL_RANGE(option) ((option) & ONIG_OPTION_WORD_BOUND_ALL_RANGE) | | ------------------ | | | | 472| 0|#define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) | | | | ------------------ | | | | | | 471| 0|#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) | | | | | | ------------------ | | | | | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | | | | | ------------------ | | | | | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (3438:6): [True: 0, False: 0] ------------------ 3439| 0| break; 3440| | 3441| 0|#ifdef USE_WORD_BEGIN_END 3442| 0| case '<': ------------------ | Branch (3442:5): [True: 0, False: 0] ------------------ 3443| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3443:11): [True: 0, False: 0] ------------------ 3444| 0| tok->type = TK_ANCHOR; 3445| 0| tok->u.anchor.subtype = ANCHOR_WORD_BEGIN; ------------------ | | 549| 0|#define ANCHOR_WORD_BEGIN (1<<8) ------------------ 3446| 0| tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3447| 0| break; 3448| | 3449| 0| case '>': ------------------ | Branch (3449:5): [True: 0, False: 0] ------------------ 3450| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3450:11): [True: 0, False: 0] ------------------ 3451| 0| tok->type = TK_ANCHOR; 3452| 0| tok->u.anchor.subtype = ANCHOR_WORD_END; ------------------ | | 550| 0|#define ANCHOR_WORD_END (1<<9) ------------------ 3453| 0| tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3454| 0| break; 3455| 0|#endif 3456| | 3457| 0| case 's': ------------------ | Branch (3457:5): [True: 0, False: 0] ------------------ 3458| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3458:11): [True: 0, False: 0] ------------------ 3459| 0| tok->type = TK_CHAR_TYPE; 3460| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; ------------------ | | 303| 0|#define ONIGENC_CTYPE_SPACE 9 ------------------ 3461| 0| tok->u.prop.not = 0; 3462| 0| break; 3463| | 3464| 0| case 'S': ------------------ | Branch (3464:5): [True: 0, False: 0] ------------------ 3465| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3465:11): [True: 0, False: 0] ------------------ 3466| 0| tok->type = TK_CHAR_TYPE; 3467| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; ------------------ | | 303| 0|#define ONIGENC_CTYPE_SPACE 9 ------------------ 3468| 0| tok->u.prop.not = 1; 3469| 0| break; 3470| | 3471| 0| case 'd': ------------------ | Branch (3471:5): [True: 0, False: 0] ------------------ 3472| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3472:11): [True: 0, False: 0] ------------------ 3473| 0| tok->type = TK_CHAR_TYPE; 3474| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; ------------------ | | 298| 0|#define ONIGENC_CTYPE_DIGIT 4 ------------------ 3475| 0| tok->u.prop.not = 0; 3476| 0| break; 3477| | 3478| 0| case 'D': ------------------ | Branch (3478:5): [True: 0, False: 0] ------------------ 3479| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3479:11): [True: 0, False: 0] ------------------ 3480| 0| tok->type = TK_CHAR_TYPE; 3481| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; ------------------ | | 298| 0|#define ONIGENC_CTYPE_DIGIT 4 ------------------ 3482| 0| tok->u.prop.not = 1; 3483| 0| break; 3484| | 3485| 0| case 'h': ------------------ | Branch (3485:5): [True: 0, False: 0] ------------------ 3486| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3486:11): [True: 0, False: 0] ------------------ 3487| 0| tok->type = TK_CHAR_TYPE; 3488| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; ------------------ | | 305| 0|#define ONIGENC_CTYPE_XDIGIT 11 ------------------ 3489| 0| tok->u.prop.not = 0; 3490| 0| break; 3491| | 3492| 0| case 'H': ------------------ | Branch (3492:5): [True: 0, False: 0] ------------------ 3493| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3493:11): [True: 0, False: 0] ------------------ 3494| 0| tok->type = TK_CHAR_TYPE; 3495| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; ------------------ | | 305| 0|#define ONIGENC_CTYPE_XDIGIT 11 ------------------ 3496| 0| tok->u.prop.not = 1; 3497| 0| break; 3498| | 3499| 0| case 'A': ------------------ | Branch (3499:5): [True: 0, False: 0] ------------------ 3500| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3500:11): [True: 0, False: 0] ------------------ 3501| 0| begin_buf: 3502| 0| tok->type = TK_ANCHOR; 3503| 0| tok->u.anchor.subtype = ANCHOR_BEGIN_BUF; ------------------ | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ 3504| 0| break; 3505| | 3506| 0| case 'Z': ------------------ | Branch (3506:5): [True: 0, False: 0] ------------------ 3507| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3507:11): [True: 0, False: 0] ------------------ 3508| 0| tok->type = TK_ANCHOR; 3509| 0| tok->u.anchor.subtype = ANCHOR_SEMI_END_BUF; ------------------ | | 544| 0|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ 3510| 0| break; 3511| | 3512| 0| case 'z': ------------------ | Branch (3512:5): [True: 0, False: 0] ------------------ 3513| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3513:11): [True: 0, False: 0] ------------------ 3514| 0| end_buf: 3515| 0| tok->type = TK_ANCHOR; 3516| 0| tok->u.anchor.subtype = ANCHOR_END_BUF; ------------------ | | 543| 0|#define ANCHOR_END_BUF (1<<3) ------------------ 3517| 0| break; 3518| | 3519| 0| case 'G': ------------------ | Branch (3519:5): [True: 0, False: 0] ------------------ 3520| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3520:11): [True: 0, False: 0] ------------------ 3521| 0| tok->type = TK_ANCHOR; 3522| 0| tok->u.anchor.subtype = ANCHOR_BEGIN_POSITION; ------------------ | | 542| 0|#define ANCHOR_BEGIN_POSITION (1<<2) ------------------ 3523| 0| break; 3524| | 3525| 0| case '`': ------------------ | Branch (3525:5): [True: 0, False: 0] ------------------ 3526| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3526:11): [True: 0, False: 0] ------------------ 3527| 0| goto begin_buf; 3528| 0| break; 3529| | 3530| 0| case '\'': ------------------ | Branch (3530:5): [True: 0, False: 0] ------------------ 3531| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3531:11): [True: 0, False: 0] ------------------ 3532| 0| goto end_buf; 3533| 0| break; 3534| | 3535| 0| case 'x': ------------------ | Branch (3535:5): [True: 0, False: 0] ------------------ 3536| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3537| | 3538| 0| prev = p; 3539| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3540| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3541| 0| num = scan_unsigned_hexadecimal_number(&p, end, 0, 8, enc); 3542| 0| if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE; ------------------ | | 694| 0|#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 ------------------ | Branch (3542:6): [True: 0, False: 0] ------------------ 3543| 0| if (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3543:6): [True: 0, False: 0] ------------------ 3544| 0| if (ONIGENC_IS_CODE_XDIGIT(enc, PPEEK)) ------------------ | | 402| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_XDIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | | Branch (375:69): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3545| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 681| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 3546| 0| } 3547| | 3548| 0| if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3548:6): [True: 0, False: 0] | Branch (3548:45): [True: 0, False: 0] ------------------ 3549| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3550| 0| tok->type = TK_CODE_POINT; 3551| 0| tok->u.code = (OnigCodePoint )num; 3552| 0| } 3553| 0| else { 3554| | /* can't read nothing or invalid format */ 3555| 0| p = prev; 3556| 0| } 3557| 0| } 3558| 0| else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3559| 0| num = scan_unsigned_hexadecimal_number(&p, end, 0, 2, enc); 3560| 0| if (num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3560:6): [True: 0, False: 0] ------------------ 3561| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3561:6): [True: 0, False: 0] ------------------ 3562| 0| num = 0; /* but, it's not error */ 3563| 0| } 3564| 0| tok->type = TK_RAW_BYTE; 3565| 0| tok->base = 16; 3566| 0| tok->u.c = num; 3567| 0| } 3568| 0| break; 3569| | 3570| 0| case 'u': ------------------ | Branch (3570:5): [True: 0, False: 0] ------------------ 3571| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3572| | 3573| 0| prev = p; 3574| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3575| 0| num = scan_unsigned_hexadecimal_number(&p, end, 4, 4, enc); 3576| 0| if (num < -1) return ONIGERR_TOO_SHORT_DIGITS; ------------------ | | 680| 0|#define ONIGERR_TOO_SHORT_DIGITS -211 ------------------ | Branch (3576:6): [True: 0, False: 0] ------------------ 3577| 0| else if (num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3577:11): [True: 0, False: 0] ------------------ 3578| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3578:6): [True: 0, False: 0] ------------------ 3579| 0| num = 0; /* but, it's not error */ 3580| 0| } 3581| 0| tok->type = TK_CODE_POINT; 3582| 0| tok->base = 16; 3583| 0| tok->u.code = (OnigCodePoint )num; 3584| 0| } 3585| 0| break; 3586| | 3587| 0| case 'o': ------------------ | Branch (3587:5): [True: 0, False: 0] ------------------ 3588| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3589| | 3590| 0| prev = p; 3591| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3592| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3593| 0| num = scan_unsigned_octal_number(&p, end, 11, enc); 3594| 0| if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE; ------------------ | | 694| 0|#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 ------------------ | Branch (3594:6): [True: 0, False: 0] ------------------ 3595| 0| if (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3595:6): [True: 0, False: 0] ------------------ 3596| 0| OnigCodePoint c = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3597| 0| if (ONIGENC_IS_CODE_DIGIT(enc, c) && c < '8') ------------------ | | 400| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3597:41): [True: 0, False: 0] ------------------ 3598| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 681| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 3599| 0| } 3600| | 3601| 0| if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3601:6): [True: 0, False: 0] | Branch (3601:45): [True: 0, False: 0] ------------------ 3602| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3603| 0| tok->type = TK_CODE_POINT; 3604| 0| tok->u.code = (OnigCodePoint )num; 3605| 0| } 3606| 0| else { 3607| | /* can't read nothing or invalid format */ 3608| 0| p = prev; 3609| 0| } 3610| 0| } 3611| 0| break; 3612| | 3613| 0| case '1': case '2': case '3': case '4': ------------------ | Branch (3613:5): [True: 0, False: 0] | Branch (3613:15): [True: 0, False: 0] | Branch (3613:25): [True: 0, False: 0] | Branch (3613:35): [True: 0, False: 0] ------------------ 3614| 0| case '5': case '6': case '7': case '8': case '9': ------------------ | Branch (3614:5): [True: 0, False: 0] | Branch (3614:15): [True: 0, False: 0] | Branch (3614:25): [True: 0, False: 0] | Branch (3614:35): [True: 0, False: 0] | Branch (3614:45): [True: 0, False: 0] ------------------ 3615| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3616| 0| prev = p; 3617| 0| num = onig_scan_unsigned_number(&p, end, enc); 3618| 0| if (num < 0 || num > ONIG_MAX_BACKREF_NUM) { ------------------ | | 442| 0|#define ONIG_MAX_BACKREF_NUM 1000 ------------------ | Branch (3618:11): [True: 0, False: 0] | Branch (3618:22): [True: 0, False: 0] ------------------ 3619| 0| goto skip_backref; 3620| 0| } 3621| | 3622| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_DECIMAL_BACKREF) && ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3623| 0| (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */ ------------------ | Branch (3623:5): [True: 0, False: 0] | Branch (3623:28): [True: 0, False: 0] ------------------ 3624| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 3625| 0| if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num])) ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | | Branch (311:49): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3625:8): [True: 0, False: 0] ------------------ 3626| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 3627| 0| } 3628| | 3629| 0| tok->type = TK_BACKREF; 3630| 0| tok->u.backref.num = 1; 3631| 0| tok->u.backref.ref1 = num; 3632| 0| tok->u.backref.by_name = 0; 3633| 0|#ifdef USE_BACKREF_WITH_LEVEL 3634| 0| tok->u.backref.exist_level = 0; 3635| 0|#endif 3636| 0| break; 3637| 0| } 3638| | 3639| 0| skip_backref: 3640| 0| if (c == '8' || c == '9') { ------------------ | Branch (3640:11): [True: 0, False: 0] | Branch (3640:23): [True: 0, False: 0] ------------------ 3641| | /* normal char */ 3642| 0| p = prev; PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3643| 0| break; 3644| 0| } 3645| | 3646| 0| p = prev; 3647| | /* fall through */ 3648| 0| case '0': ------------------ | Branch (3648:5): [True: 0, False: 0] ------------------ 3649| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3650| 0| prev = p; 3651| 0| num = scan_unsigned_octal_number(&p, end, (c == '0' ? 2:3), enc); ------------------ | Branch (3651:45): [True: 0, False: 0] ------------------ 3652| 0| if (num < 0 || 0xff < num) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3652:6): [True: 0, False: 0] | Branch (3652:17): [True: 0, False: 0] ------------------ 3653| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3653:6): [True: 0, False: 0] ------------------ 3654| 0| num = 0; /* but, it's not error */ 3655| 0| } 3656| 0| tok->type = TK_RAW_BYTE; 3657| 0| tok->base = 8; 3658| 0| tok->u.c = num; 3659| 0| } 3660| 0| else if (c != '0') { ------------------ | Branch (3660:16): [True: 0, False: 0] ------------------ 3661| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3662| 0| } 3663| 0| break; 3664| | 3665| 0|#ifdef USE_NAMED_GROUP 3666| 0| case 'k': ------------------ | Branch (3666:5): [True: 0, False: 0] ------------------ 3667| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3667:11): [True: 0, False: 0] ------------------ 3668| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3669| 0| if (c == '<' || c == '\'') { ------------------ | Branch (3669:6): [True: 0, False: 0] | Branch (3669:18): [True: 0, False: 0] ------------------ 3670| 0| r = fetch_named_backref_token(c, tok, &p, end, env); 3671| 0| if (r < 0) return r; ------------------ | Branch (3671:8): [True: 0, False: 0] ------------------ 3672| 0| } 3673| 0| else { 3674| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3675| 0| onig_syntax_warn(env, "invalid back reference"); 3676| 0| } 3677| 0| } 3678| 0| break; 3679| 0|#endif 3680| | 3681| 0|#if defined(USE_SUBEXP_CALL) || defined(USE_NAMED_GROUP) 3682| 0| case 'g': ------------------ | Branch (3682:5): [True: 0, False: 0] ------------------ 3683| 0|# ifdef USE_NAMED_GROUP 3684| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_BRACE_BACKREF)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_BRACE_BACKREF)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3684:11): [True: 0, False: 0] ------------------ 3685| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3686| 0| if (c == '{') { ------------------ | Branch (3686:6): [True: 0, False: 0] ------------------ 3687| 0| r = fetch_named_backref_token(c, tok, &p, end, env); 3688| 0| if (r < 0) return r; ------------------ | Branch (3688:8): [True: 0, False: 0] ------------------ 3689| 0| } 3690| 0| else 3691| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3692| 0| } 3693| 0|# endif 3694| 0|# ifdef USE_SUBEXP_CALL 3695| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3695:11): [True: 0, False: 0] ------------------ 3696| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3697| 0| if (c == '<' || c == '\'') { ------------------ | Branch (3697:6): [True: 0, False: 0] | Branch (3697:18): [True: 0, False: 0] ------------------ 3698| 0| int gnum = -1, rel = 0; 3699| 0| UChar* name_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3700| 0| OnigCodePoint cnext; 3701| | 3702| 0| cnext = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3703| 0| if (cnext == '0') { ------------------ | Branch (3703:8): [True: 0, False: 0] ------------------ 3704| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3705| 0| if (PPEEK_IS(get_name_end_code_point(c))) { /* \g<0>, \g'0' */ ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ 3706| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3707| 0| name_end = p; 3708| 0| gnum = 0; 3709| 0| } 3710| 0| } 3711| 0| else if (cnext == '+') { ------------------ | Branch (3711:13): [True: 0, False: 0] ------------------ 3712| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3713| 0| rel = 1; 3714| 0| } 3715| 0| prev = p; 3716| 0| if (gnum < 0) { ------------------ | Branch (3716:8): [True: 0, False: 0] ------------------ 3717| 0| r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &gnum, 1); 3718| 0| if (r < 0) return r; ------------------ | Branch (3718:10): [True: 0, False: 0] ------------------ 3719| 0| } 3720| | 3721| 0| tok->type = TK_CALL; 3722| 0| tok->u.call.name = prev; 3723| 0| tok->u.call.name_end = name_end; 3724| 0| tok->u.call.gnum = gnum; 3725| 0| tok->u.call.rel = rel; 3726| 0| } 3727| 0| else { 3728| 0| onig_syntax_warn(env, "invalid subexp call"); 3729| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3730| 0| } 3731| 0| } 3732| 0|# endif 3733| 0| break; 3734| 0|#endif 3735| | 3736| 0| case 'Q': ------------------ | Branch (3736:5): [True: 0, False: 0] ------------------ 3737| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3738| 0| tok->type = TK_QUOTE_OPEN; 3739| 0| } 3740| 0| break; 3741| | 3742| 0| case 'p': ------------------ | Branch (3742:5): [True: 0, False: 0] ------------------ 3743| 0| case 'P': ------------------ | Branch (3743:5): [True: 0, False: 0] ------------------ 3744| 0| if (PPEEK_IS('{') && ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ 3745| 0| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3746| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3747| 0| tok->type = TK_CHAR_PROPERTY; 3748| 0| tok->u.prop.not = (c == 'P' ? 1 : 0); ------------------ | Branch (3748:21): [True: 0, False: 0] ------------------ 3749| | 3750| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3750:6): [True: 0, False: 0] ------------------ 3751| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3752| 0| if (c == '^') { ------------------ | Branch (3752:8): [True: 0, False: 0] ------------------ 3753| 0| tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0); ------------------ | Branch (3753:25): [True: 0, False: 0] ------------------ 3754| 0| } 3755| 0| else 3756| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3757| 0| } 3758| 0| } 3759| 0| else { 3760| 0| onig_syntax_warn(env, "invalid Unicode Property \\%c", c); 3761| 0| } 3762| 0| break; 3763| | 3764| 0| case 'R': ------------------ | Branch (3764:5): [True: 0, False: 0] ------------------ 3765| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_R_LINEBREAK)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3766| 0| tok->type = TK_LINEBREAK; 3767| 0| } 3768| 0| break; 3769| | 3770| 0| case 'X': ------------------ | Branch (3770:5): [True: 0, False: 0] ------------------ 3771| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_X_EXTENDED_GRAPHEME_CLUSTER)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3772| 0| tok->type = TK_EXTENDED_GRAPHEME_CLUSTER; 3773| 0| } 3774| 0| break; 3775| | 3776| 0| case 'K': ------------------ | Branch (3776:5): [True: 0, False: 0] ------------------ 3777| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3778| 0| tok->type = TK_KEEP; 3779| 0| } 3780| 0| break; 3781| | 3782| 0| default: ------------------ | Branch (3782:5): [True: 0, False: 0] ------------------ 3783| 0| { 3784| 0| OnigCodePoint c2; 3785| | 3786| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3787| 0| num = fetch_escaped_value(&p, end, env, &c2); 3788| 0| if (num < 0) return num; ------------------ | Branch (3788:6): [True: 0, False: 0] ------------------ 3789| | /* set_raw: */ 3790| 0| if ((OnigCodePoint )tok->u.c != c2) { ------------------ | Branch (3790:6): [True: 0, False: 0] ------------------ 3791| 0| tok->type = TK_CODE_POINT; 3792| 0| tok->u.code = (OnigCodePoint )c2; 3793| 0| } 3794| 0| else { /* string */ 3795| 0| p = tok->backp + enclen(enc, tok->backp, end); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 3796| 0| } 3797| 0| } 3798| 0| break; 3799| 0| } 3800| 0| } 3801| 42.8k| else { 3802| 42.8k| tok->u.c = c; 3803| 42.8k| tok->escaped = 0; 3804| | 3805| 42.8k|#ifdef USE_VARIABLE_META_CHARS 3806| 42.8k| if ((c != ONIG_INEFFECTIVE_META_CHAR) && ------------------ | | 622| 42.8k|#define ONIG_INEFFECTIVE_META_CHAR 0 ------------------ | Branch (3806:9): [True: 42.8k, False: 0] ------------------ 3807| 42.8k| IS_SYNTAX_OP(syn, ONIG_SYN_OP_VARIABLE_META_CHARACTERS)) { ------------------ | | 330| 42.8k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 42.8k] | | ------------------ ------------------ 3808| 0| if (c == MC_ANYCHAR(syn)) ------------------ | | 762| 0|#define MC_ANYCHAR(syn) (syn)->meta_char_table.anychar ------------------ | Branch (3808:11): [True: 0, False: 0] ------------------ 3809| 0| goto any_char; 3810| 0| else if (c == MC_ANYTIME(syn)) ------------------ | | 763| 0|#define MC_ANYTIME(syn) (syn)->meta_char_table.anytime ------------------ | Branch (3810:16): [True: 0, False: 0] ------------------ 3811| 0| goto anytime; 3812| 0| else if (c == MC_ZERO_OR_ONE_TIME(syn)) ------------------ | | 764| 0|#define MC_ZERO_OR_ONE_TIME(syn) (syn)->meta_char_table.zero_or_one_time ------------------ | Branch (3812:16): [True: 0, False: 0] ------------------ 3813| 0| goto zero_or_one_time; 3814| 0| else if (c == MC_ONE_OR_MORE_TIME(syn)) ------------------ | | 765| 0|#define MC_ONE_OR_MORE_TIME(syn) (syn)->meta_char_table.one_or_more_time ------------------ | Branch (3814:16): [True: 0, False: 0] ------------------ 3815| 0| goto one_or_more_time; 3816| 0| else if (c == MC_ANYCHAR_ANYTIME(syn)) { ------------------ | | 766| 0|#define MC_ANYCHAR_ANYTIME(syn) (syn)->meta_char_table.anychar_anytime ------------------ | Branch (3816:16): [True: 0, False: 0] ------------------ 3817| 0| tok->type = TK_ANYCHAR_ANYTIME; 3818| 0| goto out; 3819| 0| } 3820| 0| } 3821| 42.8k|#endif 3822| | 3823| 42.8k| switch (c) { 3824| 2.04k| case '.': ------------------ | Branch (3824:5): [True: 2.04k, False: 40.8k] ------------------ 3825| 2.04k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_DOT_ANYCHAR)) break; ------------------ | | 330| 2.04k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3825:11): [True: 0, False: 2.04k] ------------------ 3826| 2.04k|#ifdef USE_VARIABLE_META_CHARS 3827| 2.04k| any_char: 3828| 2.04k|#endif 3829| 2.04k| tok->type = TK_ANYCHAR; 3830| 2.04k| break; 3831| | 3832| 0| case '*': ------------------ | Branch (3832:5): [True: 0, False: 42.8k] ------------------ 3833| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ASTERISK_ZERO_INF)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3833:11): [True: 0, False: 0] ------------------ 3834| 0|#ifdef USE_VARIABLE_META_CHARS 3835| 0| anytime: 3836| 0|#endif 3837| 0| tok->type = TK_OP_REPEAT; 3838| 0| tok->u.repeat.lower = 0; 3839| 0| tok->u.repeat.upper = REPEAT_INFINITE; ------------------ | | 421| 0|#define REPEAT_INFINITE -1 ------------------ 3840| 0| goto greedy_check; 3841| 0| break; 3842| | 3843| 8.16k| case '+': ------------------ | Branch (3843:5): [True: 8.16k, False: 34.6k] ------------------ 3844| 8.16k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_PLUS_ONE_INF)) break; ------------------ | | 330| 8.16k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3844:11): [True: 0, False: 8.16k] ------------------ 3845| 8.16k|#ifdef USE_VARIABLE_META_CHARS 3846| 8.16k| one_or_more_time: 3847| 8.16k|#endif 3848| 8.16k| tok->type = TK_OP_REPEAT; 3849| 8.16k| tok->u.repeat.lower = 1; 3850| 8.16k| tok->u.repeat.upper = REPEAT_INFINITE; ------------------ | | 421| 8.16k|#define REPEAT_INFINITE -1 ------------------ 3851| 8.16k| goto greedy_check; 3852| 0| break; 3853| | 3854| 0| case '?': ------------------ | Branch (3854:5): [True: 0, False: 42.8k] ------------------ 3855| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_ZERO_ONE)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3855:11): [True: 0, False: 0] ------------------ 3856| 0|#ifdef USE_VARIABLE_META_CHARS 3857| 0| zero_or_one_time: 3858| 0|#endif 3859| 0| tok->type = TK_OP_REPEAT; 3860| 0| tok->u.repeat.lower = 0; 3861| 0| tok->u.repeat.upper = 1; 3862| 0| goto greedy_check; 3863| 0| break; 3864| | 3865| 0| case '{': ------------------ | Branch (3865:5): [True: 0, False: 42.8k] ------------------ 3866| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACE_INTERVAL)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3866:11): [True: 0, False: 0] ------------------ 3867| 0| r = fetch_range_quantifier(&p, end, tok, env); 3868| 0| if (r < 0) return r; /* error */ ------------------ | Branch (3868:11): [True: 0, False: 0] ------------------ 3869| 0| if (r == 0) goto greedy_check; ------------------ | Branch (3869:11): [True: 0, False: 0] ------------------ 3870| 0| else if (r == 2) { /* {n} */ ------------------ | Branch (3870:16): [True: 0, False: 0] ------------------ 3871| 0| if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 3872| 0| goto possessive_check; 3873| | 3874| 0| goto greedy_check; 3875| 0| } 3876| | /* r == 1 : normal char */ 3877| 0| break; 3878| | 3879| 0| case '|': ------------------ | Branch (3879:5): [True: 0, False: 42.8k] ------------------ 3880| 0| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_VBAR_ALT)) break; ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (3880:11): [True: 0, False: 0] ------------------ 3881| 0| tok->type = TK_ALT; 3882| 0| break; 3883| | 3884| 8.16k| case '(': ------------------ | Branch (3884:5): [True: 8.16k, False: 34.6k] ------------------ 3885| 8.16k| if (PPEEK_IS('?') && ------------------ | | 320| 16.3k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 8.16k, False: 0] | | ------------------ ------------------ 3886| 8.16k| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) { ------------------ | | 331| 8.16k|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 8.16k, False: 0] | | ------------------ ------------------ 3887| 8.16k| PINC; ------------------ | | 301| 8.16k|#define PINC do { \ | | 302| 8.16k| pfetch_prev = p; \ | | 303| 8.16k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 8.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 8.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 304| 8.16k|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3888| 8.16k| if (PPEEK_IS('#')) { ------------------ | | 320| 8.16k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 8.16k] | | ------------------ ------------------ 3889| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3890| 0| while (1) { ------------------ | Branch (3890:11): [Folded - Ignored] ------------------ 3891| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 662| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 3892| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3893| 0| if (c == MC_ESC(syn)) { ------------------ | | 761| 0|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ | Branch (3893:10): [True: 0, False: 0] ------------------ 3894| 0| if (!PEND) PFETCH(c); ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND) PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ | Branch (3894:12): [True: 0, False: 0] ------------------ 3895| 0| } 3896| 0| else { 3897| 0| if (c == ')') break; ------------------ | Branch (3897:12): [True: 0, False: 0] ------------------ 3898| 0| } 3899| 0| } 3900| 0| goto start; 3901| 0| } 3902| 8.16k|#ifdef USE_PERL_SUBEXP_CALL 3903| | /* (?&name), (?n), (?R), (?0), (?+n), (?-n) */ 3904| 8.16k| c = PPEEK; ------------------ | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 8.16k, False: 0] | | ------------------ ------------------ 3905| 8.16k| if ((c == '&' || c == 'R' || ONIGENC_IS_CODE_DIGIT(enc, c)) && ------------------ | | 400| 8.16k| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 8.16k|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ ------------------ | Branch (3905:7): [True: 0, False: 8.16k] | Branch (3905:19): [True: 0, False: 8.16k] ------------------ 3906| 8.16k| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_SUBEXP_CALL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3907| | /* (?&name), (?n), (?R), (?0) */ 3908| 0| int gnum; 3909| 0| UChar *name; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3910| 0| UChar *name_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3911| | 3912| 0| if (c == 'R' || c == '0') { ------------------ | Branch (3912:8): [True: 0, False: 0] | Branch (3912:20): [True: 0, False: 0] ------------------ 3913| 0| PINC; /* skip 'R' / '0' */ ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3914| 0| if (!PPEEK_IS(')')) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3914:10): [True: 0, False: 0] ------------------ 3915| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 3916| 0| onig_scan_env_set_error_string(env, r, p - 1, p + 1); 3917| 0| return r; 3918| 0| } 3919| 0| PINC; /* skip ')' */ ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3920| 0| name_end = name = p; 3921| 0| gnum = 0; 3922| 0| } 3923| 0| else { 3924| 0| int numref = 1; 3925| 0| if (c == '&') { /* (?&name) */ ------------------ | Branch (3925:10): [True: 0, False: 0] ------------------ 3926| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3927| 0| numref = 0; /* don't allow number name */ 3928| 0| } 3929| 0| name = p; 3930| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, numref); 3931| 0| if (r < 0) return r; ------------------ | Branch (3931:10): [True: 0, False: 0] ------------------ 3932| 0| } 3933| | 3934| 0| tok->type = TK_CALL; 3935| 0| tok->u.call.name = name; 3936| 0| tok->u.call.name_end = name_end; 3937| 0| tok->u.call.gnum = gnum; 3938| 0| tok->u.call.rel = 0; 3939| 0| break; 3940| 0| } 3941| 8.16k| else if ((c == '-' || c == '+') && ------------------ | Branch (3941:12): [True: 0, False: 8.16k] | Branch (3941:24): [True: 0, False: 8.16k] ------------------ 3942| 8.16k| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_SUBEXP_CALL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3943| | /* (?+n), (?-n) */ 3944| 0| int gnum; 3945| 0| UChar *name; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3946| 0| UChar *name_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3947| 0| OnigCodePoint cnext; 3948| 0| PFETCH_READY; ------------------ | | 295| 0|# define PFETCH_READY UChar* pfetch_prev = NULL; (void)pfetch_prev | | ------------------ | | | | 76| 0|# define UChar OnigUChar | | ------------------ ------------------ 3949| | 3950| 0| PINC; /* skip '-' / '+' */ ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3951| 0| cnext = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3952| 0| if (ONIGENC_IS_CODE_DIGIT(enc, cnext)) { ------------------ | | 400| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3953| 0| if (c == '-') PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ | Branch (3953:10): [True: 0, False: 0] ------------------ 3954| 0| name = p; 3955| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, 1); 3956| 0| if (r < 0) return r; ------------------ | Branch (3956:10): [True: 0, False: 0] ------------------ 3957| | 3958| 0| tok->type = TK_CALL; 3959| 0| tok->u.call.name = name; 3960| 0| tok->u.call.name_end = name_end; 3961| 0| tok->u.call.gnum = gnum; 3962| 0| tok->u.call.rel = 1; 3963| 0| break; 3964| 0| } 3965| 0| } 3966| 8.16k|#endif /* USE_PERL_SUBEXP_CALL */ 3967| 8.16k|#ifdef USE_CAPITAL_P_NAMED_GROUP 3968| 8.16k| if (PPEEK_IS('P') && ------------------ | | 320| 16.3k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 8.16k] | | ------------------ ------------------ 3969| 8.16k| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3970| 0| int gnum; 3971| 0| UChar *name; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3972| 0| UChar *name_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 3973| 0| PFETCH_READY; ------------------ | | 295| 0|# define PFETCH_READY UChar* pfetch_prev = NULL; (void)pfetch_prev | | ------------------ | | | | 76| 0|# define UChar OnigUChar | | ------------------ ------------------ 3974| | 3975| 0| PINC; /* skip 'P' */ ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3976| 0| if (PEND) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 3977| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3978| 0| if (c == '=') { /* (?P=name): backref */ ------------------ | Branch (3978:8): [True: 0, False: 0] ------------------ 3979| 0| r = fetch_named_backref_token((OnigCodePoint )'(', tok, &p, end, env); 3980| 0| if (r < 0) return r; ------------------ | Branch (3980:10): [True: 0, False: 0] ------------------ 3981| 0| break; 3982| 0| } 3983| 0| else if (c == '>') { /* (?P>name): subexp call */ ------------------ | Branch (3983:13): [True: 0, False: 0] ------------------ 3984| 0| name = p; 3985| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, 0); 3986| 0| if (r < 0) return r; ------------------ | Branch (3986:10): [True: 0, False: 0] ------------------ 3987| | 3988| 0| tok->type = TK_CALL; 3989| 0| tok->u.call.name = name; 3990| 0| tok->u.call.name_end = name_end; 3991| 0| tok->u.call.gnum = gnum; 3992| 0| tok->u.call.rel = 0; 3993| 0| break; 3994| 0| } 3995| 0| } 3996| 8.16k|#endif /* USE_CAPITAL_P_NAMED_GROUP */ 3997| 8.16k| PUNFETCH; ------------------ | | 300| 8.16k|#define PUNFETCH p = pfetch_prev ------------------ 3998| 8.16k| } 3999| | 4000| 8.16k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break; ------------------ | | 330| 8.16k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (4000:11): [True: 0, False: 8.16k] ------------------ 4001| 8.16k| tok->type = TK_SUBEXP_OPEN; 4002| 8.16k| break; 4003| | 4004| 8.16k| case ')': ------------------ | Branch (4004:5): [True: 8.16k, False: 34.6k] ------------------ 4005| 8.16k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break; ------------------ | | 330| 8.16k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (4005:11): [True: 0, False: 8.16k] ------------------ 4006| 8.16k| tok->type = TK_SUBEXP_CLOSE; 4007| 8.16k| break; 4008| | 4009| 2.04k| case '^': ------------------ | Branch (4009:5): [True: 2.04k, False: 40.8k] ------------------ 4010| 2.04k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break; ------------------ | | 330| 2.04k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (4010:11): [True: 0, False: 2.04k] ------------------ 4011| 2.04k| tok->type = TK_ANCHOR; 4012| 2.04k| tok->u.anchor.subtype = (IS_SINGLELINE(env->option) ------------------ | | 394| 2.04k|#define IS_SINGLELINE(option) ((option) & ONIG_OPTION_SINGLELINE) | | ------------------ | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | ------------------ | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | ------------------ | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | ------------------ | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (394:35): [True: 0, False: 2.04k] | | ------------------ ------------------ 4013| 2.04k| ? ANCHOR_BEGIN_BUF : ANCHOR_BEGIN_LINE); ------------------ | | 540| 0|#define ANCHOR_BEGIN_BUF (1<<0) ------------------ ? ANCHOR_BEGIN_BUF : ANCHOR_BEGIN_LINE); ------------------ | | 541| 2.04k|#define ANCHOR_BEGIN_LINE (1<<1) ------------------ 4014| 2.04k| break; 4015| | 4016| 2.04k| case '$': ------------------ | Branch (4016:5): [True: 2.04k, False: 40.8k] ------------------ 4017| 2.04k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break; ------------------ | | 330| 2.04k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (4017:11): [True: 0, False: 2.04k] ------------------ 4018| 2.04k| tok->type = TK_ANCHOR; 4019| 2.04k| tok->u.anchor.subtype = (IS_SINGLELINE(env->option) ------------------ | | 394| 2.04k|#define IS_SINGLELINE(option) ((option) & ONIG_OPTION_SINGLELINE) | | ------------------ | | | | 458| 2.04k|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | ------------------ | | | | | | 456| 2.04k|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | ------------------ | | | | | | | | 455| 2.04k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | ------------------ | | | | | | | | | | 454| 2.04k|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (394:35): [True: 0, False: 2.04k] | | ------------------ ------------------ 4020| 2.04k| ? ANCHOR_SEMI_END_BUF : ANCHOR_END_LINE); ------------------ | | 544| 0|#define ANCHOR_SEMI_END_BUF (1<<4) ------------------ ? ANCHOR_SEMI_END_BUF : ANCHOR_END_LINE); ------------------ | | 545| 2.04k|#define ANCHOR_END_LINE (1<<5) ------------------ 4021| 2.04k| break; 4022| | 4023| 6.12k| case '[': ------------------ | Branch (4023:5): [True: 6.12k, False: 36.7k] ------------------ 4024| 6.12k| if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACKET_CC)) break; ------------------ | | 330| 6.12k|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) ------------------ | Branch (4024:11): [True: 0, False: 6.12k] ------------------ 4025| 6.12k| tok->type = TK_CC_OPEN; 4026| 6.12k| break; 4027| | 4028| 0| case ']': ------------------ | Branch (4028:5): [True: 0, False: 42.8k] ------------------ 4029| 0| if (*src > env->pattern) /* /].../ is allowed. */ ------------------ | Branch (4029:11): [True: 0, False: 0] ------------------ 4030| 0| CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]"); 4031| 0| break; 4032| | 4033| 0| case '#': ------------------ | Branch (4033:5): [True: 0, False: 42.8k] ------------------ 4034| 0| if (IS_EXTEND(env->option)) { ------------------ | | 397| 0|#define IS_EXTEND(option) ((option) & ONIG_OPTION_EXTEND) | | ------------------ | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ | | | Branch (397:35): [True: 0, False: 0] | | ------------------ ------------------ 4035| 0| while (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4035:9): [True: 0, False: 0] ------------------ 4036| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 4037| 0| if (ONIGENC_IS_CODE_NEWLINE(enc, c)) ------------------ | | 378| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_NEWLINE) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 4038| 0| break; 4039| 0| } 4040| 0| goto start; 4041| 0| break; 4042| 0| } 4043| 0| break; 4044| | 4045| 6.12k| case ' ': case '\t': case '\n': case '\r': case '\f': ------------------ | Branch (4045:5): [True: 6.12k, False: 36.7k] | Branch (4045:15): [True: 0, False: 42.8k] | Branch (4045:26): [True: 0, False: 42.8k] | Branch (4045:37): [True: 0, False: 42.8k] | Branch (4045:48): [True: 0, False: 42.8k] ------------------ 4046| 6.12k| if (IS_EXTEND(env->option)) ------------------ | | 397| 6.12k|#define IS_EXTEND(option) ((option) & ONIG_OPTION_EXTEND) | | ------------------ | | | | 455| 6.12k|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 454| 6.12k|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ | | | Branch (397:35): [True: 0, False: 6.12k] | | ------------------ ------------------ 4047| 0| goto start; 4048| 6.12k| break; 4049| | 4050| 6.12k| default: ------------------ | Branch (4050:5): [True: 0, False: 42.8k] ------------------ 4051| | /* string */ 4052| 0| break; 4053| 42.8k| } 4054| 42.8k| } 4055| | 4056| 42.8k|#ifdef USE_VARIABLE_META_CHARS 4057| 42.8k| out: 4058| 42.8k|#endif 4059| 42.8k| *src = p; 4060| 42.8k| return tok->type; 4061| 42.8k|} regparse.c:get_name_end_code_point: 2495| 8.16k|{ 2496| 8.16k| switch (start) { 2497| 8.16k| case '<': return (OnigCodePoint )'>'; break; ------------------ | Branch (2497:3): [True: 8.16k, False: 0] ------------------ 2498| 0| case '\'': return (OnigCodePoint )'\''; break; ------------------ | Branch (2498:3): [True: 0, False: 8.16k] ------------------ 2499| 0| case '(': return (OnigCodePoint )')'; break; ------------------ | Branch (2499:3): [True: 0, False: 8.16k] ------------------ 2500| 0| case '{': return (OnigCodePoint )'}'; break; ------------------ | Branch (2500:3): [True: 0, False: 8.16k] ------------------ 2501| 0| default: ------------------ | Branch (2501:3): [True: 0, False: 8.16k] ------------------ 2502| 0| break; 2503| 8.16k| } 2504| | 2505| 0| return (OnigCodePoint )0; 2506| 8.16k|} regparse.c:fetch_name: 2644| 8.16k|{ 2645| 8.16k| int r, is_num, sign; 2646| 8.16k| OnigCodePoint end_code; 2647| 8.16k| OnigCodePoint c = 0; 2648| 8.16k| OnigEncoding enc = env->enc; 2649| 8.16k| UChar *name_end; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 2650| 8.16k| UChar *pnum_head; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 2651| 8.16k| UChar *p = *src; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 2652| | 2653| 8.16k| *rback_num = 0; 2654| | 2655| 8.16k| end_code = get_name_end_code_point(start_code); 2656| | 2657| 8.16k| name_end = end; 2658| 8.16k| pnum_head = *src; 2659| 8.16k| r = 0; 2660| 8.16k| is_num = 0; 2661| 8.16k| sign = 1; 2662| 8.16k| if (PEND) { ------------------ | | 299| 8.16k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 8.16k] | | | Branch (299:23): [True: 8.16k, False: 0] | | ------------------ ------------------ 2663| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 682| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 2664| 0| } 2665| 8.16k| else { 2666| 8.16k| PFETCH_S(c); ------------------ | | 314| 8.16k|#define PFETCH_S(c) do { \ | | 315| 8.16k| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (315:8): [True: 0, False: 8.16k] | | ------------------ | | 316| 8.16k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 8.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 8.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 317| 8.16k|} while (0) | | ------------------ | | | Branch (317:10): [Folded - Ignored] | | ------------------ ------------------ 2667| 8.16k| if (c == end_code) ------------------ | Branch (2667:9): [True: 0, False: 8.16k] ------------------ 2668| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 682| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 2669| | 2670| 8.16k| if (ONIGENC_IS_CODE_DIGIT(enc, c)) { ------------------ | | 400| 8.16k| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 8.16k|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ ------------------ 2671| 0| if (ref == 1) ------------------ | Branch (2671:11): [True: 0, False: 0] ------------------ 2672| 0| is_num = 1; 2673| 0| else { 2674| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2675| 0| is_num = 0; 2676| 0| } 2677| 0| } 2678| 8.16k| else if (c == '-') { ------------------ | Branch (2678:14): [True: 0, False: 8.16k] ------------------ 2679| 0| if (ref == 1) { ------------------ | Branch (2679:11): [True: 0, False: 0] ------------------ 2680| 0| is_num = 2; 2681| 0| sign = -1; 2682| 0| pnum_head = p; 2683| 0| } 2684| 0| else { 2685| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2686| 0| is_num = 0; 2687| 0| } 2688| 0| } 2689| 8.16k| else if (!ONIGENC_IS_CODE_NAME(enc, c)) { ------------------ | | 2512| 8.16k|# define ONIGENC_IS_CODE_NAME(enc, c) ONIGENC_IS_CODE_WORD(enc, c) | | ------------------ | | | | 404| 8.16k| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 8.16k|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2689:14): [True: 0, False: 8.16k] ------------------ 2690| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 684| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 2691| 0| } 2692| 8.16k| } 2693| | 2694| 8.16k| if (r == 0) { ------------------ | Branch (2694:7): [True: 8.16k, False: 0] ------------------ 2695| 36.7k| while (!PEND) { ------------------ | | 299| 36.7k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 36.7k, False: 0] | | ------------------ ------------------ | Branch (2695:12): [True: 36.7k, False: 0] ------------------ 2696| 36.7k| name_end = p; 2697| 36.7k| PFETCH_S(c); ------------------ | | 314| 36.7k|#define PFETCH_S(c) do { \ | | 315| 36.7k| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 36.7k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (315:8): [True: 0, False: 36.7k] | | ------------------ | | 316| 36.7k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 36.7k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 36.7k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 36.7k] | | | | ------------------ | | ------------------ | | 317| 36.7k|} while (0) | | ------------------ | | | Branch (317:10): [Folded - Ignored] | | ------------------ ------------------ 2698| 36.7k| if (c == end_code || c == ')') { ------------------ | Branch (2698:11): [True: 8.16k, False: 28.5k] | Branch (2698:28): [True: 0, False: 28.5k] ------------------ 2699| 8.16k| if (is_num == 2) { ------------------ | Branch (2699:6): [True: 0, False: 8.16k] ------------------ 2700| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2701| 0| goto teardown; 2702| 0| } 2703| 8.16k| break; 2704| 8.16k| } 2705| | 2706| 28.5k| if (is_num != 0) { ------------------ | Branch (2706:11): [True: 0, False: 28.5k] ------------------ 2707| 0| if (ONIGENC_IS_CODE_DIGIT(enc, c)) { ------------------ | | 400| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2708| 0| is_num = 1; 2709| 0| } 2710| 0| else { 2711| 0| if (!ONIGENC_IS_CODE_WORD(enc, c)) ------------------ | | 404| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | ------------------ ------------------ | Branch (2711:8): [True: 0, False: 0] ------------------ 2712| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 684| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 2713| 0| else 2714| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2715| 0| goto teardown; 2716| 0| } 2717| 0| } 2718| 28.5k| else { 2719| 28.5k| if (!ONIGENC_IS_CODE_NAME(enc, c)) { ------------------ | | 2512| 28.5k|# define ONIGENC_IS_CODE_NAME(enc, c) ONIGENC_IS_CODE_WORD(enc, c) | | ------------------ | | | | 404| 28.5k| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD) | | | | ------------------ | | | | | | 375| 28.5k|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | ------------------ ------------------ | Branch (2719:6): [True: 0, False: 28.5k] ------------------ 2720| 0| r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME; ------------------ | | 684| 0|#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME -216 ------------------ 2721| 0| goto teardown; 2722| 0| } 2723| 28.5k| } 2724| 28.5k| } 2725| | 2726| 8.16k| if (c != end_code) { ------------------ | Branch (2726:9): [True: 0, False: 8.16k] ------------------ 2727| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2728| 0| name_end = end; 2729| 0| goto err; 2730| 0| } 2731| | 2732| 8.16k| if (is_num != 0) { ------------------ | Branch (2732:9): [True: 0, False: 8.16k] ------------------ 2733| 0| *rback_num = onig_scan_unsigned_number(&pnum_head, name_end, enc); 2734| 0| if (*rback_num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (2734:11): [True: 0, False: 0] ------------------ 2735| 0| else if (*rback_num == 0) { ------------------ | Branch (2735:16): [True: 0, False: 0] ------------------ 2736| 0| r = ONIGERR_INVALID_GROUP_NAME; ------------------ | | 683| 0|#define ONIGERR_INVALID_GROUP_NAME -215 ------------------ 2737| 0| goto err; 2738| 0| } 2739| | 2740| 0| *rback_num *= sign; 2741| 0| } 2742| | 2743| 8.16k| *rname_end = name_end; 2744| 8.16k| *src = p; 2745| 8.16k| return 0; 2746| 8.16k| } 2747| 0| else { 2748| 0|teardown: 2749| 0| while (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2749:12): [True: 0, False: 0] ------------------ 2750| 0| name_end = p; 2751| 0| PFETCH_S(c); ------------------ | | 314| 0|#define PFETCH_S(c) do { \ | | 315| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (315:8): [True: 0, False: 0] | | ------------------ | | 316| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 317| 0|} while (0) | | ------------------ | | | Branch (317:10): [Folded - Ignored] | | ------------------ ------------------ 2752| 0| if (c == end_code || c == ')') ------------------ | Branch (2752:11): [True: 0, False: 0] | Branch (2752:28): [True: 0, False: 0] ------------------ 2753| 0| break; 2754| 0| } 2755| 0| if (PEND) ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 2756| 0| name_end = end; 2757| | 2758| 0| err: 2759| 0| onig_scan_env_set_error_string(env, r, *src, name_end); 2760| 0| return r; 2761| 0| } 2762| 8.16k|} regparse.c:parse_subexp: 6550| 10.2k|{ 6551| 10.2k| int r; 6552| 10.2k| Node *node, **headp; 6553| | 6554| 10.2k| *top = NULL; 6555| 10.2k| env->parse_depth++; 6556| 10.2k| if (env->parse_depth > ParseDepthLimit) ------------------ | Branch (6556:7): [True: 0, False: 10.2k] ------------------ 6557| 0| return ONIGERR_PARSE_DEPTH_LIMIT_OVER; ------------------ | | 639| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 ------------------ 6558| 10.2k| r = parse_branch(&node, tok, term, src, end, env); 6559| 10.2k| if (r < 0) { ------------------ | Branch (6559:7): [True: 0, False: 10.2k] ------------------ 6560| 0| onig_node_free(node); 6561| 0| return r; 6562| 0| } 6563| | 6564| 10.2k| if (r == term) { ------------------ | Branch (6564:7): [True: 10.2k, False: 0] ------------------ 6565| 10.2k| *top = node; 6566| 10.2k| } 6567| 0| else if (r == TK_ALT) { ------------------ | Branch (6567:12): [True: 0, False: 0] ------------------ 6568| 0| *top = onig_node_new_alt(node, NULL); 6569| 0| headp = &(NCDR(*top)); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6570| 0| while (r == TK_ALT) { ------------------ | Branch (6570:12): [True: 0, False: 0] ------------------ 6571| 0| r = fetch_token(tok, src, end, env); 6572| 0| if (r < 0) return r; ------------------ | Branch (6572:11): [True: 0, False: 0] ------------------ 6573| 0| r = parse_branch(&node, tok, term, src, end, env); 6574| 0| if (r < 0) { ------------------ | Branch (6574:11): [True: 0, False: 0] ------------------ 6575| 0| onig_node_free(node); 6576| 0| return r; 6577| 0| } 6578| | 6579| 0| *headp = onig_node_new_alt(node, NULL); 6580| 0| headp = &(NCDR(*headp)); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6581| 0| } 6582| | 6583| 0| if (tok->type != (enum TokenSyms )term) ------------------ | Branch (6583:9): [True: 0, False: 0] ------------------ 6584| 0| goto err; 6585| 0| } 6586| 0| else { 6587| 0| onig_node_free(node); 6588| 0| err: 6589| 0| if (term == TK_SUBEXP_CLOSE) ------------------ | Branch (6589:9): [True: 0, False: 0] ------------------ 6590| 0| return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 661| 0|#define ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS -117 ------------------ 6591| 0| else 6592| 0| return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 6593| 0| } 6594| | 6595| 10.2k| env->parse_depth--; 6596| 10.2k| return r; 6597| 10.2k|} regparse.c:parse_branch: 6507| 10.2k|{ 6508| 10.2k| int r; 6509| 10.2k| Node *node, **headp; 6510| | 6511| 10.2k| *top = NULL; 6512| 10.2k| r = parse_exp(&node, tok, term, src, end, env); 6513| 10.2k| if (r < 0) { ------------------ | Branch (6513:7): [True: 0, False: 10.2k] ------------------ 6514| 0| onig_node_free(node); 6515| 0| return r; 6516| 0| } 6517| | 6518| 10.2k| if (r == TK_EOT || r == term || r == TK_ALT) { ------------------ | Branch (6518:7): [True: 0, False: 10.2k] | Branch (6518:22): [True: 8.16k, False: 2.04k] | Branch (6518:35): [True: 0, False: 2.04k] ------------------ 6519| 8.16k| *top = node; 6520| 8.16k| } 6521| 2.04k| else { 6522| 2.04k| *top = node_new_list(node, NULL); 6523| 2.04k| headp = &(NCDR(*top)); ------------------ | | 87| 2.04k|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 2.04k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6524| 18.3k| while (r != TK_EOT && r != term && r != TK_ALT) { ------------------ | Branch (6524:12): [True: 16.3k, False: 2.04k] | Branch (6524:27): [True: 16.3k, False: 0] | Branch (6524:40): [True: 16.3k, False: 0] ------------------ 6525| 16.3k| r = parse_exp(&node, tok, term, src, end, env); 6526| 16.3k| if (r < 0) { ------------------ | Branch (6526:11): [True: 0, False: 16.3k] ------------------ 6527| 0| onig_node_free(node); 6528| 0| return r; 6529| 0| } 6530| | 6531| 16.3k| if (NTYPE(node) == NT_LIST) { ------------------ | | 69| 16.3k|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(node) == NT_LIST) { ------------------ | | 46| 16.3k|#define NT_LIST 8 ------------------ | Branch (6531:11): [True: 0, False: 16.3k] ------------------ 6532| 0| *headp = node; 6533| 0| while (IS_NOT_NULL(NCDR(node))) node = NCDR(node); ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ while (IS_NOT_NULL(NCDR(node))) node = NCDR(node); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6534| 0| headp = &(NCDR(node)); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6535| 0| } 6536| 16.3k| else { 6537| 16.3k| *headp = node_new_list(node, NULL); 6538| 16.3k| headp = &(NCDR(*headp)); ------------------ | | 87| 16.3k|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 16.3k|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6539| 16.3k| } 6540| 16.3k| } 6541| 2.04k| } 6542| | 6543| 10.2k| return r; 6544| 10.2k|} regparse.c:parse_exp: 6129| 26.5k|{ 6130| 26.5k| int r, len, group = 0; 6131| 26.5k| Node* qn; 6132| 26.5k| Node** targetp; 6133| 26.5k| unsigned int parse_depth; 6134| | 6135| 26.5k| *np = NULL; 6136| 26.5k| if (tok->type == (enum TokenSyms )term) ------------------ | Branch (6136:7): [True: 0, False: 26.5k] ------------------ 6137| 0| goto end_of_token; 6138| | 6139| 26.5k| parse_depth = env->parse_depth; 6140| | 6141| 26.5k| switch (tok->type) { 6142| 0| case TK_ALT: ------------------ | Branch (6142:3): [True: 0, False: 26.5k] ------------------ 6143| 0| case TK_EOT: ------------------ | Branch (6143:3): [True: 0, False: 26.5k] ------------------ 6144| 0| end_of_token: 6145| 0| *np = node_new_empty(); 6146| 0| return tok->type; 6147| 0| break; 6148| | 6149| 8.16k| case TK_SUBEXP_OPEN: ------------------ | Branch (6149:3): [True: 8.16k, False: 18.3k] ------------------ 6150| 8.16k| r = parse_enclose(np, tok, TK_SUBEXP_CLOSE, src, end, env); 6151| 8.16k| if (r < 0) return r; ------------------ | Branch (6151:9): [True: 0, False: 8.16k] ------------------ 6152| 8.16k| if (r == 1) group = 1; ------------------ | Branch (6152:9): [True: 0, False: 8.16k] ------------------ 6153| 8.16k| else if (r == 2) { /* option only */ ------------------ | Branch (6153:14): [True: 0, False: 8.16k] ------------------ 6154| 0| Node* target; 6155| 0| OnigOptionType prev = env->option; 6156| | 6157| 0| env->option = NENCLOSE(*np)->option; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 6158| 0| r = fetch_token(tok, src, end, env); 6159| 0| if (r < 0) { ------------------ | Branch (6159:11): [True: 0, False: 0] ------------------ 6160| 0| env->option = prev; 6161| 0| return r; 6162| 0| } 6163| 0| r = parse_subexp(&target, tok, term, src, end, env); 6164| 0| env->option = prev; 6165| 0| if (r < 0) { ------------------ | Branch (6165:11): [True: 0, False: 0] ------------------ 6166| 0| onig_node_free(target); 6167| 0| return r; 6168| 0| } 6169| 0| NENCLOSE(*np)->target = target; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 6170| 0| return tok->type; 6171| 0| } 6172| 8.16k| break; 6173| | 6174| 8.16k| case TK_SUBEXP_CLOSE: ------------------ | Branch (6174:3): [True: 0, False: 26.5k] ------------------ 6175| 0| if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (6175:9): [True: 0, False: 0] ------------------ 6176| 0| return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS; ------------------ | | 660| 0|#define ONIGERR_UNMATCHED_CLOSE_PARENTHESIS -116 ------------------ 6177| | 6178| 0| if (tok->escaped) goto tk_raw_byte; ------------------ | Branch (6178:9): [True: 0, False: 0] ------------------ 6179| 0| else goto tk_byte; 6180| 0| break; 6181| | 6182| 0| case TK_LINEBREAK: ------------------ | Branch (6182:3): [True: 0, False: 26.5k] ------------------ 6183| 0| r = node_linebreak(np, env); 6184| 0| if (r < 0) return r; ------------------ | Branch (6184:9): [True: 0, False: 0] ------------------ 6185| 0| break; 6186| | 6187| 0| case TK_EXTENDED_GRAPHEME_CLUSTER: ------------------ | Branch (6187:3): [True: 0, False: 26.5k] ------------------ 6188| 0| r = node_extended_grapheme_cluster(np, env); 6189| 0| if (r < 0) return r; ------------------ | Branch (6189:9): [True: 0, False: 0] ------------------ 6190| 0| break; 6191| | 6192| 0| case TK_KEEP: ------------------ | Branch (6192:3): [True: 0, False: 26.5k] ------------------ 6193| 0| *np = onig_node_new_anchor(ANCHOR_KEEP); ------------------ | | 559| 0|#define ANCHOR_KEEP (1<<16) ------------------ 6194| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6195| 0| break; 6196| | 6197| 6.12k| case TK_STRING: ------------------ | Branch (6197:3): [True: 6.12k, False: 20.4k] ------------------ 6198| 6.12k| tk_byte: 6199| 6.12k| { 6200| 6.12k| *np = node_new_str(tok->backp, *src); 6201| 6.12k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 6.12k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6202| | 6203| 6.12k| string_loop: 6204| 6.12k| while (1) { ------------------ | Branch (6204:14): [Folded - Ignored] ------------------ 6205| 6.12k| r = fetch_token(tok, src, end, env); 6206| 6.12k| if (r < 0) return r; ------------------ | Branch (6206:6): [True: 0, False: 6.12k] ------------------ 6207| 6.12k| if (r == TK_STRING) { ------------------ | Branch (6207:6): [True: 0, False: 6.12k] ------------------ 6208| 0| r = onig_node_str_cat(*np, tok->backp, *src); 6209| 0| } 6210| 6.12k|#ifndef NUMBERED_CHAR_IS_NOT_CASE_AMBIG 6211| 6.12k| else if (r == TK_CODE_POINT) { ------------------ | Branch (6211:11): [True: 0, False: 6.12k] ------------------ 6212| 0| r = node_str_cat_codepoint(*np, env->enc, tok->u.code); 6213| 0| } 6214| 6.12k|#endif 6215| 6.12k| else { 6216| 6.12k| break; 6217| 6.12k| } 6218| 0| if (r < 0) return r; ------------------ | Branch (6218:6): [True: 0, False: 0] ------------------ 6219| 0| } 6220| | 6221| 6.12k| string_end: 6222| 6.12k| targetp = np; 6223| 6.12k| goto repeat; 6224| 6.12k| } 6225| 0| break; 6226| | 6227| 0| case TK_RAW_BYTE: ------------------ | Branch (6227:3): [True: 0, False: 26.5k] ------------------ 6228| 0| tk_raw_byte: 6229| 0| { 6230| 0| *np = node_new_str_raw_char((UChar )tok->u.c); 6231| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6232| 0| len = 1; 6233| 0| while (1) { ------------------ | Branch (6233:14): [Folded - Ignored] ------------------ 6234| 0| if (len >= ONIGENC_MBC_MINLEN(env->enc)) { ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (6234:6): [True: 0, False: 0] ------------------ 6235| 0| if (len == enclen(env->enc, NSTR(*np)->s, NSTR(*np)->end)) { ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6235:8): [True: 0, False: 0] ------------------ 6236| 0| r = fetch_token(tok, src, end, env); 6237| 0| NSTRING_CLEAR_RAW(*np); ------------------ | | 110| 0|#define NSTRING_CLEAR_RAW(node) (node)->u.str.flag &= ~NSTR_RAW | | ------------------ | | | | 104| 0|#define NSTR_RAW (1<<0) /* by backslashed number */ | | ------------------ ------------------ 6238| 0| goto string_end; 6239| 0| } 6240| 0| } 6241| | 6242| 0| r = fetch_token(tok, src, end, env); 6243| 0| if (r < 0) return r; ------------------ | Branch (6243:6): [True: 0, False: 0] ------------------ 6244| 0| if (r != TK_RAW_BYTE) { ------------------ | Branch (6244:6): [True: 0, False: 0] ------------------ 6245| | /* Don't use this, it is wrong for little endian encodings. */ 6246| |#ifdef USE_PAD_TO_SHORT_BYTE_CHAR 6247| | int rem; 6248| | if (len < ONIGENC_MBC_MINLEN(env->enc)) { 6249| | rem = ONIGENC_MBC_MINLEN(env->enc) - len; 6250| | (void )node_str_head_pad(NSTR(*np), rem, (UChar )0); 6251| | if (len + rem == enclen(env->enc, NSTR(*np)->s)) { 6252| | NSTRING_CLEAR_RAW(*np); 6253| | goto string_end; 6254| | } 6255| | } 6256| |#endif 6257| 0| return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 675| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 6258| 0| } 6259| | 6260| 0| r = node_str_cat_char(*np, (UChar )tok->u.c); 6261| 0| if (r < 0) return r; ------------------ | Branch (6261:6): [True: 0, False: 0] ------------------ 6262| | 6263| 0| len++; 6264| 0| } 6265| 0| } 6266| 0| break; 6267| | 6268| 0| case TK_CODE_POINT: ------------------ | Branch (6268:3): [True: 0, False: 26.5k] ------------------ 6269| 0| { 6270| 0| *np = node_new_empty(); 6271| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6272| 0| r = node_str_cat_codepoint(*np, env->enc, tok->u.code); 6273| 0| if (r != 0) return r; ------------------ | Branch (6273:11): [True: 0, False: 0] ------------------ 6274| |#ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG 6275| | NSTRING_SET_RAW(*np); 6276| |#else 6277| 0| goto string_loop; 6278| 0|#endif 6279| 0| } 6280| 0| break; 6281| | 6282| 0| case TK_QUOTE_OPEN: ------------------ | Branch (6282:3): [True: 0, False: 26.5k] ------------------ 6283| 0| { 6284| 0| OnigCodePoint end_op[2]; 6285| 0| UChar *qstart, *qend, *nextp; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 6286| | 6287| 0| end_op[0] = (OnigCodePoint )MC_ESC(env->syntax); ------------------ | | 761| 0|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ 6288| 0| end_op[1] = (OnigCodePoint )'E'; 6289| 0| qstart = *src; 6290| 0| qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc); 6291| 0| if (IS_NULL(qend)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 6292| 0| nextp = qend = end; 6293| 0| } 6294| 0| *np = node_new_str(qstart, qend); 6295| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6296| 0| *src = nextp; 6297| 0| } 6298| 0| break; 6299| | 6300| 0| case TK_CHAR_TYPE: ------------------ | Branch (6300:3): [True: 0, False: 26.5k] ------------------ 6301| 0| { 6302| 0| switch (tok->u.prop.ctype) { 6303| 0| case ONIGENC_CTYPE_WORD: ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (6303:7): [True: 0, False: 0] ------------------ 6304| 0| *np = node_new_ctype(tok->u.prop.ctype, tok->u.prop.not, 6305| 0| IS_ASCII_RANGE(env->option)); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6306| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6307| 0| break; 6308| | 6309| 0| case ONIGENC_CTYPE_SPACE: ------------------ | | 303| 0|#define ONIGENC_CTYPE_SPACE 9 ------------------ | Branch (6309:7): [True: 0, False: 0] ------------------ 6310| 0| case ONIGENC_CTYPE_DIGIT: ------------------ | | 298| 0|#define ONIGENC_CTYPE_DIGIT 4 ------------------ | Branch (6310:7): [True: 0, False: 0] ------------------ 6311| 0| case ONIGENC_CTYPE_XDIGIT: ------------------ | | 305| 0|#define ONIGENC_CTYPE_XDIGIT 11 ------------------ | Branch (6311:7): [True: 0, False: 0] ------------------ 6312| 0| { 6313| 0| CClassNode* cc; 6314| | 6315| 0| *np = node_new_cclass(); 6316| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6317| 0| cc = NCCLASS(*np); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 6318| 0| r = add_ctype_to_cc(cc, tok->u.prop.ctype, 0, 6319| 0| IS_ASCII_RANGE(env->option), env); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6320| 0| if (r != 0) return r; ------------------ | Branch (6320:8): [True: 0, False: 0] ------------------ 6321| 0| if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc); ------------------ | | 807| 0|#define NCCLASS_SET_NOT(nd) NCCLASS_FLAG_SET(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 800| 0|#define NCCLASS_FLAG_SET(cc,flag) (NCCLASS_FLAGS(cc) |= (flag)) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ | Branch (6321:8): [True: 0, False: 0] ------------------ 6322| 0| } 6323| 0| break; 6324| | 6325| 0| default: ------------------ | Branch (6325:7): [True: 0, False: 0] ------------------ 6326| 0| return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 6327| 0| break; 6328| 0| } 6329| 0| } 6330| 0| break; 6331| | 6332| 0| case TK_CHAR_PROPERTY: ------------------ | Branch (6332:3): [True: 0, False: 26.5k] ------------------ 6333| 0| r = parse_char_property(np, tok, src, end, env); 6334| 0| if (r != 0) return r; ------------------ | Branch (6334:9): [True: 0, False: 0] ------------------ 6335| 0| break; 6336| | 6337| 6.12k| case TK_CC_OPEN: ------------------ | Branch (6337:3): [True: 6.12k, False: 20.4k] ------------------ 6338| 6.12k| { 6339| 6.12k| Node *asc_node; 6340| 6.12k| CClassNode* cc; 6341| 6.12k| OnigCodePoint code; 6342| | 6343| 6.12k| r = parse_char_class(np, &asc_node, tok, src, end, env); 6344| 6.12k| if (r != 0) { ------------------ | Branch (6344:11): [True: 0, False: 6.12k] ------------------ 6345| 0| onig_node_free(asc_node); 6346| 0| return r; 6347| 0| } 6348| | 6349| 6.12k| cc = NCCLASS(*np); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 6350| 6.12k| if (is_onechar_cclass(cc, &code)) { ------------------ | Branch (6350:11): [True: 0, False: 6.12k] ------------------ 6351| 0| onig_node_free(*np); 6352| 0| onig_node_free(asc_node); 6353| 0| *np = node_new_empty(); 6354| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6355| 0| r = node_str_cat_codepoint(*np, env->enc, code); 6356| 0| if (r != 0) return r; ------------------ | Branch (6356:6): [True: 0, False: 0] ------------------ 6357| 0| goto string_loop; 6358| 0| } 6359| 6.12k| if (IS_IGNORECASE(env->option)) { ------------------ | | 396| 6.12k|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 6.12k|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (396:35): [True: 0, False: 6.12k] | | ------------------ ------------------ 6360| 0| r = cclass_case_fold(np, cc, NCCLASS(asc_node), env); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 6361| 0| if (r != 0) { ------------------ | Branch (6361:6): [True: 0, False: 0] ------------------ 6362| 0| onig_node_free(asc_node); 6363| 0| return r; 6364| 0| } 6365| 0| } 6366| 6.12k| onig_node_free(asc_node); 6367| 6.12k| } 6368| 0| break; 6369| | 6370| 2.04k| case TK_ANYCHAR: ------------------ | Branch (6370:3): [True: 2.04k, False: 24.4k] ------------------ 6371| 2.04k| *np = node_new_anychar(); 6372| 2.04k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 2.04k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 2.04k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6373| 2.04k| break; 6374| | 6375| 2.04k| case TK_ANYCHAR_ANYTIME: ------------------ | Branch (6375:3): [True: 0, False: 26.5k] ------------------ 6376| 0| *np = node_new_anychar(); 6377| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6378| 0| qn = node_new_quantifier(0, REPEAT_INFINITE, 0); ------------------ | | 421| 0|#define REPEAT_INFINITE -1 ------------------ 6379| 0| CHECK_NULL_RETURN_MEMERR(qn); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6380| 0| NQTFR(qn)->target = *np; ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 6381| 0| *np = qn; 6382| 0| break; 6383| | 6384| 0| case TK_BACKREF: ------------------ | Branch (6384:3): [True: 0, False: 26.5k] ------------------ 6385| 0| len = tok->u.backref.num; 6386| 0| *np = node_new_backref(len, 6387| 0| (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)), ------------------ | Branch (6387:7): [True: 0, False: 0] ------------------ 6388| 0| tok->u.backref.by_name, 6389| 0|#ifdef USE_BACKREF_WITH_LEVEL 6390| 0| tok->u.backref.exist_level, 6391| 0| tok->u.backref.level, 6392| 0|#endif 6393| 0| env); 6394| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6395| 0| break; 6396| | 6397| 0|#ifdef USE_SUBEXP_CALL 6398| 0| case TK_CALL: ------------------ | Branch (6398:3): [True: 0, False: 26.5k] ------------------ 6399| 0| { 6400| 0| int gnum = tok->u.call.gnum; 6401| | 6402| 0| if (gnum < 0 || tok->u.call.rel != 0) { ------------------ | Branch (6402:11): [True: 0, False: 0] | Branch (6402:23): [True: 0, False: 0] ------------------ 6403| 0| if (gnum > 0) gnum--; ------------------ | Branch (6403:6): [True: 0, False: 0] ------------------ 6404| 0| gnum = BACKREF_REL_TO_ABS(gnum, env); ------------------ | | 158| 0| ((env)->num_mem + 1 + (rel_no)) ------------------ 6405| 0| if (gnum <= 0) ------------------ | Branch (6405:6): [True: 0, False: 0] ------------------ 6406| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 6407| 0| } 6408| 0| *np = node_new_call(tok->u.call.name, tok->u.call.name_end, gnum); 6409| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6410| 0| env->num_call++; 6411| 0| } 6412| 0| break; 6413| 0|#endif 6414| | 6415| 4.08k| case TK_ANCHOR: ------------------ | Branch (6415:3): [True: 4.08k, False: 22.4k] ------------------ 6416| 4.08k| *np = onig_node_new_anchor(tok->u.anchor.subtype); 6417| 4.08k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 4.08k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 4.08k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 4.08k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6418| 4.08k| NANCHOR(*np)->ascii_range = tok->u.anchor.ascii_range; ------------------ | | 82| 4.08k|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 6419| 4.08k| break; 6420| | 6421| 0| case TK_OP_REPEAT: ------------------ | Branch (6421:3): [True: 0, False: 26.5k] ------------------ 6422| 0| case TK_INTERVAL: ------------------ | Branch (6422:3): [True: 0, False: 26.5k] ------------------ 6423| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 6424| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 6425| 0| return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED; ------------------ | | 657| 0|#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED -113 ------------------ 6426| 0| else 6427| 0| *np = node_new_empty(); 6428| 0| } 6429| 0| else { 6430| 0| goto tk_byte; 6431| 0| } 6432| 0| break; 6433| | 6434| 0| default: ------------------ | Branch (6434:3): [True: 0, False: 26.5k] ------------------ 6435| 0| return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 6436| 0| break; 6437| 26.5k| } 6438| | 6439| 20.4k| { 6440| 20.4k| targetp = np; 6441| | 6442| 28.5k| re_entry: 6443| 28.5k| r = fetch_token(tok, src, end, env); 6444| 28.5k| if (r < 0) return r; ------------------ | Branch (6444:9): [True: 0, False: 28.5k] ------------------ 6445| | 6446| 34.6k| repeat: 6447| 34.6k| if (r == TK_OP_REPEAT || r == TK_INTERVAL) { ------------------ | Branch (6447:9): [True: 8.16k, False: 26.5k] | Branch (6447:30): [True: 0, False: 26.5k] ------------------ 6448| 8.16k| if (is_invalid_quantifier_target(*targetp)) ------------------ | | 2122| 8.16k|# define is_invalid_quantifier_target(node) 0 | | ------------------ | | | Branch (2122:45): [Folded - Ignored] | | ------------------ ------------------ 6449| 0| return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID; ------------------ | | 658| 0|#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID -114 ------------------ 6450| | 6451| 8.16k| parse_depth++; 6452| 8.16k| if (parse_depth > ParseDepthLimit) ------------------ | Branch (6452:11): [True: 0, False: 8.16k] ------------------ 6453| 0| return ONIGERR_PARSE_DEPTH_LIMIT_OVER; ------------------ | | 639| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 ------------------ 6454| | 6455| 8.16k| qn = node_new_quantifier(tok->u.repeat.lower, tok->u.repeat.upper, 6456| 8.16k| (r == TK_INTERVAL ? 1 : 0)); ------------------ | Branch (6456:12): [True: 0, False: 8.16k] ------------------ 6457| 8.16k| CHECK_NULL_RETURN_MEMERR(qn); ------------------ | | 314| 8.16k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 6458| 8.16k| NQTFR(qn)->greedy = tok->u.repeat.greedy; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 6459| 8.16k| r = set_quantifier(qn, *targetp, group, env); 6460| 8.16k| if (r < 0) { ------------------ | Branch (6460:11): [True: 0, False: 8.16k] ------------------ 6461| 0| onig_node_free(qn); 6462| 0| return r; 6463| 0| } 6464| | 6465| 8.16k| if (tok->u.repeat.possessive != 0) { ------------------ | Branch (6465:11): [True: 0, False: 8.16k] ------------------ 6466| 0| Node* en; 6467| 0| en = node_new_enclose(ENCLOSE_STOP_BACKTRACK); ------------------ | | 96| 0|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ 6468| 0| if (IS_NULL(en)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 6469| 0| onig_node_free(qn); 6470| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 6471| 0| } 6472| 0| NENCLOSE(en)->target = qn; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 6473| 0| qn = en; 6474| 0| } 6475| | 6476| 8.16k| if (r == 0) { ------------------ | Branch (6476:11): [True: 8.16k, False: 0] ------------------ 6477| 8.16k| *targetp = qn; 6478| 8.16k| } 6479| 0| else if (r == 1) { ------------------ | Branch (6479:16): [True: 0, False: 0] ------------------ 6480| 0| onig_node_free(qn); 6481| 0| } 6482| 0| else if (r == 2) { /* split case: /abc+/ */ ------------------ | Branch (6482:16): [True: 0, False: 0] ------------------ 6483| 0| Node *tmp; 6484| | 6485| 0| *targetp = node_new_list(*targetp, NULL); 6486| 0| if (IS_NULL(*targetp)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 6487| 0| onig_node_free(qn); 6488| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 6489| 0| } 6490| 0| tmp = NCDR(*targetp) = node_new_list(qn, NULL); ------------------ | | 87| 0|#define NCDR(node) (NCONS(node)->cdr) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6491| 0| if (IS_NULL(tmp)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 6492| 0| onig_node_free(qn); 6493| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 6494| 0| } 6495| 0| targetp = &(NCAR(tmp)); ------------------ | | 86| 0|#define NCAR(node) (NCONS(node)->car) | | ------------------ | | | | 83| 0|#define NCONS(node) (&((node)->u.cons)) | | ------------------ ------------------ 6496| 0| } 6497| 8.16k| goto re_entry; 6498| 8.16k| } 6499| 34.6k| } 6500| | 6501| 26.5k| return r; 6502| 34.6k|} regparse.c:parse_enclose: 4965| 8.16k|{ 4966| 8.16k| int r = 0, num; 4967| 8.16k| Node *target, *work1 = NULL, *work2 = NULL; 4968| 8.16k| OnigOptionType option; 4969| 8.16k| OnigCodePoint c; 4970| 8.16k| OnigEncoding enc = env->enc; 4971| | 4972| 8.16k|#ifdef USE_NAMED_GROUP 4973| 8.16k| int list_capture; 4974| 8.16k|#endif 4975| | 4976| 8.16k| UChar* p = *src; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 4977| 8.16k| PFETCH_READY; ------------------ | | 295| 8.16k|# define PFETCH_READY UChar* pfetch_prev = NULL; (void)pfetch_prev | | ------------------ | | | | 76| 8.16k|# define UChar OnigUChar | | ------------------ ------------------ 4978| | 4979| 8.16k| *np = NULL; 4980| 8.16k| if (PEND) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 299| 8.16k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 8.16k] | | | Branch (299:23): [True: 8.16k, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS; ------------------ | | 661| 0|#define ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS -117 ------------------ 4981| | 4982| 8.16k| option = env->option; 4983| 8.16k| if (PPEEK_IS('?') && ------------------ | | 320| 16.3k|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 8.16k|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 8.16k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 8.16k, False: 0] | | ------------------ ------------------ 4984| 8.16k| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) { ------------------ | | 331| 8.16k|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 8.16k, False: 0] | | ------------------ ------------------ 4985| 8.16k| PINC; ------------------ | | 301| 8.16k|#define PINC do { \ | | 302| 8.16k| pfetch_prev = p; \ | | 303| 8.16k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 8.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 8.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 304| 8.16k|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 4986| 8.16k| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 299| 8.16k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 8.16k] | | | Branch (299:23): [True: 8.16k, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 662| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 4987| | 4988| 8.16k| PFETCH(c); ------------------ | | 305| 8.16k|#define PFETCH(c) do { \ | | 306| 8.16k| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 8.16k] | | ------------------ | | 307| 8.16k| pfetch_prev = p; \ | | 308| 8.16k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 8.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 8.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 309| 8.16k|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 4989| 8.16k| switch (c) { 4990| 0| case ':': /* (?:...) grouping only */ ------------------ | Branch (4990:5): [True: 0, False: 8.16k] ------------------ 4991| 0| group: 4992| 0| r = fetch_token(tok, &p, end, env); 4993| 0| if (r < 0) return r; ------------------ | Branch (4993:11): [True: 0, False: 0] ------------------ 4994| 0| r = parse_subexp(np, tok, term, &p, end, env); 4995| 0| if (r < 0) return r; ------------------ | Branch (4995:11): [True: 0, False: 0] ------------------ 4996| 0| *src = p; 4997| 0| return 1; /* group */ 4998| 0| break; 4999| | 5000| 0| case '=': ------------------ | Branch (5000:5): [True: 0, False: 8.16k] ------------------ 5001| 0| *np = onig_node_new_anchor(ANCHOR_PREC_READ); ------------------ | | 551| 0|#define ANCHOR_PREC_READ (1<<10) ------------------ 5002| 0| break; 5003| 0| case '!': /* preceding read */ ------------------ | Branch (5003:5): [True: 0, False: 8.16k] ------------------ 5004| 0| *np = onig_node_new_anchor(ANCHOR_PREC_READ_NOT); ------------------ | | 552| 0|#define ANCHOR_PREC_READ_NOT (1<<11) ------------------ 5005| 0| break; 5006| 0| case '>': /* (?>...) stop backtrack */ ------------------ | Branch (5006:5): [True: 0, False: 8.16k] ------------------ 5007| 0| *np = node_new_enclose(ENCLOSE_STOP_BACKTRACK); ------------------ | | 96| 0|#define ENCLOSE_STOP_BACKTRACK (1<<2) ------------------ 5008| 0| break; 5009| 0| case '~': /* (?~...) absent operator */ ------------------ | Branch (5009:5): [True: 0, False: 8.16k] ------------------ 5010| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_TILDE_ABSENT)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5011| 0| *np = node_new_enclose(ENCLOSE_ABSENT); ------------------ | | 98| 0|#define ENCLOSE_ABSENT (1<<4) ------------------ 5012| 0| } 5013| 0| else { 5014| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5015| 0| } 5016| 0| break; 5017| | 5018| 0|#ifdef USE_NAMED_GROUP 5019| 0| case '\'': ------------------ | Branch (5019:5): [True: 0, False: 8.16k] ------------------ 5020| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5021| 0| goto named_group1; 5022| 0| } 5023| 0| else 5024| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5025| 0| break; 5026| | 5027| 0|# ifdef USE_CAPITAL_P_NAMED_GROUP 5028| 0| case 'P': /* (?P...) */ ------------------ | Branch (5028:5): [True: 0, False: 8.16k] ------------------ 5029| 0| if (!PEND && ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5029:11): [True: 0, False: 0] ------------------ 5030| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5031| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5032| 0| if (c == '<') goto named_group1; ------------------ | Branch (5032:6): [True: 0, False: 0] ------------------ 5033| 0| } 5034| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5035| 0| break; 5036| 0|# endif 5037| 0|#endif 5038| | 5039| 8.16k| case '<': /* look behind (?<=...), (?max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 8.16k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 8.16k] | | ------------------ | | 307| 8.16k| pfetch_prev = p; \ | | 308| 8.16k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 8.16k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 8.16k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 309| 8.16k|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5042| 8.16k| if (c == '=') ------------------ | Branch (5042:11): [True: 0, False: 8.16k] ------------------ 5043| 0| *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND); ------------------ | | 553| 0|#define ANCHOR_LOOK_BEHIND (1<<12) ------------------ 5044| 8.16k| else if (c == '!') ------------------ | Branch (5044:16): [True: 0, False: 8.16k] ------------------ 5045| 0| *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT); ------------------ | | 554| 0|#define ANCHOR_LOOK_BEHIND_NOT (1<<13) ------------------ 5046| 8.16k|#ifdef USE_NAMED_GROUP 5047| 8.16k| else { /* (?...) */ 5048| 8.16k| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 331| 8.16k|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 8.16k, False: 0] | | ------------------ ------------------ 5049| 8.16k| UChar *name; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 5050| 8.16k| UChar *name_end; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 5051| | 5052| 8.16k| PUNFETCH; ------------------ | | 300| 8.16k|#define PUNFETCH p = pfetch_prev ------------------ 5053| 8.16k| c = '<'; 5054| | 5055| 8.16k| named_group1: 5056| 8.16k| list_capture = 0; 5057| | 5058| 8.16k|# ifdef USE_CAPTURE_HISTORY 5059| 8.16k| named_group2: 5060| 8.16k|# endif 5061| 8.16k| name = p; 5062| 8.16k| r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0); 5063| 8.16k| if (r < 0) return r; ------------------ | Branch (5063:8): [True: 0, False: 8.16k] ------------------ 5064| | 5065| 8.16k| num = scan_env_add_mem_entry(env); 5066| 8.16k| if (num < 0) return num; ------------------ | Branch (5066:8): [True: 0, False: 8.16k] ------------------ 5067| 8.16k| if (list_capture != 0 && num >= (int )BIT_STATUS_BITS_NUM) ------------------ | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) ------------------ | Branch (5067:8): [True: 0, False: 8.16k] | Branch (5067:29): [True: 0, False: 0] ------------------ 5068| 0| return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY; ------------------ | | 690| 0|#define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY -222 ------------------ 5069| | 5070| 8.16k| r = name_add(env->reg, name, name_end, num, env); 5071| 8.16k| if (r != 0) return r; ------------------ | Branch (5071:8): [True: 0, False: 8.16k] ------------------ 5072| 8.16k| *np = node_new_enclose_memory(env->option, 1); 5073| 8.16k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 8.16k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5074| 8.16k| NENCLOSE(*np)->regnum = num; ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5075| 8.16k| if (list_capture != 0) ------------------ | Branch (5075:8): [True: 0, False: 8.16k] ------------------ 5076| 0| BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num); ------------------ | | 380| 0|#define BIT_STATUS_ON_AT_SIMPLE(stats,n) do {\ | | 381| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (381:7): [True: 0, False: 0] | | ------------------ | | 382| 0| (stats) |= (1 << (n));\ | | 383| 0|} while (0) | | ------------------ | | | Branch (383:10): [Folded - Ignored] | | ------------------ ------------------ 5077| 8.16k| env->num_named++; 5078| 8.16k| } 5079| 0| else { 5080| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5081| 0| } 5082| 8.16k| } 5083| |#else 5084| | else { 5085| | return ONIGERR_UNDEFINED_GROUP_OPTION; 5086| | } 5087| |#endif 5088| 8.16k| break; 5089| | 5090| 8.16k|#ifdef USE_CAPTURE_HISTORY 5091| 8.16k| case '@': ------------------ | Branch (5091:5): [True: 0, False: 8.16k] ------------------ 5092| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5093| 0|# ifdef USE_NAMED_GROUP 5094| 0| if (!PEND && ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5094:6): [True: 0, False: 0] ------------------ 5095| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5096| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5097| 0| if (c == '<' || c == '\'') { ------------------ | Branch (5097:8): [True: 0, False: 0] | Branch (5097:20): [True: 0, False: 0] ------------------ 5098| 0| list_capture = 1; 5099| 0| goto named_group2; /* (?@...) */ 5100| 0| } 5101| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 5102| 0| } 5103| 0|# endif 5104| 0| *np = node_new_enclose_memory(env->option, 0); 5105| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5106| 0| num = scan_env_add_mem_entry(env); 5107| 0| if (num < 0) return num; ------------------ | Branch (5107:6): [True: 0, False: 0] ------------------ 5108| 0| if (num >= (int )BIT_STATUS_BITS_NUM) ------------------ | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) ------------------ | Branch (5108:6): [True: 0, False: 0] ------------------ 5109| 0| return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY; ------------------ | | 690| 0|#define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY -222 ------------------ 5110| | 5111| 0| NENCLOSE(*np)->regnum = num; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5112| 0| BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num); ------------------ | | 380| 0|#define BIT_STATUS_ON_AT_SIMPLE(stats,n) do {\ | | 381| 0| if ((n) < (int )BIT_STATUS_BITS_NUM)\ | | ------------------ | | | | 367| 0|#define BIT_STATUS_BITS_NUM (sizeof(BitStatusType) * 8) | | ------------------ | | | Branch (381:7): [True: 0, False: 0] | | ------------------ | | 382| 0| (stats) |= (1 << (n));\ | | 383| 0|} while (0) | | ------------------ | | | Branch (383:10): [Folded - Ignored] | | ------------------ ------------------ 5113| 0| } 5114| 0| else { 5115| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5116| 0| } 5117| 0| break; 5118| 0|#endif /* USE_CAPTURE_HISTORY */ 5119| | 5120| 0| case '(': /* conditional expression: (?(cond)yes), (?(cond)yes|no) */ ------------------ | Branch (5120:5): [True: 0, False: 8.16k] ------------------ 5121| 0| if (!PEND && ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5121:11): [True: 0, False: 0] ------------------ 5122| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LPAREN_CONDITION)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5123| 0| UChar *name = NULL; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 5124| 0| UChar *name_end; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 5125| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5126| 0| if (ONIGENC_IS_CODE_DIGIT(enc, c)) { /* (n) */ ------------------ | | 400| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 5127| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 5128| 0| r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &num, 1); 5129| 0| if (r < 0) return r; ------------------ | Branch (5129:8): [True: 0, False: 0] ------------------ 5130| |#if 0 5131| | /* Relative number is not currently supported. (same as Perl) */ 5132| | if (num < 0) { 5133| | num = BACKREF_REL_TO_ABS(num, env); 5134| | if (num <= 0) 5135| | return ONIGERR_INVALID_BACKREF; 5136| | } 5137| |#endif 5138| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 5139| 0| if (num > env->num_mem || ------------------ | Branch (5139:10): [True: 0, False: 0] ------------------ 5140| 0| IS_NULL(SCANENV_MEM_NODES(env)[num])) ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | | Branch (311:49): [True: 0, False: 0] | | ------------------ ------------------ 5141| 0| return ONIGERR_INVALID_BACKREF; ------------------ | | 677| 0|#define ONIGERR_INVALID_BACKREF -208 ------------------ 5142| 0| } 5143| 0| } 5144| 0|#ifdef USE_NAMED_GROUP 5145| 0| else if (c == '<' || c == '\'') { /* (), ('name') */ ------------------ | Branch (5145:11): [True: 0, False: 0] | Branch (5145:23): [True: 0, False: 0] ------------------ 5146| 0| name = p; 5147| 0| r = fetch_named_backref_token(c, tok, &p, end, env); 5148| 0| if (r < 0) return r; ------------------ | Branch (5148:8): [True: 0, False: 0] ------------------ 5149| 0| if (!PPEEK_IS(')')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (!PPEEK_IS(')')) return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ | Branch (5149:8): [True: 0, False: 0] ------------------ 5150| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 5151| | 5152| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_USE_LEFT_MOST_NAMED_GROUP)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 5153| 0| num = tok->u.backref.ref1; 5154| 0| } 5155| 0| else { 5156| | /* FIXME: 5157| | * Use left most named group for now. This is the same as Perl. 5158| | * However this should use the same strategy as normal back- 5159| | * references on Ruby syntax; search right to left. */ 5160| 0| int len = tok->u.backref.num; 5161| 0| num = len > 1 ? tok->u.backref.refs[0] : tok->u.backref.ref1; ------------------ | Branch (5161:12): [True: 0, False: 0] ------------------ 5162| 0| } 5163| 0| } 5164| 0|#endif 5165| 0| else 5166| 0| return ONIGERR_INVALID_CONDITION_PATTERN; ------------------ | | 667| 0|#define ONIGERR_INVALID_CONDITION_PATTERN -124 ------------------ 5167| 0| *np = node_new_enclose(ENCLOSE_CONDITION); ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ 5168| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5169| 0| NENCLOSE(*np)->regnum = num; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5170| 0| if (IS_NOT_NULL(name)) NENCLOSE(*np)->state |= NST_NAME_REF; ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NOT_NULL(name)) NENCLOSE(*np)->state |= NST_NAME_REF; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ if (IS_NOT_NULL(name)) NENCLOSE(*np)->state |= NST_NAME_REF; ------------------ | | 139| 0|#define NST_NAME_REF (1<<11) ------------------ 5171| 0| } 5172| 0| else 5173| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5174| 0| break; 5175| | 5176| |#if 0 5177| | case '|': /* branch reset: (?|...) */ 5178| | if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_VBAR_BRANCH_RESET)) { 5179| | /* TODO */ 5180| | } 5181| | else 5182| | return ONIGERR_UNDEFINED_GROUP_OPTION; 5183| | break; 5184| |#endif 5185| | 5186| 0| case '^': /* loads default options */ ------------------ | Branch (5186:5): [True: 0, False: 8.16k] ------------------ 5187| 0| if (!PEND && IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5187:11): [True: 0, False: 0] ------------------ 5188| | /* d-imsx */ 5189| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5190| 0| ONOFF(option, ONIG_OPTION_IGNORECASE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5191| 0| ONOFF(option, ONIG_OPTION_SINGLELINE, 0); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5192| 0| ONOFF(option, ONIG_OPTION_MULTILINE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5193| 0| ONOFF(option, ONIG_OPTION_EXTEND, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5194| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5195| 0| } 5196| |#if 0 5197| | else if (!PEND && IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) { 5198| | /* d-imx */ 5199| | ONOFF(option, ONIG_OPTION_ASCII_RANGE, 0); 5200| | ONOFF(option, ONIG_OPTION_POSIX_BRACKET_ALL_RANGE, 0); 5201| | ONOFF(option, ONIG_OPTION_WORD_BOUND_ALL_RANGE, 0); 5202| | ONOFF(option, ONIG_OPTION_IGNORECASE, 1); 5203| | ONOFF(option, ONIG_OPTION_MULTILINE, 1); 5204| | ONOFF(option, ONIG_OPTION_EXTEND, 1); 5205| | PFETCH(c); 5206| | } 5207| |#endif 5208| 0| else { 5209| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5210| 0| } 5211| | /* fall through */ 5212| |#ifdef USE_POSIXLINE_OPTION 5213| | case 'p': 5214| |#endif 5215| 0| case '-': case 'i': case 'm': case 's': case 'x': ------------------ | Branch (5215:5): [True: 0, False: 8.16k] | Branch (5215:15): [True: 0, False: 8.16k] | Branch (5215:25): [True: 0, False: 8.16k] | Branch (5215:35): [True: 0, False: 8.16k] | Branch (5215:45): [True: 0, False: 8.16k] ------------------ 5216| 0| case 'a': case 'd': case 'l': case 'u': ------------------ | Branch (5216:5): [True: 0, False: 8.16k] | Branch (5216:15): [True: 0, False: 8.16k] | Branch (5216:25): [True: 0, False: 8.16k] | Branch (5216:35): [True: 0, False: 8.16k] ------------------ 5217| 0| { 5218| 0| int neg = 0; 5219| | 5220| 0| while (1) { ------------------ | Branch (5220:9): [Folded - Ignored] ------------------ 5221| 0| switch (c) { 5222| 0| case ':': ------------------ | Branch (5222:4): [True: 0, False: 0] ------------------ 5223| 0| case ')': ------------------ | Branch (5223:4): [True: 0, False: 0] ------------------ 5224| 0| break; 5225| | 5226| 0| case '-': neg = 1; break; ------------------ | Branch (5226:4): [True: 0, False: 0] ------------------ 5227| 0| case 'x': ONOFF(option, ONIG_OPTION_EXTEND, neg); break; ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5227:4): [True: 0, False: 0] ------------------ 5228| 0| case 'i': ONOFF(option, ONIG_OPTION_IGNORECASE, neg); break; ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5228:4): [True: 0, False: 0] ------------------ 5229| 0| case 's': ------------------ | Branch (5229:4): [True: 0, False: 0] ------------------ 5230| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5231| 0| ONOFF(option, ONIG_OPTION_MULTILINE, neg); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [True: 0, False: 0] | | ------------------ ------------------ 5232| 0| } 5233| 0| else 5234| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5235| 0| break; 5236| | 5237| 0| case 'm': ------------------ | Branch (5237:4): [True: 0, False: 0] ------------------ 5238| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5239| 0| ONOFF(option, ONIG_OPTION_SINGLELINE, (neg == 0 ? 1 : 0)); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [True: 0, False: 0] | | | Branch (160:33): [True: 0, False: 0] | | ------------------ ------------------ 5240| 0| } 5241| 0| else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5242| 0| ONOFF(option, ONIG_OPTION_MULTILINE, neg); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [True: 0, False: 0] | | ------------------ ------------------ 5243| 0| } 5244| 0| else 5245| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5246| 0| break; 5247| |#ifdef USE_POSIXLINE_OPTION 5248| | case 'p': 5249| | ONOFF(option, ONIG_OPTION_MULTILINE|ONIG_OPTION_SINGLELINE, neg); 5250| | break; 5251| |#endif 5252| | 5253| 0| case 'a': /* limits \d, \s, \w and POSIX brackets to ASCII range */ ------------------ | Branch (5253:4): [True: 0, False: 0] ------------------ 5254| 0| if ((IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) || ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5255| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5256| 0| (neg == 0)) { ------------------ | Branch (5256:3): [True: 0, False: 0] ------------------ 5257| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 0); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5258| 0| ONOFF(option, ONIG_OPTION_POSIX_BRACKET_ALL_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5259| 0| ONOFF(option, ONIG_OPTION_WORD_BOUND_ALL_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5260| 0| } 5261| 0| else 5262| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5263| 0| break; 5264| | 5265| 0| case 'u': ------------------ | Branch (5265:4): [True: 0, False: 0] ------------------ 5266| 0| if ((IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) || ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5267| 0| IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5268| 0| (neg == 0)) { ------------------ | Branch (5268:3): [True: 0, False: 0] ------------------ 5269| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5270| 0| ONOFF(option, ONIG_OPTION_POSIX_BRACKET_ALL_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5271| 0| ONOFF(option, ONIG_OPTION_WORD_BOUND_ALL_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5272| 0| } 5273| 0| else 5274| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5275| 0| break; 5276| | 5277| 0| case 'd': ------------------ | Branch (5277:4): [True: 0, False: 0] ------------------ 5278| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5279| 0| (neg == 0)) { ------------------ | Branch (5279:3): [True: 0, False: 0] ------------------ 5280| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5281| 0| } 5282| 0| else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 5283| 0| (neg == 0)) { ------------------ | Branch (5283:3): [True: 0, False: 0] ------------------ 5284| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 0); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5285| 0| ONOFF(option, ONIG_OPTION_POSIX_BRACKET_ALL_RANGE, 0); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5286| 0| ONOFF(option, ONIG_OPTION_WORD_BOUND_ALL_RANGE, 0); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5287| 0| } 5288| 0| else 5289| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5290| 0| break; 5291| | 5292| 0| case 'l': ------------------ | Branch (5292:4): [True: 0, False: 0] ------------------ 5293| 0| if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) && (neg == 0)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (5293:66): [True: 0, False: 0] ------------------ 5294| 0| ONOFF(option, ONIG_OPTION_ASCII_RANGE, 1); ------------------ | | 160| 0|#define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f)) | | ------------------ | | | Branch (160:32): [Folded - Ignored] | | ------------------ ------------------ 5295| 0| } 5296| 0| else 5297| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5298| 0| break; 5299| | 5300| 0| default: ------------------ | Branch (5300:4): [True: 0, False: 0] ------------------ 5301| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5302| 0| } 5303| | 5304| 0| if (c == ')') { ------------------ | Branch (5304:8): [True: 0, False: 0] ------------------ 5305| 0| *np = node_new_option(option); 5306| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5307| 0| *src = p; 5308| 0| return 2; /* option only */ 5309| 0| } 5310| 0| else if (c == ':') { ------------------ | Branch (5310:13): [True: 0, False: 0] ------------------ 5311| 0| OnigOptionType prev = env->option; 5312| | 5313| 0| env->option = option; 5314| 0| r = fetch_token(tok, &p, end, env); 5315| 0| if (r < 0) { ------------------ | Branch (5315:10): [True: 0, False: 0] ------------------ 5316| 0| env->option = prev; 5317| 0| return r; 5318| 0| } 5319| 0| r = parse_subexp(&target, tok, term, &p, end, env); 5320| 0| env->option = prev; 5321| 0| if (r < 0) return r; ------------------ | Branch (5321:10): [True: 0, False: 0] ------------------ 5322| 0| *np = node_new_option(option); 5323| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5324| 0| NENCLOSE(*np)->target = target; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5325| 0| *src = p; 5326| 0| return 0; 5327| 0| } 5328| | 5329| 0| if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_IN_GROUP; ------------------ | | 662| 0|#define ONIGERR_END_PATTERN_IN_GROUP -118 ------------------ 5330| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 5331| 0| } 5332| 0| } 5333| 0| break; 5334| | 5335| 0| default: ------------------ | Branch (5335:5): [True: 0, False: 8.16k] ------------------ 5336| 0| return ONIGERR_UNDEFINED_GROUP_OPTION; ------------------ | | 663| 0|#define ONIGERR_UNDEFINED_GROUP_OPTION -119 ------------------ 5337| 8.16k| } 5338| 8.16k| } 5339| 0| else { 5340| 0| if (ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_DONT_CAPTURE_GROUP)) ------------------ | | 479| 0|#define ONIG_IS_OPTION_ON(options,option) ((options) & (option)) | | ------------------ | | | Branch (479:45): [True: 0, False: 0] | | ------------------ ------------------ 5341| 0| goto group; 5342| | 5343| 0| *np = node_new_enclose_memory(env->option, 0); 5344| 0| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5345| 0| num = scan_env_add_mem_entry(env); 5346| 0| if (num < 0) return num; ------------------ | Branch (5346:9): [True: 0, False: 0] ------------------ 5347| 0| NENCLOSE(*np)->regnum = num; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5348| 0| } 5349| | 5350| 8.16k| CHECK_NULL_RETURN_MEMERR(*np); ------------------ | | 314| 8.16k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 5351| 8.16k| r = fetch_token(tok, &p, end, env); 5352| 8.16k| if (r < 0) return r; ------------------ | Branch (5352:7): [True: 0, False: 8.16k] ------------------ 5353| 8.16k| r = parse_subexp(&target, tok, term, &p, end, env); 5354| 8.16k| if (r < 0) { ------------------ | Branch (5354:7): [True: 0, False: 8.16k] ------------------ 5355| 0| onig_node_free(target); 5356| 0| return r; 5357| 0| } 5358| | 5359| 8.16k| if (NTYPE(*np) == NT_ANCHOR) ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(*np) == NT_ANCHOR) ------------------ | | 45| 8.16k|#define NT_ANCHOR 7 ------------------ | Branch (5359:7): [True: 0, False: 8.16k] ------------------ 5360| 0| NANCHOR(*np)->target = target; ------------------ | | 82| 0|#define NANCHOR(node) (&((node)->u.anchor)) ------------------ 5361| 8.16k| else { 5362| 8.16k| NENCLOSE(*np)->target = target; ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5363| 8.16k| if (NENCLOSE(*np)->type == ENCLOSE_MEMORY) { ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ if (NENCLOSE(*np)->type == ENCLOSE_MEMORY) { ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ | Branch (5363:9): [True: 8.16k, False: 0] ------------------ 5364| | /* Don't move this to previous of parse_subexp() */ 5365| 8.16k| r = scan_env_set_mem_node(env, NENCLOSE(*np)->regnum, *np); ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5366| 8.16k| if (r != 0) return r; ------------------ | Branch (5366:11): [True: 0, False: 8.16k] ------------------ 5367| 8.16k| } 5368| 0| else if (NENCLOSE(*np)->type == ENCLOSE_CONDITION) { ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ else if (NENCLOSE(*np)->type == ENCLOSE_CONDITION) { ------------------ | | 97| 0|#define ENCLOSE_CONDITION (1<<3) ------------------ | Branch (5368:14): [True: 0, False: 0] ------------------ 5369| 0| if (NTYPE(target) != NT_ALT) { ------------------ | | 69| 0|#define NTYPE(node) ((node)->u.base.type) ------------------ if (NTYPE(target) != NT_ALT) { ------------------ | | 47| 0|#define NT_ALT 9 ------------------ | Branch (5369:11): [True: 0, False: 0] ------------------ 5370| | /* convert (?(cond)yes) to (?(cond)yes|empty) */ 5371| 0| work1 = node_new_empty(); 5372| 0| if (IS_NULL(work1)) goto err; ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 5373| 0| work2 = onig_node_new_alt(work1, NULL_NODE); ------------------ | | 283| 0|#define NULL_NODE ((Node* )0) ------------------ 5374| 0| if (IS_NULL(work2)) goto err; ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 5375| 0| work1 = onig_node_new_alt(target, work2); 5376| 0| if (IS_NULL(work1)) goto err; ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 5377| 0| NENCLOSE(*np)->target = work1; ------------------ | | 81| 0|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 5378| 0| } 5379| 0| } 5380| 8.16k| } 5381| | 5382| 8.16k| *src = p; 5383| 8.16k| return 0; 5384| | 5385| 0| err: 5386| 0| onig_node_free(work1); 5387| 0| onig_node_free(work2); 5388| 0| onig_node_free(*np); 5389| 0| *np = NULL; 5390| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 5391| 8.16k|} regparse.c:scan_env_add_mem_entry: 1016| 8.16k|{ 1017| 8.16k| int i, need, alloc; 1018| 8.16k| Node** p; 1019| | 1020| 8.16k| need = env->num_mem + 1; 1021| 8.16k| if (need > ONIG_MAX_CAPTURE_GROUP_NUM) ------------------ | | 441| 8.16k|#define ONIG_MAX_CAPTURE_GROUP_NUM 32767 ------------------ | Branch (1021:7): [True: 0, False: 8.16k] ------------------ 1022| 0| return ONIGERR_TOO_MANY_CAPTURE_GROUPS; ------------------ | | 679| 0|#define ONIGERR_TOO_MANY_CAPTURE_GROUPS -210 ------------------ 1023| 8.16k| if (need >= SCANENV_MEMNODES_SIZE) { ------------------ | | 285| 8.16k|#define SCANENV_MEMNODES_SIZE 8 ------------------ | Branch (1023:7): [True: 0, False: 8.16k] ------------------ 1024| 0| if (env->mem_alloc <= need) { ------------------ | Branch (1024:9): [True: 0, False: 0] ------------------ 1025| 0| if (IS_NULL(env->mem_nodes_dynamic)) { ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 1026| 0| alloc = INIT_SCANENV_MEMNODES_ALLOC_SIZE; ------------------ | | 980| 0|#define INIT_SCANENV_MEMNODES_ALLOC_SIZE 16 ------------------ 1027| 0| p = (Node** )xmalloc(sizeof(Node*) * alloc); ------------------ | | 142| 0|# define xmalloc malloc ------------------ 1028| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1029| 0| xmemcpy(p, env->mem_nodes_static, ------------------ | | 215| 0|#define xmemcpy memcpy ------------------ 1030| 0| sizeof(Node*) * SCANENV_MEMNODES_SIZE); ------------------ | | 285| 0|#define SCANENV_MEMNODES_SIZE 8 ------------------ 1031| 0| } 1032| 0| else { 1033| 0| alloc = env->mem_alloc * 2; 1034| 0| p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc); ------------------ | | 143| 0|# define xrealloc realloc ------------------ 1035| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 1036| 0| } 1037| | 1038| 0| for (i = env->num_mem + 1; i < alloc; i++) ------------------ | Branch (1038:34): [True: 0, False: 0] ------------------ 1039| 0| p[i] = NULL_NODE; ------------------ | | 283| 0|#define NULL_NODE ((Node* )0) ------------------ 1040| | 1041| 0| env->mem_nodes_dynamic = p; 1042| 0| env->mem_alloc = alloc; 1043| 0| } 1044| 0| } 1045| | 1046| 8.16k| env->num_mem++; 1047| 8.16k| return env->num_mem; 1048| 8.16k|} regparse.c:name_add: 773| 8.16k|{ 774| 8.16k| int alloc; 775| 8.16k| NameEntry* e; 776| 8.16k| NameTable* t = (NameTable* )reg->name_table; 777| | 778| 8.16k| if (name_end - name <= 0) ------------------ | Branch (778:7): [True: 0, False: 8.16k] ------------------ 779| 0| return ONIGERR_EMPTY_GROUP_NAME; ------------------ | | 682| 0|#define ONIGERR_EMPTY_GROUP_NAME -214 ------------------ 780| | 781| 8.16k| e = name_find(reg, name, name_end); 782| 8.16k| if (IS_NULL(e)) { ------------------ | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 8.16k, False: 0] | | ------------------ ------------------ 783| 8.16k|# ifdef USE_ST_LIBRARY 784| 8.16k| if (IS_NULL(t)) { ------------------ | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 2.04k, False: 6.12k] | | ------------------ ------------------ 785| 2.04k| t = onig_st_init_strend_table_with_size(5); 786| 2.04k| reg->name_table = (void* )t; 787| 2.04k| } 788| 8.16k| e = (NameEntry* )xmalloc(sizeof(NameEntry)); ------------------ | | 142| 8.16k|# define xmalloc malloc ------------------ 789| 8.16k| CHECK_NULL_RETURN_MEMERR(e); ------------------ | | 314| 8.16k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 790| | 791| 8.16k| e->name = strdup_with_null(reg->enc, name, name_end); 792| 8.16k| if (IS_NULL(e->name)) { ------------------ | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 8.16k] | | ------------------ ------------------ 793| 0| xfree(e); ------------------ | | 145| 0|# define xfree free ------------------ 794| 0| return ONIGERR_MEMORY; ------------------ | | 632| 0|#define ONIGERR_MEMORY -5 ------------------ 795| 0| } 796| 8.16k| onig_st_insert_strend(t, e->name, (e->name + (name_end - name)), 797| 8.16k| (HashDataType )e); 798| | 799| 8.16k| e->name_len = name_end - name; 800| 8.16k| e->back_num = 0; 801| 8.16k| e->back_alloc = 0; 802| 8.16k| e->back_refs = (int* )NULL; 803| | 804| |# else 805| | 806| | if (IS_NULL(t)) { 807| | alloc = INIT_NAMES_ALLOC_NUM; 808| | t = (NameTable* )xmalloc(sizeof(NameTable)); 809| | CHECK_NULL_RETURN_MEMERR(t); 810| | t->e = NULL; 811| | t->alloc = 0; 812| | t->num = 0; 813| | 814| | t->e = (NameEntry* )xmalloc(sizeof(NameEntry) * alloc); 815| | if (IS_NULL(t->e)) { 816| | xfree(t); 817| | return ONIGERR_MEMORY; 818| | } 819| | t->alloc = alloc; 820| | reg->name_table = t; 821| | goto clear; 822| | } 823| | else if (t->num == t->alloc) { 824| | int i; 825| | NameEntry* p; 826| | 827| | alloc = t->alloc * 2; 828| | p = (NameEntry* )xrealloc(t->e, sizeof(NameEntry) * alloc); 829| | CHECK_NULL_RETURN_MEMERR(p); 830| | t->e = p; 831| | t->alloc = alloc; 832| | 833| | clear: 834| | for (i = t->num; i < t->alloc; i++) { 835| | t->e[i].name = NULL; 836| | t->e[i].name_len = 0; 837| | t->e[i].back_num = 0; 838| | t->e[i].back_alloc = 0; 839| | t->e[i].back_refs = (int* )NULL; 840| | } 841| | } 842| | e = &(t->e[t->num]); 843| | t->num++; 844| | e->name = strdup_with_null(reg->enc, name, name_end); 845| | if (IS_NULL(e->name)) return ONIGERR_MEMORY; 846| | e->name_len = name_end - name; 847| |# endif 848| 8.16k| } 849| | 850| 8.16k| if (e->back_num >= 1 && ------------------ | Branch (850:7): [True: 0, False: 8.16k] ------------------ 851| 8.16k| ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (851:7): [True: 0, False: 0] ------------------ 852| 0| onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME, ------------------ | | 687| 0|#define ONIGERR_MULTIPLEX_DEFINED_NAME -219 ------------------ 853| 0| name, name_end); 854| 0| return ONIGERR_MULTIPLEX_DEFINED_NAME; ------------------ | | 687| 0|#define ONIGERR_MULTIPLEX_DEFINED_NAME -219 ------------------ 855| 0| } 856| | 857| 8.16k| e->back_num++; 858| 8.16k| if (e->back_num == 1) { ------------------ | Branch (858:7): [True: 8.16k, False: 0] ------------------ 859| 8.16k| e->back_ref1 = backref; 860| 8.16k| } 861| 0| else { 862| 0| if (e->back_num == 2) { ------------------ | Branch (862:9): [True: 0, False: 0] ------------------ 863| 0| alloc = INIT_NAME_BACKREFS_ALLOC_NUM; ------------------ | | 451| 0|# define INIT_NAME_BACKREFS_ALLOC_NUM 8 ------------------ 864| 0| e->back_refs = (int* )xmalloc(sizeof(int) * alloc); ------------------ | | 142| 0|# define xmalloc malloc ------------------ 865| 0| CHECK_NULL_RETURN_MEMERR(e->back_refs); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 866| 0| e->back_alloc = alloc; 867| 0| e->back_refs[0] = e->back_ref1; 868| 0| e->back_refs[1] = backref; 869| 0| } 870| 0| else { 871| 0| if (e->back_num > e->back_alloc) { ------------------ | Branch (871:11): [True: 0, False: 0] ------------------ 872| 0| int* p; 873| 0| alloc = e->back_alloc * 2; 874| 0| p = (int* )xrealloc(e->back_refs, sizeof(int) * alloc); ------------------ | | 143| 0|# define xrealloc realloc ------------------ 875| 0| CHECK_NULL_RETURN_MEMERR(p); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 876| 0| e->back_refs = p; 877| 0| e->back_alloc = alloc; 878| 0| } 879| 0| e->back_refs[e->back_num - 1] = backref; 880| 0| } 881| 0| } 882| | 883| 8.16k| return 0; 884| 8.16k|} regparse.c:strdup_with_null: 271| 8.16k|{ 272| 8.16k| ptrdiff_t slen; 273| 8.16k| int term_len, i; 274| 8.16k| UChar *r; ------------------ | | 76| 8.16k|# define UChar OnigUChar ------------------ 275| | 276| 8.16k| slen = end - s; 277| 8.16k| term_len = ONIGENC_MBC_MINLEN(enc); ------------------ | | 367| 8.16k|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ 278| | 279| 8.16k| r = (UChar* )xmalloc(slen + term_len); ------------------ | | 142| 8.16k|# define xmalloc malloc ------------------ 280| 8.16k| CHECK_NULL_RETURN(r); ------------------ | | 313| 8.16k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ ------------------ 281| 8.16k| xmemcpy(r, s, slen); ------------------ | | 215| 8.16k|#define xmemcpy memcpy ------------------ 282| | 283| 16.3k| for (i = 0; i < term_len; i++) ------------------ | Branch (283:15): [True: 8.16k, False: 8.16k] ------------------ 284| 8.16k| r[slen + i] = (UChar )0; 285| | 286| 8.16k| return r; 287| 8.16k|} regparse.c:node_new_cclass: 1141| 6.12k|{ 1142| 6.12k| Node* node = node_new(); 1143| 6.12k| CHECK_NULL_RETURN(node); ------------------ | | 313| 6.12k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ ------------------ 1144| | 1145| 6.12k| SET_NTYPE(node, NT_CCLASS); ------------------ | | 71| 6.12k| do { \ | | 72| 6.12k| int value = ntype; \ | | 73| 6.12k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 6.12k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1146| 6.12k| initialize_cclass(NCCLASS(node)); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 1147| 6.12k| return node; 1148| 6.12k|} regparse.c:initialize_cclass: 1132| 6.12k|{ 1133| 6.12k| BITSET_CLEAR(cc->bs); ------------------ | | 440| 6.12k|#define BITSET_CLEAR(bs) do {\ | | 441| 6.12k| int i;\ | | 442| 55.1k| for (i = 0; i < BITSET_SIZE; i++) { (bs)[i] = 0; } \ | | ------------------ | | | | 428| 55.1k|#define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 426| 55.1k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 55.1k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 427| 55.1k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 55.1k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (442:15): [True: 48.9k, False: 6.12k] | | ------------------ | | 443| 6.12k|} while (0) | | ------------------ | | | Branch (443:10): [Folded - Ignored] | | ------------------ ------------------ 1134| | /* cc->base.flags = 0; */ 1135| 6.12k| cc->flags = 0; 1136| 6.12k| cc->mbuf = NULL; 1137| 6.12k|} regparse.c:parse_char_class: 4562| 6.12k|{ 4563| 6.12k| int r, neg, len, fetched, and_start; 4564| 6.12k| OnigCodePoint v, vs; 4565| 6.12k| UChar *p; ------------------ | | 76| 6.12k|# define UChar OnigUChar ------------------ 4566| 6.12k| Node* node; 4567| 6.12k| Node* asc_node; 4568| 6.12k| CClassNode *cc, *prev_cc; 4569| 6.12k| CClassNode *asc_cc, *asc_prev_cc; 4570| 6.12k| CClassNode work_cc, asc_work_cc; 4571| | 4572| 6.12k| enum CCSTATE state; 4573| 6.12k| enum CCVALTYPE val_type, in_type; 4574| 6.12k| int val_israw, in_israw; 4575| | 4576| 6.12k| *np = *asc_np = NULL_NODE; ------------------ | | 283| 6.12k|#define NULL_NODE ((Node* )0) ------------------ 4577| 6.12k| env->parse_depth++; 4578| 6.12k| if (env->parse_depth > ParseDepthLimit) ------------------ | Branch (4578:7): [True: 0, False: 6.12k] ------------------ 4579| 0| return ONIGERR_PARSE_DEPTH_LIMIT_OVER; ------------------ | | 639| 0|#define ONIGERR_PARSE_DEPTH_LIMIT_OVER -16 ------------------ 4580| 6.12k| prev_cc = asc_prev_cc = (CClassNode* )NULL; 4581| 6.12k| r = fetch_token_in_cc(tok, src, end, env); 4582| 6.12k| if (r == TK_CHAR && tok->u.c == '^' && tok->escaped == 0) { ------------------ | Branch (4582:7): [True: 6.12k, False: 0] | Branch (4582:23): [True: 6.12k, False: 0] | Branch (4582:42): [True: 6.12k, False: 0] ------------------ 4583| 6.12k| neg = 1; 4584| 6.12k| r = fetch_token_in_cc(tok, src, end, env); 4585| 6.12k| } 4586| 0| else { 4587| 0| neg = 0; 4588| 0| } 4589| | 4590| 6.12k| if (r < 0) return r; ------------------ | Branch (4590:7): [True: 0, False: 6.12k] ------------------ 4591| 6.12k| if (r == TK_CC_CLOSE) { ------------------ | Branch (4591:7): [True: 0, False: 6.12k] ------------------ 4592| 0| if (! code_exist_check((OnigCodePoint )']', ------------------ | Branch (4592:9): [True: 0, False: 0] ------------------ 4593| 0| *src, env->pattern_end, 1, env)) 4594| 0| return ONIGERR_EMPTY_CHAR_CLASS; ------------------ | | 647| 0|#define ONIGERR_EMPTY_CHAR_CLASS -102 ------------------ 4595| | 4596| 0| CC_ESC_WARN(env, (UChar* )"]"); 4597| 0| r = tok->type = TK_CHAR; /* allow []...] */ 4598| 0| } 4599| | 4600| 6.12k| *np = node = node_new_cclass(); 4601| 6.12k| CHECK_NULL_RETURN_MEMERR(node); ------------------ | | 314| 6.12k|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 6.12k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4602| 6.12k| cc = NCCLASS(node); ------------------ | | 77| 6.12k|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 4603| | 4604| 6.12k| if (IS_IGNORECASE(env->option)) { ------------------ | | 396| 6.12k|#define IS_IGNORECASE(option) ((option) & ONIG_OPTION_IGNORECASE) | | ------------------ | | | | 454| 6.12k|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ | | | Branch (396:35): [True: 0, False: 6.12k] | | ------------------ ------------------ 4605| 0| *asc_np = asc_node = node_new_cclass(); 4606| 0| CHECK_NULL_RETURN_MEMERR(asc_node); ------------------ | | 314| 0|#define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define CHECK_NULL_RETURN_MEMERR(p) if (IS_NULL(p)) return ONIGERR_MEMORY | | ------------------ | | | | 632| 0|#define ONIGERR_MEMORY -5 | | ------------------ ------------------ 4607| 0| asc_cc = NCCLASS(asc_node); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 4608| 0| } 4609| 6.12k| else { 4610| 6.12k| asc_node = NULL_NODE; ------------------ | | 283| 6.12k|#define NULL_NODE ((Node* )0) ------------------ 4611| 6.12k| asc_cc = NULL; 4612| 6.12k| } 4613| | 4614| 6.12k| and_start = 0; 4615| 6.12k| state = CCS_START; 4616| 6.12k| p = *src; 4617| 12.2k| while (r != TK_CC_CLOSE) { ------------------ | Branch (4617:10): [True: 6.12k, False: 6.12k] ------------------ 4618| 6.12k| fetched = 0; 4619| 6.12k| switch (r) { 4620| 6.12k| case TK_CHAR: ------------------ | Branch (4620:5): [True: 6.12k, False: 0] ------------------ 4621| 6.12k| if ((tok->u.code >= SINGLE_BYTE_SIZE) || ------------------ | | 426| 6.12k|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | ------------------ ------------------ | Branch (4621:11): [True: 0, False: 6.12k] ------------------ 4622| 6.12k| (len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c)) > 1) { ------------------ | | 370| 6.12k|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code,enc) ------------------ | Branch (4622:4): [True: 0, False: 6.12k] ------------------ 4623| 0| in_type = CCV_CODE_POINT; 4624| 0| } 4625| 6.12k| else if (len < 0) { ------------------ | Branch (4625:16): [True: 0, False: 6.12k] ------------------ 4626| 0| r = len; 4627| 0| goto err; 4628| 0| } 4629| 6.12k| else { 4630| 6.12k| sb_char: 4631| 6.12k| in_type = CCV_SB; 4632| 6.12k| } 4633| 6.12k| v = (OnigCodePoint )tok->u.c; 4634| 6.12k| in_israw = 0; 4635| 6.12k| goto val_entry2; 4636| 0| break; 4637| | 4638| 0| case TK_RAW_BYTE: ------------------ | Branch (4638:5): [True: 0, False: 6.12k] ------------------ 4639| | /* tok->base != 0 : octal or hexadec. */ 4640| 0| if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base != 0) { ------------------ | | 318| 0|#define ONIGENC_IS_SINGLEBYTE(enc) (ONIGENC_MBC_MAXLEN(enc) == 1) | | ------------------ | | | | 365| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) | | ------------------ ------------------ | Branch (4640:11): [True: 0, False: 0] | Branch (4640:48): [True: 0, False: 0] ------------------ 4641| 0| UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN]; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 4642| 0| UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN; ------------------ | | 289| 0|#define ONIGENC_CODE_TO_MBC_MAXLEN 7 ------------------ 4643| 0| UChar* psave = p; ------------------ | | 76| 0|# define UChar OnigUChar ------------------ 4644| 0| int i, base = tok->base; 4645| | 4646| 0| buf[0] = (UChar )tok->u.c; 4647| 0| for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) { ------------------ | | 365| 0|#define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) ------------------ | Branch (4647:14): [True: 0, False: 0] ------------------ 4648| 0| r = fetch_token_in_cc(tok, &p, end, env); 4649| 0| if (r < 0) goto err; ------------------ | Branch (4649:8): [True: 0, False: 0] ------------------ 4650| 0| if (r != TK_RAW_BYTE || tok->base != base) { ------------------ | Branch (4650:8): [True: 0, False: 0] | Branch (4650:28): [True: 0, False: 0] ------------------ 4651| 0| fetched = 1; 4652| 0| break; 4653| 0| } 4654| 0| buf[i] = (UChar )tok->u.c; 4655| 0| } 4656| | 4657| 0| if (i < ONIGENC_MBC_MINLEN(env->enc)) { ------------------ | | 367| 0|#define ONIGENC_MBC_MINLEN(enc) ((enc)->min_enc_len) ------------------ | Branch (4657:6): [True: 0, False: 0] ------------------ 4658| 0| r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 675| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 4659| 0| goto err; 4660| 0| } 4661| | 4662| 0| if (env->enc == ONIG_ENCODING_EUC_JP || ------------------ | | 247| 0|# define ONIG_ENCODING_EUC_JP (&OnigEncodingEUC_JP) ------------------ | Branch (4662:6): [True: 0, False: 0] ------------------ 4663| 0| env->enc == ONIG_ENCODING_SJIS) { ------------------ | | 266| 0|# define ONIG_ENCODING_SJIS ONIG_ENCODING_SHIFT_JIS | | ------------------ | | | | 251| 0|# define ONIG_ENCODING_SHIFT_JIS (&OnigEncodingShift_JIS) | | ------------------ ------------------ | Branch (4663:3): [True: 0, False: 0] ------------------ 4664| | /* Strict version of enclen does not handle invalid single code 4665| | * point for SJIS and EUC-JP...*/ 4666| 0| len = enclen_approximate(env->enc, buf, buf + i); ------------------ | | 94| 0|#define enclen_approximate(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN_APPROX(enc,p,e)) | | ------------------ | | | | 363| 0|#define ONIGENC_MBC_ENC_LEN_APPROX(enc,p,e) onigenc_mbclen_approximate(p,e,enc) | | ------------------ | | | Branch (94:38): [True: 0, False: 0] | | ------------------ ------------------ 4667| 0| } 4668| 0| else { 4669| 0| len = enclen(env->enc, buf, buf + i); ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ 4670| 0| } 4671| 0| if (i < len) { ------------------ | Branch (4671:6): [True: 0, False: 0] ------------------ 4672| 0| r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING; ------------------ | | 675| 0|#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING -206 ------------------ 4673| 0| goto err; 4674| 0| } 4675| 0| else if (i > len) { /* fetch back */ ------------------ | Branch (4675:11): [True: 0, False: 0] ------------------ 4676| 0| p = psave; 4677| 0| for (i = 1; i < len; i++) { ------------------ | Branch (4677:16): [True: 0, False: 0] ------------------ 4678| 0| (void)fetch_token_in_cc(tok, &p, end, env); 4679| | /* no need to check the retun value (already checked above) */ 4680| 0| } 4681| 0| fetched = 0; 4682| 0| } 4683| | 4684| 0| if (i == 1) { ------------------ | Branch (4684:6): [True: 0, False: 0] ------------------ 4685| 0| v = (OnigCodePoint )buf[0]; 4686| 0| goto raw_single; 4687| 0| } 4688| 0| else { 4689| 0| v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe); ------------------ | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) ------------------ 4690| 0| in_type = CCV_CODE_POINT; 4691| 0| } 4692| 0| } 4693| 0| else { 4694| 0| v = (OnigCodePoint )tok->u.c; 4695| 0| raw_single: 4696| 0| in_type = CCV_SB; 4697| 0| } 4698| 0| in_israw = 1; 4699| 0| goto val_entry2; 4700| 0| break; 4701| | 4702| 0| case TK_CODE_POINT: ------------------ | Branch (4702:5): [True: 0, False: 6.12k] ------------------ 4703| 0| v = tok->u.code; 4704| 0| in_israw = 1; 4705| 0| val_entry: 4706| 0| len = ONIGENC_CODE_TO_MBCLEN(env->enc, v); ------------------ | | 370| 0|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code,enc) ------------------ 4707| 0| if (len < 0) { ------------------ | Branch (4707:11): [True: 0, False: 0] ------------------ 4708| 0| r = len; 4709| 0| goto err; 4710| 0| } 4711| 0| in_type = (len == 1 ? CCV_SB : CCV_CODE_POINT); ------------------ | Branch (4711:18): [True: 0, False: 0] ------------------ 4712| 6.12k| val_entry2: 4713| 6.12k| r = next_state_val(cc, asc_cc, &vs, v, &val_israw, in_israw, in_type, &val_type, 4714| 6.12k| &state, env); 4715| 6.12k| if (r != 0) goto err; ------------------ | Branch (4715:11): [True: 0, False: 6.12k] ------------------ 4716| 6.12k| break; 4717| | 4718| 6.12k| case TK_POSIX_BRACKET_OPEN: ------------------ | Branch (4718:5): [True: 0, False: 6.12k] ------------------ 4719| 0| r = parse_posix_bracket(cc, asc_cc, &p, end, env); 4720| 0| if (r < 0) goto err; ------------------ | Branch (4720:11): [True: 0, False: 0] ------------------ 4721| 0| if (r == 1) { /* is not POSIX bracket */ ------------------ | Branch (4721:11): [True: 0, False: 0] ------------------ 4722| 0| CC_ESC_WARN(env, (UChar* )"["); 4723| 0| p = tok->backp; 4724| 0| v = (OnigCodePoint )tok->u.c; 4725| 0| in_israw = 0; 4726| 0| goto val_entry; 4727| 0| } 4728| 0| goto next_class; 4729| 0| break; 4730| | 4731| 0| case TK_CHAR_TYPE: ------------------ | Branch (4731:5): [True: 0, False: 6.12k] ------------------ 4732| 0| r = add_ctype_to_cc(cc, tok->u.prop.ctype, tok->u.prop.not, 4733| 0| IS_ASCII_RANGE(env->option), env); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4734| 0| if (r != 0) return r; ------------------ | Branch (4734:11): [True: 0, False: 0] ------------------ 4735| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4736| 0| if (tok->u.prop.ctype != ONIGENC_CTYPE_WORD) ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ | Branch (4736:6): [True: 0, False: 0] ------------------ 4737| 0| r = add_ctype_to_cc(asc_cc, tok->u.prop.ctype, tok->u.prop.not, 4738| 0| IS_ASCII_RANGE(env->option), env); ------------------ | | 406| 0|#define IS_ASCII_RANGE(option) ((option) & ONIG_OPTION_ASCII_RANGE) | | ------------------ | | | | 470| 0|#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_NOTEOS << 1) | | | | ------------------ | | | | | | 468| 0|#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) | | | | | | ------------------ | | | | | | | | 467| 0|#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NOTEOL << 1) | | | | | | | | ------------------ | | | | | | | | | | 466| 0|#define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) | | | | | | | | | | ------------------ | | | | | | | | | | | | 465| 0|#define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 463| 0|#define ONIG_OPTION_CAPTURE_GROUP (ONIG_OPTION_DONT_CAPTURE_GROUP << 1) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 462| 0|#define ONIG_OPTION_DONT_CAPTURE_GROUP (ONIG_OPTION_NEGATE_SINGLELINE << 1) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 461| 0|#define ONIG_OPTION_NEGATE_SINGLELINE (ONIG_OPTION_FIND_NOT_EMPTY << 1) | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | 460| 0|#define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | 459| 0|#define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | 458| 0|#define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4739| 0| if (r != 0) return r; ------------------ | Branch (4739:6): [True: 0, False: 0] ------------------ 4740| 0| } 4741| | 4742| 0| next_class: 4743| 0| r = next_state_class(cc, asc_cc, &vs, &val_type, &state, env); 4744| 0| if (r != 0) goto err; ------------------ | Branch (4744:11): [True: 0, False: 0] ------------------ 4745| 0| break; 4746| | 4747| 0| case TK_CHAR_PROPERTY: ------------------ | Branch (4747:5): [True: 0, False: 6.12k] ------------------ 4748| 0| { 4749| 0| int ctype; 4750| | 4751| 0| ctype = fetch_char_property_to_ctype(&p, end, env); 4752| 0| if (ctype < 0) return ctype; ------------------ | Branch (4752:6): [True: 0, False: 0] ------------------ 4753| 0| r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, 0, env); 4754| 0| if (r != 0) return r; ------------------ | Branch (4754:6): [True: 0, False: 0] ------------------ 4755| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4756| 0| if (ctype != ONIGENC_CTYPE_ASCII) ------------------ | | 308| 0|#define ONIGENC_CTYPE_ASCII 14 ------------------ | Branch (4756:8): [True: 0, False: 0] ------------------ 4757| 0| r = add_ctype_to_cc(asc_cc, ctype, tok->u.prop.not, 0, env); 4758| 0| if (r != 0) return r; ------------------ | Branch (4758:8): [True: 0, False: 0] ------------------ 4759| 0| } 4760| 0| goto next_class; 4761| 0| } 4762| 0| break; 4763| | 4764| 0| case TK_CC_RANGE: ------------------ | Branch (4764:5): [True: 0, False: 6.12k] ------------------ 4765| 0| if (state == CCS_VALUE) { ------------------ | Branch (4765:11): [True: 0, False: 0] ------------------ 4766| 0| r = fetch_token_in_cc(tok, &p, end, env); 4767| 0| if (r < 0) goto err; ------------------ | Branch (4767:6): [True: 0, False: 0] ------------------ 4768| 0| fetched = 1; 4769| 0| if (r == TK_CC_CLOSE) { /* allow [x-] */ ------------------ | Branch (4769:6): [True: 0, False: 0] ------------------ 4770| 0| range_end_val: 4771| 0| v = (OnigCodePoint )'-'; 4772| 0| in_israw = 0; 4773| 0| goto val_entry; 4774| 0| } 4775| 0| else if (r == TK_CC_AND) { ------------------ | Branch (4775:11): [True: 0, False: 0] ------------------ 4776| 0| CC_ESC_WARN(env, (UChar* )"-"); 4777| 0| goto range_end_val; 4778| 0| } 4779| | 4780| 0| if (val_type == CCV_CLASS) { ------------------ | Branch (4780:6): [True: 0, False: 0] ------------------ 4781| 0| r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS; ------------------ | | 656| 0|#define ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS -112 ------------------ 4782| 0| goto err; 4783| 0| } 4784| | 4785| 0| state = CCS_RANGE; 4786| 0| } 4787| 0| else if (state == CCS_START) { ------------------ | Branch (4787:16): [True: 0, False: 0] ------------------ 4788| | /* [-xa] is allowed */ 4789| 0| v = (OnigCodePoint )tok->u.c; 4790| 0| in_israw = 0; 4791| | 4792| 0| r = fetch_token_in_cc(tok, &p, end, env); 4793| 0| if (r < 0) goto err; ------------------ | Branch (4793:6): [True: 0, False: 0] ------------------ 4794| 0| fetched = 1; 4795| | /* [--x] or [a&&-x] is warned. */ 4796| 0| if (r == TK_CC_RANGE || and_start != 0) ------------------ | Branch (4796:6): [True: 0, False: 0] | Branch (4796:26): [True: 0, False: 0] ------------------ 4797| 0| CC_ESC_WARN(env, (UChar* )"-"); 4798| | 4799| 0| goto val_entry; 4800| 0| } 4801| 0| else if (state == CCS_RANGE) { ------------------ | Branch (4801:16): [True: 0, False: 0] ------------------ 4802| 0| CC_ESC_WARN(env, (UChar* )"-"); 4803| 0| goto sb_char; /* [!--x] is allowed */ 4804| 0| } 4805| 0| else { /* CCS_COMPLETE */ 4806| 0| r = fetch_token_in_cc(tok, &p, end, env); 4807| 0| if (r < 0) goto err; ------------------ | Branch (4807:6): [True: 0, False: 0] ------------------ 4808| 0| fetched = 1; 4809| 0| if (r == TK_CC_CLOSE) goto range_end_val; /* allow [a-b-] */ ------------------ | Branch (4809:6): [True: 0, False: 0] ------------------ 4810| 0| else if (r == TK_CC_AND) { ------------------ | Branch (4810:11): [True: 0, False: 0] ------------------ 4811| 0| CC_ESC_WARN(env, (UChar* )"-"); 4812| 0| goto range_end_val; 4813| 0| } 4814| | 4815| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 4816| 0| CC_ESC_WARN(env, (UChar* )"-"); 4817| 0| goto range_end_val; /* [0-9-a] is allowed as [0-9\-a] */ 4818| 0| } 4819| 0| r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS; ------------------ | | 656| 0|#define ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS -112 ------------------ 4820| 0| goto err; 4821| 0| } 4822| 0| break; 4823| | 4824| 0| case TK_CC_CC_OPEN: /* [ */ ------------------ | Branch (4824:5): [True: 0, False: 6.12k] ------------------ 4825| 0| { 4826| 0| Node *anode, *aasc_node; 4827| 0| CClassNode* acc; 4828| | 4829| 0| r = parse_char_class(&anode, &aasc_node, tok, &p, end, env); 4830| 0| if (r == 0) { ------------------ | Branch (4830:6): [True: 0, False: 0] ------------------ 4831| 0| acc = NCCLASS(anode); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 4832| 0| r = or_cclass(cc, acc, env); 4833| 0| } 4834| 0| if (r == 0 && IS_NOT_NULL(aasc_node)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ | Branch (4834:6): [True: 0, False: 0] ------------------ 4835| 0| acc = NCCLASS(aasc_node); ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ 4836| 0| r = or_cclass(asc_cc, acc, env); 4837| 0| } 4838| 0| onig_node_free(anode); 4839| 0| onig_node_free(aasc_node); 4840| 0| if (r != 0) goto err; ------------------ | Branch (4840:6): [True: 0, False: 0] ------------------ 4841| 0| } 4842| 0| break; 4843| | 4844| 0| case TK_CC_AND: /* && */ ------------------ | Branch (4844:5): [True: 0, False: 6.12k] ------------------ 4845| 0| { 4846| 0| if (state == CCS_VALUE) { ------------------ | Branch (4846:6): [True: 0, False: 0] ------------------ 4847| 0| r = next_state_val(cc, asc_cc, &vs, 0, &val_israw, 0, val_type, 4848| 0| &val_type, &state, env); 4849| 0| if (r != 0) goto err; ------------------ | Branch (4849:8): [True: 0, False: 0] ------------------ 4850| 0| } 4851| | /* initialize local variables */ 4852| 0| and_start = 1; 4853| 0| state = CCS_START; 4854| | 4855| 0| if (IS_NOT_NULL(prev_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4856| 0| r = and_cclass(prev_cc, cc, env); 4857| 0| if (r != 0) goto err; ------------------ | Branch (4857:8): [True: 0, False: 0] ------------------ 4858| 0| bbuf_free(cc->mbuf); 4859| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4860| 0| r = and_cclass(asc_prev_cc, asc_cc, env); 4861| 0| if (r != 0) goto err; ------------------ | Branch (4861:10): [True: 0, False: 0] ------------------ 4862| 0| bbuf_free(asc_cc->mbuf); 4863| 0| } 4864| 0| } 4865| 0| else { 4866| 0| prev_cc = cc; 4867| 0| cc = &work_cc; 4868| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4869| 0| asc_prev_cc = asc_cc; 4870| 0| asc_cc = &asc_work_cc; 4871| 0| } 4872| 0| } 4873| 0| initialize_cclass(cc); 4874| 0| if (IS_NOT_NULL(asc_cc)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4875| 0| initialize_cclass(asc_cc); 4876| 0| } 4877| 0| break; 4878| | 4879| 0| case TK_EOT: ------------------ | Branch (4879:5): [True: 0, False: 6.12k] ------------------ 4880| 0| r = ONIGERR_PREMATURE_END_OF_CHAR_CLASS; ------------------ | | 648| 0|#define ONIGERR_PREMATURE_END_OF_CHAR_CLASS -103 ------------------ 4881| 0| goto err; 4882| 0| break; 4883| 0| default: ------------------ | Branch (4883:5): [True: 0, False: 6.12k] ------------------ 4884| 0| r = ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 4885| 0| goto err; 4886| 0| break; 4887| 6.12k| } 4888| | 4889| 6.12k| if (fetched) ------------------ | Branch (4889:9): [True: 0, False: 6.12k] ------------------ 4890| 0| r = tok->type; 4891| 6.12k| else { 4892| 6.12k| r = fetch_token_in_cc(tok, &p, end, env); 4893| 6.12k| if (r < 0) goto err; ------------------ | Branch (4893:11): [True: 0, False: 6.12k] ------------------ 4894| 6.12k| } 4895| 6.12k| } 4896| | 4897| 6.12k| if (state == CCS_VALUE) { ------------------ | Branch (4897:7): [True: 6.12k, False: 0] ------------------ 4898| 6.12k| r = next_state_val(cc, asc_cc, &vs, 0, &val_israw, 0, val_type, 4899| 6.12k| &val_type, &state, env); 4900| 6.12k| if (r != 0) goto err; ------------------ | Branch (4900:9): [True: 0, False: 6.12k] ------------------ 4901| 6.12k| } 4902| | 4903| 6.12k| if (IS_NOT_NULL(prev_cc)) { ------------------ | | 312| 6.12k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 6.12k] | | ------------------ ------------------ 4904| 0| r = and_cclass(prev_cc, cc, env); 4905| 0| if (r != 0) goto err; ------------------ | Branch (4905:9): [True: 0, False: 0] ------------------ 4906| 0| bbuf_free(cc->mbuf); 4907| 0| cc = prev_cc; 4908| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4909| 0| r = and_cclass(asc_prev_cc, asc_cc, env); 4910| 0| if (r != 0) goto err; ------------------ | Branch (4910:11): [True: 0, False: 0] ------------------ 4911| 0| bbuf_free(asc_cc->mbuf); 4912| 0| asc_cc = asc_prev_cc; 4913| 0| } 4914| 0| } 4915| | 4916| 6.12k| if (neg != 0) { ------------------ | Branch (4916:7): [True: 6.12k, False: 0] ------------------ 4917| 6.12k| NCCLASS_SET_NOT(cc); ------------------ | | 807| 6.12k|#define NCCLASS_SET_NOT(nd) NCCLASS_FLAG_SET(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 800| 6.12k|#define NCCLASS_FLAG_SET(cc,flag) (NCCLASS_FLAGS(cc) |= (flag)) | | | | ------------------ | | | | | | 799| 6.12k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 4918| 6.12k| if (IS_NOT_NULL(asc_cc)) ------------------ | | 312| 6.12k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 6.12k] | | ------------------ ------------------ 4919| 6.12k| NCCLASS_SET_NOT(asc_cc); ------------------ | | 807| 0|#define NCCLASS_SET_NOT(nd) NCCLASS_FLAG_SET(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 800| 0|#define NCCLASS_FLAG_SET(cc,flag) (NCCLASS_FLAGS(cc) |= (flag)) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 4920| 6.12k| } 4921| 0| else { 4922| 0| NCCLASS_CLEAR_NOT(cc); ------------------ | | 808| 0|#define NCCLASS_CLEAR_NOT(nd) NCCLASS_FLAG_CLEAR(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 801| 0|#define NCCLASS_FLAG_CLEAR(cc,flag) (NCCLASS_FLAGS(cc) &= ~(flag)) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 4923| 0| if (IS_NOT_NULL(asc_cc)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4924| 0| NCCLASS_CLEAR_NOT(asc_cc); ------------------ | | 808| 0|#define NCCLASS_CLEAR_NOT(nd) NCCLASS_FLAG_CLEAR(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 801| 0|#define NCCLASS_FLAG_CLEAR(cc,flag) (NCCLASS_FLAGS(cc) &= ~(flag)) | | | | ------------------ | | | | | | 799| 0|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | ------------------ ------------------ 4925| 0| } 4926| 6.12k| if (IS_NCCLASS_NOT(cc) && ------------------ | | 809| 6.12k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 12.2k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 6.12k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 6.12k, False: 0] | | | | ------------------ | | ------------------ ------------------ 4927| 6.12k| IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) { ------------------ | | 332| 6.12k|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 6.12k] | | ------------------ ------------------ 4928| 0| int is_empty; 4929| | 4930| 0| is_empty = (IS_NULL(cc->mbuf) ? 1 : 0); ------------------ | | 311| 0|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | ------------------ | | | Branch (311:39): [True: 0, False: 0] | | ------------------ ------------------ 4931| 0| if (is_empty != 0) ------------------ | Branch (4931:9): [True: 0, False: 0] ------------------ 4932| 0| BITSET_IS_EMPTY(cc->bs, is_empty); ------------------ | | 181| 0|#define BITSET_IS_EMPTY(bs,empty) do {\ | | 182| 0| int i;\ | | 183| 0| empty = 1;\ | | 184| 0| for (i = 0; i < BITSET_SIZE; i++) {\ | | ------------------ | | | | 428| 0|#define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (184:15): [True: 0, False: 0] | | ------------------ | | 185| 0| if ((bs)[i] != 0) {\ | | ------------------ | | | Branch (185:9): [True: 0, False: 0] | | ------------------ | | 186| 0| empty = 0; break;\ | | 187| 0| }\ | | 188| 0| }\ | | 189| 0|} while (0) | | ------------------ | | | Branch (189:10): [Folded - Ignored] | | ------------------ ------------------ 4933| | 4934| 0| if (is_empty == 0) { ------------------ | Branch (4934:9): [True: 0, False: 0] ------------------ 4935| 0|#define NEWLINE_CODE 0x0a 4936| | 4937| 0| if (ONIGENC_IS_CODE_NEWLINE(env->enc, NEWLINE_CODE)) { ------------------ | | 378| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_NEWLINE) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 4938| 0| if (ONIGENC_CODE_TO_MBCLEN(env->enc, NEWLINE_CODE) == 1) ------------------ | | 370| 0|#define ONIGENC_CODE_TO_MBCLEN(enc,code) (enc)->code_to_mbclen(code,enc) ------------------ | Branch (4938:6): [True: 0, False: 0] ------------------ 4939| 0| BITSET_SET_BIT_CHKDUP(cc->bs, NEWLINE_CODE); ------------------ | | 176| 0|#define BITSET_SET_BIT_CHKDUP(bs, pos) do { \ | | 177| 0| if (BITSET_AT(bs, pos)) CC_DUP_WARN(env, pos, pos); \ | | ------------------ | | | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | | | ------------------ | | | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | | | ------------------ | | | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | | | ------------------ | | | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | | | ------------------ | | | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | | | ------------------ | | | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | | | ------------------ | | | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (448:36): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 178| 0| BS_ROOM(bs, pos) |= BS_BIT(pos); \ | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | BS_ROOM(bs, pos) |= BS_BIT(pos); \ | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 179| 0|} while (0) | | ------------------ | | | Branch (179:10): [Folded - Ignored] | | ------------------ ------------------ 4940| 0| else { 4941| 0| r = add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE); ------------------ | | 4935| 0|#define NEWLINE_CODE 0x0a ------------------ r = add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE); ------------------ | | 4935| 0|#define NEWLINE_CODE 0x0a ------------------ 4942| 0| if (r < 0) goto err; ------------------ | Branch (4942:8): [True: 0, False: 0] ------------------ 4943| 0| } 4944| 0| } 4945| 0| } 4946| 0| } 4947| 6.12k| *src = p; 4948| 6.12k| env->parse_depth--; 4949| 6.12k| return 0; 4950| | 4951| 0| err: 4952| 0| if (cc != NCCLASS(*np)) ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ | Branch (4952:7): [True: 0, False: 0] ------------------ 4953| 0| bbuf_free(cc->mbuf); 4954| 0| if (IS_NOT_NULL(asc_cc) && (asc_cc != NCCLASS(*asc_np))) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ if (IS_NOT_NULL(asc_cc) && (asc_cc != NCCLASS(*asc_np))) ------------------ | | 77| 0|#define NCCLASS(node) (&((node)->u.cclass)) ------------------ | Branch (4954:30): [True: 0, False: 0] ------------------ 4955| 0| bbuf_free(asc_cc->mbuf); 4956| 0| return r; 4957| 6.12k|} regparse.c:fetch_token_in_cc: 2980| 18.3k|{ 2981| 18.3k| int num; 2982| 18.3k| OnigCodePoint c, c2; 2983| 18.3k| const OnigSyntaxType* syn = env->syntax; 2984| 18.3k| OnigEncoding enc = env->enc; 2985| 18.3k| UChar* prev; ------------------ | | 76| 18.3k|# define UChar OnigUChar ------------------ 2986| 18.3k| UChar* p = *src; ------------------ | | 76| 18.3k|# define UChar OnigUChar ------------------ 2987| 18.3k| PFETCH_READY; ------------------ | | 295| 18.3k|# define PFETCH_READY UChar* pfetch_prev = NULL; (void)pfetch_prev | | ------------------ | | | | 76| 18.3k|# define UChar OnigUChar | | ------------------ ------------------ 2988| | 2989| 18.3k| if (PEND) { ------------------ | | 299| 18.3k|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 18.3k] | | | Branch (299:23): [True: 18.3k, False: 0] | | ------------------ ------------------ 2990| 0| tok->type = TK_EOT; 2991| 0| return tok->type; 2992| 0| } 2993| | 2994| 18.3k| PFETCH(c); ------------------ | | 305| 18.3k|#define PFETCH(c) do { \ | | 306| 18.3k| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 18.3k|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 18.3k] | | ------------------ | | 307| 18.3k| pfetch_prev = p; \ | | 308| 18.3k| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 18.3k|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 18.3k|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 18.3k] | | | | ------------------ | | ------------------ | | 309| 18.3k|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 2995| 18.3k| tok->type = TK_CHAR; 2996| 18.3k| tok->base = 0; 2997| 18.3k| tok->u.c = c; 2998| 18.3k| tok->escaped = 0; 2999| | 3000| 18.3k| if (c == ']') { ------------------ | Branch (3000:7): [True: 6.12k, False: 12.2k] ------------------ 3001| 6.12k| tok->type = TK_CC_CLOSE; 3002| 6.12k| } 3003| 12.2k| else if (c == '-') { ------------------ | Branch (3003:12): [True: 0, False: 12.2k] ------------------ 3004| 0| tok->type = TK_CC_RANGE; 3005| 0| } 3006| 12.2k| else if (c == MC_ESC(syn)) { ------------------ | | 761| 12.2k|#define MC_ESC(syn) (syn)->meta_char_table.esc ------------------ | Branch (3006:12): [True: 0, False: 12.2k] ------------------ 3007| 0| if (! IS_SYNTAX_BV(syn, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) ------------------ | Branch (3007:9): [True: 0, False: 0] ------------------ 3008| 0| goto end; 3009| | 3010| 0| if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE; ------------------ | | 649| 0|#define ONIGERR_END_PATTERN_AT_ESCAPE -104 ------------------ 3011| | 3012| 0| PFETCH(c); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3013| 0| tok->escaped = 1; 3014| 0| tok->u.c = c; 3015| 0| switch (c) { 3016| 0| case 'w': ------------------ | Branch (3016:5): [True: 0, False: 0] ------------------ 3017| 0| tok->type = TK_CHAR_TYPE; 3018| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ 3019| 0| tok->u.prop.not = 0; 3020| 0| break; 3021| 0| case 'W': ------------------ | Branch (3021:5): [True: 0, False: 0] ------------------ 3022| 0| tok->type = TK_CHAR_TYPE; 3023| 0| tok->u.prop.ctype = ONIGENC_CTYPE_WORD; ------------------ | | 306| 0|#define ONIGENC_CTYPE_WORD 12 ------------------ 3024| 0| tok->u.prop.not = 1; 3025| 0| break; 3026| 0| case 'd': ------------------ | Branch (3026:5): [True: 0, False: 0] ------------------ 3027| 0| tok->type = TK_CHAR_TYPE; 3028| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; ------------------ | | 298| 0|#define ONIGENC_CTYPE_DIGIT 4 ------------------ 3029| 0| tok->u.prop.not = 0; 3030| 0| break; 3031| 0| case 'D': ------------------ | Branch (3031:5): [True: 0, False: 0] ------------------ 3032| 0| tok->type = TK_CHAR_TYPE; 3033| 0| tok->u.prop.ctype = ONIGENC_CTYPE_DIGIT; ------------------ | | 298| 0|#define ONIGENC_CTYPE_DIGIT 4 ------------------ 3034| 0| tok->u.prop.not = 1; 3035| 0| break; 3036| 0| case 's': ------------------ | Branch (3036:5): [True: 0, False: 0] ------------------ 3037| 0| tok->type = TK_CHAR_TYPE; 3038| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; ------------------ | | 303| 0|#define ONIGENC_CTYPE_SPACE 9 ------------------ 3039| 0| tok->u.prop.not = 0; 3040| 0| break; 3041| 0| case 'S': ------------------ | Branch (3041:5): [True: 0, False: 0] ------------------ 3042| 0| tok->type = TK_CHAR_TYPE; 3043| 0| tok->u.prop.ctype = ONIGENC_CTYPE_SPACE; ------------------ | | 303| 0|#define ONIGENC_CTYPE_SPACE 9 ------------------ 3044| 0| tok->u.prop.not = 1; 3045| 0| break; 3046| 0| case 'h': ------------------ | Branch (3046:5): [True: 0, False: 0] ------------------ 3047| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3047:11): [True: 0, False: 0] ------------------ 3048| 0| tok->type = TK_CHAR_TYPE; 3049| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; ------------------ | | 305| 0|#define ONIGENC_CTYPE_XDIGIT 11 ------------------ 3050| 0| tok->u.prop.not = 0; 3051| 0| break; 3052| 0| case 'H': ------------------ | Branch (3052:5): [True: 0, False: 0] ------------------ 3053| 0| if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break; ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) ------------------ | Branch (3053:11): [True: 0, False: 0] ------------------ 3054| 0| tok->type = TK_CHAR_TYPE; 3055| 0| tok->u.prop.ctype = ONIGENC_CTYPE_XDIGIT; ------------------ | | 305| 0|#define ONIGENC_CTYPE_XDIGIT 11 ------------------ 3056| 0| tok->u.prop.not = 1; 3057| 0| break; 3058| | 3059| 0| case 'p': ------------------ | Branch (3059:5): [True: 0, False: 0] ------------------ 3060| 0| case 'P': ------------------ | Branch (3060:5): [True: 0, False: 0] ------------------ 3061| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3062| | 3063| 0| c2 = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3064| 0| if (c2 == '{' && ------------------ | Branch (3064:11): [True: 0, False: 0] ------------------ 3065| 0| IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3066| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3067| 0| tok->type = TK_CHAR_PROPERTY; 3068| 0| tok->u.prop.not = (c == 'P' ? 1 : 0); ------------------ | Branch (3068:21): [True: 0, False: 0] ------------------ 3069| | 3070| 0| if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (!PEND && IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3070:6): [True: 0, False: 0] ------------------ 3071| 0| PFETCH(c2); ------------------ | | 305| 0|#define PFETCH(c) do { \ | | 306| 0| c = ((enc->max_enc_len == 1) ? *p : ONIGENC_MBC_TO_CODE(enc, p, end)); \ | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | | Branch (306:8): [True: 0, False: 0] | | ------------------ | | 307| 0| pfetch_prev = p; \ | | 308| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 309| 0|} while (0) | | ------------------ | | | Branch (309:10): [Folded - Ignored] | | ------------------ ------------------ 3072| 0| if (c2 == '^') { ------------------ | Branch (3072:8): [True: 0, False: 0] ------------------ 3073| 0| tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0); ------------------ | Branch (3073:25): [True: 0, False: 0] ------------------ 3074| 0| } 3075| 0| else 3076| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3077| 0| } 3078| 0| } 3079| 0| else { 3080| 0| onig_syntax_warn(env, "invalid Unicode Property \\%c", c); 3081| 0| } 3082| 0| break; 3083| | 3084| 0| case 'x': ------------------ | Branch (3084:5): [True: 0, False: 0] ------------------ 3085| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3086| | 3087| 0| prev = p; 3088| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3089| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3090| 0| num = scan_unsigned_hexadecimal_number(&p, end, 0, 8, enc); 3091| 0| if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE; ------------------ | | 694| 0|#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 ------------------ | Branch (3091:6): [True: 0, False: 0] ------------------ 3092| 0| if (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3092:6): [True: 0, False: 0] ------------------ 3093| 0| c2 = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3094| 0| if (ONIGENC_IS_CODE_XDIGIT(enc, c2)) ------------------ | | 402| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_XDIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3095| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 681| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 3096| 0| } 3097| | 3098| 0| if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3098:6): [True: 0, False: 0] | Branch (3098:43): [True: 0, False: 0] | Branch (3098:52): [True: 0, False: 0] ------------------ 3099| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3100| 0| tok->type = TK_CODE_POINT; 3101| 0| tok->base = 16; 3102| 0| tok->u.code = (OnigCodePoint )num; 3103| 0| } 3104| 0| else { 3105| | /* can't read nothing or invalid format */ 3106| 0| p = prev; 3107| 0| } 3108| 0| } 3109| 0| else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3110| 0| num = scan_unsigned_hexadecimal_number(&p, end, 0, 2, enc); 3111| 0| if (num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3111:6): [True: 0, False: 0] ------------------ 3112| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3112:6): [True: 0, False: 0] ------------------ 3113| 0| num = 0; /* but, it's not error */ 3114| 0| } 3115| 0| tok->type = TK_RAW_BYTE; 3116| 0| tok->base = 16; 3117| 0| tok->u.c = num; 3118| 0| } 3119| 0| break; 3120| | 3121| 0| case 'u': ------------------ | Branch (3121:5): [True: 0, False: 0] ------------------ 3122| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3123| | 3124| 0| prev = p; 3125| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3126| 0| num = scan_unsigned_hexadecimal_number(&p, end, 4, 4, enc); 3127| 0| if (num < -1) return ONIGERR_TOO_SHORT_DIGITS; ------------------ | | 680| 0|#define ONIGERR_TOO_SHORT_DIGITS -211 ------------------ | Branch (3127:6): [True: 0, False: 0] ------------------ 3128| 0| else if (num < 0) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3128:11): [True: 0, False: 0] ------------------ 3129| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3129:6): [True: 0, False: 0] ------------------ 3130| 0| num = 0; /* but, it's not error */ 3131| 0| } 3132| 0| tok->type = TK_CODE_POINT; 3133| 0| tok->base = 16; 3134| 0| tok->u.code = (OnigCodePoint )num; 3135| 0| } 3136| 0| break; 3137| | 3138| 0| case 'o': ------------------ | Branch (3138:5): [True: 0, False: 0] ------------------ 3139| 0| if (PEND) break; ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:22): [True: 0, False: 0] | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ 3140| | 3141| 0| prev = p; 3142| 0| if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (320:22): [True: 0, False: 0] | | ------------------ ------------------ if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_O_BRACE_OCTAL)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3143| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3144| 0| num = scan_unsigned_octal_number(&p, end, 11, enc); 3145| 0| if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE; ------------------ | | 694| 0|#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 ------------------ | Branch (3145:6): [True: 0, False: 0] ------------------ 3146| 0| if (!PEND) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3146:6): [True: 0, False: 0] ------------------ 3147| 0| c2 = PPEEK; ------------------ | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | ------------------ | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | ------------------ | | | | 291| 0|#define PEND_VALUE 0 | | ------------------ | | | Branch (319:23): [True: 0, False: 0] | | ------------------ ------------------ 3148| 0| if (ONIGENC_IS_CODE_DIGIT(enc, c2) && c2 < '8') ------------------ | | 400| 0| ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT) | | ------------------ | | | | 375| 0|#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype) (enc)->is_code_ctype(code,ctype,enc) | | | | ------------------ | | | | | Branch (375:48): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3148:42): [True: 0, False: 0] ------------------ 3149| 0| return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE; ------------------ | | 681| 0|#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 ------------------ 3150| 0| } 3151| | 3152| 0| if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | ------------------ | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | ------------------ | | | Branch (93:26): [True: 0, False: 0] | | ------------------ ------------------ if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3152:6): [True: 0, False: 0] | Branch (3152:43): [True: 0, False: 0] | Branch (3152:52): [True: 0, False: 0] ------------------ 3153| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3154| 0| tok->type = TK_CODE_POINT; 3155| 0| tok->base = 8; 3156| 0| tok->u.code = (OnigCodePoint )num; 3157| 0| } 3158| 0| else { 3159| | /* can't read nothing or invalid format */ 3160| 0| p = prev; 3161| 0| } 3162| 0| } 3163| 0| break; 3164| | 3165| 0| case '0': ------------------ | Branch (3165:5): [True: 0, False: 0] ------------------ 3166| 0| case '1': case '2': case '3': case '4': case '5': case '6': case '7': ------------------ | Branch (3166:5): [True: 0, False: 0] | Branch (3166:15): [True: 0, False: 0] | Branch (3166:25): [True: 0, False: 0] | Branch (3166:35): [True: 0, False: 0] | Branch (3166:45): [True: 0, False: 0] | Branch (3166:55): [True: 0, False: 0] | Branch (3166:65): [True: 0, False: 0] ------------------ 3167| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ 3168| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3169| 0| prev = p; 3170| 0| num = scan_unsigned_octal_number(&p, end, 3, enc); 3171| 0| if (num < 0 || 0xff < num) return ONIGERR_TOO_BIG_NUMBER; ------------------ | | 669| 0|#define ONIGERR_TOO_BIG_NUMBER -200 ------------------ | Branch (3171:6): [True: 0, False: 0] | Branch (3171:17): [True: 0, False: 0] ------------------ 3172| 0| if (p == prev) { /* can't read nothing. */ ------------------ | Branch (3172:6): [True: 0, False: 0] ------------------ 3173| 0| num = 0; /* but, it's not error */ 3174| 0| } 3175| 0| tok->type = TK_RAW_BYTE; 3176| 0| tok->base = 8; 3177| 0| tok->u.c = num; 3178| 0| } 3179| 0| break; 3180| | 3181| 0| default: ------------------ | Branch (3181:5): [True: 0, False: 0] ------------------ 3182| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3183| 0| num = fetch_escaped_value(&p, end, env, &c2); 3184| 0| if (num < 0) return num; ------------------ | Branch (3184:11): [True: 0, False: 0] ------------------ 3185| 0| if ((OnigCodePoint )tok->u.c != c2) { ------------------ | Branch (3185:11): [True: 0, False: 0] ------------------ 3186| 0| tok->u.code = (OnigCodePoint )c2; 3187| 0| tok->type = TK_CODE_POINT; 3188| 0| } 3189| 0| break; 3190| 0| } 3191| 0| } 3192| 12.2k| else if (c == '[') { ------------------ | Branch (3192:12): [True: 0, False: 12.2k] ------------------ 3193| 0| if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_POSIX_BRACKET) && (PPEEK_IS(':'))) { ------------------ | | 330| 0|#define IS_SYNTAX_OP(syn, opm) (((syn)->op & (opm)) != 0) | | ------------------ | | | Branch (330:35): [True: 0, False: 0] | | ------------------ ------------------ if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_POSIX_BRACKET) && (PPEEK_IS(':'))) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3193:57): [True: 0, False: 0] ------------------ 3194| 0| OnigCodePoint send[] = { (OnigCodePoint )':', (OnigCodePoint )']' }; 3195| 0| tok->backp = p; /* point at '[' is read */ 3196| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3197| 0| if (str_exist_check_with_esc(send, 2, p, end, ------------------ | Branch (3197:11): [True: 0, False: 0] ------------------ 3198| 0| (OnigCodePoint )']', enc, syn)) { 3199| 0| tok->type = TK_POSIX_BRACKET_OPEN; 3200| 0| } 3201| 0| else { 3202| 0| PUNFETCH; ------------------ | | 300| 0|#define PUNFETCH p = pfetch_prev ------------------ 3203| 0| goto cc_in_cc; 3204| 0| } 3205| 0| } 3206| 0| else { 3207| 0| cc_in_cc: 3208| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP)) { ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3209| 0| tok->type = TK_CC_CC_OPEN; 3210| 0| } 3211| 0| else { 3212| 0| CC_ESC_WARN(env, (UChar* )"["); 3213| 0| } 3214| 0| } 3215| 0| } 3216| 12.2k| else if (c == '&') { ------------------ | Branch (3216:12): [True: 0, False: 12.2k] ------------------ 3217| 0| if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP) && ------------------ | | 331| 0|#define IS_SYNTAX_OP2(syn, opm) (((syn)->op2 & (opm)) != 0) | | ------------------ | | | Branch (331:35): [True: 0, False: 0] | | ------------------ ------------------ 3218| 0| !PEND && (PPEEK_IS('&'))) { ------------------ | | 299| 0|#define PEND (p < end ? 0 : 1) | | ------------------ | | | Branch (299:23): [True: 0, False: 0] | | ------------------ ------------------ !PEND && (PPEEK_IS('&'))) { ------------------ | | 320| 0|#define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c) | | ------------------ | | | | 319| 0|#define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 369| 0|#define ONIGENC_MBC_TO_CODE(enc,p,end) (enc)->mbc_to_code((p),(end),enc) | | | | ------------------ | | | | #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE) | | | | ------------------ | | | | | | 291| 0|#define PEND_VALUE 0 | | | | ------------------ | | | | | Branch (319:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (3218:2): [True: 0, False: 0] | Branch (3218:11): [True: 0, False: 0] ------------------ 3219| 0| PINC; ------------------ | | 301| 0|#define PINC do { \ | | 302| 0| pfetch_prev = p; \ | | 303| 0| p += enclen(enc, p, end); \ | | ------------------ | | | | 93| 0|#define enclen(enc,p,e) ((enc->max_enc_len == enc->min_enc_len) ? enc->min_enc_len : ONIGENC_MBC_ENC_LEN(enc,p,e)) | | | | ------------------ | | | | | | 364| 0|#define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen(p,e,enc) | | | | ------------------ | | | | | Branch (93:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 304| 0|} while (0) | | ------------------ | | | Branch (304:10): [Folded - Ignored] | | ------------------ ------------------ 3220| 0| tok->type = TK_CC_AND; 3221| 0| } 3222| 0| } 3223| | 3224| 18.3k| end: 3225| 18.3k| *src = p; 3226| 18.3k| return tok->type; 3227| 18.3k|} regparse.c:next_state_val: 4456| 12.2k|{ 4457| 12.2k| int r; 4458| | 4459| 12.2k| switch (*state) { 4460| 6.12k| case CCS_VALUE: ------------------ | Branch (4460:3): [True: 6.12k, False: 6.12k] ------------------ 4461| 6.12k| if (*type == CCV_SB) { ------------------ | Branch (4461:9): [True: 6.12k, False: 0] ------------------ 4462| 6.12k| BITSET_SET_BIT_CHKDUP(cc->bs, (int )(*from)); ------------------ | | 176| 6.12k|#define BITSET_SET_BIT_CHKDUP(bs, pos) do { \ | | 177| 6.12k| if (BITSET_AT(bs, pos)) CC_DUP_WARN(env, pos, pos); \ | | ------------------ | | | | 448| 6.12k|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | | | ------------------ | | | | | | 445| 6.12k|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | | | ------------------ | | | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | | | ------------------ | | | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | | | ------------------ | | | | | | 446| 6.12k|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | | | ------------------ | | | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | | | ------------------ | | | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (448:36): [True: 0, False: 6.12k] | | | | ------------------ | | ------------------ | | 178| 6.12k| BS_ROOM(bs, pos) |= BS_BIT(pos); \ | | ------------------ | | | | 445| 6.12k|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | BS_ROOM(bs, pos) |= BS_BIT(pos); \ | | ------------------ | | | | 446| 6.12k|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 6.12k|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 6.12k|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 179| 6.12k|} while (0) | | ------------------ | | | Branch (179:10): [Folded - Ignored] | | ------------------ ------------------ 4463| 6.12k| if (IS_NOT_NULL(asc_cc)) ------------------ | | 312| 6.12k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 6.12k] | | ------------------ ------------------ 4464| 6.12k| BITSET_SET_BIT(asc_cc->bs, (int )(*from)); ------------------ | | 449| 0|#define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_SET_BIT(bs, pos) BS_ROOM(bs,pos) |= BS_BIT(pos) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 4465| 6.12k| } 4466| 0| else if (*type == CCV_CODE_POINT) { ------------------ | Branch (4466:14): [True: 0, False: 0] ------------------ 4467| 0| r = add_code_range(&(cc->mbuf), env, *from, *from); 4468| 0| if (r < 0) return r; ------------------ | Branch (4468:11): [True: 0, False: 0] ------------------ 4469| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4470| 0| r = add_code_range0(&(asc_cc->mbuf), env, *from, *from, 0); 4471| 0| if (r < 0) return r; ------------------ | Branch (4471:6): [True: 0, False: 0] ------------------ 4472| 0| } 4473| 0| } 4474| 6.12k| break; 4475| | 4476| 6.12k| case CCS_RANGE: ------------------ | Branch (4476:3): [True: 0, False: 12.2k] ------------------ 4477| 0| if (intype == *type) { ------------------ | Branch (4477:9): [True: 0, False: 0] ------------------ 4478| 0| if (intype == CCV_SB) { ------------------ | Branch (4478:11): [True: 0, False: 0] ------------------ 4479| 0| if (*from > 0xff || to > 0xff) ------------------ | Branch (4479:6): [True: 0, False: 0] | Branch (4479:22): [True: 0, False: 0] ------------------ 4480| 0| return ONIGERR_INVALID_CODE_POINT_VALUE; ------------------ | | 692| 0|#define ONIGERR_INVALID_CODE_POINT_VALUE -400 ------------------ 4481| | 4482| 0| if (*from > to) { ------------------ | Branch (4482:6): [True: 0, False: 0] ------------------ 4483| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 4484| 0| goto ccs_range_end; 4485| 0| else 4486| 0| return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS; ------------------ | | 672| 0|#define ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS -203 ------------------ 4487| 0| } 4488| 0| bitset_set_range(env, cc->bs, (int )*from, (int )to); 4489| 0| if (IS_NOT_NULL(asc_cc)) ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4490| 0| bitset_set_range(env, asc_cc->bs, (int )*from, (int )to); 4491| 0| } 4492| 0| else { 4493| 0| r = add_code_range(&(cc->mbuf), env, *from, to); 4494| 0| if (r < 0) return r; ------------------ | Branch (4494:6): [True: 0, False: 0] ------------------ 4495| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4496| 0| r = add_code_range0(&(asc_cc->mbuf), env, *from, to, 0); 4497| 0| if (r < 0) return r; ------------------ | Branch (4497:8): [True: 0, False: 0] ------------------ 4498| 0| } 4499| 0| } 4500| 0| } 4501| 0| else { 4502| 0| if (*from > to) { ------------------ | Branch (4502:11): [True: 0, False: 0] ------------------ 4503| 0| if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC)) ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 4504| 0| goto ccs_range_end; 4505| 0| else 4506| 0| return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS; ------------------ | | 672| 0|#define ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS -203 ------------------ 4507| 0| } 4508| 0| bitset_set_range(env, cc->bs, (int )*from, (int )(to < 0xff ? to : 0xff)); ------------------ | Branch (4508:57): [True: 0, False: 0] ------------------ 4509| 0| r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*from, to); 4510| 0| if (r < 0) return r; ------------------ | Branch (4510:11): [True: 0, False: 0] ------------------ 4511| 0| if (IS_NOT_NULL(asc_cc)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 4512| 0| bitset_set_range(env, asc_cc->bs, (int )*from, (int )(to < 0xff ? to : 0xff)); ------------------ | Branch (4512:56): [True: 0, False: 0] ------------------ 4513| 0| r = add_code_range0(&(asc_cc->mbuf), env, (OnigCodePoint )*from, to, 0); 4514| 0| if (r < 0) return r; ------------------ | Branch (4514:6): [True: 0, False: 0] ------------------ 4515| 0| } 4516| 0| } 4517| 0| ccs_range_end: 4518| 0| *state = CCS_COMPLETE; 4519| 0| break; 4520| | 4521| 0| case CCS_COMPLETE: ------------------ | Branch (4521:3): [True: 0, False: 12.2k] ------------------ 4522| 6.12k| case CCS_START: ------------------ | Branch (4522:3): [True: 6.12k, False: 6.12k] ------------------ 4523| 6.12k| *state = CCS_VALUE; 4524| 6.12k| break; 4525| | 4526| 0| default: ------------------ | Branch (4526:3): [True: 0, False: 12.2k] ------------------ 4527| 0| break; 4528| 12.2k| } 4529| | 4530| 12.2k| *from_israw = to_israw; 4531| 12.2k| *from = to; 4532| 12.2k| *type = intype; 4533| 12.2k| return 0; 4534| 12.2k|} regparse.c:is_onechar_cclass: 6078| 6.12k|{ 6079| 6.12k| const OnigCodePoint not_found = ONIG_LAST_CODE_POINT; ------------------ | | 317| 6.12k|#define ONIG_LAST_CODE_POINT (~((OnigCodePoint )0)) ------------------ 6080| 6.12k| OnigCodePoint c = not_found; 6081| 6.12k| int i; 6082| 6.12k| BBuf *bbuf = cc->mbuf; 6083| | 6084| 6.12k| if (IS_NCCLASS_NOT(cc)) return 0; ------------------ | | 809| 6.12k|#define IS_NCCLASS_NOT(nd) IS_NCCLASS_FLAG_ON(nd, FLAG_NCCLASS_NOT) | | ------------------ | | | | 802| 6.12k|#define IS_NCCLASS_FLAG_ON(cc,flag) ((NCCLASS_FLAGS(cc) & (flag)) != 0) | | | | ------------------ | | | | | | 799| 6.12k|#define NCCLASS_FLAGS(cc) ((cc)->flags) | | | | ------------------ | | | | | Branch (802:37): [True: 6.12k, False: 0] | | | | ------------------ | | ------------------ ------------------ 6085| | 6086| | /* check bbuf */ 6087| 0| if (IS_NOT_NULL(bbuf)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 6088| 0| OnigCodePoint n, *data; 6089| 0| GET_CODE_POINT(n, bbuf->p); ------------------ | | 710| 0|#define GET_CODE_POINT(code,p) code = *((OnigCodePoint* )(p)) ------------------ 6090| 0| data = (OnigCodePoint* )(bbuf->p) + 1; 6091| 0| if ((n == 1) && (data[0] == data[1])) { ------------------ | Branch (6091:9): [True: 0, False: 0] | Branch (6091:21): [True: 0, False: 0] ------------------ 6092| | /* only one char found in the bbuf, save the code point. */ 6093| 0| c = data[0]; 6094| 0| if (((c < SINGLE_BYTE_SIZE) && BITSET_AT(cc->bs, c))) { ------------------ | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ if (((c < SINGLE_BYTE_SIZE) && BITSET_AT(cc->bs, c))) { ------------------ | | 448| 0|#define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 445| 0|#define BS_ROOM(bs,pos) (bs)[(int )(pos) / BITS_IN_ROOM] | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define BITSET_AT(bs, pos) (BS_ROOM(bs,pos) & BS_BIT(pos)) | | ------------------ | | | | 446| 0|#define BS_BIT(pos) (1U << ((int )(pos) % BITS_IN_ROOM)) | | | | ------------------ | | | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | | | ------------------ | | | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (448:36): [True: 0, False: 0] | | ------------------ ------------------ | Branch (6094:12): [True: 0, False: 0] ------------------ 6095| | /* skip if c is included in the bitset */ 6096| 0| c = not_found; 6097| 0| } 6098| 0| } 6099| 0| else { 6100| 0| return 0; /* the bbuf contains multiple chars */ 6101| 0| } 6102| 0| } 6103| | 6104| | /* check bitset */ 6105| 0| for (i = 0; i < BITSET_SIZE; i++) { ------------------ | | 428| 0|#define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | ------------------ | | | | 426| 0|#define SINGLE_BYTE_SIZE (1 << BITS_PER_BYTE) | | | | ------------------ | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | ------------------ | | ------------------ | | #define BITSET_SIZE (SINGLE_BYTE_SIZE / BITS_IN_ROOM) | | ------------------ | | | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | | | ------------------ | | | | | | 425| 0|#define BITS_PER_BYTE 8 | | | | ------------------ | | ------------------ ------------------ | Branch (6105:15): [True: 0, False: 0] ------------------ 6106| 0| Bits b1 = cc->bs[i]; 6107| 0| if (b1 != 0) { ------------------ | Branch (6107:9): [True: 0, False: 0] ------------------ 6108| 0| if (((b1 & (b1 - 1)) == 0) && (c == not_found)) { ------------------ | Branch (6108:11): [True: 0, False: 0] | Branch (6108:37): [True: 0, False: 0] ------------------ 6109| 0| c = BITS_IN_ROOM * i + countbits(b1 - 1); ------------------ | | 427| 0|#define BITS_IN_ROOM ((int )sizeof(Bits) * BITS_PER_BYTE) | | ------------------ | | | | 425| 0|#define BITS_PER_BYTE 8 | | ------------------ ------------------ 6110| 0| } else { 6111| 0| return 0; /* the character class contains multiple chars */ 6112| 0| } 6113| 0| } 6114| 0| } 6115| | 6116| 0| if (c != not_found) { ------------------ | Branch (6116:7): [True: 0, False: 0] ------------------ 6117| 0| *code = c; 6118| 0| return 1; 6119| 0| } 6120| | 6121| | /* the character class contains no char. */ 6122| 0| return 0; 6123| 0|} regparse.c:node_new_anychar: 1165| 2.04k|{ 1166| 2.04k| Node* node = node_new(); 1167| 2.04k| CHECK_NULL_RETURN(node); ------------------ | | 313| 2.04k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 2.04k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 2.04k] | | | | ------------------ | | ------------------ ------------------ 1168| | 1169| 2.04k| SET_NTYPE(node, NT_CANY); ------------------ | | 71| 2.04k| do { \ | | 72| 2.04k| int value = ntype; \ | | 73| 2.04k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 2.04k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1170| 2.04k| return node; 1171| 2.04k|} regparse.c:node_new_quantifier: 1305| 8.16k|{ 1306| 8.16k| Node* node = node_new(); 1307| 8.16k| CHECK_NULL_RETURN(node); ------------------ | | 313| 8.16k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ ------------------ 1308| | 1309| 8.16k| SET_NTYPE(node, NT_QTFR); ------------------ | | 71| 8.16k| do { \ | | 72| 8.16k| int value = ntype; \ | | 73| 8.16k| memcpy(&((node)->u.base.type), &value, sizeof(int)); \ | | 74| 8.16k| } while (0) | | ------------------ | | | Branch (74:14): [Folded - Ignored] | | ------------------ ------------------ 1310| 8.16k| NQTFR(node)->state = 0; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1311| 8.16k| NQTFR(node)->target = NULL; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1312| 8.16k| NQTFR(node)->lower = lower; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1313| 8.16k| NQTFR(node)->upper = upper; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1314| 8.16k| NQTFR(node)->greedy = 1; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1315| 8.16k| NQTFR(node)->target_empty_info = NQ_TARGET_ISNOT_EMPTY; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ NQTFR(node)->target_empty_info = NQ_TARGET_ISNOT_EMPTY; ------------------ | | 122| 8.16k|#define NQ_TARGET_ISNOT_EMPTY 0 ------------------ 1316| 8.16k| NQTFR(node)->head_exact = NULL_NODE; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ NQTFR(node)->head_exact = NULL_NODE; ------------------ | | 283| 8.16k|#define NULL_NODE ((Node* )0) ------------------ 1317| 8.16k| NQTFR(node)->next_head_exact = NULL_NODE; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ NQTFR(node)->next_head_exact = NULL_NODE; ------------------ | | 283| 8.16k|#define NULL_NODE ((Node* )0) ------------------ 1318| 8.16k| NQTFR(node)->is_referred = 0; ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 1319| 8.16k| if (by_number != 0) ------------------ | Branch (1319:7): [True: 0, False: 8.16k] ------------------ 1320| 0| NQTFR(node)->state |= NST_BY_NUMBER; ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ NQTFR(node)->state |= NST_BY_NUMBER; ------------------ | | 142| 0|#define NST_BY_NUMBER (1<<14) /* {n,m} */ ------------------ 1321| | 1322| |#ifdef USE_COMBINATION_EXPLOSION_CHECK 1323| | NQTFR(node)->comb_exp_check_num = 0; 1324| |#endif 1325| | 1326| 8.16k| return node; 1327| 8.16k|} regparse.c:set_quantifier: 5403| 8.16k|{ 5404| 8.16k| QtfrNode* qn; 5405| | 5406| 8.16k| qn = NQTFR(qnode); ------------------ | | 80| 8.16k|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 5407| 8.16k| if (qn->lower == 1 && qn->upper == 1) { ------------------ | Branch (5407:7): [True: 8.16k, False: 0] | Branch (5407:25): [True: 0, False: 8.16k] ------------------ 5408| 0| return 1; 5409| 0| } 5410| | 5411| 8.16k| switch (NTYPE(target)) { ------------------ | | 69| 8.16k|#define NTYPE(node) ((node)->u.base.type) ------------------ 5412| 0| case NT_STR: ------------------ | | 38| 0|#define NT_STR 0 ------------------ | Branch (5412:3): [True: 0, False: 8.16k] ------------------ 5413| 0| if (! group) { ------------------ | Branch (5413:9): [True: 0, False: 0] ------------------ 5414| 0| StrNode* sn = NSTR(target); ------------------ | | 76| 0|#define NSTR(node) (&((node)->u.str)) ------------------ 5415| 0| if (str_node_can_be_split(sn, env->enc)) { ------------------ | Branch (5415:11): [True: 0, False: 0] ------------------ 5416| 0| Node* n = str_node_split_last_char(sn, env->enc); 5417| 0| if (IS_NOT_NULL(n)) { ------------------ | | 312| 0|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | ------------------ | | | Branch (312:39): [True: 0, False: 0] | | ------------------ ------------------ 5418| 0| qn->target = n; 5419| 0| return 2; 5420| 0| } 5421| 0| } 5422| 0| } 5423| 0| break; 5424| | 5425| 0| case NT_QTFR: ------------------ | | 43| 0|#define NT_QTFR 5 ------------------ | Branch (5425:3): [True: 0, False: 8.16k] ------------------ 5426| 0| { /* check redundant double repeat. */ 5427| | /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */ 5428| 0| QtfrNode* qnt = NQTFR(target); ------------------ | | 80| 0|#define NQTFR(node) (&((node)->u.qtfr)) ------------------ 5429| 0| int nestq_num = popular_quantifier_num(qn); 5430| 0| int targetq_num = popular_quantifier_num(qnt); 5431| | 5432| 0|#ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR 5433| 0| if (nestq_num >= 0 && targetq_num >= 0 && ------------------ | Branch (5433:11): [True: 0, False: 0] | Branch (5433:29): [True: 0, False: 0] ------------------ 5434| 0| IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) { ------------------ | | 332| 0|#define IS_SYNTAX_BV(syn, bvm) (((syn)->behavior & (bvm)) != 0) | | ------------------ | | | Branch (332:35): [True: 0, False: 0] | | ------------------ ------------------ 5435| 0| switch (ReduceTypeTable[targetq_num][nestq_num]) { 5436| 0| case RQ_ASIS: ------------------ | Branch (5436:2): [True: 0, False: 0] ------------------ 5437| 0| break; 5438| | 5439| 0| case RQ_DEL: ------------------ | Branch (5439:2): [True: 0, False: 0] ------------------ 5440| 0| if (onig_warn != onig_null_warn) { ------------------ | Branch (5440:8): [True: 0, False: 0] ------------------ 5441| 0| onig_syntax_warn(env, "regular expression has redundant nested repeat operator '%s'", 5442| 0| PopularQStr[targetq_num]); 5443| 0| } 5444| 0| goto warn_exit; 5445| 0| break; 5446| | 5447| 0| default: ------------------ | Branch (5447:2): [True: 0, False: 0] ------------------ 5448| 0| if (onig_warn != onig_null_warn) { ------------------ | Branch (5448:8): [True: 0, False: 0] ------------------ 5449| 0| onig_syntax_warn(env, "nested repeat operator '%s' and '%s' was replaced with '%s' in regular expression", 5450| 0| PopularQStr[targetq_num], PopularQStr[nestq_num], 5451| 0| ReduceQStr[ReduceTypeTable[targetq_num][nestq_num]]); 5452| 0| } 5453| 0| goto warn_exit; 5454| 0| break; 5455| 0| } 5456| 0| } 5457| | 5458| 0| warn_exit: 5459| 0|#endif 5460| 0| if (targetq_num >= 0) { ------------------ | Branch (5460:11): [True: 0, False: 0] ------------------ 5461| 0| if (nestq_num >= 0) { ------------------ | Branch (5461:6): [True: 0, False: 0] ------------------ 5462| 0| onig_reduce_nested_quantifier(qnode, target); 5463| 0| goto q_exit; 5464| 0| } 5465| 0| else if (targetq_num == 1 || targetq_num == 2) { /* * or + */ ------------------ | Branch (5465:11): [True: 0, False: 0] | Branch (5465:31): [True: 0, False: 0] ------------------ 5466| | /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */ 5467| 0| if (! IS_REPEAT_INFINITE(qn->upper) && qn->upper > 1 && qn->greedy) { ------------------ | | 422| 0|#define IS_REPEAT_INFINITE(n) ((n) == REPEAT_INFINITE) | | ------------------ | | | | 421| 0|#define REPEAT_INFINITE -1 | | ------------------ ------------------ | Branch (5467:8): [True: 0, False: 0] | Branch (5467:43): [True: 0, False: 0] | Branch (5467:60): [True: 0, False: 0] ------------------ 5468| 0| qn->upper = (qn->lower == 0 ? 1 : qn->lower); ------------------ | Branch (5468:19): [True: 0, False: 0] ------------------ 5469| 0| } 5470| 0| } 5471| 0| } 5472| 0| } 5473| 0| break; 5474| | 5475| 8.16k| default: ------------------ | Branch (5475:3): [True: 8.16k, False: 0] ------------------ 5476| 8.16k| break; 5477| 8.16k| } 5478| | 5479| 8.16k| qn->target = target; 5480| 8.16k| q_exit: 5481| 8.16k| return 0; 5482| 8.16k|} regparse.c:node_new_enclose_memory: 1354| 8.16k|{ 1355| 8.16k| Node* node = node_new_enclose(ENCLOSE_MEMORY); ------------------ | | 94| 8.16k|#define ENCLOSE_MEMORY (1<<0) ------------------ 1356| 8.16k| CHECK_NULL_RETURN(node); ------------------ | | 313| 8.16k|#define CHECK_NULL_RETURN(p) if (IS_NULL(p)) return NULL | | ------------------ | | | | 311| 8.16k|#define IS_NULL(p) (((void*)(p)) == (void*)0) | | | | ------------------ | | | | | Branch (311:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ ------------------ 1357| 8.16k| if (is_named != 0) ------------------ | Branch (1357:7): [True: 8.16k, False: 0] ------------------ 1358| 8.16k| SET_ENCLOSE_STATUS(node, NST_NAMED_GROUP); ------------------ | | 144| 8.16k|#define SET_ENCLOSE_STATUS(node,f) (node)->u.enclose.state |= (f) ------------------ 1359| | 1360| 8.16k|#ifdef USE_SUBEXP_CALL 1361| 8.16k| NENCLOSE(node)->option = option; ------------------ | | 81| 8.16k|#define NENCLOSE(node) (&((node)->u.enclose)) ------------------ 1362| 8.16k|#endif 1363| 8.16k| return node; 1364| 8.16k|} regparse.c:scan_env_set_mem_node: 1052| 8.16k|{ 1053| 8.16k| if (env->num_mem >= num) ------------------ | Branch (1053:7): [True: 8.16k, False: 0] ------------------ 1054| 8.16k| SCANENV_MEM_NODES(env)[num] = node; ------------------ | | 287| 8.16k| (IS_NOT_NULL((senv)->mem_nodes_dynamic) ? \ | | ------------------ | | | | 312| 8.16k|#define IS_NOT_NULL(p) (((void*)(p)) != (void*)0) | | | | ------------------ | | | | | Branch (312:39): [True: 0, False: 8.16k] | | | | ------------------ | | ------------------ | | 288| 8.16k| (senv)->mem_nodes_dynamic : (senv)->mem_nodes_static) ------------------ 1055| 0| else 1056| 0| return ONIGERR_PARSER_BUG; ------------------ | | 634| 0|#define ONIGERR_PARSER_BUG -11 ------------------ 1057| 8.16k| return 0; 1058| 8.16k|} onig_st_init_table_with_size: 582| 2.04k|{ 583| 2.04k| st_table *tab; 584| 2.04k| int n; 585| | 586| |#ifdef HASH_LOG 587| |#if HASH_LOG+0 < 0 588| | { 589| | const char *e = getenv("ST_HASH_LOG"); 590| | if (!e || !*e) init_st = 1; 591| | } 592| |#endif 593| | if (init_st == 0) { 594| | init_st = 1; 595| | atexit(stat_col); 596| | } 597| |#endif 598| | 599| 2.04k| n = get_power2(size); 600| 2.04k|#ifndef RUBY 601| 2.04k| if (n < 0) ------------------ | Branch (601:9): [True: 0, False: 2.04k] ------------------ 602| 0| return NULL; 603| 2.04k|#endif 604| 2.04k| tab = (st_table *) malloc(sizeof (st_table)); 605| 2.04k|#ifndef RUBY 606| 2.04k| if (tab == NULL) ------------------ | Branch (606:9): [True: 0, False: 2.04k] ------------------ 607| 0| return NULL; 608| 2.04k|#endif 609| 2.04k| tab->type = type; 610| 2.04k| tab->entry_power = n; 611| 2.04k| tab->bin_power = features[n].bin_power; 612| 2.04k| tab->size_ind = features[n].size_ind; 613| 2.04k| if (n <= MAX_POWER2_FOR_TABLES_WITHOUT_BINS) ------------------ | | 343| 2.04k|#define MAX_POWER2_FOR_TABLES_WITHOUT_BINS 4 ------------------ | Branch (613:9): [True: 2.04k, False: 0] ------------------ 614| 2.04k| tab->bins = NULL; 615| 0| else { 616| 0| tab->bins = (st_index_t *) malloc(bins_size(tab)); 617| 0|#ifndef RUBY 618| 0| if (tab->bins == NULL) { ------------------ | Branch (618:13): [True: 0, False: 0] ------------------ 619| 0| free(tab); 620| 0| return NULL; 621| 0| } 622| 0|#endif 623| 0| } 624| 2.04k| tab->entries = (st_table_entry *) malloc(get_allocated_entries(tab) 625| 2.04k| * sizeof(st_table_entry)); 626| 2.04k|#ifndef RUBY 627| 2.04k| if (tab->entries == NULL) { ------------------ | Branch (627:9): [True: 0, False: 2.04k] ------------------ 628| 0| st_free_table(tab); ------------------ | | 193| 0|# define st_free_table onig_st_free_table ------------------ 629| 0| return NULL; 630| 0| } 631| 2.04k|#endif 632| |#ifdef ST_DEBUG 633| | memset(tab->entries, ST_INIT_VAL_BYTE, 634| | get_allocated_entries(tab) * sizeof(st_table_entry)); 635| | if (tab->bins != NULL) 636| | memset(tab->bins, ST_INIT_VAL_BYTE, bins_size(tab)); 637| |#endif 638| 2.04k| make_tab_empty(tab); 639| 2.04k| tab->rebuilds_num = 0; 640| |#ifdef ST_DEBUG 641| | st_check(tab); 642| |#endif 643| 2.04k| return tab; 644| 2.04k|} onig_st_free_table: 716| 2.04k|{ 717| 2.04k| if (tab->bins != NULL) ------------------ | Branch (717:9): [True: 0, False: 2.04k] ------------------ 718| 0| free(tab->bins); 719| 2.04k| free(tab->entries); 720| 2.04k| free(tab); 721| 2.04k|} onig_st_lookup: 1110| 6.12k|{ 1111| 6.12k| st_index_t bin; 1112| 6.12k| st_hash_t hash = do_hash(key, tab); 1113| | 1114| 6.12k| retry: 1115| 6.12k| if (tab->bins == NULL) { ------------------ | Branch (1115:9): [True: 6.12k, False: 0] ------------------ 1116| 6.12k| bin = find_entry(tab, hash, key); 1117| 6.12k| if (EXPECT(bin == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 6.12k|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 6.12k] | | ------------------ ------------------ 1118| 0| goto retry; 1119| 6.12k| if (bin == UNDEFINED_ENTRY_IND) ------------------ | | 399| 6.12k|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ | Branch (1119:6): [True: 6.12k, False: 0] ------------------ 1120| 6.12k| return 0; 1121| 6.12k| } 1122| 0| else { 1123| 0| bin = find_table_entry_ind(tab, hash, key); 1124| 0| if (EXPECT(bin == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 0|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 0] | | ------------------ ------------------ 1125| 0| goto retry; 1126| 0| if (bin == UNDEFINED_ENTRY_IND) ------------------ | | 399| 0|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ | Branch (1126:6): [True: 0, False: 0] ------------------ 1127| 0| return 0; 1128| 0| bin -= ENTRY_BASE; ------------------ | | 391| 0|#define ENTRY_BASE 2 ------------------ 1129| 0| } 1130| 0| if (value != 0) ------------------ | Branch (1130:9): [True: 0, False: 0] ------------------ 1131| 0| *value = tab->entries[bin].record; 1132| 0| return 1; 1133| 6.12k|} onig_st_insert: 1182| 8.16k|{ 1183| 8.16k| st_table_entry *entry; 1184| 8.16k| st_index_t bin; 1185| 8.16k| st_index_t ind; 1186| 8.16k| st_hash_t hash_value; 1187| 8.16k| st_index_t bin_ind; 1188| 8.16k| int new_p; 1189| | 1190| 8.16k| hash_value = do_hash(key, tab); 1191| 8.16k| retry: 1192| 8.16k| rebuild_table_if_necessary(tab); 1193| 8.16k| if (tab->bins == NULL) { ------------------ | Branch (1193:9): [True: 8.16k, False: 0] ------------------ 1194| 8.16k| bin = find_entry(tab, hash_value, key); 1195| 8.16k| if (EXPECT(bin == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 8.16k|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 8.16k] | | ------------------ ------------------ 1196| 0| goto retry; 1197| 8.16k| new_p = bin == UNDEFINED_ENTRY_IND; ------------------ | | 399| 8.16k|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ 1198| 8.16k| if (new_p) ------------------ | Branch (1198:6): [True: 8.16k, False: 0] ------------------ 1199| 8.16k| tab->num_entries++; 1200| 8.16k| bin_ind = UNDEFINED_BIN_IND; ------------------ | | 400| 8.16k|#define UNDEFINED_BIN_IND (~(st_index_t) 0) ------------------ 1201| 8.16k| } 1202| 0| else { 1203| 0| bin = find_table_bin_ptr_and_reserve(tab, &hash_value, 1204| 0| key, &bin_ind); 1205| 0| if (EXPECT(bin == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 0|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 0] | | ------------------ ------------------ 1206| 0| goto retry; 1207| 0| new_p = bin == UNDEFINED_ENTRY_IND; ------------------ | | 399| 0|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ 1208| 0| bin -= ENTRY_BASE; ------------------ | | 391| 0|#define ENTRY_BASE 2 ------------------ 1209| 0| } 1210| 8.16k| if (new_p) { ------------------ | Branch (1210:9): [True: 8.16k, False: 0] ------------------ 1211| 8.16k| st_assert(tab->entries_bound < get_allocated_entries(tab)); ------------------ | | 128| 8.16k|#define st_assert(cond) ((void)(0 && (cond))) | | ------------------ | | | Branch (128:33): [Folded - Ignored] | | | Branch (128:38): [True: 0, False: 0] | | ------------------ ------------------ 1212| 8.16k| ind = tab->entries_bound++; 1213| 8.16k| entry = &tab->entries[ind]; 1214| 8.16k| entry->hash = hash_value; 1215| 8.16k| entry->key = key; 1216| 8.16k| entry->record = value; 1217| 8.16k| if (bin_ind != UNDEFINED_BIN_IND) ------------------ | | 400| 8.16k|#define UNDEFINED_BIN_IND (~(st_index_t) 0) ------------------ | Branch (1217:6): [True: 0, False: 8.16k] ------------------ 1218| 0| set_bin(tab->bins, get_size_ind(tab), bin_ind, ind + ENTRY_BASE); ------------------ | | 391| 0|#define ENTRY_BASE 2 ------------------ 1219| |#ifdef ST_DEBUG 1220| | st_check(tab); 1221| |#endif 1222| 8.16k| return 0; 1223| 8.16k| } 1224| 0| tab->entries[bin].record = value; 1225| |#ifdef ST_DEBUG 1226| | st_check(tab); 1227| |#endif 1228| 0| return 1; 1229| 8.16k|} onig_st_foreach: 1723| 2.04k|{ 1724| 2.04k| return st_general_foreach(tab, func, NULL, arg, FALSE); ------------------ | | 77| 2.04k|# define FALSE 0 ------------------ 1725| 2.04k|} st.c:get_power2: 348| 2.04k|{ 349| 2.04k| unsigned int n; 350| | 351| 8.16k| for (n = 0; size != 0; n++) ------------------ | Branch (351:17): [True: 6.12k, False: 2.04k] ------------------ 352| 6.12k| size >>= 1; 353| 2.04k| if (n <= MAX_POWER2) ------------------ | | 210| 2.04k|#define MAX_POWER2 62 ------------------ | Branch (353:9): [True: 2.04k, False: 0] ------------------ 354| 2.04k| return n < MINIMAL_POWER2 ? MINIMAL_POWER2 : n; ------------------ | | 335| 2.04k|#define MINIMAL_POWER2 2 ------------------ return n < MINIMAL_POWER2 ? MINIMAL_POWER2 : n; ------------------ | | 335| 0|#define MINIMAL_POWER2 2 ------------------ | Branch (354:16): [True: 0, False: 2.04k] ------------------ 355| |#ifdef RUBY 356| | /* Ran out of the table entries */ 357| | rb_raise(rb_eRuntimeError, "st_table too big"); 358| |#endif 359| | /* should raise exception */ 360| 0| return -1; 361| 2.04k|} st.c:get_allocated_entries: 466| 10.2k|{ 467| 10.2k| return ((st_index_t) 1)<entry_power; 468| 10.2k|} st.c:make_tab_empty: 487| 2.04k|{ 488| 2.04k| tab->num_entries = 0; 489| 2.04k| tab->entries_start = tab->entries_bound = 0; 490| 2.04k| if (tab->bins != NULL) ------------------ | Branch (490:9): [True: 0, False: 2.04k] ------------------ 491| 0| initialize_bins(tab); 492| 2.04k|} st.c:do_hash: 326| 14.2k|{ 327| 14.2k| st_hash_t hash = (st_hash_t)(tab->type->hash)(key); 328| | 329| | /* RESERVED_HASH_VAL is used for a deleted entry. Map it into 330| | another value. Such mapping should be extremely rare. */ 331| 14.2k| return hash == RESERVED_HASH_VAL ? RESERVED_HASH_SUBSTITUTION_VAL : hash; ------------------ | | 317| 14.2k|#define RESERVED_HASH_VAL (~(st_hash_t) 0) ------------------ return hash == RESERVED_HASH_VAL ? RESERVED_HASH_SUBSTITUTION_VAL : hash; ------------------ | | 318| 0|#define RESERVED_HASH_SUBSTITUTION_VAL ((st_hash_t) 0) ------------------ | Branch (331:12): [True: 0, False: 14.2k] ------------------ 332| 14.2k|} st.c:find_entry: 881| 22.4k|{ 882| 22.4k| int eq_p, rebuilt_p; 883| 22.4k| st_index_t i, bound; 884| 22.4k| st_table_entry *entries; 885| | 886| 22.4k| bound = tab->entries_bound; 887| 22.4k| entries = tab->entries; 888| 46.9k| for (i = tab->entries_start; i < bound; i++) { ------------------ | Branch (888:34): [True: 32.6k, False: 14.2k] ------------------ 889| 32.6k| DO_PTR_EQUAL_CHECK(tab, &entries[i], hash_value, key, eq_p, rebuilt_p); ------------------ | | 187| 32.6k| do { \ | | 188| 32.6k| unsigned int _old_rebuilds_num = (tab)->rebuilds_num; \ | | 189| 32.6k| res = PTR_EQUAL(tab, ptr, hash_val, key); \ | | ------------------ | | | | 182| 32.6k| ((ptr)->hash == (hash_val) && EQUAL((tab), (key_), (ptr)->key)) | | | | ------------------ | | | | | | 180| 8.16k|#define EQUAL(tab,x,y) ((x) == (y) || (*(tab)->type->compare)((x),(y)) == 0) | | | | | | ------------------ | | | | | | | Branch (180:25): [True: 8.16k, False: 0] | | | | | | | Branch (180:39): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (182:6): [True: 8.16k, False: 24.4k] | | | | ------------------ | | ------------------ | | 190| 32.6k| rebuilt_p = _old_rebuilds_num != (tab)->rebuilds_num; \ | | 191| 32.6k| } while (FALSE) | | ------------------ | | | | 77| 32.6k|# define FALSE 0 | | | | ------------------ | | | | | Branch (77:18): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 890| 32.6k| if (EXPECT(rebuilt_p, 0)) ------------------ | | 117| 32.6k|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 32.6k] | | ------------------ ------------------ 891| 0| return REBUILT_TABLE_ENTRY_IND; ------------------ | | 404| 0|#define REBUILT_TABLE_ENTRY_IND (~(st_index_t) 1) ------------------ 892| 32.6k| if (eq_p) ------------------ | Branch (892:6): [True: 8.16k, False: 24.4k] ------------------ 893| 8.16k| return i; 894| 32.6k| } 895| 14.2k| return UNDEFINED_ENTRY_IND; ------------------ | | 399| 14.2k|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ 896| 22.4k|} st.c:rebuild_table_if_necessary: 1169| 8.16k|{ 1170| 8.16k| st_index_t bound = tab->entries_bound; 1171| | 1172| 8.16k| if (bound == get_allocated_entries(tab)) ------------------ | Branch (1172:9): [True: 0, False: 8.16k] ------------------ 1173| 0| rebuild_table(tab); 1174| 8.16k| st_assert(tab->entries_bound < get_allocated_entries(tab)); ------------------ | | 128| 8.16k|#define st_assert(cond) ((void)(0 && (cond))) | | ------------------ | | | Branch (128:33): [Folded - Ignored] | | | Branch (128:38): [True: 0, False: 0] | | ------------------ ------------------ 1175| 8.16k|} st.c:st_general_foreach: 1605| 2.04k|{ 1606| 2.04k| st_index_t bin; 1607| 2.04k| st_index_t bin_ind; 1608| 2.04k| st_table_entry *entries, *curr_entry_ptr; 1609| 2.04k| enum st_retval retval; 1610| 2.04k| st_index_t i, rebuilds_num; 1611| 2.04k| st_hash_t hash; 1612| 2.04k| st_data_t key; 1613| 2.04k| int error_p, packed_p = tab->bins == NULL; 1614| | 1615| 2.04k| st_assert(tab->entries_start <= tab->entries_bound); ------------------ | | 128| 2.04k|#define st_assert(cond) ((void)(0 && (cond))) | | ------------------ | | | Branch (128:33): [Folded - Ignored] | | | Branch (128:38): [True: 0, False: 0] | | ------------------ ------------------ 1616| 2.04k| entries = tab->entries; 1617| | /* The bound can change inside the loop even without rebuilding 1618| | the table, e.g. by an entry inesrtion. */ 1619| 10.2k| for (i = tab->entries_start; i < tab->entries_bound; i++) { ------------------ | Branch (1619:34): [True: 8.16k, False: 2.04k] ------------------ 1620| 8.16k| curr_entry_ptr = &entries[i]; 1621| 8.16k| if (EXPECT(DELETED_ENTRY_P(curr_entry_ptr), 0)) ------------------ | | 117| 8.16k|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 8.16k] | | ------------------ ------------------ 1622| 0| continue; 1623| 8.16k| key = curr_entry_ptr->key; 1624| 8.16k| rebuilds_num = tab->rebuilds_num; 1625| 8.16k| hash = curr_entry_ptr->hash; 1626| 8.16k| retval = (*func)(key, curr_entry_ptr->record, arg, 0); 1627| | 1628| 8.16k| if (retval == ST_REPLACE && replace) { ------------------ | Branch (1628:13): [True: 0, False: 8.16k] | Branch (1628:37): [True: 0, False: 0] ------------------ 1629| 0| st_data_t value; 1630| 0| value = curr_entry_ptr->record; 1631| 0| retval = (*replace)(&key, &value, arg, TRUE); ------------------ | | 73| 0|# define TRUE 1 ------------------ 1632| 0| curr_entry_ptr->key = key; 1633| 0| curr_entry_ptr->record = value; 1634| 0| } 1635| | 1636| 8.16k| if (rebuilds_num != tab->rebuilds_num) { ------------------ | Branch (1636:6): [True: 0, False: 8.16k] ------------------ 1637| 0| retry: 1638| 0| entries = tab->entries; 1639| 0| packed_p = tab->bins == NULL; 1640| 0| if (packed_p) { ------------------ | Branch (1640:10): [True: 0, False: 0] ------------------ 1641| 0| i = find_entry(tab, hash, key); 1642| 0| if (EXPECT(i == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 0|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 0] | | ------------------ ------------------ 1643| 0| goto retry; 1644| 0| error_p = i == UNDEFINED_ENTRY_IND; ------------------ | | 399| 0|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ 1645| 0| } 1646| 0| else { 1647| 0| i = find_table_entry_ind(tab, hash, key); 1648| 0| if (EXPECT(i == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 0|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 0] | | ------------------ ------------------ 1649| 0| goto retry; 1650| 0| error_p = i == UNDEFINED_ENTRY_IND; ------------------ | | 399| 0|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ 1651| 0| i -= ENTRY_BASE; ------------------ | | 391| 0|#define ENTRY_BASE 2 ------------------ 1652| 0| } 1653| 0| if (error_p && check_p) { ------------------ | Branch (1653:10): [True: 0, False: 0] | Branch (1653:21): [True: 0, False: 0] ------------------ 1654| | /* call func with error notice */ 1655| 0| retval = (*func)(0, 0, arg, 1); 1656| |#ifdef ST_DEBUG 1657| | st_check(tab); 1658| |#endif 1659| 0| return 1; 1660| 0| } 1661| 0| curr_entry_ptr = &entries[i]; 1662| 0| } 1663| 8.16k| switch (retval) { ------------------ | Branch (1663:10): [True: 0, False: 8.16k] ------------------ 1664| 0| case ST_REPLACE: ------------------ | Branch (1664:11): [True: 0, False: 8.16k] ------------------ 1665| 0| break; 1666| 0| case ST_CONTINUE: ------------------ | Branch (1666:4): [True: 0, False: 8.16k] ------------------ 1667| 0| break; 1668| 0| case ST_CHECK: ------------------ | Branch (1668:4): [True: 0, False: 8.16k] ------------------ 1669| 0| if (check_p) ------------------ | Branch (1669:10): [True: 0, False: 0] ------------------ 1670| 0| break; 1671| 0| case ST_STOP: ------------------ | Branch (1671:4): [True: 0, False: 8.16k] ------------------ 1672| |#ifdef ST_DEBUG 1673| | st_check(tab); 1674| |#endif 1675| 0| return 0; 1676| 8.16k| case ST_DELETE: { ------------------ | Branch (1676:4): [True: 8.16k, False: 0] ------------------ 1677| 8.16k| st_data_t key = curr_entry_ptr->key; 1678| | 1679| 8.16k| again: 1680| 8.16k| if (packed_p) { ------------------ | Branch (1680:10): [True: 8.16k, False: 0] ------------------ 1681| 8.16k| bin = find_entry(tab, hash, key); 1682| 8.16k| if (EXPECT(bin == REBUILT_TABLE_ENTRY_IND, 0)) ------------------ | | 117| 8.16k|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 8.16k] | | ------------------ ------------------ 1683| 0| goto again; 1684| 8.16k| if (bin == UNDEFINED_ENTRY_IND) ------------------ | | 399| 8.16k|#define UNDEFINED_ENTRY_IND (~(st_index_t) 0) ------------------ | Branch (1684:7): [True: 0, False: 8.16k] ------------------ 1685| 0| break; 1686| 8.16k| } 1687| 0| else { 1688| 0| bin_ind = find_table_bin_ind(tab, hash, key); 1689| 0| if (EXPECT(bin_ind == REBUILT_TABLE_BIN_IND, 0)) ------------------ | | 117| 0|#define EXPECT(expr, val) __builtin_expect(expr, val) | | ------------------ | | | Branch (117:27): [True: 0, False: 0] | | ------------------ ------------------ 1690| 0| goto again; 1691| 0| if (bin_ind == UNDEFINED_BIN_IND) ------------------ | | 400| 0|#define UNDEFINED_BIN_IND (~(st_index_t) 0) ------------------ | Branch (1691:7): [True: 0, False: 0] ------------------ 1692| 0| break; 1693| 0| bin = get_bin(tab->bins, get_size_ind(tab), bin_ind) - ENTRY_BASE; ------------------ | | 391| 0|#define ENTRY_BASE 2 ------------------ 1694| 0| MARK_BIN_DELETED(tab, bin_ind); ------------------ | | 411| 0| do { \ | | 412| 0| st_assert(i != UNDEFINED_BIN_IND); \ | | ------------------ | | | | 128| 0|#define st_assert(cond) ((void)(0 && (cond))) | | | | ------------------ | | | | | Branch (128:33): [Folded - Ignored] | | | | | Branch (128:38): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 413| 0| st_assert(! IND_EMPTY_OR_DELETED_BIN_P(tab, i)); \ | | ------------------ | | | | 128| 0|#define st_assert(cond) ((void)(0 && (cond))) | | | | ------------------ | | | | | Branch (128:33): [Folded - Ignored] | | | | | Branch (128:38): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 414| 0| set_bin((tab)->bins, get_size_ind(tab), i, DELETED_BIN); \ | | ------------------ | | | | 389| 0|#define DELETED_BIN 1 | | ------------------ | | 415| 0| } while (0) | | ------------------ | | | Branch (415:14): [Folded - Ignored] | | ------------------ ------------------ 1695| 0| } 1696| 8.16k| curr_entry_ptr = &entries[bin]; 1697| 8.16k| MARK_ENTRY_DELETED(curr_entry_ptr); ------------------ | | 431| 8.16k|#define MARK_ENTRY_DELETED(e_ptr) ((e_ptr)->hash = RESERVED_HASH_VAL) | | ------------------ | | | | 317| 8.16k|#define RESERVED_HASH_VAL (~(st_hash_t) 0) | | ------------------ ------------------ 1698| 8.16k| tab->num_entries--; 1699| 8.16k| update_range_for_deleted(tab, bin); 1700| |#ifdef ST_DEBUG 1701| | st_check(tab); 1702| |#endif 1703| 8.16k| break; 1704| 8.16k| } 1705| 8.16k| } 1706| 8.16k| } 1707| |#ifdef ST_DEBUG 1708| | st_check(tab); 1709| |#endif 1710| 2.04k| return 0; 1711| 2.04k|} st.c:update_range_for_deleted: 1375| 8.16k|{ 1376| | /* Do not update entries_bound here. Otherwise, we can fill all 1377| | bins by deleted entry value before rebuilding the table. */ 1378| 8.16k| if (tab->entries_start == n) ------------------ | Branch (1378:9): [True: 8.16k, False: 0] ------------------ 1379| 8.16k| tab->entries_start = n + 1; 1380| 8.16k|} flb_gzip_compress: 149| 2.04k|{ 150| 2.04k| int flush; 151| 2.04k| int status; 152| 2.04k| int footer_start; 153| 2.04k| uint8_t *pb; 154| 2.04k| size_t out_size; 155| 2.04k| void *out_buf; 156| 2.04k| z_stream strm; ------------------ | | 484| 2.04k|#define z_stream mz_stream ------------------ 157| 2.04k| mz_ulong crc; 158| | 159| | /* 160| | * Calculating the upper bound for a gzip compression is 161| | * non-trivial, so we rely on miniz's own calculation 162| | * to guarantee memory safety. 163| | */ 164| 2.04k| out_size = compressBound(in_len); ------------------ | | 495| 2.04k|#define compressBound mz_compressBound ------------------ 165| 2.04k| out_buf = flb_malloc(out_size); 166| | 167| 2.04k| if (!out_buf) { ------------------ | Branch (167:9): [True: 0, False: 2.04k] ------------------ 168| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 169| 0| flb_error("[gzip] could not allocate outgoing buffer"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 170| 0| return -1; 171| 0| } 172| | 173| | /* Initialize streaming buffer context */ 174| 2.04k| memset(&strm, '\0', sizeof(strm)); 175| 2.04k| strm.zalloc = Z_NULL; ------------------ | | 453| 2.04k|#define Z_NULL 0 ------------------ 176| 2.04k| strm.zfree = Z_NULL; ------------------ | | 453| 2.04k|#define Z_NULL 0 ------------------ 177| 2.04k| strm.opaque = Z_NULL; ------------------ | | 453| 2.04k|#define Z_NULL 0 ------------------ 178| 2.04k| strm.next_in = in_data; 179| 2.04k| strm.avail_in = in_len; 180| 2.04k| strm.total_out = 0; 181| | 182| | /* Deflate mode */ 183| 2.04k| deflateInit2(&strm, Z_DEFAULT_COMPRESSION, ------------------ | | 488| 2.04k|#define deflateInit2 mz_deflateInit2 ------------------ deflateInit2(&strm, Z_DEFAULT_COMPRESSION, ------------------ | | 473| 2.04k|#define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION ------------------ 184| 2.04k| Z_DEFLATED, -Z_DEFAULT_WINDOW_BITS, 9, Z_DEFAULT_STRATEGY); ------------------ | | 479| 2.04k|#define Z_DEFLATED MZ_DEFLATED | | ------------------ | | | | 256| 2.04k|#define MZ_DEFLATED 8 | | ------------------ ------------------ Z_DEFLATED, -Z_DEFAULT_WINDOW_BITS, 9, Z_DEFAULT_STRATEGY); ------------------ | | 480| 2.04k|#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS | | ------------------ | | | | 311| 2.04k|#define MZ_DEFAULT_WINDOW_BITS 15 | | ------------------ ------------------ Z_DEFLATED, -Z_DEFAULT_WINDOW_BITS, 9, Z_DEFAULT_STRATEGY); ------------------ | | 474| 2.04k|#define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY ------------------ 185| | 186| | /* 187| | * Miniz don't support GZip format directly, instead we will: 188| | * 189| | * - append manual GZip magic bytes 190| | * - deflate raw content 191| | * - append manual CRC32 data 192| | */ 193| 2.04k| gzip_header(out_buf); 194| | 195| | /* Header offset */ 196| 2.04k| pb = (uint8_t *) out_buf + FLB_GZIP_HEADER_OFFSET; ------------------ | | 28| 2.04k|#define FLB_GZIP_HEADER_OFFSET 10 ------------------ 197| | 198| 2.04k| flush = Z_NO_FLUSH; ------------------ | | 454| 2.04k|#define Z_NO_FLUSH MZ_NO_FLUSH ------------------ 199| 4.08k| while (1) { ------------------ | Branch (199:12): [Folded - Ignored] ------------------ 200| 4.08k| strm.next_out = pb + strm.total_out; 201| 4.08k| strm.avail_out = out_size - (pb - (uint8_t *) out_buf); 202| | 203| 4.08k| if (strm.avail_in == 0) { ------------------ | Branch (203:13): [True: 2.04k, False: 2.04k] ------------------ 204| 2.04k| flush = Z_FINISH; ------------------ | | 458| 2.04k|#define Z_FINISH MZ_FINISH ------------------ 205| 2.04k| } 206| | 207| 4.08k| status = deflate(&strm, flush); ------------------ | | 490| 4.08k|#define deflate mz_deflate ------------------ 208| 4.08k| if (status == Z_STREAM_END) { ------------------ | | 461| 4.08k|#define Z_STREAM_END MZ_STREAM_END ------------------ | Branch (208:13): [True: 2.04k, False: 2.04k] ------------------ 209| 2.04k| break; 210| 2.04k| } 211| 2.04k| else if (status != Z_OK) { ------------------ | | 460| 2.04k|#define Z_OK MZ_OK ------------------ | Branch (211:18): [True: 0, False: 2.04k] ------------------ 212| 0| deflateEnd(&strm); ------------------ | | 491| 0|#define deflateEnd mz_deflateEnd ------------------ 213| 0| return -1; 214| 0| } 215| 4.08k| } 216| | 217| 2.04k| if (deflateEnd(&strm) != Z_OK) { ------------------ | | 491| 2.04k|#define deflateEnd mz_deflateEnd ------------------ if (deflateEnd(&strm) != Z_OK) { ------------------ | | 460| 2.04k|#define Z_OK MZ_OK ------------------ | Branch (217:9): [True: 0, False: 2.04k] ------------------ 218| 0| flb_free(out_buf); 219| 0| return -1; 220| 0| } 221| 2.04k| *out_len = strm.total_out; 222| | 223| | /* Construct the gzip checksum (CRC32 footer) */ 224| 2.04k| footer_start = FLB_GZIP_HEADER_OFFSET + *out_len; ------------------ | | 28| 2.04k|#define FLB_GZIP_HEADER_OFFSET 10 ------------------ 225| 2.04k| pb = (uint8_t *) out_buf + footer_start; 226| | 227| 2.04k| crc = mz_crc32(MZ_CRC32_INIT, in_data, in_len); ------------------ | | 241| 2.04k|#define MZ_CRC32_INIT (0) ------------------ 228| 2.04k| *pb++ = crc & 0xFF; 229| 2.04k| *pb++ = (crc >> 8) & 0xFF; 230| 2.04k| *pb++ = (crc >> 16) & 0xFF; 231| 2.04k| *pb++ = (crc >> 24) & 0xFF; 232| 2.04k| *pb++ = in_len & 0xFF; 233| 2.04k| *pb++ = (in_len >> 8) & 0xFF; 234| 2.04k| *pb++ = (in_len >> 16) & 0xFF; 235| 2.04k| *pb++ = (in_len >> 24) & 0xFF; 236| | 237| | /* Set the real buffer size for the caller */ 238| 2.04k| *out_len += FLB_GZIP_HEADER_OFFSET + 8; ------------------ | | 28| 2.04k|#define FLB_GZIP_HEADER_OFFSET 10 ------------------ 239| 2.04k| *out_data = out_buf; 240| | 241| 2.04k| return 0; 242| 2.04k|} flb_gzip_uncompress: 247| 4.08k|{ 248| 4.08k| int status; 249| 4.08k| uint8_t *p; 250| 4.08k| void *out_buf; 251| 4.08k| size_t out_size = 0; 252| 4.08k| void *zip_data; 253| 4.08k| size_t zip_len; 254| 4.08k| unsigned char flg; 255| 4.08k| unsigned int xlen, hcrc; 256| 4.08k| unsigned int dlen, crc; 257| 4.08k| mz_ulong crc_out; 258| 4.08k| mz_stream stream; 259| 4.08k| const unsigned char *start; 260| | 261| | /* Minimal length: header + crc32 */ 262| 4.08k| if (in_len < 18) { ------------------ | Branch (262:9): [True: 0, False: 4.08k] ------------------ 263| 0| flb_error("[gzip] unexpected content length"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 264| 0| return -1; 265| 0| } 266| | 267| | /* Magic bytes */ 268| 4.08k| p = in_data; 269| 4.08k| if (p[0] != 0x1F || p[1] != 0x8B) { ------------------ | Branch (269:9): [True: 1.50k, False: 2.57k] | Branch (269:25): [True: 11, False: 2.56k] ------------------ 270| 1.51k| flb_error("[gzip] invalid magic bytes"); ------------------ | | 170| 1.51k| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 1.51k|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 1.51k, False: 0] | | ------------------ | | 171| 1.51k| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 1.51k|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 271| 1.51k| return -1; 272| 1.51k| } 273| | 274| 2.56k| if (p[2] != 8) { ------------------ | Branch (274:9): [True: 5, False: 2.56k] ------------------ 275| 5| flb_error("[gzip] invalid method"); ------------------ | | 170| 5| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 5|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 5, False: 0] | | ------------------ | | 171| 5| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 5|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 276| 5| return -1; 277| 5| } 278| | 279| | /* Flag byte */ 280| 2.56k| flg = p[3]; 281| | 282| | /* Reserved bits */ 283| 2.56k| if (flg & 0xE0) { ------------------ | Branch (283:9): [True: 2, False: 2.55k] ------------------ 284| 2| flb_error("[gzip] invalid flag"); ------------------ | | 170| 2| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 2|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 2, False: 0] | | ------------------ | | 171| 2| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 2|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 285| 2| return -1; 286| 2| } 287| | 288| | /* Skip base header of 10 bytes */ 289| 2.55k| start = p + FLB_GZIP_HEADER_OFFSET; ------------------ | | 28| 2.55k|#define FLB_GZIP_HEADER_OFFSET 10 ------------------ 290| | 291| | /* Skip extra data if present */ 292| 2.55k| if (flg & FEXTRA) { ------------------ | Branch (292:9): [True: 86, False: 2.47k] ------------------ 293| 86| xlen = read_le16(start); 294| 86| if (xlen > in_len - 12) { ------------------ | Branch (294:13): [True: 13, False: 73] ------------------ 295| 13| flb_error("[gzip] invalid gzip data"); ------------------ | | 170| 13| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 13|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 13, False: 0] | | ------------------ | | 171| 13| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 13|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 296| 13| return -1; 297| 13| } 298| 73| start += xlen + 2; 299| 73| } 300| | 301| | /* Skip file name if present */ 302| 2.54k| if (flg & FNAME) { ------------------ | Branch (302:9): [True: 166, False: 2.38k] ------------------ 303| 102k| do { 304| 102k| if (start - p >= in_len) { ------------------ | Branch (304:17): [True: 5, False: 102k] ------------------ 305| 5| flb_error("[gzip] invalid gzip data (FNAME)"); ------------------ | | 170| 5| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 5|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 5, False: 0] | | ------------------ | | 171| 5| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 5|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 306| 5| return -1; 307| 5| } 308| 102k| } while (*start++); ------------------ | Branch (308:18): [True: 102k, False: 161] ------------------ 309| 166| } 310| | 311| | /* Skip file comment if present */ 312| 2.54k| if (flg & FCOMMENT) { ------------------ | Branch (312:9): [True: 126, False: 2.41k] ------------------ 313| 128k| do { 314| 128k| if (start - p >= in_len) { ------------------ | Branch (314:17): [True: 10, False: 128k] ------------------ 315| 10| flb_error("[gzip] invalid gzip data (FCOMMENT)"); ------------------ | | 170| 10| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 10|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 10, False: 0] | | ------------------ | | 171| 10| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 10|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 316| 10| return -1; 317| 10| } 318| 128k| } while (*start++); ------------------ | Branch (318:18): [True: 128k, False: 116] ------------------ 319| 126| } 320| | 321| | /* Check header crc if present */ 322| 2.53k| if (flg & FHCRC) { ------------------ | Branch (322:9): [True: 68, False: 2.46k] ------------------ 323| 68| if (start - p > in_len - 2) { ------------------ | Branch (323:13): [True: 11, False: 57] ------------------ 324| 11| flb_error("[gzip] invalid gzip data (FHRC)"); ------------------ | | 170| 11| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 11|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 11, False: 0] | | ------------------ | | 171| 11| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 11|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 325| 11| return -1; 326| 11| } 327| | 328| 57| hcrc = read_le16(start); 329| 57| crc = mz_crc32(MZ_CRC32_INIT, p, start - p) & 0x0000FFFF; ------------------ | | 241| 57|#define MZ_CRC32_INIT (0) ------------------ 330| 57| if (hcrc != crc) { ------------------ | Branch (330:13): [True: 55, False: 2] ------------------ 331| 55| flb_error("[gzip] invalid gzip header CRC"); ------------------ | | 170| 55| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 55|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 55, False: 0] | | ------------------ | | 171| 55| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 55|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 332| 55| return -1; 333| 55| } 334| 2| start += 2; 335| 2| } 336| | 337| | /* Get decompressed length */ 338| 2.46k| dlen = read_le32(&p[in_len - 4]); 339| | 340| | /* Limit decompressed length to 100MB */ 341| 2.46k| if (dlen > 100000000) { ------------------ | Branch (341:9): [True: 20, False: 2.44k] ------------------ 342| 20| flb_error("[gzip] maximum decompression size is 100MB"); ------------------ | | 170| 20| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 20|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 20, False: 0] | | ------------------ | | 171| 20| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 20|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 343| 20| return -1; 344| 20| } 345| | 346| | /* Get CRC32 checksum of original data */ 347| 2.44k| crc = read_le32(&p[in_len - 8]); 348| | 349| | /* Decompress data */ 350| 2.44k| if ((p + in_len) - p < 8) { ------------------ | Branch (350:9): [True: 0, False: 2.44k] ------------------ 351| 0| flb_error("[gzip] invalid gzip CRC32 checksum"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 352| 0| return -1; 353| 0| } 354| | 355| | /* Allocate outgoing buffer */ 356| 2.44k| out_buf = flb_malloc(dlen); 357| 2.44k| if (!out_buf) { ------------------ | Branch (357:9): [True: 2, False: 2.44k] ------------------ 358| 2| flb_errno(); ------------------ | | 232| 2|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 359| 2| return -1; 360| 2| } 361| 2.44k| out_size = dlen; 362| | 363| | /* Ensure size is above 0 */ 364| 2.44k| if (((p + in_len) - start - 8) <= 0) { ------------------ | Branch (364:9): [True: 4, False: 2.43k] ------------------ 365| 4| flb_free(out_buf); 366| 4| return -1; 367| 4| } 368| | 369| | /* Map zip content */ 370| 2.43k| zip_data = (uint8_t *) start; 371| 2.43k| zip_len = (p + in_len) - start - 8; 372| | 373| 2.43k| memset(&stream, 0, sizeof(stream)); 374| 2.43k| stream.next_in = zip_data; 375| 2.43k| stream.avail_in = zip_len; 376| 2.43k| stream.next_out = out_buf; 377| 2.43k| stream.avail_out = out_size; 378| | 379| 2.43k| status = mz_inflateInit2(&stream, -Z_DEFAULT_WINDOW_BITS); ------------------ | | 480| 2.43k|#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS | | ------------------ | | | | 311| 2.43k|#define MZ_DEFAULT_WINDOW_BITS 15 | | ------------------ ------------------ 380| 2.43k| if (status != MZ_OK) { ------------------ | Branch (380:9): [True: 0, False: 2.43k] ------------------ 381| 0| flb_free(out_buf); 382| 0| return -1; 383| 0| } 384| | 385| 2.43k| status = mz_inflate(&stream, MZ_FINISH); 386| 2.43k| if (status != MZ_STREAM_END) { ------------------ | Branch (386:9): [True: 322, False: 2.11k] ------------------ 387| 322| mz_inflateEnd(&stream); 388| 322| flb_free(out_buf); 389| 322| return -1; 390| 322| } 391| | 392| 2.11k| if (stream.total_out != dlen) { ------------------ | Branch (392:9): [True: 27, False: 2.09k] ------------------ 393| 27| mz_inflateEnd(&stream); 394| 27| flb_free(out_buf); 395| 27| flb_error("[gzip] invalid gzip data size"); ------------------ | | 170| 27| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 27|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 27, False: 0] | | ------------------ | | 171| 27| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 27|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 396| 27| return -1; 397| 27| } 398| | 399| | /* terminate the stream, it's not longer required */ 400| 2.09k| mz_inflateEnd(&stream); 401| | 402| | /* Validate message CRC vs inflated data CRC */ 403| 2.09k| crc_out = mz_crc32(MZ_CRC32_INIT, out_buf, dlen); ------------------ | | 241| 2.09k|#define MZ_CRC32_INIT (0) ------------------ 404| 2.09k| if (crc_out != crc) { ------------------ | Branch (404:9): [True: 47, False: 2.04k] ------------------ 405| 47| flb_free(out_buf); 406| 47| flb_error("[gzip] invalid GZip checksum (CRC32)"); ------------------ | | 170| 47| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 47|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 47, False: 0] | | ------------------ | | 171| 47| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 47|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 407| 47| return -1; 408| 47| } 409| | 410| | /* set the uncompressed data */ 411| 2.04k| *out_len = dlen; 412| 2.04k| *out_data = out_buf; 413| | 414| 2.04k| return 0; 415| 2.09k|} flb_gzip.c:gzip_header: 71| 2.04k|{ 72| 2.04k| uint8_t *p; 73| | 74| | /* GZip Magic bytes */ 75| 2.04k| p = buf; 76| 2.04k| *p++ = 0x1F; 77| 2.04k| *p++ = 0x8B; 78| 2.04k| *p++ = 8; 79| 2.04k| *p++ = 0; 80| 2.04k| *p++ = 0; 81| 2.04k| *p++ = 0; 82| 2.04k| *p++ = 0; 83| 2.04k| *p++ = 0; 84| 2.04k| *p++ = 0; 85| 2.04k| *p++ = 0xFF; 86| 2.04k|} flb_gzip.c:read_le16: 58| 143|{ 59| 143| return ((unsigned int) p[0]) | ((unsigned int) p[1] << 8); 60| 143|} flb_gzip.c:read_le32: 63| 4.91k|{ 64| 4.91k| return ((unsigned int) p[0]) 65| 4.91k| | ((unsigned int) p[1] << 8) 66| 4.91k| | ((unsigned int) p[2] << 16) 67| 4.91k| | ((unsigned int) p[3] << 24); 68| 4.91k|} flb_hash_init: 42| 2.04k|{ 43| 2.04k| const EVP_MD *digest_algorithm; 44| 2.04k| int result; 45| | 46| 2.04k| if (context == NULL) { ------------------ | Branch (46:9): [True: 0, False: 2.04k] ------------------ 47| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 48| 0| } 49| | 50| 2.04k| digest_algorithm = flb_crypto_get_digest_algorithm_instance_by_id(hash_type); 51| | 52| 2.04k| if (digest_algorithm == NULL) { ------------------ | Branch (52:9): [True: 0, False: 2.04k] ------------------ 53| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 54| 0| } 55| | 56| 2.04k| context->backend_context = EVP_MD_CTX_create(); 57| | 58| 2.04k| if (context->backend_context == NULL) { ------------------ | Branch (58:9): [True: 0, False: 2.04k] ------------------ 59| 0| context->last_error = ERR_get_error(); 60| | 61| 0| return FLB_CRYPTO_BACKEND_ERROR; ------------------ | | 32| 0|#define FLB_CRYPTO_BACKEND_ERROR 1 ------------------ 62| 0| } 63| | 64| 2.04k| result = EVP_DigestInit_ex(context->backend_context, digest_algorithm, 0); 65| | 66| 2.04k| if (result == 0) { ------------------ | Branch (66:9): [True: 0, False: 2.04k] ------------------ 67| 0| context->last_error = ERR_get_error(); 68| | 69| 0| return FLB_CRYPTO_BACKEND_ERROR; ------------------ | | 32| 0|#define FLB_CRYPTO_BACKEND_ERROR 1 ------------------ 70| 0| } 71| | 72| 2.04k| context->digest_size = EVP_MD_CTX_size(context->backend_context); 73| | 74| 2.04k| return FLB_CRYPTO_SUCCESS; ------------------ | | 31| 2.04k|#define FLB_CRYPTO_SUCCESS 0 ------------------ 75| 2.04k|} flb_hash_finalize: 80| 2.04k|{ 81| 2.04k| unsigned int digest_length; 82| 2.04k| int result; 83| | 84| 2.04k| if (context->backend_context == NULL) { ------------------ | Branch (84:9): [True: 0, False: 2.04k] ------------------ 85| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 86| 0| } 87| | 88| 2.04k| if (digest_buffer == NULL) { ------------------ | Branch (88:9): [True: 0, False: 2.04k] ------------------ 89| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 90| 0| } 91| | 92| 2.04k| if (digest_buffer_size < context->digest_size) { ------------------ | Branch (92:9): [True: 0, False: 2.04k] ------------------ 93| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 94| 0| } 95| | 96| 2.04k| result = EVP_DigestFinal_ex(context->backend_context, 97| 2.04k| digest_buffer, &digest_length); 98| | 99| 2.04k| if (result == 0) { ------------------ | Branch (99:9): [True: 0, False: 2.04k] ------------------ 100| 0| context->last_error = ERR_get_error(); 101| | 102| 0| return FLB_CRYPTO_BACKEND_ERROR; ------------------ | | 32| 0|#define FLB_CRYPTO_BACKEND_ERROR 1 ------------------ 103| 0| } 104| | 105| 2.04k| (void) digest_length; 106| | 107| 2.04k| return FLB_CRYPTO_SUCCESS; ------------------ | | 31| 2.04k|#define FLB_CRYPTO_SUCCESS 0 ------------------ 108| 2.04k|} flb_hash_update: 113| 6.12k|{ 114| 6.12k| int result; 115| | 116| 6.12k| if (context->backend_context == NULL) { ------------------ | Branch (116:9): [True: 0, False: 6.12k] ------------------ 117| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 118| 0| } 119| | 120| 6.12k| if (data == NULL) { ------------------ | Branch (120:9): [True: 0, False: 6.12k] ------------------ 121| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 122| 0| } 123| | 124| 6.12k| result = EVP_DigestUpdate(context->backend_context, 125| 6.12k| data, 126| 6.12k| data_length); 127| | 128| 6.12k| if (result == 0) { ------------------ | Branch (128:9): [True: 0, False: 6.12k] ------------------ 129| 0| context->last_error = ERR_get_error(); 130| | 131| 0| return FLB_CRYPTO_BACKEND_ERROR; ------------------ | | 32| 0|#define FLB_CRYPTO_BACKEND_ERROR 1 ------------------ 132| 0| } 133| | 134| 6.12k| return FLB_CRYPTO_SUCCESS; ------------------ | | 31| 6.12k|#define FLB_CRYPTO_SUCCESS 0 ------------------ 135| 6.12k|} flb_hash_cleanup: 138| 2.04k|{ 139| 2.04k| if (context->backend_context == NULL) { ------------------ | Branch (139:9): [True: 0, False: 2.04k] ------------------ 140| 0| return FLB_CRYPTO_INVALID_ARGUMENT; ------------------ | | 34| 0|#define FLB_CRYPTO_INVALID_ARGUMENT 3 ------------------ 141| 0| } 142| | 143| 2.04k| EVP_MD_CTX_destroy(context->backend_context); 144| | 145| 2.04k| context->backend_context = NULL; 146| | 147| 2.04k| return FLB_CRYPTO_SUCCESS; ------------------ | | 31| 2.04k|#define FLB_CRYPTO_SUCCESS 0 ------------------ 148| 2.04k|} flb_hash.c:flb_crypto_get_digest_algorithm_instance_by_id: 22| 2.04k|{ 23| 2.04k| const EVP_MD *algorithm; 24| | 25| 2.04k| if (algorithm_id == FLB_HASH_SHA256) { ------------------ | | 48| 2.04k|#define FLB_HASH_SHA256 2 ------------------ | Branch (25:9): [True: 0, False: 2.04k] ------------------ 26| 0| algorithm = EVP_sha256(); 27| 0| } 28| 2.04k| else if (algorithm_id == FLB_HASH_SHA512) { ------------------ | | 49| 2.04k|#define FLB_HASH_SHA512 3 ------------------ | Branch (28:14): [True: 2.04k, False: 0] ------------------ 29| 2.04k| algorithm = EVP_sha512(); 30| 2.04k| } 31| 0| else if (algorithm_id == FLB_HASH_MD5) { ------------------ | | 47| 0|#define FLB_HASH_MD5 1 ------------------ | Branch (31:14): [True: 0, False: 0] ------------------ 32| 0| algorithm = EVP_md5(); 33| 0| } 34| 0| else { 35| 0| algorithm = NULL; 36| 0| } 37| | 38| 2.04k| return algorithm; 39| 2.04k|} flb_hash_table_create: 103| 2.04k|{ 104| 2.04k| int i; 105| 2.04k| struct flb_hash_table_chain *tmp; 106| 2.04k| struct flb_hash_table *ht; 107| | 108| 2.04k| if (size <= 0) { ------------------ | Branch (108:9): [True: 58, False: 1.98k] ------------------ 109| 58| return NULL; 110| 58| } 111| | 112| 1.98k| ht = flb_calloc(1, sizeof(struct flb_hash_table)); 113| 1.98k| if (!ht) { ------------------ | Branch (113:9): [True: 0, False: 1.98k] ------------------ 114| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 115| 0| return NULL; 116| 0| } 117| | 118| 1.98k| mk_list_init(&ht->entries); 119| 1.98k| ht->evict_mode = evict_mode; 120| 1.98k| ht->max_entries = max_entries; 121| 1.98k| ht->size = size; 122| 1.98k| ht->total_count = 0; 123| 1.98k| ht->cache_ttl = 0; 124| 1.98k| ht->case_sensitivity = FLB_TRUE; ------------------ | | 26| 1.98k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 1.98k|#define FLB_FALSE 0 | | ------------------ ------------------ 125| 1.98k| ht->table = flb_calloc(1, sizeof(struct flb_hash_table_chain) * size); 126| 1.98k| if (!ht->table) { ------------------ | Branch (126:9): [True: 0, False: 1.98k] ------------------ 127| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 128| 0| flb_free(ht); 129| 0| return NULL; 130| 0| } 131| | 132| | /* Initialize chains list head */ 133| 115k| for (i = 0; i < size; i++) { ------------------ | Branch (133:17): [True: 113k, False: 1.98k] ------------------ 134| 113k| tmp = &ht->table[i]; 135| 113k| tmp->count = 0; 136| 113k| mk_list_init(&tmp->chains); 137| 113k| } 138| | 139| 1.98k| return ht; 140| 1.98k|} flb_hash_table_del_ptr: 159| 1.98k|{ 160| 1.98k| int id; 161| 1.98k| int result; 162| 1.98k| uint64_t hash; 163| 1.98k| struct mk_list *head; 164| 1.98k| struct flb_hash_table_entry *entry = NULL; 165| 1.98k| struct flb_hash_table_chain *table; 166| | 167| | /* Generate hash number */ 168| 1.98k| result = flb_hash_table_compute_key_hash( 169| 1.98k| &hash, 170| 1.98k| key, key_len, 171| 1.98k| ht->case_sensitivity); 172| | 173| 1.98k| if (result != 0) { ------------------ | Branch (173:9): [True: 0, False: 1.98k] ------------------ 174| 0| return -1; 175| 0| } 176| | 177| 1.98k| id = (hash % ht->size); 178| | 179| | /* Link the new entry in our table at the end of the list */ 180| 1.98k| table = &ht->table[id]; 181| | 182| 9.84k| mk_list_foreach(head, &table->chains) { ------------------ | | 205| 11.8k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 9.84k, False: 1.98k] | | ------------------ ------------------ 183| 9.84k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 9.84k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 9.84k|#define container_of(ptr, type, member) ({ \ | | | | 39| 9.84k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 9.84k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 184| 9.84k| if (strncmp(entry->key, key, key_len) == 0 && entry->val == ptr) { ------------------ | Branch (184:13): [True: 1.47k, False: 8.37k] | Branch (184:55): [True: 0, False: 1.47k] ------------------ 185| 0| break; 186| 0| } 187| 9.84k| entry = NULL; 188| 9.84k| } 189| | 190| 1.98k| if (!entry) { ------------------ | Branch (190:9): [True: 1.98k, False: 0] ------------------ 191| 1.98k| return -1; 192| 1.98k| } 193| | 194| | /* delete the entry */ 195| 0| flb_hash_table_entry_free(ht, entry); 196| 0| return 0; 197| 1.98k|} flb_hash_table_destroy: 201| 1.98k|{ 202| 1.98k| int i; 203| 1.98k| struct mk_list *tmp; 204| 1.98k| struct mk_list *head; 205| 1.98k| struct flb_hash_table_entry *entry; 206| 1.98k| struct flb_hash_table_chain *table; 207| | 208| 115k| for (i = 0; i < ht->size; i++) { ------------------ | Branch (208:17): [True: 113k, False: 1.98k] ------------------ 209| 113k| table = &ht->table[i]; 210| 113k| mk_list_foreach_safe(head, tmp, &table->chains) { ------------------ | | 207| 213k| for (curr = (head)->next, n = curr->next; curr != (head); curr = n, n = curr->next) | | ------------------ | | | Branch (207:47): [True: 100k, False: 113k] | | ------------------ ------------------ 211| 100k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 100k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 100k|#define container_of(ptr, type, member) ({ \ | | | | 39| 100k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 100k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 212| 100k| flb_hash_table_entry_free(ht, entry); 213| 100k| } 214| 113k| } 215| | 216| 1.98k| flb_free(ht->table); 217| 1.98k| flb_free(ht); 218| 1.98k|} flb_hash_table_add: 406| 255k|{ 407| 255k| int id; 408| 255k| int ret; 409| 255k| uint64_t hash; 410| 255k| struct flb_hash_table_entry *entry; 411| 255k| struct flb_hash_table_chain *table; 412| | 413| 255k| if (!key || key_len <= 0) { ------------------ | Branch (413:9): [True: 0, False: 255k] | Branch (413:17): [True: 0, False: 255k] ------------------ 414| 0| return -1; 415| 0| } 416| | 417| | /* Check capacity */ 418| 255k| if (ht->max_entries > 0 && ht->total_count >= ht->max_entries) { ------------------ | Branch (418:9): [True: 254k, False: 1.41k] | Branch (418:32): [True: 64.3k, False: 189k] ------------------ 419| 64.3k| if (ht->evict_mode == FLB_HASH_TABLE_EVICT_NONE) { ------------------ | | 32| 64.3k|#define FLB_HASH_TABLE_EVICT_NONE 0 ------------------ | Branch (419:13): [True: 7.75k, False: 56.6k] ------------------ 420| | /* Do nothing */ 421| 7.75k| } 422| 56.6k| else if (ht->evict_mode == FLB_HASH_TABLE_EVICT_OLDER) { ------------------ | | 33| 56.6k|#define FLB_HASH_TABLE_EVICT_OLDER 1 ------------------ | Branch (422:18): [True: 5.98k, False: 50.6k] ------------------ 423| 5.98k| flb_hash_table_evict_older(ht); 424| 5.98k| } 425| 50.6k| else if (ht->evict_mode == FLB_HASH_TABLE_EVICT_LESS_USED) { ------------------ | | 34| 50.6k|#define FLB_HASH_TABLE_EVICT_LESS_USED 2 ------------------ | Branch (425:18): [True: 46.4k, False: 4.25k] ------------------ 426| 46.4k| flb_hash_table_evict_less_used(ht); 427| 46.4k| } 428| 4.25k| else if (ht->evict_mode == FLB_HASH_TABLE_EVICT_RANDOM) { ------------------ | | 35| 4.25k|#define FLB_HASH_TABLE_EVICT_RANDOM 3 ------------------ | Branch (428:18): [True: 4.25k, False: 0] ------------------ 429| 4.25k| flb_hash_table_evict_random(ht); 430| 4.25k| } 431| 64.3k| } 432| | 433| | /* Check if this is a replacement */ 434| 255k| entry = hash_get_entry(ht, key, key_len, &id); 435| 255k| if (entry) { ------------------ | Branch (435:9): [True: 98.5k, False: 157k] ------------------ 436| | /* 437| | * The key already exists, just perform a value replacement, check if the 438| | * value refers to our own previous allocation. 439| | */ 440| 98.5k| ret = entry_set_value(entry, val, val_size); 441| 98.5k| if (ret == -1) { ------------------ | Branch (441:13): [True: 0, False: 98.5k] ------------------ 442| 0| return -1; 443| 0| } 444| | 445| 98.5k| return id; 446| 98.5k| } 447| | 448| | /* 449| | * Below is just code to handle the creation of a new entry in the table 450| | */ 451| | 452| 157k| ret = flb_hash_table_compute_key_hash( 453| 157k| &hash, 454| 157k| key, key_len, 455| 157k| ht->case_sensitivity); 456| | 457| 157k| if (ret != 0) { ------------------ | Branch (457:9): [True: 0, False: 157k] ------------------ 458| 0| return -1; 459| 0| } 460| | 461| 157k| id = (hash % ht->size); 462| | 463| | /* Allocate the entry */ 464| 157k| entry = flb_calloc(1, sizeof(struct flb_hash_table_entry)); 465| 157k| if (!entry) { ------------------ | Branch (465:9): [True: 0, False: 157k] ------------------ 466| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 467| 0| return -1; 468| 0| } 469| 157k| entry->created = time(NULL); 470| 157k| entry->hash = hash; 471| 157k| entry->hits = 0; 472| | 473| | /* Store the key and value as a new memory region */ 474| 157k| entry->key = flb_strndup(key, key_len); 475| 157k| entry->key_len = key_len; 476| 157k| entry->val_size = 0; 477| | 478| | /* store or reference the value */ 479| 157k| ret = entry_set_value(entry, val, val_size); 480| 157k| if (ret == -1) { ------------------ | Branch (480:9): [True: 0, False: 157k] ------------------ 481| 0| flb_free(entry); 482| 0| return -1; 483| 0| } 484| | 485| | /* Link the new entry in our table at the end of the list */ 486| 157k| table = &ht->table[id]; 487| 157k| entry->table = table; 488| | 489| | /* Add the new entry */ 490| 157k| mk_list_add(&entry->_head, &table->chains); 491| 157k| mk_list_add(&entry->_head_parent, &ht->entries); 492| | 493| | /* Update counters */ 494| 157k| table->count++; 495| 157k| ht->total_count++; 496| | 497| 157k| return id; 498| 157k|} flb_hash_table_get: 503| 1.98k|{ 504| 1.98k| int id; 505| 1.98k| struct flb_hash_table_entry *entry; 506| 1.98k| time_t expiration; 507| | 508| 1.98k| entry = hash_get_entry(ht, key, key_len, &id); 509| 1.98k| if (!entry) { ------------------ | Branch (509:9): [True: 0, False: 1.98k] ------------------ 510| 0| return -1; 511| 0| } 512| | 513| 1.98k| if (ht->cache_ttl > 0) { ------------------ | Branch (513:9): [True: 0, False: 1.98k] ------------------ 514| 0| expiration = entry->created + ht->cache_ttl; 515| 0| if (time(NULL) > expiration) { ------------------ | Branch (515:13): [True: 0, False: 0] ------------------ 516| 0| flb_hash_table_entry_free(ht, entry); 517| 0| return -1; 518| 0| } 519| 0| } 520| | 521| 1.98k| entry->hits++; 522| 1.98k| *out_buf = entry->val; 523| 1.98k| *out_size = entry->val_size; 524| | 525| 1.98k| return id; 526| 1.98k|} flb_hash_table_exists: 530| 1.98k|{ 531| 1.98k| int id; 532| 1.98k| struct mk_list *head; 533| 1.98k| struct flb_hash_table_chain *table; 534| 1.98k| struct flb_hash_table_entry *entry; 535| | 536| 1.98k| id = (hash % ht->size); 537| 1.98k| table = &ht->table[id]; 538| | 539| | /* Iterate entries */ 540| 9.63k| mk_list_foreach(head, &table->chains) { ------------------ | | 205| 11.6k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 9.63k, False: 1.98k] | | ------------------ ------------------ 541| 9.63k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 9.63k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 9.63k|#define container_of(ptr, type, member) ({ \ | | | | 39| 9.63k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 9.63k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 542| 9.63k| if (entry->hash == hash) { ------------------ | Branch (542:13): [True: 1, False: 9.62k] ------------------ 543| 1| return FLB_TRUE; ------------------ | | 26| 1|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 1|#define FLB_FALSE 0 | | ------------------ ------------------ 544| 1| } 545| 9.63k| } 546| | 547| 1.98k| return FLB_FALSE; ------------------ | | 25| 1.98k|#define FLB_FALSE 0 ------------------ 548| 1.98k|} flb_hash_table_get_by_id: 557| 39.6k|{ 558| 39.6k| struct mk_list *head; 559| 39.6k| struct flb_hash_table_entry *entry = NULL; 560| 39.6k| struct flb_hash_table_chain *table; 561| | 562| 39.6k| if (ht->size <= id) { ------------------ | Branch (562:9): [True: 26.7k, False: 12.8k] ------------------ 563| 26.7k| return -1; 564| 26.7k| } 565| | 566| 12.8k| table = &ht->table[id]; 567| 12.8k| if (table->count == 0) { ------------------ | Branch (567:9): [True: 5.85k, False: 7.04k] ------------------ 568| 5.85k| return -1; 569| 5.85k| } 570| | 571| 7.04k| if (table->count == 1) { ------------------ | Branch (571:9): [True: 3.53k, False: 3.50k] ------------------ 572| 3.53k| entry = mk_list_entry_first(&table->chains, ------------------ | | 226| 3.53k|#define mk_list_entry_first(ptr, type, member) container_of((ptr)->next, type, member) | | ------------------ | | | | 38| 3.53k|#define container_of(ptr, type, member) ({ \ | | | | 39| 3.53k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 3.53k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 573| 3.53k| struct flb_hash_table_entry, _head); 574| 3.53k| } 575| 3.50k| else { 576| 10.1k| mk_list_foreach(head, &table->chains) { ------------------ | | 205| 13.2k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 10.1k, False: 3.10k] | | ------------------ ------------------ 577| 10.1k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 10.1k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 10.1k|#define container_of(ptr, type, member) ({ \ | | | | 39| 10.1k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 10.1k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 578| 10.1k| if (strcmp(entry->key, key) == 0) { ------------------ | Branch (578:17): [True: 407, False: 9.71k] ------------------ 579| 407| break; 580| 407| } 581| 9.71k| entry = NULL; 582| 9.71k| } 583| 3.50k| } 584| | 585| 7.04k| if (!entry) { ------------------ | Branch (585:9): [True: 3.10k, False: 3.94k] ------------------ 586| 3.10k| return -1; 587| 3.10k| } 588| | 589| 3.94k| *out_buf = entry->val; 590| 3.94k| *out_size = entry->val_size; 591| | 592| 3.94k| return 0; 593| 7.04k|} flb_hash_table_get_ptr: 596| 1.98k|{ 597| 1.98k| int id; 598| 1.98k| struct flb_hash_table_entry *entry; 599| | 600| 1.98k| entry = hash_get_entry(ht, key, key_len, &id); 601| 1.98k| if (!entry) { ------------------ | Branch (601:9): [True: 1.97k, False: 4] ------------------ 602| 1.97k| return NULL; 603| 1.97k| } 604| | 605| 4| entry->hits++; 606| 4| return entry->val; 607| 1.98k|} flb_hash_table_del: 610| 1.98k|{ 611| 1.98k| int id; 612| 1.98k| int len; 613| 1.98k| int result; 614| 1.98k| uint64_t hash; 615| 1.98k| struct mk_list *head; 616| 1.98k| struct flb_hash_table_entry *entry = NULL; 617| 1.98k| struct flb_hash_table_chain *table; 618| | 619| 1.98k| if (!key) { ------------------ | Branch (619:9): [True: 0, False: 1.98k] ------------------ 620| 0| return -1; 621| 0| } 622| | 623| 1.98k| len = strlen(key); 624| 1.98k| if (len == 0) { ------------------ | Branch (624:9): [True: 9, False: 1.97k] ------------------ 625| 9| return -1; 626| 9| } 627| | 628| 1.97k| result = flb_hash_table_compute_key_hash( 629| 1.97k| &hash, 630| 1.97k| key, len, 631| 1.97k| ht->case_sensitivity); 632| | 633| 1.97k| if (result != 0) { ------------------ | Branch (633:9): [True: 0, False: 1.97k] ------------------ 634| 0| return -1; 635| 0| } 636| | 637| 1.97k| id = (hash % ht->size); 638| | 639| 1.97k| table = &ht->table[id]; 640| 1.97k| if (table->count == 1) { ------------------ | Branch (640:9): [True: 632, False: 1.34k] ------------------ 641| 632| entry = mk_list_entry_first(&table->chains, ------------------ | | 226| 632|#define mk_list_entry_first(ptr, type, member) container_of((ptr)->next, type, member) | | ------------------ | | | | 38| 632|#define container_of(ptr, type, member) ({ \ | | | | 39| 632| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 632| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 642| 632| struct flb_hash_table_entry, 643| 632| _head); 644| 632| if (ht->case_sensitivity) { ------------------ | Branch (644:13): [True: 632, False: 0] ------------------ 645| 632| if (strncmp(entry->key, key, len) != 0) { ------------------ | Branch (645:17): [True: 628, False: 4] ------------------ 646| 628| entry = NULL; 647| 628| } 648| 632| } 649| 0| else { 650| 0| if (strncasecmp(entry->key, key, len) != 0) { ------------------ | Branch (650:17): [True: 0, False: 0] ------------------ 651| 0| entry = NULL; 652| 0| } 653| 0| } 654| 632| } 655| 1.34k| else { 656| 9.37k| mk_list_foreach(head, &table->chains) { ------------------ | | 205| 10.6k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 9.37k, False: 1.32k] | | ------------------ ------------------ 657| 9.37k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 9.37k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 9.37k|#define container_of(ptr, type, member) ({ \ | | | | 39| 9.37k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 9.37k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 658| | 659| 9.37k| if (ht->case_sensitivity) { ------------------ | Branch (659:17): [True: 9.37k, False: 0] ------------------ 660| 9.37k| if (strncmp(entry->key, key, len) == 0) { ------------------ | Branch (660:21): [True: 19, False: 9.35k] ------------------ 661| 19| break; 662| 19| } 663| 9.37k| } 664| 0| else { 665| 0| if (strncasecmp(entry->key, key, len) == 0) { ------------------ | Branch (665:21): [True: 0, False: 0] ------------------ 666| 0| break; 667| 0| } 668| 0| } 669| | 670| 9.35k| entry = NULL; 671| 9.35k| } 672| 1.34k| } 673| | 674| 1.97k| if (!entry) { ------------------ | Branch (674:9): [True: 1.95k, False: 23] ------------------ 675| 1.95k| return -1; 676| 1.95k| } 677| | 678| 23| flb_hash_table_entry_free(ht, entry); 679| | 680| 23| return 0; 681| 1.97k|} flb_hash_table.c:flb_hash_table_compute_key_hash: 56| 420k|{ 57| 420k| char local_caseless_key_buffer[64]; 58| 420k| char *caseless_key_buffer; 59| | 60| 420k| if (!case_sensitivity) { ------------------ | Branch (60:9): [True: 0, False: 420k] ------------------ 61| 0| if (key_len > (sizeof(local_caseless_key_buffer) - 1)) { ------------------ | Branch (61:13): [True: 0, False: 0] ------------------ 62| 0| caseless_key_buffer = NULL; 63| 0| } 64| 0| else { 65| 0| caseless_key_buffer = local_caseless_key_buffer; 66| 0| } 67| | 68| 0| key = flb_hash_table_convert_string_to_lowercase(caseless_key_buffer, 69| 0| key, 70| 0| key_len); 71| | 72| 0| if (key == NULL) { ------------------ | Branch (72:13): [True: 0, False: 0] ------------------ 73| 0| return -1; 74| 0| } 75| 0| } 76| | 77| 420k| *hash = cfl_hash_64bits(key, key_len); ------------------ | | 33| 420k|#define cfl_hash_64bits XXH3_64bits | | ------------------ | | | | 286| 420k|# define XXH3_64bits XXH_NAME2(XXH_NAMESPACE, XXH3_64bits) | | | | ------------------ | | | | | | 263| 420k|# define XXH_NAME2(A,B) XXH_CAT(A,B) | | | | | | ------------------ | | | | | | | | 262| 420k|# define XXH_CAT(A,B) A##B | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 78| | 79| 420k| if (!case_sensitivity) { ------------------ | Branch (79:9): [True: 0, False: 420k] ------------------ 80| 0| if (caseless_key_buffer != local_caseless_key_buffer) { ------------------ | Branch (80:13): [True: 0, False: 0] ------------------ 81| 0| flb_free(caseless_key_buffer); 82| 0| } 83| 0| } 84| | 85| 420k| return 0; 86| 420k|} flb_hash_table.c:flb_hash_table_entry_free: 90| 157k|{ 91| 157k| mk_list_del(&entry->_head); 92| 157k| mk_list_del(&entry->_head_parent); 93| 157k| entry->table->count--; 94| 157k| ht->total_count--; 95| 157k| flb_free(entry->key); 96| 157k| if (entry->val && entry->val_size > 0) { ------------------ | Branch (96:9): [True: 157k, False: 0] | Branch (96:23): [True: 157k, False: 0] ------------------ 97| 157k| flb_free(entry->val); 98| 157k| } 99| 157k| flb_free(entry); 100| 157k|} flb_hash_table.c:flb_hash_table_evict_older: 268| 5.98k|{ 269| 5.98k| struct flb_hash_table_entry *entry; 270| | 271| 5.98k| entry = mk_list_entry_first(&ht->entries, struct flb_hash_table_entry, _head_parent); ------------------ | | 226| 5.98k|#define mk_list_entry_first(ptr, type, member) container_of((ptr)->next, type, member) | | ------------------ | | | | 38| 5.98k|#define container_of(ptr, type, member) ({ \ | | | | 39| 5.98k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 5.98k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 272| 5.98k| flb_hash_table_entry_free(ht, entry); 273| 5.98k|} flb_hash_table.c:flb_hash_table_evict_less_used: 249| 46.4k|{ 250| 46.4k| struct mk_list *head; 251| 46.4k| struct flb_hash_table_entry *entry; 252| 46.4k| struct flb_hash_table_entry *entry_less_used = NULL; 253| | 254| 279k| mk_list_foreach(head, &ht->entries) { ------------------ | | 205| 325k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 279k, False: 46.4k] | | ------------------ ------------------ 255| 279k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head_parent); ------------------ | | 214| 279k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 279k|#define container_of(ptr, type, member) ({ \ | | | | 39| 279k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 279k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 256| 279k| if (!entry_less_used) { ------------------ | Branch (256:13): [True: 46.4k, False: 232k] ------------------ 257| 46.4k| entry_less_used = entry; 258| 46.4k| } 259| 232k| else if (entry->hits < entry_less_used->hits) { ------------------ | Branch (259:18): [True: 42.5k, False: 190k] ------------------ 260| 42.5k| entry_less_used = entry; 261| 42.5k| } 262| 279k| } 263| | 264| 46.4k| flb_hash_table_entry_free(ht, entry_less_used); 265| 46.4k|} flb_hash_table.c:flb_hash_table_evict_random: 230| 4.25k|{ 231| 4.25k| int id; 232| 4.25k| int count = 0; 233| 4.25k| struct mk_list *tmp; 234| 4.25k| struct mk_list *head; 235| 4.25k| struct flb_hash_table_entry *entry; 236| | 237| 4.25k| id = random() % ht->total_count; 238| 86.0k| mk_list_foreach_safe(head, tmp, &ht->entries) { ------------------ | | 207| 86.0k| for (curr = (head)->next, n = curr->next; curr != (head); curr = n, n = curr->next) | | ------------------ | | | Branch (207:47): [True: 86.0k, False: 0] | | ------------------ ------------------ 239| 86.0k| if (id == count) { ------------------ | Branch (239:13): [True: 4.25k, False: 81.8k] ------------------ 240| 4.25k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head_parent); ------------------ | | 214| 4.25k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 4.25k|#define container_of(ptr, type, member) ({ \ | | | | 39| 4.25k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 4.25k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 241| 4.25k| flb_hash_table_entry_free(ht, entry); 242| 4.25k| break; 243| 4.25k| } 244| 81.8k| count++; 245| 81.8k| } 246| 4.25k|} flb_hash_table.c:hash_get_entry: 277| 259k|{ 278| 259k| int id; 279| 259k| int result; 280| 259k| uint64_t hash; 281| 259k| struct mk_list *head; 282| 259k| struct flb_hash_table_chain *table; 283| 259k| struct flb_hash_table_entry *entry; 284| | 285| 259k| if (!key || key_len <= 0) { ------------------ | Branch (285:9): [True: 0, False: 259k] | Branch (285:17): [True: 137, False: 259k] ------------------ 286| 137| return NULL; 287| 137| } 288| | 289| 259k| if (out_id == NULL) { ------------------ | Branch (289:9): [True: 0, False: 259k] ------------------ 290| 0| return NULL; 291| 0| } 292| | 293| 259k| result = flb_hash_table_compute_key_hash( 294| 259k| &hash, 295| 259k| key, key_len, 296| 259k| ht->case_sensitivity); 297| | 298| 259k| if (result != 0) { ------------------ | Branch (298:9): [True: 0, False: 259k] ------------------ 299| 0| return NULL; 300| 0| } 301| | 302| 259k| id = (hash % ht->size); 303| | 304| 259k| table = &ht->table[id]; 305| 259k| if (table->count == 0) { ------------------ | Branch (305:9): [True: 84.4k, False: 175k] ------------------ 306| 84.4k| return NULL; 307| 84.4k| } 308| | 309| 175k| if (table->count == 1) { ------------------ | Branch (309:9): [True: 104k, False: 70.5k] ------------------ 310| 104k| entry = mk_list_entry_first(&table->chains, ------------------ | | 226| 104k|#define mk_list_entry_first(ptr, type, member) container_of((ptr)->next, type, member) | | ------------------ | | | | 38| 104k|#define container_of(ptr, type, member) ({ \ | | | | 39| 104k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 104k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 311| 104k| struct flb_hash_table_entry, _head); 312| | 313| 104k| if (entry->key_len != key_len) { ------------------ | Branch (313:13): [True: 20.7k, False: 83.8k] ------------------ 314| 20.7k| entry = NULL; 315| 20.7k| } 316| 83.8k| else { 317| 83.8k| if (ht->case_sensitivity) { ------------------ | Branch (317:17): [True: 83.8k, False: 0] ------------------ 318| 83.8k| if (strncmp(entry->key, key, key_len) != 0) { ------------------ | Branch (318:21): [True: 24.3k, False: 59.5k] ------------------ 319| 24.3k| entry = NULL; 320| 24.3k| } 321| 83.8k| } 322| 0| else { 323| 0| if (strncasecmp(entry->key, key, key_len) != 0) { ------------------ | Branch (323:21): [True: 0, False: 0] ------------------ 324| 0| entry = NULL; 325| 0| } 326| 0| } 327| 83.8k| } 328| 104k| } 329| 70.5k| else { 330| | /* Iterate entries */ 331| 573k| mk_list_foreach(head, &table->chains) { ------------------ | | 205| 603k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 573k, False: 29.5k] | | ------------------ ------------------ 332| 573k| entry = mk_list_entry(head, struct flb_hash_table_entry, _head); ------------------ | | 214| 573k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 573k|#define container_of(ptr, type, member) ({ \ | | | | 39| 573k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 573k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 333| 573k| if (entry->key_len != key_len) { ------------------ | Branch (333:17): [True: 23.5k, False: 550k] ------------------ 334| 23.5k| entry = NULL; 335| 23.5k| continue; 336| 23.5k| } 337| | 338| 550k| if (ht->case_sensitivity) { ------------------ | Branch (338:17): [True: 550k, False: 0] ------------------ 339| 550k| if (strncmp(entry->key, key, key_len) == 0) { ------------------ | Branch (339:21): [True: 41.0k, False: 509k] ------------------ 340| 41.0k| break; 341| 41.0k| } 342| 550k| } 343| 0| else { 344| 0| if (strncasecmp(entry->key, key, key_len) == 0) { ------------------ | Branch (344:21): [True: 0, False: 0] ------------------ 345| 0| break; 346| 0| } 347| 0| } 348| | 349| 509k| entry = NULL; 350| 509k| } 351| 70.5k| } 352| | 353| 175k| if (entry) { ------------------ | Branch (353:9): [True: 100k, False: 74.6k] ------------------ 354| 100k| *out_id = id; 355| 100k| } 356| | 357| 175k| return entry; 358| 259k|} flb_hash_table.c:entry_set_value: 361| 255k|{ 362| 255k| char *ptr; 363| | 364| | /* 365| | * If the entry already contains a previous value in the heap, just remove 366| | * the previously assigned memory. 367| | */ 368| 255k| if (entry->val_size > 0) { ------------------ | Branch (368:9): [True: 98.5k, False: 157k] ------------------ 369| 98.5k| flb_free(entry->val); 370| 98.5k| } 371| | 372| | /* 373| | * Now set the new value. If val_size > 0, we create a new memory area, otherwise 374| | * it means the caller just wants to store a pointer address, no allocation 375| | * is required. 376| | */ 377| 255k| if (val_size > 0) { ------------------ | Branch (377:9): [True: 255k, False: 0] ------------------ 378| 255k| entry->val = flb_malloc(val_size + 1); 379| 255k| if (!entry->val) { ------------------ | Branch (379:13): [True: 0, False: 255k] ------------------ 380| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 381| 0| return -1; 382| 0| } 383| | 384| | /* 385| | * Copy the buffer and append a NULL byte in case the caller set and 386| | * expects a string. 387| | */ 388| 255k| memcpy(entry->val, val, val_size); 389| 255k| ptr = (char *) entry->val; 390| 255k| ptr[val_size] = '\0'; 391| 255k| entry->val_size = val_size; 392| 255k| } 393| 0| else { 394| | /* just do a reference */ 395| 0| entry->val = val; 396| 0| entry->val_size = -1; 397| 0| } 398| | 399| 255k| entry->created = time(NULL); 400| | 401| 255k| return 0; 402| 255k|} flb_log_construct: 501| 3.88k|{ 502| 3.88k| int body_size; 503| 3.88k| int ret; 504| 3.88k| int len; 505| 3.88k| int total; 506| 3.88k| time_t now; 507| 3.88k| const char *header_color = NULL; 508| 3.88k| const char *header_title = NULL; 509| 3.88k| const char *bold_color = ANSI_BOLD; ------------------ | | 47| 3.88k|#define ANSI_BOLD "\033[1m" ------------------ 510| 3.88k| const char *reset_color = ANSI_RESET; ------------------ | | 46| 3.88k|#define ANSI_RESET "\033[0m" ------------------ 511| 3.88k| struct tm result; 512| 3.88k| struct tm *current; 513| | 514| 3.88k| switch (type) { ------------------ | Branch (514:13): [True: 0, False: 3.88k] ------------------ 515| 0| case FLB_LOG_HELP: ------------------ | | 45| 0|#define FLB_LOG_HELP 6 /* unused by log level */ ------------------ | Branch (515:5): [True: 0, False: 3.88k] ------------------ 516| 0| header_title = "help"; 517| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 518| 0| break; 519| 0| case FLB_LOG_INFO: ------------------ | | 42| 0|#define FLB_LOG_INFO 3 /* default */ ------------------ | Branch (519:5): [True: 0, False: 3.88k] ------------------ 520| 0| header_title = "info"; 521| 0| header_color = ANSI_GREEN; ------------------ | | 53| 0|#define ANSI_GREEN "\033[92m" ------------------ 522| 0| break; 523| 0| case FLB_LOG_WARN: ------------------ | | 41| 0|#define FLB_LOG_WARN 2 ------------------ | Branch (523:5): [True: 0, False: 3.88k] ------------------ 524| 0| header_title = "warn"; 525| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 526| 0| break; 527| 3.88k| case FLB_LOG_ERROR: ------------------ | | 40| 3.88k|#define FLB_LOG_ERROR 1 ------------------ | Branch (527:5): [True: 3.88k, False: 0] ------------------ 528| 3.88k| header_title = "error"; 529| 3.88k| header_color = ANSI_RED; ------------------ | | 50| 3.88k|#define ANSI_RED "\033[91m" ------------------ 530| 3.88k| break; 531| 0| case FLB_LOG_DEBUG: ------------------ | | 43| 0|#define FLB_LOG_DEBUG 4 ------------------ | Branch (531:5): [True: 0, False: 3.88k] ------------------ 532| 0| header_title = "debug"; 533| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 534| 0| break; 535| 0| case FLB_LOG_IDEBUG: ------------------ | | 47| 0|#define FLB_LOG_IDEBUG 10 ------------------ | Branch (535:5): [True: 0, False: 3.88k] ------------------ 536| 0| header_title = "debug"; 537| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 538| 0| break; 539| 0| case FLB_LOG_TRACE: ------------------ | | 44| 0|#define FLB_LOG_TRACE 5 ------------------ | Branch (539:5): [True: 0, False: 3.88k] ------------------ 540| 0| header_title = "trace"; 541| 0| header_color = ANSI_BLUE; ------------------ | | 52| 0|#define ANSI_BLUE "\033[94m" ------------------ 542| 0| break; 543| 3.88k| } 544| | 545| | #ifdef FLB_LOG_NO_CONTROL_CHARS 546| | header_color = ""; 547| | bold_color = ""; 548| | reset_color = ""; 549| | #else 550| | /* Only print colors to a terminal */ 551| 3.88k| if (!isatty(STDOUT_FILENO)) { ------------------ | Branch (551:9): [True: 3.88k, False: 0] ------------------ 552| 3.88k| header_color = ""; 553| 3.88k| bold_color = ""; 554| 3.88k| reset_color = ""; 555| 3.88k| } 556| 3.88k| #endif // FLB_LOG_NO_CONTROL_CHARS 557| | 558| 3.88k| now = time(NULL); 559| 3.88k| current = localtime_r(&now, &result); 560| | 561| 3.88k| if (current == NULL) { ------------------ | Branch (561:9): [True: 0, False: 3.88k] ------------------ 562| 0| return -1; 563| 0| } 564| | 565| 3.88k| len = snprintf(msg->msg, sizeof(msg->msg) - 1, 566| 3.88k| "%s[%s%i/%02i/%02i %02i:%02i:%02i%s]%s [%s%5s%s] ", 567| | /* time */ /* type */ 568| | 569| | /* time variables */ 570| 3.88k| bold_color, reset_color, 571| 3.88k| current->tm_year + 1900, 572| 3.88k| current->tm_mon + 1, 573| 3.88k| current->tm_mday, 574| 3.88k| current->tm_hour, 575| 3.88k| current->tm_min, 576| 3.88k| current->tm_sec, 577| 3.88k| bold_color, reset_color, 578| | 579| | /* type format */ 580| 3.88k| header_color, header_title, reset_color); 581| | 582| 3.88k| body_size = (sizeof(msg->msg) - 2) - len; 583| 3.88k| total = vsnprintf(msg->msg + len, 584| 3.88k| body_size, 585| 3.88k| fmt, *args); 586| 3.88k| if (total < 0) { ------------------ | Branch (586:9): [True: 0, False: 3.88k] ------------------ 587| 0| return -1; 588| 0| } 589| 3.88k| ret = total; /* ret means a buffer size need to save log body */ 590| | 591| 3.88k| total = strlen(msg->msg + len) + len; 592| 3.88k| msg->msg[total++] = '\n'; 593| 3.88k| msg->msg[total] = '\0'; 594| 3.88k| msg->size = total; 595| | 596| 3.88k| *ret_len = len; 597| | 598| 3.88k| if (ret >= body_size) { ------------------ | Branch (598:9): [True: 60, False: 3.82k] ------------------ 599| | /* log is truncated */ 600| 60| return ret - body_size; 601| 60| } 602| | 603| 3.82k| return 0; 604| 3.88k|} flb_log_print: 633| 3.88k|{ 634| 3.88k| int n; 635| 3.88k| int len; 636| 3.88k| int ret; 637| 3.88k| struct log_message msg = {0}; 638| 3.88k| va_list args; 639| | 640| 3.88k| struct flb_worker *w; 641| | 642| 3.88k| va_start(args, fmt); 643| 3.88k| ret = flb_log_construct(&msg, &len, type, file, line, fmt, &args); 644| 3.88k| va_end(args); 645| | 646| 3.88k| if (ret < 0) { ------------------ | Branch (646:9): [True: 0, False: 3.88k] ------------------ 647| 0| return; 648| 0| } 649| | 650| 3.88k| w = flb_worker_get(); 651| 3.88k| if (w) { ------------------ | Branch (651:9): [True: 0, False: 3.88k] ------------------ 652| 0| n = flb_pipe_write_all(w->log[1], &msg, sizeof(msg)); 653| 0| if (n == -1) { ------------------ | Branch (653:13): [True: 0, False: 0] ------------------ 654| 0| fprintf(stderr, "%s", (char *) msg.msg); 655| 0| perror("write"); 656| 0| } 657| 0| } 658| 3.88k| else { 659| 3.88k| fprintf(stderr, "%s", (char *) msg.msg); 660| 3.88k| } 661| | 662| | #ifdef FLB_HAVE_AWS_ERROR_REPORTER 663| | if (is_error_reporting_enabled()) { 664| | if (type == FLB_LOG_ERROR) { 665| | flb_aws_error_reporter_write(error_reporter, msg.msg + len); 666| | } 667| | 668| | flb_aws_error_reporter_clean(error_reporter); 669| | } 670| | #endif 671| 3.88k|} flb_errno_print: 674| 69|{ 675| 69| char buf[256]; 676| | 677| 69| strerror_r(errnum, buf, sizeof(buf) - 1); 678| 69| flb_error("[%s:%i errno=%i] %s", file, line, errnum, buf); ------------------ | | 170| 69| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 69|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 69, False: 0] | | ------------------ | | 171| 69| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 69|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 679| 69| return 0; 680| 69|} flb_regex_init: 156| 2.04k|{ 157| 2.04k| return onig_init(); 158| 2.04k|} flb_regex_create: 161| 2.04k|{ 162| 2.04k| int ret; 163| 2.04k| struct flb_regex *r; 164| | 165| | /* Create context */ 166| 2.04k| r = flb_malloc(sizeof(struct flb_regex)); 167| 2.04k| if (!r) { ------------------ | Branch (167:9): [True: 0, False: 2.04k] ------------------ 168| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 169| 0| return NULL; 170| 0| } 171| | 172| | /* Compile pattern */ 173| 2.04k| ret = str_to_regex(pattern, (OnigRegex*)&r->regex); 174| 2.04k| if (ret == -1) { ------------------ | Branch (174:9): [True: 0, False: 2.04k] ------------------ 175| 0| flb_free(r); 176| 0| return NULL; 177| 0| } 178| | 179| 2.04k| return r; 180| 2.04k|} flb_regex_match: 271| 2.04k|{ 272| 2.04k| int ret; 273| 2.04k| unsigned char *start; 274| 2.04k| unsigned char *end; 275| 2.04k| unsigned char *range; 276| | 277| | /* Search scope */ 278| 2.04k| start = (unsigned char *) str; 279| 2.04k| end = start + slen; 280| 2.04k| range = end; 281| | 282| 2.04k| ret = onig_search(r->regex, str, end, start, range, NULL, ONIG_OPTION_NONE); ------------------ | | 453| 2.04k|#define ONIG_OPTION_NONE 0U ------------------ 283| | 284| 2.04k| if (ret == ONIG_MISMATCH) { ------------------ | | 628| 2.04k|#define ONIG_MISMATCH -1 ------------------ | Branch (284:9): [True: 1.41k, False: 630] ------------------ 285| 1.41k| return 0; 286| 1.41k| } 287| 630| else if (ret < 0) { ------------------ | Branch (287:14): [True: 0, False: 630] ------------------ 288| 0| return ret; 289| 0| } 290| 630| return 1; 291| 2.04k|} flb_regex_destroy: 316| 2.04k|{ 317| 2.04k| onig_free(r->regex); 318| 2.04k| flb_free(r); 319| 2.04k| return 0; 320| 2.04k|} flb_regex_exit: 323| 2.04k|{ 324| 2.04k| onig_end(); 325| 2.04k|} flb_regex.c:str_to_regex: 117| 2.04k|{ 118| 2.04k| int ret; 119| 2.04k| size_t len; 120| 2.04k| const char *start; 121| 2.04k| const char *end; 122| 2.04k| char *new_end = NULL; 123| 2.04k| OnigErrorInfo einfo; 124| 2.04k| OnigOptionType option; 125| | 126| 2.04k| len = strlen(pattern); 127| 2.04k| start = pattern; 128| 2.04k| end = pattern + len; 129| | 130| 2.04k| option = check_option(start, end, &new_end); 131| | 132| 2.04k| if (pattern[0] == '/' && pattern[len - 1] == '/') { ------------------ | Branch (132:9): [True: 0, False: 2.04k] | Branch (132:30): [True: 0, False: 0] ------------------ 133| 0| start++; 134| 0| end--; 135| 0| } 136| | 137| 2.04k| if (new_end != NULL) { ------------------ | Branch (137:9): [True: 0, False: 2.04k] ------------------ 138| | /* pattern is /pat/option. new_end indicates a last '/'. */ 139| 0| start++; 140| 0| end = new_end; 141| 0| } 142| | 143| 2.04k| ret = onig_new(reg, 144| 2.04k| (const unsigned char *)start, (const unsigned char *)end, 145| 2.04k| option, 146| 2.04k| ONIG_ENCODING_UTF8, ONIG_SYNTAX_RUBY, &einfo); ------------------ | | 274| 2.04k|# define ONIG_ENCODING_UTF8 ONIG_ENCODING_UTF_8 | | ------------------ | | | | 242| 2.04k|# define ONIG_ENCODING_UTF_8 (&OnigEncodingUTF_8) | | ------------------ ------------------ ONIG_ENCODING_UTF8, ONIG_SYNTAX_RUBY, &einfo); ------------------ | | 514| 2.04k|#define ONIG_SYNTAX_RUBY (&OnigSyntaxRuby) ------------------ 147| | 148| 2.04k| if (ret != ONIG_NORMAL) { ------------------ | | 627| 2.04k|#define ONIG_NORMAL 0 ------------------ | Branch (148:9): [True: 0, False: 2.04k] ------------------ 149| 0| return -1; 150| 0| } 151| 2.04k| return 0; 152| 2.04k|} flb_regex.c:check_option: 61| 2.04k|{ 62| 2.04k| char *chr = NULL; 63| 2.04k| OnigOptionType option = ONIG_OPTION_NONE; ------------------ | | 453| 2.04k|#define ONIG_OPTION_NONE 0U ------------------ 64| | 65| 2.04k| if (start == NULL || end == NULL || new_end == NULL) { ------------------ | Branch (65:9): [True: 0, False: 2.04k] | Branch (65:26): [True: 0, False: 2.04k] | Branch (65:41): [True: 0, False: 2.04k] ------------------ 66| 0| return ONIG_OPTION_DEFAULT; ------------------ | | 450| 0|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 0|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 67| 0| } 68| 2.04k| else if (start[0] != '/') { ------------------ | Branch (68:14): [True: 2.04k, False: 0] ------------------ 69| 2.04k| *new_end = NULL; 70| 2.04k| return ONIG_OPTION_DEFAULT; ------------------ | | 450| 2.04k|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 2.04k|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 71| 2.04k| } 72| | 73| 0| chr = strrchr(start, '/'); 74| 0| if (!chr) { ------------------ | Branch (74:9): [True: 0, False: 0] ------------------ 75| 0| *new_end = NULL; 76| 0| return ONIG_OPTION_DEFAULT; ------------------ | | 450| 0|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 0|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 77| 0| } 78| | 79| 0| if (chr == start || chr == end) { ------------------ | Branch (79:9): [True: 0, False: 0] | Branch (79:25): [True: 0, False: 0] ------------------ 80| 0| *new_end = NULL; 81| 0| return ONIG_OPTION_DEFAULT; ------------------ | | 450| 0|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 0|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 82| 0| } 83| 0| *new_end = chr; 84| | 85| 0| chr++; 86| 0| while(chr != end && *chr != '\0') { ------------------ | Branch (86:11): [True: 0, False: 0] | Branch (86:25): [True: 0, False: 0] ------------------ 87| 0| switch (*chr) { 88| 0| case 'm': ------------------ | Branch (88:9): [True: 0, False: 0] ------------------ 89| 0| option |= ONIG_OPTION_MULTILINE; ------------------ | | 456| 0|#define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) | | ------------------ | | | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | | | ------------------ | | | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | | | ------------------ | | ------------------ ------------------ 90| 0| break; 91| 0| case 'i': ------------------ | Branch (91:9): [True: 0, False: 0] ------------------ 92| 0| option |= ONIG_OPTION_IGNORECASE; ------------------ | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U ------------------ 93| 0| break; 94| 0| case 'o': ------------------ | Branch (94:9): [True: 0, False: 0] ------------------ 95| 0| flb_debug("[regex:%s]: 'o' option is not supported.", __FUNCTION__); ------------------ | | 197| 0| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 0] | | ------------------ | | 198| 0| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 96| 0| break; 97| 0| case 'x': ------------------ | Branch (97:9): [True: 0, False: 0] ------------------ 98| 0| option |= ONIG_OPTION_EXTEND; ------------------ | | 455| 0|#define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) | | ------------------ | | | | 454| 0|#define ONIG_OPTION_IGNORECASE 1U | | ------------------ ------------------ 99| 0| break; 100| 0| default: ------------------ | Branch (100:9): [True: 0, False: 0] ------------------ 101| 0| flb_debug("[regex:%s]: unknown option. use default.", __FUNCTION__); ------------------ | | 197| 0| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 0] | | ------------------ | | 198| 0| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 102| 0| *new_end = NULL; 103| 0| return ONIG_OPTION_DEFAULT; ------------------ | | 450| 0|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 0|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 104| 0| } 105| 0| chr++; 106| 0| } 107| | 108| 0| if (option == ONIG_OPTION_NONE) { ------------------ | | 453| 0|#define ONIG_OPTION_NONE 0U ------------------ | Branch (108:9): [True: 0, False: 0] ------------------ 109| 0| *new_end = NULL; 110| 0| option = ONIG_OPTION_DEFAULT; ------------------ | | 450| 0|#define ONIG_OPTION_DEFAULT ONIG_OPTION_NONE | | ------------------ | | | | 453| 0|#define ONIG_OPTION_NONE 0U | | ------------------ ------------------ 111| 0| } 112| | 113| 0| return option; 114| 0|} flb_sds_create_len: 59| 4.08k|{ 60| 4.08k| flb_sds_t s; 61| 4.08k| struct flb_sds *head; 62| | 63| 4.08k| s = sds_alloc(len); 64| 4.08k| if (!s) { ------------------ | Branch (64:9): [True: 0, False: 4.08k] ------------------ 65| 0| return NULL; 66| 0| } 67| | 68| 4.08k| if (str) { ------------------ | Branch (68:9): [True: 4.08k, False: 0] ------------------ 69| 4.08k| memcpy(s, str, len); 70| 4.08k| s[len] = '\0'; 71| | 72| 4.08k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 4.08k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 4.08k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 73| 4.08k| head->len = len; 74| 4.08k| } 75| 4.08k| return s; 76| 4.08k|} flb_sds_create_size: 93| 2.04k|{ 94| 2.04k| return sds_alloc(size); 95| 2.04k|} flb_sds_increase: 99| 975k|{ 100| 975k| size_t new_size; 101| 975k| struct flb_sds *head; 102| 975k| flb_sds_t out; 103| 975k| void *tmp; 104| | 105| 975k| out = s; 106| 975k| new_size = (FLB_SDS_HEADER_SIZE + flb_sds_alloc(s) + len + 1); ------------------ | | 34| 975k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 107| 975k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 975k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 975k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 108| 975k| tmp = flb_realloc(head, new_size); 109| 975k| if (!tmp) { ------------------ | Branch (109:9): [True: 0, False: 975k] ------------------ 110| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 111| 0| return NULL; 112| 0| } 113| 975k| head = (struct flb_sds *) tmp; 114| 975k| head->alloc += len; 115| 975k| out = head->buf; 116| | 117| 975k| return out; 118| 975k|} flb_sds_cat: 121| 3.59M|{ 122| 3.59M| size_t avail; 123| 3.59M| struct flb_sds *head; 124| 3.59M| flb_sds_t tmp = NULL; 125| | 126| 3.59M| avail = flb_sds_avail(s); 127| 3.59M| if (avail < len) { ------------------ | Branch (127:9): [True: 13.4k, False: 3.58M] ------------------ 128| 13.4k| tmp = flb_sds_increase(s, len); 129| 13.4k| if (!tmp) { ------------------ | Branch (129:13): [True: 0, False: 13.4k] ------------------ 130| 0| return NULL; 131| 0| } 132| 13.4k| s = tmp; 133| 13.4k| } 134| 3.59M| memcpy((char *) (s + flb_sds_len(s)), str, len); 135| | 136| 3.59M| head = FLB_SDS_HEADER(s); ------------------ | | 46| 3.59M|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 3.59M|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 137| 3.59M| head->len += len; 138| 3.59M| s[head->len] = '\0'; 139| | 140| 3.59M| return s; 141| 3.59M|} flb_sds_cat_esc: 218| 2.04k|{ 219| 2.04k| size_t avail; 220| 2.04k| struct flb_sds *head; 221| 2.04k| flb_sds_t tmp = NULL; 222| 2.04k| uint32_t c; 223| 2.04k| int i; 224| | 225| 2.04k| avail = flb_sds_avail(s); 226| 2.04k| if (avail < len) { ------------------ | Branch (226:9): [True: 2.04k, False: 0] ------------------ 227| 2.04k| tmp = flb_sds_increase(s, len); 228| 2.04k| if (!tmp) { ------------------ | Branch (228:13): [True: 0, False: 2.04k] ------------------ 229| 0| return NULL; 230| 0| } 231| 2.04k| s = tmp; 232| 2.04k| } 233| 2.04k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 2.04k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 2.04k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 234| | 235| 20.4k| for (i = 0; i < len; i++) { ------------------ | Branch (235:17): [True: 18.3k, False: 2.04k] ------------------ 236| 18.3k| if (flb_sds_avail(s) < 8) { ------------------ | Branch (236:13): [True: 2.04k, False: 16.3k] ------------------ 237| 2.04k| tmp = flb_sds_increase(s, 8); 238| 2.04k| if (tmp == NULL) { ------------------ | Branch (238:17): [True: 0, False: 2.04k] ------------------ 239| 0| return NULL; 240| 0| } 241| 2.04k| s = tmp; 242| 2.04k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 2.04k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 2.04k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 243| 2.04k| } 244| 18.3k| c = (unsigned char) str[i]; 245| 18.3k| if (esc != NULL && c < esc_size && esc[c] != 0) { ------------------ | Branch (245:13): [True: 18.3k, False: 0] | Branch (245:28): [True: 0, False: 18.3k] | Branch (245:44): [True: 0, False: 0] ------------------ 246| 0| s[head->len++] = '\\'; 247| 0| s[head->len++] = esc[c]; 248| 0| } 249| 18.3k| else { 250| 18.3k| s[head->len++] = c; 251| 18.3k| } 252| 18.3k| } 253| | 254| 2.04k| s[head->len] = '\0'; 255| | 256| 2.04k| return s; 257| 2.04k|} flb_sds_printf: 337| 4.74M|{ 338| 4.74M| va_list ap; 339| 4.74M| int len = strlen(fmt)*2; 340| 4.74M| int size; 341| 4.74M| flb_sds_t tmp = NULL; 342| 4.74M| flb_sds_t s; 343| 4.74M| struct flb_sds *head; 344| | 345| 4.74M| if (len < 64) len = 64; ------------------ | Branch (345:9): [True: 4.74M, False: 0] ------------------ 346| | 347| 4.74M| s = *sds; 348| 4.74M| if (flb_sds_avail(s) < len) { ------------------ | Branch (348:9): [True: 957k, False: 3.78M] ------------------ 349| 957k| tmp = flb_sds_increase(s, len - flb_sds_avail(s)); 350| 957k| if (!tmp) { ------------------ | Branch (350:13): [True: 0, False: 957k] ------------------ 351| 0| return NULL; 352| 0| } 353| 957k| *sds = s = tmp; 354| 957k| } 355| | 356| 4.74M| va_start(ap, fmt); 357| 4.74M| size = vsnprintf((char *) (s + flb_sds_len(s)), flb_sds_avail(s), fmt, ap); 358| 4.74M| if (size < 0) { ------------------ | Branch (358:9): [True: 0, False: 4.74M] ------------------ 359| 0| flb_warn("[%s] buggy vsnprintf return %d", __FUNCTION__, size); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 360| 0| va_end(ap); 361| 0| return NULL; 362| 0| } 363| 4.74M| va_end(ap); 364| | 365| 4.74M| if (size >= flb_sds_avail(s)) { ------------------ | Branch (365:9): [True: 0, False: 4.74M] ------------------ 366| 0| tmp = flb_sds_increase(s, size - flb_sds_avail(s) + 1); 367| 0| if (!tmp) { ------------------ | Branch (367:13): [True: 0, False: 0] ------------------ 368| 0| return NULL; 369| 0| } 370| 0| *sds = s = tmp; 371| | 372| 0| va_start(ap, fmt); 373| 0| size = vsnprintf((char *) (s + flb_sds_len(s)), flb_sds_avail(s), fmt, ap); 374| 0| if (size > flb_sds_avail(s)) { ------------------ | Branch (374:13): [True: 0, False: 0] ------------------ 375| 0| flb_warn("[%s] vsnprintf is insatiable ", __FUNCTION__); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 376| 0| va_end(ap); 377| 0| return NULL; 378| 0| } 379| 0| va_end(ap); 380| 0| } 381| | 382| 4.74M| head = FLB_SDS_HEADER(s); ------------------ | | 46| 4.74M|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 4.74M|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 383| 4.74M| head->len += size; 384| 4.74M| s[head->len] = '\0'; 385| | 386| 4.74M| return s; 387| 4.74M|} flb_sds_destroy: 390| 6.12k|{ 391| 6.12k| struct flb_sds *head; 392| | 393| 6.12k| if (!s) { ------------------ | Branch (393:9): [True: 0, False: 6.12k] ------------------ 394| 0| return; 395| 0| } 396| | 397| 6.12k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 6.12k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 6.12k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 398| 6.12k| flb_free(head); 399| 6.12k|} flb_sds.c:sds_alloc: 37| 6.12k|{ 38| 6.12k| void *buf; 39| 6.12k| flb_sds_t s; 40| 6.12k| struct flb_sds *head; 41| | 42| 6.12k| buf = flb_malloc(FLB_SDS_HEADER_SIZE + size + 1); ------------------ | | 34| 6.12k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 43| 6.12k| if (!buf) { ------------------ | Branch (43:9): [True: 0, False: 6.12k] ------------------ 44| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 45| 0| return NULL; 46| 0| } 47| | 48| 6.12k| head = buf; 49| 6.12k| head->len = 0; 50| 6.12k| head->alloc = size; 51| | 52| 6.12k| s = head->buf; 53| 6.12k| *s = '\0'; 54| | 55| 6.12k| return s; 56| 6.12k|} flb_slist_create: 28| 2.04k|{ 29| 2.04k| mk_list_init(list); 30| 2.04k| return 0; 31| 2.04k|} flb_slist_add_sds: 55| 2.04k|{ 56| 2.04k| struct flb_slist_entry *e; 57| | 58| 2.04k| e = flb_malloc(sizeof(struct flb_slist_entry)); 59| 2.04k| if (!e) { ------------------ | Branch (59:9): [True: 0, False: 2.04k] ------------------ 60| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 61| 0| return -1; 62| 0| } 63| | 64| 2.04k| e->str = str; 65| 2.04k| mk_list_add(&e->_head, head); 66| 2.04k| return 0; 67| 2.04k|} flb_slist_dump: 311| 2.04k|{ 312| 2.04k| struct mk_list *head; 313| 2.04k| struct flb_slist_entry *e; 314| | 315| 2.04k| printf("[slist %p]\n", list); 316| 2.04k| mk_list_foreach(head, list) { ------------------ | | 205| 4.08k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 2.04k, False: 2.04k] | | ------------------ ------------------ 317| 2.04k| e = mk_list_entry(head, struct flb_slist_entry, _head); ------------------ | | 214| 2.04k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 2.04k|#define container_of(ptr, type, member) ({ \ | | | | 39| 2.04k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 2.04k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 318| 2.04k| printf(" - '%s'\n", e->str); 319| 2.04k| } 320| 2.04k|} flb_slist_destroy: 323| 2.04k|{ 324| 2.04k| struct mk_list *tmp; 325| 2.04k| struct mk_list *head; 326| 2.04k| struct flb_slist_entry *e; 327| | 328| 2.04k| mk_list_foreach_safe(head, tmp, list) { ------------------ | | 207| 4.08k| for (curr = (head)->next, n = curr->next; curr != (head); curr = n, n = curr->next) | | ------------------ | | | Branch (207:47): [True: 2.04k, False: 2.04k] | | ------------------ ------------------ 329| 2.04k| e = mk_list_entry(head, struct flb_slist_entry, _head); ------------------ | | 214| 2.04k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 2.04k|#define container_of(ptr, type, member) ({ \ | | | | 39| 2.04k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 2.04k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 330| 2.04k| flb_sds_destroy(e->str); 331| 2.04k| mk_list_del(&e->_head); 332| 2.04k| flb_free(e); 333| 2.04k| } 334| 2.04k|} flb_slist_entry_get: 338| 2.04k|{ 339| 2.04k| int i = 0; 340| 2.04k| struct mk_list *head; 341| 2.04k| struct flb_slist_entry *e; 342| | 343| 2.04k| if (!list || mk_list_size(list) == 0) { ------------------ | Branch (343:9): [True: 0, False: 2.04k] | Branch (343:18): [True: 0, False: 2.04k] ------------------ 344| 0| return NULL; 345| 0| } 346| | 347| 2.04k| mk_list_foreach(head, list) { ------------------ | | 205| 4.08k|#define mk_list_foreach(curr, head) for( curr = (head)->next; curr != (head); curr = curr->next ) | | ------------------ | | | Branch (205:63): [True: 2.04k, False: 2.04k] | | ------------------ ------------------ 348| 2.04k| if (i == n) { ------------------ | Branch (348:13): [True: 0, False: 2.04k] ------------------ 349| 0| e = mk_list_entry(head, struct flb_slist_entry, _head); ------------------ | | 214| 0|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 0|#define container_of(ptr, type, member) ({ \ | | | | 39| 0| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 0| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 350| 0| return e; 351| 0| } 352| 2.04k| i++; 353| 2.04k| } 354| | 355| 2.04k| return NULL; 356| 2.04k|} flb_uri_encode: 34| 2.04k|{ 35| 2.04k| int i; 36| 2.04k| flb_sds_t buf = NULL; 37| 2.04k| flb_sds_t tmp = NULL; 38| | 39| 2.04k| buf = flb_sds_create_size(len * 2); 40| 2.04k| if (!buf) { ------------------ | Branch (40:9): [True: 0, False: 2.04k] ------------------ 41| 0| flb_error("[uri] cannot allocate buffer for URI encoding"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 42| 0| return NULL; 43| 0| } 44| | 45| 8.34M| for (i = 0; i < len; i++) { ------------------ | Branch (45:17): [True: 8.34M, False: 2.04k] ------------------ 46| 8.34M| if (flb_uri_to_encode(uri[i]) == FLB_TRUE) { ------------------ | | 26| 8.34M|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 8.34M|#define FLB_FALSE 0 | | ------------------ ------------------ | Branch (46:13): [True: 4.74M, False: 3.59M] ------------------ 47| 4.74M| tmp = flb_sds_printf(&buf, "%%%02X", (unsigned char) *(uri + i)); 48| 4.74M| if (!tmp) { ------------------ | Branch (48:17): [True: 0, False: 4.74M] ------------------ 49| 0| flb_error("[uri] error formatting special character"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 50| 0| flb_sds_destroy(buf); 51| 0| return NULL; 52| 0| } 53| 4.74M| continue; 54| 4.74M| } 55| | 56| | /* Direct assignment, just copy the character */ 57| 3.59M| if (buf) { ------------------ | Branch (57:13): [True: 3.59M, False: 0] ------------------ 58| 3.59M| tmp = flb_sds_cat(buf, uri + i, 1); 59| 3.59M| if (!tmp) { ------------------ | Branch (59:17): [True: 0, False: 3.59M] ------------------ 60| 0| flb_error("[uri] error composing outgoing buffer"); ------------------ | | 170| 0| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 0, False: 0] | | ------------------ | | 171| 0| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 61| 0| flb_sds_destroy(buf); 62| 0| return NULL; 63| 0| } 64| 3.59M| buf = tmp; 65| 3.59M| } 66| 3.59M| } 67| | 68| 2.04k| return buf; 69| 2.04k|} flb_uri_get: 73| 2.04k|{ 74| 2.04k| if (pos < 0) { ------------------ | Branch (74:9): [True: 0, False: 2.04k] ------------------ 75| 0| flb_trace("[uri] negative pos"); ------------------ | | 223| 0|#define flb_trace(fmt, ...) do {} while(0) | | ------------------ | | | Branch (223:42): [Folded - Ignored] | | ------------------ ------------------ 76| 0| return NULL; 77| 0| } 78| | 79| 2.04k| if (pos >= FLB_URI_MAX || pos > uri->count) { ------------------ | | 28| 4.08k|#define FLB_URI_MAX 8 ------------------ | Branch (79:9): [True: 1.53k, False: 504] | Branch (79:31): [True: 248, False: 256] ------------------ 80| 1.78k| flb_trace("[uri] requested position > FLB_URI_MAX"); ------------------ | | 223| 1.78k|#define flb_trace(fmt, ...) do {} while(0) | | ------------------ | | | Branch (223:42): [Folded - Ignored] | | ------------------ ------------------ 81| 1.78k| return NULL; 82| 1.78k| } 83| | 84| 256| return &uri->map[pos]; 85| 2.04k|} flb_uri_create: 92| 2.04k|{ 93| 2.04k| int end; 94| 2.04k| unsigned int len; 95| 2.04k| unsigned int val_len; 96| 2.04k| unsigned int i = 0; 97| 2.04k| char *val; 98| 2.04k| size_t uri_size; 99| 2.04k| void *p; 100| 2.04k| struct flb_uri_field *field; 101| 2.04k| struct flb_uri *uri; 102| | 103| | /* Set the required memory space */ 104| 2.04k| uri_size = sizeof(struct flb_uri); 105| 2.04k| uri_size += (sizeof(struct flb_uri_field) * FLB_URI_MAX); ------------------ | | 28| 2.04k|#define FLB_URI_MAX 8 ------------------ 106| | 107| 2.04k| p = flb_calloc(1, uri_size); 108| 2.04k| if (!p) { ------------------ | Branch (108:9): [True: 0, False: 2.04k] ------------------ 109| 0| perror("malloc"); 110| 0| return NULL; 111| 0| } 112| | 113| | /* Link the 'map' */ 114| 2.04k| uri = p; 115| 2.04k| p = ((char *) p) + sizeof(struct flb_uri); 116| 2.04k| uri->map = p; 117| | 118| | /* Initialize fields list */ 119| 2.04k| mk_list_init(&uri->list); 120| 2.04k| uri->count = 0; 121| | 122| 2.04k| len = strlen(full_uri); 123| 7.98k| while (i < len && uri->count < FLB_URI_MAX) { ------------------ | | 28| 6.00k|#define FLB_URI_MAX 8 ------------------ | Branch (123:12): [True: 6.00k, False: 1.97k] | Branch (123:23): [True: 5.94k, False: 67] ------------------ 124| 5.94k| end = mk_string_char_search(full_uri + i, '/', len - i); 125| | 126| 5.94k| if (end >= 0 && end + i < len) { ------------------ | Branch (126:13): [True: 4.04k, False: 1.89k] | Branch (126:25): [True: 4.04k, False: 0] ------------------ 127| 4.04k| end += i; 128| | 129| 4.04k| if (i == (unsigned int) end) { ------------------ | Branch (129:17): [True: 2.04k, False: 1.99k] ------------------ 130| 2.04k| i++; 131| 2.04k| continue; 132| 2.04k| } 133| | 134| 1.99k| val = mk_string_copy_substr(full_uri, i, end); 135| 1.99k| val_len = end - i; 136| 1.99k| } 137| 1.89k| else { 138| 1.89k| val = mk_string_copy_substr(full_uri, i, len); 139| 1.89k| val_len = len - i; 140| 1.89k| end = len; 141| | 142| 1.89k| } 143| | 144| | /* Alloc node */ 145| 3.89k| field = &uri->map[uri->count]; 146| 3.89k| field->value = flb_strdup(val); 147| 3.89k| field->length = val_len; 148| 3.89k| mk_list_add(&field->_head, &uri->list); 149| 3.89k| i = end + 1; 150| 3.89k| uri->count++; 151| | 152| 3.89k| mk_mem_free(val); 153| 3.89k| } 154| | 155| 2.04k| uri->full = flb_strdup(full_uri); 156| 2.04k| return uri; 157| 2.04k|} flb_uri_destroy: 161| 2.04k|{ 162| 2.04k| struct mk_list *tmp; 163| 2.04k| struct mk_list *head; 164| 2.04k| struct flb_uri_field *field; 165| | 166| 3.89k| mk_list_foreach_safe(head, tmp, &uri->list) { ------------------ | | 207| 5.93k| for (curr = (head)->next, n = curr->next; curr != (head); curr = n, n = curr->next) | | ------------------ | | | Branch (207:47): [True: 3.89k, False: 2.04k] | | ------------------ ------------------ 167| 3.89k| field = mk_list_entry(head, struct flb_uri_field, _head); ------------------ | | 214| 3.89k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 3.89k|#define container_of(ptr, type, member) ({ \ | | | | 39| 3.89k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 3.89k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 168| 3.89k| mk_list_del(&field->_head); 169| 3.89k| flb_free(field->value); 170| 3.89k| } 171| | 172| 2.04k| flb_free(uri->full); 173| 2.04k| flb_free(uri); 174| 2.04k|} flb_uri_dump: 177| 2.04k|{ 178| 2.04k| int i; 179| 2.04k| struct flb_uri_field *f; 180| | 181| 5.93k| for (i = 0; i < uri->count; i++) { ------------------ | Branch (181:17): [True: 3.89k, False: 2.04k] ------------------ 182| 3.89k| f = &uri->map[i]; 183| 3.89k| printf("[%i] length=%lu value='%s'\n", 184| 3.89k| i, f->length, f->value); 185| 3.89k| } 186| 2.04k|} flb_utf8_len: 40| 218M|{ 41| 218M| return trailing_bytes_for_utf8[(unsigned int)(unsigned char)s[0]] + 1; 42| 218M|} flb_utf8_decode: 45| 318M|{ 46| | /* Start of a new character */ 47| 318M| if (*state == 0) { ------------------ | Branch (47:9): [True: 218M, False: 100M] ------------------ 48| 218M| if (byte <= 0x7F) { ------------------ | Branch (48:13): [True: 0, False: 218M] ------------------ 49| | /* ASCII */ 50| 0| *codep = byte; 51| 0| return FLB_UTF8_ACCEPT; ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 52| 0| } 53| 218M| else if ((byte & 0xE0) == 0xC0) { ------------------ | Branch (53:18): [True: 48.5M, False: 170M] ------------------ 54| | /* start of a 2-byte sequence */ 55| 48.5M| *codep = byte & 0x1F; 56| 48.5M| *state = 1; 57| 48.5M| } 58| 170M| else if ((byte & 0xF0) == 0xE0) { ------------------ | Branch (58:18): [True: 26.6M, False: 143M] ------------------ 59| | /* start of a 3-byte sequence */ 60| 26.6M| *codep = byte & 0x0F; 61| 26.6M| *state = 2; 62| 26.6M| } 63| 143M| else if ((byte & 0xF8) == 0xF0) { ------------------ | Branch (63:18): [True: 13.5M, False: 129M] ------------------ 64| | /* start of a 4-byte sequence */ 65| 13.5M| *codep = byte & 0x07; 66| 13.5M| *state = 3; 67| 13.5M| } 68| 129M| else { 69| | /* invalid first byte */ 70| 129M| *state = FLB_UTF8_REJECT; ------------------ | | 24| 129M|#define FLB_UTF8_REJECT 1 ------------------ 71| 129M| return FLB_UTF8_REJECT; ------------------ | | 24| 129M|#define FLB_UTF8_REJECT 1 ------------------ 72| 129M| } 73| 218M| } 74| 100M| else { 75| | /* continuation byte */ 76| 100M| if ((byte & 0xC0) == 0x80) { ------------------ | Branch (76:13): [True: 25.3M, False: 74.7M] ------------------ 77| 25.3M| *codep = (*codep << 6) | (byte & 0x3F); 78| | 79| | /* reduce the expected continuation bytes */ 80| 25.3M| (*state)--; 81| 25.3M| } 82| 74.7M| else { 83| | /* invalid continuation byte */ 84| 74.7M| *state = FLB_UTF8_REJECT; ------------------ | | 24| 74.7M|#define FLB_UTF8_REJECT 1 ------------------ 85| 74.7M| return FLB_UTF8_REJECT; ------------------ | | 24| 74.7M|#define FLB_UTF8_REJECT 1 ------------------ 86| 74.7M| } 87| 100M| } 88| | 89| 114M| if (*state == 0) { ------------------ | Branch (89:9): [True: 14.0M, False: 100M] ------------------ 90| | /* sequence complete */ 91| 14.0M| if (*codep >= 0xD800 && *codep <= 0xDFFF) { ------------------ | Branch (91:13): [True: 1.58M, False: 12.4M] | Branch (91:33): [True: 35.5k, False: 1.55M] ------------------ 92| | /* invalid surrogate pair */ 93| 35.5k| *state = FLB_UTF8_REJECT; ------------------ | | 24| 35.5k|#define FLB_UTF8_REJECT 1 ------------------ 94| 35.5k| return FLB_UTF8_REJECT; ------------------ | | 24| 35.5k|#define FLB_UTF8_REJECT 1 ------------------ 95| 35.5k| } 96| 13.9M| else if (*codep > 0x10FFFF) { ------------------ | Branch (96:18): [True: 65.7k, False: 13.9M] ------------------ 97| | /* codepoint is out of range */ 98| 65.7k| *state = FLB_UTF8_REJECT; ------------------ | | 24| 65.7k|#define FLB_UTF8_REJECT 1 ------------------ 99| 65.7k| return FLB_UTF8_REJECT; ------------------ | | 24| 65.7k|#define FLB_UTF8_REJECT 1 ------------------ 100| 65.7k| } 101| 13.9M| return FLB_UTF8_ACCEPT; ------------------ | | 23| 13.9M|#define FLB_UTF8_ACCEPT 0 ------------------ 102| 14.0M| } 103| | 104| | /* we are still processing the current sequence */ 105| 100M| return FLB_UTF8_CONTINUE; ------------------ | | 25| 100M|#define FLB_UTF8_CONTINUE 2 ------------------ 106| 114M|} flb_utils_split_quoted: 460| 2.04k|{ 461| 2.04k| return split(line, separator, max_split, FLB_TRUE); ------------------ | | 26| 2.04k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2.04k|#define FLB_FALSE 0 | | ------------------ ------------------ 462| 2.04k|} flb_utils_split: 465| 2.04k|{ 466| 2.04k| return split(line, separator, max_split, FLB_FALSE); ------------------ | | 25| 2.04k|#define FLB_FALSE 0 ------------------ 467| 2.04k|} flb_utils_split_free_entry: 471| 5.11k|{ 472| 5.11k| mk_list_del(&entry->_head); 473| 5.11k| flb_free(entry->value); 474| 5.11k| flb_free(entry); 475| 5.11k|} flb_utils_split_free: 478| 4.08k|{ 479| 4.08k| struct mk_list *tmp; 480| 4.08k| struct mk_list *head; 481| 4.08k| struct flb_split_entry *entry; 482| | 483| 5.11k| mk_list_foreach_safe(head, tmp, list) { ------------------ | | 207| 9.19k| for (curr = (head)->next, n = curr->next; curr != (head); curr = n, n = curr->next) | | ------------------ | | | Branch (207:47): [True: 5.11k, False: 4.08k] | | ------------------ ------------------ 484| 5.11k| entry = mk_list_entry(head, struct flb_split_entry, _head); ------------------ | | 214| 5.11k|#define mk_list_entry( ptr, type, member ) container_of( ptr, type, member ) | | ------------------ | | | | 38| 5.11k|#define container_of(ptr, type, member) ({ \ | | | | 39| 5.11k| const typeof( ((type *)0)->member ) *__mptr = (ptr); \ | | | | 40| 5.11k| (type *)( (char *)__mptr - offsetof(type,member) );}) | | ------------------ ------------------ 485| 5.11k| flb_utils_split_free_entry(entry); 486| 5.11k| } 487| | 488| 4.08k| flb_free(list); 489| 4.08k|} flb_utils_size_to_bytes: 528| 2.04k|{ 529| 2.04k| int i; 530| 2.04k| int len; 531| 2.04k| int plen = 0; 532| 2.04k| double val; 533| 2.04k| char c; 534| 2.04k| char tmp[3] = {0}; 535| 2.04k| int64_t KB = 1000; 536| 2.04k| int64_t MB = 1000 * KB; 537| 2.04k| int64_t GB = 1000 * MB; 538| | 539| 2.04k| if (!size) { ------------------ | Branch (539:9): [True: 0, False: 2.04k] ------------------ 540| 0| return -1; 541| 0| } 542| | 543| 2.04k| if (strcasecmp(size, "false") == 0) { ------------------ | Branch (543:9): [True: 1, False: 2.04k] ------------------ 544| 1| return 0; 545| 1| } 546| | 547| 2.04k| len = strlen(size); 548| 2.04k| val = atof(size); 549| | 550| 2.04k| if (len == 0) { ------------------ | Branch (550:9): [True: 58, False: 1.98k] ------------------ 551| 58| return -1; 552| 58| } 553| | 554| 198k| for (i = len - 1; i > 0; i--) { ------------------ | Branch (554:23): [True: 197k, False: 950] ------------------ 555| 197k| if (isdigit(size[i])) { 556| 1.03k| break; 557| 1.03k| } 558| 196k| else { 559| 196k| plen++; 560| 196k| } 561| 197k| } 562| | 563| 1.98k| if (plen == 0) { ------------------ | Branch (563:9): [True: 188, False: 1.79k] ------------------ 564| 188| return (int64_t)val; 565| 188| } 566| 1.79k| else if (plen > 2) { ------------------ | Branch (566:14): [True: 1.23k, False: 562] ------------------ 567| 1.23k| return -1; 568| 1.23k| } 569| | 570| 1.48k| for (i = 0; i < plen; i++) { ------------------ | Branch (570:17): [True: 921, False: 562] ------------------ 571| 921| c = size[(len - plen) + i]; 572| 921| tmp[i] = toupper(c); 573| 921| } 574| | 575| 562| if (plen == 2) { ------------------ | Branch (575:9): [True: 359, False: 203] ------------------ 576| 359| if (tmp[1] != 'B') { ------------------ | Branch (576:13): [True: 355, False: 4] ------------------ 577| 355| return -1; 578| 355| } 579| 359| } 580| | 581| 207| if (tmp[0] == 'K') { ------------------ | Branch (581:9): [True: 6, False: 201] ------------------ 582| | /* set upper bound (2**64/KB)/2 to avoid overflows */ 583| 6| if (val >= 9223372036854775.0 || val <= -9223372036854774.0) ------------------ | Branch (583:13): [True: 1, False: 5] | Branch (583:42): [True: 3, False: 2] ------------------ 584| 4| { 585| 4| return -1; 586| 4| } 587| 2| return (int64_t)(val * KB); 588| 6| } 589| 201| else if (tmp[0] == 'M') { ------------------ | Branch (589:14): [True: 12, False: 189] ------------------ 590| | /* set upper bound (2**64/MB)/2 to avoid overflows */ 591| 12| if (val >= 9223372036854 || val <= -9223372036853) { ------------------ | Branch (591:13): [True: 2, False: 10] | Branch (591:37): [True: 1, False: 9] ------------------ 592| 3| return -1; 593| 3| } 594| 9| return (int64_t)(val * MB); 595| 12| } 596| 189| else if (tmp[0] == 'G') { ------------------ | Branch (596:14): [True: 5, False: 184] ------------------ 597| | /* set upper bound (2**64/GB)/2 to avoid overflows */ 598| 5| if (val >= 9223372036 || val <= -9223372035) { ------------------ | Branch (598:13): [True: 1, False: 4] | Branch (598:34): [True: 1, False: 3] ------------------ 599| 2| return -1; 600| 2| } 601| 3| return (int64_t)(val * GB); 602| 5| } 603| 184| else { 604| 184| return -1; 605| 184| } 606| | 607| 0| return (int64_t)val; 608| 207|} flb_utils_hex2int: 611| 2.04k|{ 612| 2.04k| int i = 0; 613| 2.04k| int64_t res = 0; 614| 2.04k| char c; 615| | 616| 60.5k| while ((c = *hex++) && i < len) { ------------------ | Branch (616:12): [True: 60.4k, False: 145] | Branch (616:28): [True: 60.4k, False: 0] ------------------ 617| | /* Ensure no overflow */ 618| 60.4k| if (res >= (int64_t)((INT64_MAX/0x10) - 0xff)) { ------------------ | Branch (618:13): [True: 109, False: 60.3k] ------------------ 619| 109| return -1; 620| 109| } 621| | 622| 60.3k| res *= 0x10; 623| | 624| 60.3k| if (c >= 'a' && c <= 'f') { ------------------ | Branch (624:13): [True: 827, False: 59.4k] | Branch (624:25): [True: 560, False: 267] ------------------ 625| 560| res += (c - 0x57); 626| 560| } 627| 59.7k| else if (c >= 'A' && c <= 'F') { ------------------ | Branch (627:18): [True: 1.19k, False: 58.5k] | Branch (627:30): [True: 880, False: 313] ------------------ 628| 880| res += (c - 0x37); 629| 880| } 630| 58.8k| else if (c >= '0' && c <= '9') { ------------------ | Branch (630:18): [True: 57.4k, False: 1.40k] | Branch (630:30): [True: 57.0k, False: 384] ------------------ 631| 57.0k| res += (c - 0x30); 632| 57.0k| } 633| 1.78k| else { 634| 1.78k| return -1; 635| 1.78k| } 636| 58.5k| i++; 637| 58.5k| } 638| | 639| 145| if (res < 0) { ------------------ | Branch (639:9): [True: 0, False: 145] ------------------ 640| 0| return -1; 641| 0| } 642| | 643| 145| return res; 644| 145|} flb_utils_time_to_seconds: 647| 2.04k|{ 648| 2.04k| int len; 649| 2.04k| size_t val; 650| | 651| 2.04k| len = strlen(time); 652| 2.04k| if (len == 0) { ------------------ | Branch (652:9): [True: 58, False: 1.98k] ------------------ 653| 58| return 0; 654| 58| } 655| 1.98k| val = atoi(time); 656| | 657| | /* String time to seconds */ 658| 1.98k| if (time[len - 1] == 'D' || time[len - 1] == 'd') { ------------------ | Branch (658:9): [True: 8, False: 1.97k] | Branch (658:33): [True: 19, False: 1.95k] ------------------ 659| 27| val *= 86400; 660| 27| } 661| 1.98k| if (time[len - 1] == 'H' || time[len - 1] == 'h') { ------------------ | Branch (661:9): [True: 7, False: 1.97k] | Branch (661:33): [True: 5, False: 1.97k] ------------------ 662| 12| val *= 3600; 663| 12| } 664| 1.97k| else if (time[len - 1] == 'M' || time[len - 1] == 'm') { ------------------ | Branch (664:14): [True: 12, False: 1.95k] | Branch (664:38): [True: 4, False: 1.95k] ------------------ 665| 16| val *= 60; 666| 16| } 667| | 668| 1.98k| return val; 669| 2.04k|} flb_utils_bool: 672| 2.04k|{ 673| 2.04k| if (strcasecmp(val, "true") == 0 || ------------------ | Branch (673:9): [True: 2, False: 2.03k] ------------------ 674| 2.04k| strcasecmp(val, "on") == 0 || ------------------ | Branch (674:9): [True: 3, False: 2.03k] ------------------ 675| 2.04k| strcasecmp(val, "yes") == 0) { ------------------ | Branch (675:9): [True: 1, False: 2.03k] ------------------ 676| 6| return FLB_TRUE; ------------------ | | 26| 6|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 6|#define FLB_FALSE 0 | | ------------------ ------------------ 677| 6| } 678| 2.03k| else if (strcasecmp(val, "false") == 0 || ------------------ | Branch (678:14): [True: 1, False: 2.03k] ------------------ 679| 2.03k| strcasecmp(val, "off") == 0 || ------------------ | Branch (679:14): [True: 1, False: 2.03k] ------------------ 680| 2.03k| strcasecmp(val, "no") == 0) { ------------------ | Branch (680:14): [True: 1, False: 2.03k] ------------------ 681| 3| return FLB_FALSE; ------------------ | | 25| 3|#define FLB_FALSE 0 ------------------ 682| 3| } 683| | 684| 2.03k| return -1; 685| 2.04k|} flb_utils_time_split: 689| 2.04k|{ 690| 2.04k| char *p; 691| 2.04k| char *end; 692| 2.04k| long val = 0; 693| | 694| 2.04k| errno = 0; 695| 2.04k| val = strtol(time, &end, 10); 696| 2.04k| if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ------------------ | Branch (696:10): [True: 31, False: 2.01k] | Branch (696:30): [True: 30, False: 1] | Branch (696:49): [True: 1, False: 0] ------------------ 697| 2.04k| || (errno != 0 && val == 0)) { ------------------ | Branch (697:13): [True: 0, False: 2.01k] | Branch (697:27): [True: 0, False: 0] ------------------ 698| 31| flb_errno(); ------------------ | | 232| 31|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 699| 31| return -1; 700| 31| } 701| 2.01k| if (end == time) { ------------------ | Branch (701:9): [True: 1.77k, False: 239] ------------------ 702| 1.77k| return -1; 703| 1.77k| } 704| 239| *sec = (int) val; 705| | 706| | /* Try to find subseconds */ 707| 239| *nsec = 0; 708| 239| p = strchr(time, '.'); 709| 239| if (p) { ------------------ | Branch (709:9): [True: 32, False: 207] ------------------ 710| 32| p += 1; 711| 32| val = strtol(p, &end, 10); 712| 32| if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ------------------ | Branch (712:14): [True: 5, False: 27] | Branch (712:34): [True: 3, False: 2] | Branch (712:53): [True: 2, False: 0] ------------------ 713| 32| || (errno != 0 && val == 0)) { ------------------ | Branch (713:17): [True: 0, False: 27] | Branch (713:31): [True: 0, False: 0] ------------------ 714| 5| flb_errno(); ------------------ | | 232| 5|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 715| 5| return -1; 716| 5| } 717| 27| if (end == p) { ------------------ | Branch (717:13): [True: 5, False: 22] ------------------ 718| 5| return -1; 719| 5| } 720| 22| *nsec = val; 721| 22| } 722| | 723| 229| return 0; 724| 239|} flb_utils_write_str: 792| 55.2k|{ 793| 55.2k| int i, b, ret, len, hex_bytes, utf_sequence_length, utf_sequence_number; 794| 55.2k| int processed_bytes = 0; 795| 55.2k| int is_valid, copypos = 0, vlen; 796| 55.2k| uint32_t c; 797| 55.2k| uint32_t codepoint = 0; 798| 55.2k| uint32_t state = 0; 799| 55.2k| size_t available; 800| 55.2k| uint8_t *s; 801| 55.2k| off_t offset = 0; 802| 55.2k| char tmp[16]; 803| 55.2k| char *p; 804| | 805| | /* to encode codepoints > 0xFFFF */ 806| 55.2k| uint16_t high; 807| 55.2k| uint16_t low; 808| | 809| 55.2k| available = size - *off; 810| | 811| | /* Ensure we have some minimum space in the buffer */ 812| 55.2k| if (available < str_len) { ------------------ | Branch (812:9): [True: 0, False: 55.2k] ------------------ 813| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 814| 0| } 815| | 816| 55.2k| p = buf + *off; 817| | 818| | /* align length to the nearest multiple of the vector size for safe SIMD processing */ 819| 55.2k| vlen = str_len & ~(sizeof(flb_vector8) - 1); 820| 596M| for (i = 0;;) { 821| | /* SIMD optimization: Process chunk of input string */ 822| 596M| for (; i < vlen; i += sizeof(flb_vector8)) { ------------------ | Branch (822:16): [True: 596M, False: 2.04k] ------------------ 823| 596M| flb_vector8 chunk; 824| 596M| flb_vector8_load(&chunk, (const uint8_t *)&str[i]); 825| | 826| | /* 827| | * Look for the special characters we are interested in, 828| | * if they are found we break the loop and escape them 829| | * in a char-by-char basis. Otherwise the do a bulk copy 830| | */ 831| 596M| if (flb_vector8_has_le(chunk, (unsigned char) 0x1F) || ------------------ | Branch (831:17): [True: 596M, False: 0] ------------------ 832| 596M| flb_vector8_has(chunk, (unsigned char) '"') || ------------------ | Branch (832:17): [True: 0, False: 0] ------------------ 833| 596M| flb_vector8_has(chunk, (unsigned char) '\\')) { ------------------ | Branch (833:17): [True: 0, False: 0] ------------------ 834| 596M| break; 835| 596M| } 836| 596M| } 837| | 838| | /* Copy the chunk processed so far */ 839| 596M| if (copypos < i) { ------------------ | Branch (839:13): [True: 0, False: 596M] ------------------ 840| | /* check if we have enough space */ 841| 0| if (available < i - copypos) { ------------------ | Branch (841:17): [True: 0, False: 0] ------------------ 842| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 843| 0| } 844| | 845| | /* copy and adjust pointers */ 846| 0| memcpy(p, &str[copypos], i - copypos); 847| 0| p += i - copypos; 848| 0| offset += i - copypos; 849| 0| available -= (i - copypos); 850| 0| copypos = i; 851| 0| } 852| | 853| | /* Process remaining characters one by one */ 854| 1.19G| for (b = 0; b < sizeof(flb_vector8); b++) { ------------------ | Branch (854:21): [True: 596M, False: 596M] ------------------ 855| 596M| if (i >= str_len) { ------------------ | Branch (855:17): [True: 2.04k, False: 596M] ------------------ 856| | /* all characters has been processed */ 857| 2.04k| goto done; 858| 2.04k| } 859| | 860| 596M| c = (uint32_t) str[i]; 861| | 862| | /* Use lookup table for escaping known sequences */ 863| 596M| if (c < 128 && json_escape_table[c].seq) { ------------------ | Branch (863:17): [True: 377M, False: 218M] | Branch (863:28): [True: 185M, False: 191M] ------------------ 864| | /* 865| | * All characters in the table have a lenght of 2 or 6 bytes, 866| | * just check if the second byte starts with 'u' so we know 867| | * it's unicode and needs 6 bytes of space. 868| | */ 869| 185M| if (json_escape_table[c].seq[1] == 'u') { ------------------ | Branch (869:21): [True: 175M, False: 10.2M] ------------------ 870| 175M| len = 6; 871| 175M| } 872| 10.2M| else { 873| 10.2M| len = 2; 874| 10.2M| } 875| | 876| | /* check if we have anough space */ 877| 185M| if (available < len) { ------------------ | Branch (877:21): [True: 27.9k, False: 185M] ------------------ 878| 27.9k| return FLB_FALSE; ------------------ | | 25| 27.9k|#define FLB_FALSE 0 ------------------ 879| 27.9k| } 880| | 881| | /* copy the escape sequence */ 882| 185M| memcpy(p, json_escape_table[c].seq, len); 883| 185M| p += len; 884| 185M| offset += len; 885| 185M| available -= len; 886| 185M| } 887| | /* Handle UTF-8 sequences from 0x80 to 0xFFFF */ 888| 410M| else if (c >= 0x80 && c <= 0xFFFF) { ------------------ | Branch (888:22): [True: 218M, False: 191M] | Branch (888:35): [True: 0, False: 218M] ------------------ 889| 0| hex_bytes = flb_utf8_len(&str[i]); 890| | 891| | /* Handle invalid or truncated sequence */ 892| 0| if (hex_bytes == 0 || i + hex_bytes > str_len) { ------------------ | Branch (892:21): [True: 0, False: 0] | Branch (892:39): [True: 0, False: 0] ------------------ 893| | /* check for the minimum space required */ 894| 0| if (available < 3) { ------------------ | Branch (894:25): [True: 0, False: 0] ------------------ 895| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 896| 0| } 897| | 898| | /* insert replacement character (U+FFFD) */ 899| 0| p[0] = 0xEF; 900| 0| p[1] = 0xBF; 901| 0| p[2] = 0xBD; 902| 0| p += 3; 903| 0| offset += 3; 904| 0| available -= 3; 905| | 906| | /* skip the original byte */ 907| 0| i++; 908| 0| continue; 909| 0| } 910| | 911| | /* decode UTF-8 sequence */ 912| 0| state = FLB_UTF8_ACCEPT; ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 913| 0| codepoint = 0; 914| 0| processed_bytes = 0; 915| | 916| 0| for (b = 0; b < hex_bytes; b++) { ------------------ | Branch (916:29): [True: 0, False: 0] ------------------ 917| 0| s = (unsigned char *) &str[i + b]; 918| 0| ret = flb_utf8_decode(&state, &codepoint, *s); 919| 0| processed_bytes++; 920| | 921| 0| if (ret == FLB_UTF8_ACCEPT) { ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (921:25): [True: 0, False: 0] ------------------ 922| | /* check if all required bytes for the sequence are processed */ 923| 0| if (processed_bytes == hex_bytes) { ------------------ | Branch (923:29): [True: 0, False: 0] ------------------ 924| 0| break; 925| 0| } 926| 0| } 927| 0| else if (ret == FLB_UTF8_REJECT) { ------------------ | | 24| 0|#define FLB_UTF8_REJECT 1 ------------------ | Branch (927:30): [True: 0, False: 0] ------------------ 928| 0| flb_warn("[pack] Invalid UTF-8 bytes found, skipping."); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 929| 0| break; 930| 0| } 931| 0| } 932| | 933| 0| if (state == FLB_UTF8_ACCEPT) { ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (933:21): [True: 0, False: 0] ------------------ 934| 0| len = snprintf(tmp, sizeof(tmp), "\\u%.4x", codepoint); 935| 0| if (available < len) { ------------------ | Branch (935:25): [True: 0, False: 0] ------------------ 936| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 937| 0| } 938| 0| memcpy(p, tmp, len); 939| 0| p += len; 940| 0| offset += len; 941| 0| available -= len; 942| 0| } 943| 0| else { 944| 0| flb_warn("[pack] Invalid UTF-8 bytes found, skipping."); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 945| 0| } 946| | 947| 0| i += processed_bytes; 948| 0| } 949| | /* Handle sequences beyond 0xFFFF */ 950| 410M| else if (c > 0xFFFF) { ------------------ | Branch (950:22): [True: 218M, False: 191M] ------------------ 951| 218M| utf_sequence_length = flb_utf8_len(str + i); 952| | 953| | /* skip truncated UTF-8 ? */ 954| 218M| if (i + utf_sequence_length > str_len) { ------------------ | Branch (954:21): [True: 1.42k, False: 218M] ------------------ 955| 1.42k| i++; 956| 1.42k| break; 957| 1.42k| } 958| | 959| 218M| state = FLB_UTF8_ACCEPT; ------------------ | | 23| 218M|#define FLB_UTF8_ACCEPT 0 ------------------ 960| 218M| codepoint = 0; 961| 218M| is_valid = FLB_TRUE; ------------------ | | 26| 218M|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 218M|#define FLB_FALSE 0 | | ------------------ ------------------ 962| | 963| | /* Decode the sequence */ 964| 332M| for (utf_sequence_number = 0; utf_sequence_number < utf_sequence_length; utf_sequence_number++) { ------------------ | Branch (964:47): [True: 318M, False: 13.9M] ------------------ 965| 318M| ret = flb_utf8_decode(&state, &codepoint, (uint8_t) str[i]); 966| | 967| 318M| if (ret == FLB_UTF8_REJECT) { ------------------ | | 24| 318M|#define FLB_UTF8_REJECT 1 ------------------ | Branch (967:25): [True: 204M, False: 114M] ------------------ 968| | /* Handle invalid leading byte */ 969| 204M| if (utf_sequence_number == 0) { ------------------ | Branch (969:29): [True: 129M, False: 74.8M] ------------------ 970| 129M| flb_debug("[pack] unexpected UTF-8 leading byte, substituting character"); ------------------ | | 197| 129M| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 129M|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 129M] | | ------------------ | | 198| 129M| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 971| 129M| tmp[utf_sequence_number] = str[i]; 972| 129M| utf_sequence_length = utf_sequence_number + 1; /* Process only this invalid byte */ 973| 129M| i++; /* Consume invalid byte */ 974| 129M| } 975| | /* Handle invalid continuation byte */ 976| 74.8M| else { 977| 74.8M| flb_debug("[pack] unexpected UTF-8 continuation byte, substituting character"); ------------------ | | 197| 74.8M| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 74.8M|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 74.8M] | | ------------------ | | 198| 74.8M| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 978| 74.8M| utf_sequence_length = utf_sequence_number; /* Adjust length */ 979| 74.8M| } 980| 204M| is_valid = FLB_FALSE; ------------------ | | 25| 204M|#define FLB_FALSE 0 ------------------ 981| 204M| break; 982| 204M| } 983| | 984| 114M| tmp[utf_sequence_number] = str[i]; 985| 114M| ++i; 986| 114M| } 987| | 988| 218M| --i; 989| | 990| 218M| if (is_valid) { ------------------ | Branch (990:21): [True: 13.9M, False: 204M] ------------------ 991| 13.9M| if (available < utf_sequence_length) { ------------------ | Branch (991:25): [True: 724, False: 13.9M] ------------------ 992| | /* not enough space */ 993| 724| return FLB_FALSE; ------------------ | | 25| 724|#define FLB_FALSE 0 ------------------ 994| 724| } 995| | 996| | /* Handle codepoints beyond BMP (requires surrogate pairs in UTF-16) */ 997| 13.9M| if (codepoint > 0xFFFF) { ------------------ | Branch (997:25): [True: 1.21M, False: 12.6M] ------------------ 998| 1.21M| high = 0xD800 + ((codepoint - 0x10000) >> 10); 999| 1.21M| low = 0xDC00 + ((codepoint - 0x10000) & 0x3FF); 1000| | 1001| 1.21M| len = snprintf(tmp, sizeof(tmp), "\\u%.4x\\u%.4x", high, low); 1002| 1.21M| } 1003| 12.6M| else { 1004| 12.6M| len = snprintf(tmp, sizeof(tmp), "\\u%.4x", codepoint); 1005| 12.6M| } 1006| | 1007| 13.9M| if (available < len) { ------------------ | Branch (1007:25): [True: 1.36k, False: 13.9M] ------------------ 1008| | /* not enough space */ 1009| 1.36k| return FLB_FALSE; ------------------ | | 25| 1.36k|#define FLB_FALSE 0 ------------------ 1010| 1.36k| } 1011| 13.9M| memcpy(p, tmp, len); 1012| 13.9M| p += len; 1013| 13.9M| offset += len; 1014| 13.9M| available -= len; 1015| 13.9M| } 1016| 204M| else { 1017| 204M| if (available < utf_sequence_length * 3) { ------------------ | Branch (1017:25): [True: 16.9k, False: 204M] ------------------ 1018| 16.9k| return FLB_FALSE; ------------------ | | 25| 16.9k|#define FLB_FALSE 0 ------------------ 1019| 16.9k| } 1020| | 1021| | /* 1022| | * Utf-8 sequence is invalid. Map fragments to private use area 1023| | * codepoints in range: 1024| | * 0x00 to 1025| | * 0xFF 1026| | */ 1027| 417M| for (b = 0; b < utf_sequence_length; ++b) { ------------------ | Branch (1027:33): [True: 212M, False: 204M] ------------------ 1028| | /* 1029| | * Utf-8 private block invalid hex mapping. Format unicode charpoint 1030| | * in the following format: 1031| | * 1032| | * +--------+--------+--------+ 1033| | * |1110PPPP|10PPPPHH|10HHHHHH| 1034| | * +--------+--------+--------+ 1035| | * 1036| | * Where: 1037| | * P is FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR bits (1 byte) 1038| | * H is Utf-8 fragment hex bits (1 byte) 1039| | * 1 is bit 1 1040| | * 0 is bit 0 1041| | */ 1042| | 1043| | /* unicode codepoint start */ 1044| 212M| *p = 0xE0; 1045| | 1046| | /* print unicode private block header first 4 bits */ 1047| 212M| *p |= FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR >> 4; ------------------ | | 67| 212M|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 1048| 212M| ++p; 1049| | 1050| | /* unicode codepoint middle */ 1051| 212M| *p = 0x80; 1052| | 1053| | /* print end of unicode private block header last 4 bits */ 1054| 212M| *p |= ((FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR << 2) & 0x3f); ------------------ | | 67| 212M|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 1055| | 1056| | /* print hex fragment first 2 bits */ 1057| 212M| *p |= (tmp[b] >> 6) & 0x03; 1058| 212M| ++p; 1059| | 1060| | /* unicode codepoint middle */ 1061| 212M| *p = 0x80; 1062| | 1063| | /* print hex fragment last 6 bits */ 1064| 212M| *p |= tmp[b] & 0x3f; 1065| 212M| ++p; 1066| | 1067| 212M| offset += 3; 1068| 212M| available -= 3; 1069| 212M| } 1070| 204M| } 1071| | 1072| 218M| } 1073| 191M| else { 1074| 191M| if (available < 1) { ------------------ | Branch (1074:21): [True: 6.29k, False: 191M] ------------------ 1075| | /* no space for a single byte */ 1076| 6.29k| return FLB_FALSE; ------------------ | | 25| 6.29k|#define FLB_FALSE 0 ------------------ 1077| 6.29k| } 1078| 191M| *p++ = c; 1079| 191M| offset++; 1080| 191M| available--; 1081| 191M| } 1082| | 1083| 596M| i++; 1084| 596M| } 1085| | 1086| 596M| copypos = i; 1087| 596M| } 1088| | 1089| 2.04k|done: 1090| | /* update the buffer offset */ 1091| 2.04k| *off += offset; 1092| | 1093| 2.04k| return FLB_TRUE; ------------------ | | 26| 2.04k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2.04k|#define FLB_FALSE 0 | | ------------------ ------------------ 1094| 55.2k|} flb_utils_write_str_buf: 1097| 2.04k|{ 1098| 2.04k| int ret; 1099| 2.04k| int off; 1100| 2.04k| char *tmp; 1101| 2.04k| char *buf; 1102| 2.04k| size_t s; 1103| | 1104| 2.04k| s = str_len + 1; 1105| 2.04k| buf = flb_malloc(s); 1106| 2.04k| if (!buf) { ------------------ | Branch (1106:9): [True: 0, False: 2.04k] ------------------ 1107| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 1108| 0| return -1; 1109| 0| } 1110| | 1111| 55.2k| while (1) { ------------------ | Branch (1111:12): [Folded - Ignored] ------------------ 1112| 55.2k| off = 0; 1113| 55.2k| ret = flb_utils_write_str(buf, &off, s, str, str_len); 1114| 55.2k| if (ret == FLB_FALSE) { ------------------ | | 25| 55.2k|#define FLB_FALSE 0 ------------------ | Branch (1114:13): [True: 53.2k, False: 2.04k] ------------------ 1115| 53.2k| s += 256; 1116| 53.2k| tmp = flb_realloc(buf, s); 1117| 53.2k| if (!tmp) { ------------------ | Branch (1117:17): [True: 0, False: 53.2k] ------------------ 1118| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 1119| 0| flb_free(buf); 1120| 0| return -1; 1121| 0| } 1122| 53.2k| buf = tmp; 1123| 53.2k| } 1124| 2.04k| else { 1125| | /* done */ 1126| 2.04k| break; 1127| 2.04k| } 1128| 55.2k| } 1129| | 1130| 2.04k| *out = buf; 1131| 2.04k| *out_size = off; 1132| 2.04k| return 0; 1133| 2.04k|} flb_utils_url_split: 1149| 2.04k|{ 1150| 2.04k| char *protocol = NULL; 1151| 2.04k| char *host = NULL; 1152| 2.04k| char *port = NULL; 1153| 2.04k| char *uri = NULL; 1154| 2.04k| char *p; 1155| 2.04k| char *tmp; 1156| 2.04k| char *sep; 1157| | 1158| | /* Protocol */ 1159| 2.04k| p = strstr(in_url, "://"); 1160| 2.04k| if (!p) { ------------------ | Branch (1160:9): [True: 1.50k, False: 533] ------------------ 1161| 1.50k| return -1; 1162| 1.50k| } 1163| 533| if (p == in_url) { ------------------ | Branch (1163:9): [True: 24, False: 509] ------------------ 1164| 24| return -1; 1165| 24| } 1166| | 1167| 509| protocol = mk_string_copy_substr(in_url, 0, p - in_url); 1168| 509| if (!protocol) { ------------------ | Branch (1168:9): [True: 0, False: 509] ------------------ 1169| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 1170| 0| return -1; 1171| 0| } 1172| | 1173| | /* Advance position after protocol */ 1174| 509| p += 3; 1175| | 1176| | /* Check for first '/' */ 1177| 509| sep = strchr(p, '/'); 1178| 509| tmp = strchr(p, ':'); 1179| | 1180| | /* Validate port separator is found before the first slash */ 1181| 509| if (sep && tmp) { ------------------ | Branch (1181:9): [True: 284, False: 225] | Branch (1181:16): [True: 238, False: 46] ------------------ 1182| 238| if (tmp > sep) { ------------------ | Branch (1182:13): [True: 74, False: 164] ------------------ 1183| 74| tmp = NULL; 1184| 74| } 1185| 238| } 1186| | 1187| 509| if (tmp) { ------------------ | Branch (1187:9): [True: 221, False: 288] ------------------ 1188| 221| host = flb_copy_host(p, 0, tmp - p); 1189| 221| if (!host) { ------------------ | Branch (1189:13): [True: 31, False: 190] ------------------ 1190| 31| flb_errno(); ------------------ | | 232| 31|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 1191| 31| goto error; 1192| 31| } 1193| 190| p = tmp + 1; 1194| | 1195| | /* Look for an optional URI */ 1196| 190| tmp = strchr(p, '/'); 1197| 190| if (tmp) { ------------------ | Branch (1197:13): [True: 137, False: 53] ------------------ 1198| 137| port = mk_string_copy_substr(p, 0, tmp - p); 1199| 137| uri = flb_strdup(tmp); 1200| 137| } 1201| 53| else { 1202| 53| port = flb_strdup(p); 1203| 53| uri = flb_strdup("/"); 1204| 53| } 1205| 190| } 1206| 288| else { 1207| 288| tmp = strchr(p, '/'); 1208| 288| if (tmp) { ------------------ | Branch (1208:13): [True: 120, False: 168] ------------------ 1209| 120| host = flb_copy_host(p, 0, tmp - p); 1210| 120| uri = flb_strdup(tmp); 1211| 120| } 1212| 168| else { 1213| 168| host = flb_copy_host(p, 0, strlen(p)); 1214| 168| uri = flb_strdup("/"); 1215| 168| } 1216| 288| } 1217| | 1218| 478| if (!port) { ------------------ | Branch (1218:9): [True: 288, False: 190] ------------------ 1219| 288| if (strcmp(protocol, "http") == 0) { ------------------ | Branch (1219:13): [True: 21, False: 267] ------------------ 1220| 21| port = flb_strdup("80"); 1221| 21| } 1222| 267| else if (strcmp(protocol, "https") == 0) { ------------------ | Branch (1222:18): [True: 3, False: 264] ------------------ 1223| 3| port = flb_strdup("443"); 1224| 3| } 1225| 288| } 1226| | 1227| 478| *out_protocol = protocol; 1228| 478| *out_host = host; 1229| 478| *out_port = port; 1230| 478| *out_uri = uri; 1231| | 1232| 478| return 0; 1233| | 1234| 31| error: 1235| 31| if (protocol) { ------------------ | Branch (1235:9): [True: 31, False: 0] ------------------ 1236| 31| flb_free(protocol); 1237| 31| } 1238| | 1239| 31| return -1; 1240| 509|} flb_utils_proxy_url_split: 1251| 2.04k|{ 1252| 2.04k| char *protocol = NULL; 1253| 2.04k| char *username = NULL; 1254| 2.04k| char *password = NULL; 1255| 2.04k| char *host = NULL; 1256| 2.04k| char *port = NULL; 1257| 2.04k| char *proto_sep; 1258| 2.04k| char *at_sep; 1259| 2.04k| char *tmp; 1260| | 1261| | /* Parse protocol */ 1262| 2.04k| proto_sep = strstr(in_url, "://"); 1263| 2.04k| if (!proto_sep) { ------------------ | Branch (1263:9): [True: 1.50k, False: 533] ------------------ 1264| 1.50k| flb_error("HTTP_PROXY variable must be set in the form of 'http://[username:password@]host:port'"); ------------------ | | 170| 1.50k| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 1.50k|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 1.50k, False: 0] | | ------------------ | | 171| 1.50k| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 1.50k|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 1265| 1.50k| return -1; 1266| 1.50k| } 1267| 533| if (proto_sep == in_url) { ------------------ | Branch (1267:9): [True: 24, False: 509] ------------------ 1268| 24| flb_error("HTTP_PROXY variable must be set in the form of 'http://[username:password@]host:port'"); ------------------ | | 170| 24| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 24|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 24, False: 0] | | ------------------ | | 171| 24| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 24|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 1269| 24| return -1; 1270| 24| } 1271| | 1272| 509| protocol = mk_string_copy_substr(in_url, 0, proto_sep - in_url); 1273| 509| if (!protocol) { ------------------ | Branch (1273:9): [True: 0, False: 509] ------------------ 1274| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 1275| 0| return -1; 1276| 0| } 1277| | /* Only HTTP proxy is supported for now. */ 1278| 509| if (strcmp(protocol, "http") != 0) { ------------------ | Branch (1278:9): [True: 457, False: 52] ------------------ 1279| 457| flb_error("only HTTP proxy is supported."); ------------------ | | 170| 457| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 457|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 457, False: 0] | | ------------------ | | 171| 457| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 457|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 1280| 457| flb_free(protocol); 1281| 457| return -1; 1282| 457| } 1283| | 1284| | /* Advance position after protocol */ 1285| 52| proto_sep += 3; 1286| | 1287| | /* Separate `username:password` and `host:port` */ 1288| 52| at_sep = strrchr(proto_sep, '@'); 1289| 52| if (at_sep) { ------------------ | Branch (1289:9): [True: 35, False: 17] ------------------ 1290| | /* Parse username:password part. */ 1291| 35| tmp = strchr(proto_sep, ':'); 1292| 35| if (!tmp) { ------------------ | Branch (1292:13): [True: 3, False: 32] ------------------ 1293| 3| flb_free(protocol); 1294| 3| return -1; 1295| 3| } 1296| 32| username = mk_string_copy_substr(proto_sep, 0, tmp - proto_sep); 1297| 32| tmp += 1; 1298| 32| password = mk_string_copy_substr(tmp, 0, at_sep - tmp); 1299| | 1300| | /* Parse host:port part. */ 1301| 32| at_sep += 1; 1302| 32| tmp = strchr(at_sep, ':'); 1303| 32| if (tmp) { ------------------ | Branch (1303:13): [True: 25, False: 7] ------------------ 1304| 25| host = flb_copy_host(at_sep, 0, tmp - at_sep); 1305| 25| tmp += 1; 1306| 25| port = strdup(tmp); 1307| 25| } 1308| 7| else { 1309| 7| host = flb_copy_host(at_sep, 0, strlen(at_sep)); 1310| 7| port = flb_strdup("80"); 1311| 7| } 1312| 32| } 1313| 17| else { 1314| | /* Parse host:port part. */ 1315| 17| tmp = strchr(proto_sep, ':'); 1316| 17| if (tmp) { ------------------ | Branch (1316:13): [True: 10, False: 7] ------------------ 1317| 10| host = flb_copy_host(proto_sep, 0, tmp - proto_sep); 1318| 10| tmp += 1; 1319| 10| port = strdup(tmp); 1320| 10| } 1321| 7| else { 1322| 7| host = flb_copy_host(proto_sep, 0, strlen(proto_sep)); 1323| 7| port = flb_strdup("80"); 1324| 7| } 1325| 17| } 1326| | 1327| 49| *out_protocol = protocol; 1328| 49| *out_host = host; 1329| 49| *out_port = port; 1330| 49| if (username) { ------------------ | Branch (1330:9): [True: 32, False: 17] ------------------ 1331| 32| *out_username = username; 1332| 32| } 1333| 49| if (password) { ------------------ | Branch (1333:9): [True: 14, False: 35] ------------------ 1334| 14| *out_password = password; 1335| 14| } 1336| | 1337| 49| return 0; 1338| 52|} flb_utils.c:split: 387| 4.08k|{ 388| 4.08k| int i = 0; 389| 4.08k| int count = 0; 390| 4.08k| int val_len; 391| 4.08k| int len; 392| 4.08k| int end; 393| 4.08k| char *val; 394| 4.08k| struct mk_list *list; 395| 4.08k| struct flb_split_entry *new; 396| | 397| 4.08k| if (!line) { ------------------ | Branch (397:9): [True: 0, False: 4.08k] ------------------ 398| 0| return NULL; 399| 0| } 400| | 401| 4.08k| list = flb_malloc(sizeof(struct mk_list)); 402| 4.08k| if (!list) { ------------------ | Branch (402:9): [True: 0, False: 4.08k] ------------------ 403| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 404| 0| return NULL; 405| 0| } 406| 4.08k| mk_list_init(list); 407| | 408| 4.08k| len = strlen(line); 409| 8.84k| while (i < len) { ------------------ | Branch (409:12): [True: 5.05k, False: 3.79k] ------------------ 410| 5.05k| end = next_token(line + i, separator, &val, &val_len, quoted); 411| 5.05k| if (end == -1) { ------------------ | Branch (411:13): [True: 116, False: 4.94k] ------------------ 412| 116| flb_error("Parsing failed: %s", line); ------------------ | | 170| 116| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 116|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 116, False: 0] | | ------------------ | | 171| 116| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 116|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 413| 116| flb_utils_split_free(list); 414| 116| return NULL; 415| 116| } 416| | 417| | /* Update last position */ 418| 4.94k| i += end; 419| | 420| | /* Create new entry */ 421| 4.94k| new = flb_malloc(sizeof(struct flb_split_entry)); 422| 4.94k| if (!new) { ------------------ | Branch (422:13): [True: 0, False: 4.94k] ------------------ 423| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 424| 0| flb_free(val); 425| 0| flb_utils_split_free(list); 426| 0| return NULL; 427| 0| } 428| 4.94k| new->value = val; 429| 4.94k| new->len = val_len; 430| 4.94k| new->last_pos = i; 431| 4.94k| mk_list_add(&new->_head, list); 432| 4.94k| count++; 433| | 434| | /* Update index for next loop */ 435| 4.94k| i++; 436| | 437| | /* 438| | * If the counter exceeded the maximum specified and there 439| | * are still remaining bytes, append those bytes in a new 440| | * and last entry. 441| | */ 442| 4.94k| if (count >= max_split && max_split > 0 && i < len) { ------------------ | Branch (442:13): [True: 320, False: 4.62k] | Branch (442:35): [True: 320, False: 0] | Branch (442:52): [True: 176, False: 144] ------------------ 443| 176| new = flb_malloc(sizeof(struct flb_split_entry)); 444| 176| if (!new) { ------------------ | Branch (444:17): [True: 0, False: 176] ------------------ 445| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 446| 0| flb_utils_split_free(list); 447| 0| return NULL; 448| 0| } 449| 176| new->value = mk_string_copy_substr(line, i, len); 450| 176| new->len = len - i; 451| 176| mk_list_add(&new->_head, list); 452| 176| break; 453| 176| } 454| 4.94k| } 455| | 456| 3.96k| return list; 457| 4.08k|} flb_utils.c:next_token: 321| 5.05k|static int next_token(const char *str, int separator, char **out, int *out_len, int parse_quotes) { 322| 5.05k| const char *token_in = str; 323| 5.05k| char *token_out; 324| 5.05k| int next_separator = 0; 325| 5.05k| int quote = 0; /* Parser state: 0 not inside quoted string, or '"' or '\'' when inside quoted string. */ 326| 5.05k| int len = 0; 327| 5.05k| int i; 328| | 329| | /* Skip leading separators. */ 330| 6.63k| while (*token_in == separator) { ------------------ | Branch (330:12): [True: 1.57k, False: 5.05k] ------------------ 331| 1.57k| token_in++; 332| 1.57k| } 333| | 334| | /* Should quotes be parsed? Or is token quoted? If not, copy until separator or the end of string. */ 335| 5.05k| if (parse_quotes == FLB_FALSE || (*token_in != '"' && *token_in != '\'')) { ------------------ | | 25| 10.1k|#define FLB_FALSE 0 ------------------ | Branch (335:9): [True: 2.53k, False: 2.52k] | Branch (335:39): [True: 2.43k, False: 90] | Branch (335:59): [True: 2.30k, False: 127] ------------------ 336| 4.83k| len = (int)strlen(token_in); 337| 4.83k| next_separator = mk_string_char_search(token_in, separator, len); 338| 4.83k| if (next_separator > 0) { ------------------ | Branch (338:13): [True: 1.17k, False: 3.66k] ------------------ 339| 1.17k| len = next_separator; 340| 1.17k| } 341| 4.83k| *out_len = len; 342| 4.83k| *out = mk_string_copy_substr(token_in, 0, len); 343| 4.83k| if (*out == NULL) { ------------------ | Branch (343:13): [True: 0, False: 4.83k] ------------------ 344| 0| return -1; 345| 0| } 346| | 347| 4.83k| return (int)(token_in - str) + len; 348| 4.83k| } 349| | 350| | /* Token is quoted. */ 351| | 352| 217| len = quoted_string_len(token_in); 353| 217| if (len < 0) { ------------------ | Branch (353:9): [True: 116, False: 101] ------------------ 354| 116| return -1; 355| 116| } 356| | 357| | /* Consume the quote character. */ 358| 101| quote = *token_in++; 359| | 360| 101| token_out = flb_malloc(len + 1); 361| 101| if (!token_out) { ------------------ | Branch (361:9): [True: 0, False: 101] ------------------ 362| 0| return -1; 363| 0| } 364| | 365| | /* Copy the token */ 366| 203k| for (i = 0; i < len; i++) { ------------------ | Branch (366:17): [True: 203k, False: 101] ------------------ 367| | /* Handle escapes when inside quoted token: 368| | * \" -> " 369| | * \' -> ' 370| | * \\ -> \ 371| | */ 372| 203k| if (*token_in == '\\' && (token_in[1] == quote || token_in[1] == '\\')) { ------------------ | Branch (372:13): [True: 1.97k, False: 201k] | Branch (372:35): [True: 253, False: 1.72k] | Branch (372:59): [True: 1.23k, False: 490] ------------------ 373| 1.48k| token_in++; 374| 1.48k| } 375| 203k| token_out[i] = *token_in++; 376| 203k| } 377| 101| token_out[i] = '\0'; 378| | 379| 101| *out = token_out; 380| 101| *out_len = len; 381| | 382| 101| return (int)(token_in - str); 383| 101|} flb_utils.c:quoted_string_len: 279| 217|{ 280| 217| int len = 0; 281| 217| char quote = *str++; /* Consume the quote character. */ 282| | 283| 682k| while (quote != 0) { ------------------ | Branch (283:12): [True: 681k, False: 101] ------------------ 284| 681k| char c = *str++; 285| 681k| switch (c) { 286| 116| case '\0': ------------------ | Branch (286:13): [True: 116, False: 681k] ------------------ 287| | /* Error: string ends before end-quote was seen. */ 288| 116| return -1; 289| 4.55k| case '\\': ------------------ | Branch (289:13): [True: 4.55k, False: 677k] ------------------ 290| | /* Skip escaped quote or \\. */ 291| 4.55k| if (*str == quote || *str == '\\') { ------------------ | Branch (291:21): [True: 739, False: 3.81k] | Branch (291:38): [True: 2.82k, False: 983] ------------------ 292| 3.56k| str++; 293| 3.56k| } 294| 4.55k| break; 295| 1.95k| case '\'': ------------------ | Branch (295:13): [True: 1.95k, False: 679k] ------------------ 296| 2.97k| case '"': ------------------ | Branch (296:13): [True: 1.01k, False: 680k] ------------------ 297| | /* End-quote seen: stop iterating. */ 298| 2.97k| if (c == quote) { ------------------ | Branch (298:21): [True: 101, False: 2.87k] ------------------ 299| 101| quote = 0; 300| 101| } 301| 2.97k| break; 302| 674k| default: ------------------ | Branch (302:13): [True: 674k, False: 7.64k] ------------------ 303| 674k| break; 304| 681k| } 305| 681k| len++; 306| 681k| } 307| | 308| | /* Go back one character to ignore end-quote */ 309| 101| len--; 310| | 311| 101| return len; 312| 217|} flb_utils.c:flb_copy_host: 1136| 558|{ 1137| 558| if (string[pos_init] == '[') { /* IPv6 */ ------------------ | Branch (1137:9): [True: 125, False: 433] ------------------ 1138| 125| if (string[pos_end-1] != ']') ------------------ | Branch (1138:13): [True: 115, False: 10] ------------------ 1139| 115| return NULL; 1140| | 1141| 10| return mk_string_copy_substr(string, pos_init + 1, pos_end - 1); 1142| 125| } 1143| 433| else 1144| 433| return mk_string_copy_substr(string, pos_init, pos_end); 1145| 558|} flb_worker_get: 135| 3.88k|{ 136| 3.88k| return FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 3.88k|#define FLB_TLS_GET(key) key ------------------ 137| 3.88k|} get_null_terminated: 29| 6.12k|{ 30| 6.12k| char *tmp = flb_malloc(size+1); 31| 6.12k| if (tmp == NULL) { ------------------ | Branch (31:7): [True: 0, False: 6.12k] ------------------ 32| 0| tmp = malloc(size+1); 33| 0| } 34| 6.12k| memcpy(tmp, *data, size); 35| 6.12k| tmp[size] = '\0'; 36| | 37| | /* Modify the fuzz variables */ 38| 6.12k| *total_data_size -= size; 39| 6.12k| *data += size; 40| | 41| 6.12k| return tmp; 42| 6.12k|} LLVMFuzzerTestOneInput: 34| 2.10k|{ 35| 2.10k| TIMEOUT_GUARD ------------------ | | 25| 2.10k|#define TIMEOUT_GUARD if (size > 32768) return 0; | | ------------------ | | | Branch (25:27): [True: 18, False: 2.08k] | | ------------------ ------------------ 36| | 37| 2.08k| if (size < 750) { ------------------ | Branch (37:9): [True: 42, False: 2.04k] ------------------ 38| 42| return 0; 39| 42| } 40| | 41| | /* Set fuzzer-malloc chance of failure */ 42| 2.04k| flb_malloc_mod = 25000; 43| 2.04k| flb_malloc_p = 0; 44| | 45| 2.04k| uint64_t ran_hash = *(uint64_t *)data; 46| 2.04k| char *null_terminated1 = get_null_terminated(25, &data, &size); 47| 2.04k| char *null_terminated2 = get_null_terminated(25, &data, &size); 48| 2.04k| char *null_terminated3 = get_null_terminated(25, &data, &size); 49| | 50| | /* Prepare a general null-terminated string */ 51| 2.04k| char *null_terminated = (char*)malloc(size+1); 52| 2.04k| null_terminated[size] = '\0'; 53| 2.04k| memcpy(null_terminated, data, size); 54| | 55| | /* Fuzzing of flb_utils.c */ 56| 2.04k| int sec; 57| 2.04k| long nsec; 58| 2.04k| size_t new_size; 59| 2.04k| char *prot = NULL; 60| 2.04k| char *host = NULL; 61| 2.04k| char *port = NULL; 62| 2.04k| char *uri = NULL; 63| 2.04k| char *new_dst = NULL; 64| | 65| 2.04k| if (flb_utils_write_str_buf(null_terminated, size, &new_dst, &new_size) == 0) { ------------------ | Branch (65:9): [True: 2.04k, False: 0] ------------------ 66| 2.04k| flb_free(new_dst); 67| 2.04k| } 68| | 69| 2.04k| struct mk_list *list = flb_utils_split(null_terminated, 'A', 3); 70| 2.04k| if (list != NULL) { ------------------ | Branch (70:9): [True: 2.04k, False: 0] ------------------ 71| 2.04k| flb_utils_split_free(list); 72| 2.04k| } 73| 2.04k| struct mk_list *list2 = flb_utils_split_quoted(null_terminated, 'A', 3); 74| 2.04k| if (list2 != NULL) { ------------------ | Branch (74:9): [True: 1.92k, False: 116] ------------------ 75| 1.92k| flb_utils_split_free(list2); 76| 1.92k| } 77| | 78| 2.04k| if (flb_utils_url_split(null_terminated, &prot, &host, &port, &uri) == 0) { ------------------ | Branch (78:9): [True: 478, False: 1.56k] ------------------ 79| 478| flb_free(prot); 80| 478| flb_free(port); 81| 478| flb_free(host); 82| 478| flb_free(uri); 83| 478| } 84| | 85| 2.04k| char *split_protocol = NULL; 86| 2.04k| char *split_username = NULL; 87| 2.04k| char *split_password = NULL; 88| 2.04k| char *split_host = NULL; 89| 2.04k| char *split_port = NULL; 90| 2.04k| if (flb_utils_proxy_url_split(null_terminated, &split_protocol, ------------------ | Branch (90:9): [True: 49, False: 1.99k] ------------------ 91| 2.04k| &split_username, &split_password, &split_host, &split_port) == 0) { 92| 49| if (split_protocol) { ------------------ | Branch (92:13): [True: 49, False: 0] ------------------ 93| 49| flb_free(split_protocol); 94| 49| } 95| 49| if (split_username) { ------------------ | Branch (95:13): [True: 32, False: 17] ------------------ 96| 32| flb_free(split_username); 97| 32| } 98| 49| if (split_password) { ------------------ | Branch (98:13): [True: 14, False: 35] ------------------ 99| 14| flb_free(split_password); 100| 14| } 101| 49| if (split_host) { ------------------ | Branch (101:13): [True: 39, False: 10] ------------------ 102| 39| flb_free(split_host); 103| 39| } 104| 49| if (split_port) { ------------------ | Branch (104:13): [True: 49, False: 0] ------------------ 105| 49| flb_free(split_port); 106| 49| } 107| 49| } 108| | 109| | 110| 2.04k| flb_utils_size_to_bytes(null_terminated); 111| 2.04k| flb_utils_time_split(null_terminated, &sec, &nsec); 112| 2.04k| flb_utils_time_to_seconds(null_terminated); 113| 2.04k| flb_utils_bool(null_terminated); 114| 2.04k| flb_utils_hex2int(null_terminated, size); 115| | 116| | /* Fuzzong of flb_uri.c */ 117| 2.04k| struct flb_uri *uri2 = NULL; 118| 2.04k| uri2 = flb_uri_create(null_terminated); 119| 2.04k| if (uri2 != NULL) { ------------------ | Branch (119:9): [True: 2.04k, False: 0] ------------------ 120| 2.04k| flb_uri_get(uri2, (int)data[0]); 121| 2.04k| flb_uri_dump(uri2); 122| 2.04k| flb_uri_destroy(uri2); 123| 2.04k| } 124| 2.04k| flb_sds_t encoded = flb_uri_encode((char*)data, size); 125| 2.04k| if (encoded != NULL) { ------------------ | Branch (125:9): [True: 2.04k, False: 0] ------------------ 126| 2.04k| flb_sds_destroy(encoded); 127| 2.04k| } 128| | 129| | /* Fuzzing of flb_hash.c */ 130| 2.04k| struct flb_hash_table *ht = NULL; 131| 2.04k| ht = flb_hash_table_create((int)(data[2] % 0x04), 132| 2.04k| (size_t)data[0], 133| 2.04k| (int)data[1]); 134| 2.04k| if (ht != NULL) { ------------------ | Branch (134:9): [True: 1.98k, False: 58] ------------------ 135| 1.98k| flb_hash_table_add(ht, null_terminated, size, null_terminated, size); 136| | 137| 1.98k| char *out_buf = NULL; 138| 1.98k| size_t out_size; 139| 1.98k| flb_hash_table_get(ht, null_terminated, size, (void **)&out_buf, &out_size); 140| | 141| | /* now let's create some more instances */ 142| 1.98k| char *instances1[128] = { NULL }; 143| 1.98k| char *instances2[128] = { NULL }; 144| 255k| for (int i = 0; i < 128; i++) { ------------------ | Branch (144:25): [True: 253k, False: 1.98k] ------------------ 145| 253k| char *in1 = malloc(3); 146| 253k| char *in2 = malloc(3); 147| 253k| memcpy(in1, data+(i*4), 2); 148| 253k| memcpy(in2, data+(i*4)+2, 2); 149| 253k| in1[2] = '\0'; 150| 253k| in2[2] = '\0'; 151| 253k| flb_hash_table_add(ht, in1, 2, in2, 2); 152| 253k| instances1[i] = in1; 153| 253k| instances2[i] = in2; 154| 253k| } 155| | 156| 41.6k| for(int i = 0; i < 20; i++) { ------------------ | Branch (156:24): [True: 39.6k, False: 1.98k] ------------------ 157| 39.6k| char *hash_out_buf; 158| 39.6k| size_t hash_out_size; 159| 39.6k| flb_hash_table_get_by_id(ht, (int)data[i], null_terminated, 160| 39.6k| (const char **)&hash_out_buf, &hash_out_size); 161| 39.6k| } 162| | 163| 1.98k| flb_hash_table_del(ht, null_terminated1); 164| 1.98k| flb_hash_table_exists(ht, ran_hash); 165| 1.98k| flb_hash_table_del_ptr(ht, null_terminated2, strlen(null_terminated2), NULL); 166| 1.98k| flb_hash_table_get_ptr(ht, null_terminated3, strlen(null_terminated3)); 167| | 168| 1.98k| flb_hash_table_destroy(ht); 169| 255k| for (int i =0; i<128; i++) { ------------------ | Branch (169:24): [True: 253k, False: 1.98k] ------------------ 170| 253k| flb_free(instances1[i]); 171| 253k| flb_free(instances2[i]); 172| 253k| } 173| 1.98k| } 174| | 175| | /* sds */ 176| 2.04k| flb_sds_t fs = flb_sds_create_len((const char*)data, size); 177| 2.04k| if (fs != NULL) { ------------------ | Branch (177:9): [True: 2.04k, False: 0] ------------------ 178| 2.04k| fs = flb_sds_cat_esc(fs, "AAABBBCCC", 9, "ABC", 3); 179| 2.04k| if (fs != NULL) { ------------------ | Branch (179:13): [True: 2.04k, False: 0] ------------------ 180| 2.04k| flb_sds_destroy(fs); 181| 2.04k| } 182| 2.04k| } 183| | 184| | /* Fuzzing of flb_gzip.c */ 185| 2.04k| void *str = NULL; 186| 2.04k| size_t len; 187| 2.04k| void *out_data = NULL; 188| 2.04k| size_t out_len; 189| 2.04k| if (flb_gzip_compress((char*)data, size, &str, &len) != -1) { ------------------ | Branch (189:9): [True: 2.04k, False: 0] ------------------ 190| 2.04k| flb_gzip_uncompress(str, len, &out_data, &out_len); 191| 2.04k| } 192| 2.04k| if (str != NULL) { ------------------ | Branch (192:9): [True: 2.04k, False: 0] ------------------ 193| 2.04k| free(str); 194| 2.04k| } 195| 2.04k| if (out_data != NULL) { ------------------ | Branch (195:9): [True: 2.04k, False: 0] ------------------ 196| 2.04k| free(out_data); 197| 2.04k| } 198| 2.04k| void *out_data2 = NULL; 199| 2.04k| size_t out2_len; 200| 2.04k| int uncompress_ret = flb_gzip_uncompress((char*)data, size, &out_data2, &out2_len); 201| 2.04k| if (uncompress_ret != -1 && out_data2 != NULL) { ------------------ | Branch (201:9): [True: 2, False: 2.03k] | Branch (201:33): [True: 2, False: 0] ------------------ 202| 2| flb_free(out_data2); 203| 2| } 204| | 205| | /* Fuzzing the sha routines */ 206| 2.04k| struct flb_hash sha512; 207| 2.04k| uint8_t buf[64]; 208| | 209| 2.04k| flb_hash_init(&sha512, FLB_HASH_SHA512); ------------------ | | 49| 2.04k|#define FLB_HASH_SHA512 3 ------------------ 210| 2.04k| flb_hash_update(&sha512, (unsigned char *) null_terminated, 32); 211| 2.04k| flb_hash_update(&sha512, (unsigned char *) null_terminated+32, 32); 212| 2.04k| flb_hash_update(&sha512, (unsigned char *) null_terminated+64, 32); 213| 2.04k| flb_hash_finalize(&sha512, buf, sizeof(buf)); 214| 2.04k| flb_hash_cleanup(&sha512); 215| | 216| | /* regex */ 217| 2.04k| char *pregex = "^(?[^ ]+) (?[^ ]+) (?[^ ]+) (?.+)$"; 218| 2.04k| flb_regex_init(); 219| 2.04k| struct flb_regex *freg = flb_regex_create(pregex); 220| 2.04k| if (freg != NULL) { ------------------ | Branch (220:9): [True: 2.04k, False: 0] ------------------ 221| 2.04k| flb_regex_match(freg, (unsigned char*)null_terminated, size); 222| 2.04k| flb_regex_destroy(freg); 223| 2.04k| } 224| 2.04k| flb_regex_exit(); 225| | 226| | /* slist */ 227| 2.04k| struct mk_list list3; 228| 2.04k| flb_slist_create(&list3); 229| 2.04k| flb_sds_t slist_str = flb_sds_create_len((const char*)data, size); 230| 2.04k| flb_slist_add_sds(&list3, slist_str); 231| 2.04k| flb_slist_entry_get(&list3, 100); 232| 2.04k| flb_slist_dump(&list3); 233| 2.04k| flb_slist_destroy(&list3); 234| | 235| | 236| | /* General cleanup */ 237| 2.04k| flb_free(null_terminated); 238| 2.04k| flb_free(null_terminated1); 239| 2.04k| flb_free(null_terminated2); 240| 2.04k| flb_free(null_terminated3); 241| 2.04k| return 0; 242| 2.08k|}